Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
2918 lines
126 KiB
Java
2918 lines
126 KiB
Java
package androidx.appcompat.app;
|
|
|
|
import android.R;
|
|
import android.annotation.SuppressLint;
|
|
import android.app.Activity;
|
|
import android.app.Dialog;
|
|
import android.app.UiModeManager;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.ContextWrapper;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.res.Configuration;
|
|
import android.content.res.Resources;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Rect;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.LocaleList;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.os.PowerManager;
|
|
import android.text.TextUtils;
|
|
import android.util.AndroidRuntimeException;
|
|
import android.util.AttributeSet;
|
|
import android.util.TypedValue;
|
|
import android.view.ActionMode;
|
|
import android.view.ContextThemeWrapper;
|
|
import android.view.KeyCharacterMap;
|
|
import android.view.KeyEvent;
|
|
import android.view.KeyboardShortcutGroup;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.ViewGroup;
|
|
import android.view.ViewParent;
|
|
import android.view.Window;
|
|
import android.view.WindowManager;
|
|
import android.widget.FrameLayout;
|
|
import android.widget.PopupWindow;
|
|
import android.widget.TextView;
|
|
import android.window.OnBackInvokedCallback;
|
|
import android.window.OnBackInvokedDispatcher;
|
|
import androidx.annotation.CallSuper;
|
|
import androidx.annotation.DoNotInline;
|
|
import androidx.annotation.IdRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RequiresApi;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.annotation.StyleRes;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import androidx.appcompat.app.ActionBarDrawerToggle;
|
|
import androidx.appcompat.content.res.AppCompatResources;
|
|
import androidx.appcompat.view.ActionMode;
|
|
import androidx.appcompat.view.SupportActionModeWrapper;
|
|
import androidx.appcompat.view.SupportMenuInflater;
|
|
import androidx.appcompat.view.WindowCallbackWrapper;
|
|
import androidx.appcompat.view.menu.ListMenuPresenter;
|
|
import androidx.appcompat.view.menu.MenuBuilder;
|
|
import androidx.appcompat.view.menu.MenuPresenter;
|
|
import androidx.appcompat.view.menu.MenuView;
|
|
import androidx.appcompat.widget.ActionBarContextView;
|
|
import androidx.appcompat.widget.AppCompatDrawableManager;
|
|
import androidx.appcompat.widget.ContentFrameLayout;
|
|
import androidx.appcompat.widget.DecorContentParent;
|
|
import androidx.appcompat.widget.FitWindowsViewGroup;
|
|
import androidx.appcompat.widget.TintTypedArray;
|
|
import androidx.appcompat.widget.Toolbar;
|
|
import androidx.appcompat.widget.VectorEnabledTintResources;
|
|
import androidx.appcompat.widget.ViewUtils;
|
|
import androidx.collection.SimpleArrayMap;
|
|
import androidx.core.app.NavUtils;
|
|
import androidx.core.content.ContextCompat;
|
|
import androidx.core.content.res.ResourcesCompat;
|
|
import androidx.core.os.LocaleListCompat;
|
|
import androidx.core.view.KeyEventDispatcher;
|
|
import androidx.core.view.LayoutInflaterCompat;
|
|
import androidx.core.view.OnApplyWindowInsetsListener;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.core.view.ViewPropertyAnimatorCompat;
|
|
import androidx.core.view.ViewPropertyAnimatorListenerAdapter;
|
|
import androidx.core.view.WindowInsetsCompat;
|
|
import androidx.lifecycle.Lifecycle;
|
|
import androidx.lifecycle.LifecycleOwner;
|
|
import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
|
|
import java.lang.Thread;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Objects;
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
/* loaded from: classes.dex */
|
|
class AppCompatDelegateImpl extends AppCompatDelegate implements MenuBuilder.Callback, LayoutInflater.Factory2 {
|
|
static final String EXCEPTION_HANDLER_MESSAGE_SUFFIX = ". If the resource you are trying to use is a vector resource, you may be referencing it in an unsupported way. See AppCompatDelegate.setCompatVectorFromResourcesEnabled() for more info.";
|
|
private static boolean sInstalledExceptionHandler;
|
|
ActionBar mActionBar;
|
|
private ActionMenuPresenterCallback mActionMenuPresenterCallback;
|
|
ActionMode mActionMode;
|
|
PopupWindow mActionModePopup;
|
|
ActionBarContextView mActionModeView;
|
|
private int mActivityHandlesConfigFlags;
|
|
private boolean mActivityHandlesConfigFlagsChecked;
|
|
final AppCompatCallback mAppCompatCallback;
|
|
private AppCompatViewInflater mAppCompatViewInflater;
|
|
private AppCompatWindowCallback mAppCompatWindowCallback;
|
|
private AutoNightModeManager mAutoBatteryNightModeManager;
|
|
private AutoNightModeManager mAutoTimeNightModeManager;
|
|
private OnBackInvokedCallback mBackCallback;
|
|
private boolean mBaseContextAttached;
|
|
private boolean mClosingActionMenu;
|
|
final Context mContext;
|
|
private boolean mCreated;
|
|
private DecorContentParent mDecorContentParent;
|
|
boolean mDestroyed;
|
|
private OnBackInvokedDispatcher mDispatcher;
|
|
private Configuration mEffectiveConfiguration;
|
|
private boolean mEnableDefaultActionBarUp;
|
|
ViewPropertyAnimatorCompat mFadeAnim;
|
|
private boolean mFeatureIndeterminateProgress;
|
|
private boolean mFeatureProgress;
|
|
private boolean mHandleNativeActionModes;
|
|
boolean mHasActionBar;
|
|
final Object mHost;
|
|
int mInvalidatePanelMenuFeatures;
|
|
boolean mInvalidatePanelMenuPosted;
|
|
private final Runnable mInvalidatePanelMenuRunnable;
|
|
boolean mIsFloating;
|
|
private LayoutIncludeDetector mLayoutIncludeDetector;
|
|
private int mLocalNightMode;
|
|
private boolean mLongPressBackDown;
|
|
MenuInflater mMenuInflater;
|
|
boolean mOverlayActionBar;
|
|
boolean mOverlayActionMode;
|
|
private PanelMenuPresenterCallback mPanelMenuPresenterCallback;
|
|
private PanelFeatureState[] mPanels;
|
|
private PanelFeatureState mPreparedPanel;
|
|
Runnable mShowActionModePopup;
|
|
private View mStatusGuard;
|
|
ViewGroup mSubDecor;
|
|
private boolean mSubDecorInstalled;
|
|
private Rect mTempRect1;
|
|
private Rect mTempRect2;
|
|
private int mThemeResId;
|
|
private CharSequence mTitle;
|
|
private TextView mTitleView;
|
|
Window mWindow;
|
|
boolean mWindowNoTitle;
|
|
private static final SimpleArrayMap<String, Integer> sLocalNightModes = new SimpleArrayMap<>();
|
|
private static final boolean IS_PRE_LOLLIPOP = false;
|
|
private static final int[] sWindowBackgroundStyleable = {R.attr.windowBackground};
|
|
private static final boolean sCanReturnDifferentContext = !"robolectric".equals(Build.FINGERPRINT);
|
|
|
|
public interface ActionBarMenuCallback {
|
|
@Nullable
|
|
View onCreatePanelView(int i);
|
|
|
|
boolean onPreparePanel(int i);
|
|
}
|
|
|
|
private int sanitizeWindowFeatureId(int i) {
|
|
if (i == 8) {
|
|
return 108;
|
|
}
|
|
if (i == 9) {
|
|
return 109;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public Context getContextForDelegate() {
|
|
return this.mContext;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public int getLocalNightMode() {
|
|
return this.mLocalNightMode;
|
|
}
|
|
|
|
public ViewGroup getSubDecor() {
|
|
return this.mSubDecor;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public boolean isHandleNativeActionModesEnabled() {
|
|
return this.mHandleNativeActionModes;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onSaveInstanceState(Bundle bundle) {
|
|
}
|
|
|
|
public void onSubDecorInstalled(ViewGroup viewGroup) {
|
|
}
|
|
|
|
public final ActionBar peekSupportActionBar() {
|
|
return this.mActionBar;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setHandleNativeActionModesEnabled(boolean z) {
|
|
this.mHandleNativeActionModes = z;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setTheme(@StyleRes int i) {
|
|
this.mThemeResId = i;
|
|
}
|
|
|
|
/* renamed from: androidx.appcompat.app.AppCompatDelegateImpl$1, reason: invalid class name */
|
|
public class AnonymousClass1 implements Thread.UncaughtExceptionHandler {
|
|
final /* synthetic */ Thread.UncaughtExceptionHandler val$defHandler;
|
|
|
|
public AnonymousClass1(Thread.UncaughtExceptionHandler uncaughtExceptionHandler) {
|
|
this.val$defHandler = uncaughtExceptionHandler;
|
|
}
|
|
|
|
@Override // java.lang.Thread.UncaughtExceptionHandler
|
|
public void uncaughtException(@NonNull Thread thread, @NonNull Throwable th) {
|
|
if (shouldWrapException(th)) {
|
|
Resources.NotFoundException notFoundException = new Resources.NotFoundException(th.getMessage() + AppCompatDelegateImpl.EXCEPTION_HANDLER_MESSAGE_SUFFIX);
|
|
notFoundException.initCause(th.getCause());
|
|
notFoundException.setStackTrace(th.getStackTrace());
|
|
this.val$defHandler.uncaughtException(thread, notFoundException);
|
|
return;
|
|
}
|
|
this.val$defHandler.uncaughtException(thread, th);
|
|
}
|
|
|
|
private boolean shouldWrapException(Throwable th) {
|
|
String message;
|
|
if (!(th instanceof Resources.NotFoundException) || (message = th.getMessage()) == null) {
|
|
return false;
|
|
}
|
|
return message.contains("drawable") || message.contains("Drawable");
|
|
}
|
|
}
|
|
|
|
public AppCompatDelegateImpl(Activity activity, AppCompatCallback appCompatCallback) {
|
|
this(activity, null, appCompatCallback, activity);
|
|
}
|
|
|
|
public AppCompatDelegateImpl(Dialog dialog, AppCompatCallback appCompatCallback) {
|
|
this(dialog.getContext(), dialog.getWindow(), appCompatCallback, dialog);
|
|
}
|
|
|
|
public AppCompatDelegateImpl(Context context, Window window, AppCompatCallback appCompatCallback) {
|
|
this(context, window, appCompatCallback, context);
|
|
}
|
|
|
|
public AppCompatDelegateImpl(Context context, Activity activity, AppCompatCallback appCompatCallback) {
|
|
this(context, null, appCompatCallback, activity);
|
|
}
|
|
|
|
private AppCompatDelegateImpl(Context context, Window window, AppCompatCallback appCompatCallback, Object obj) {
|
|
SimpleArrayMap<String, Integer> simpleArrayMap;
|
|
Integer num;
|
|
AppCompatActivity tryUnwrapContext;
|
|
this.mFadeAnim = null;
|
|
this.mHandleNativeActionModes = true;
|
|
this.mLocalNightMode = -100;
|
|
this.mInvalidatePanelMenuRunnable = new Runnable() { // from class: androidx.appcompat.app.AppCompatDelegateImpl.2
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
AppCompatDelegateImpl appCompatDelegateImpl = AppCompatDelegateImpl.this;
|
|
if ((appCompatDelegateImpl.mInvalidatePanelMenuFeatures & 1) != 0) {
|
|
appCompatDelegateImpl.doInvalidatePanelMenu(0);
|
|
}
|
|
AppCompatDelegateImpl appCompatDelegateImpl2 = AppCompatDelegateImpl.this;
|
|
if ((appCompatDelegateImpl2.mInvalidatePanelMenuFeatures & 4096) != 0) {
|
|
appCompatDelegateImpl2.doInvalidatePanelMenu(108);
|
|
}
|
|
AppCompatDelegateImpl appCompatDelegateImpl3 = AppCompatDelegateImpl.this;
|
|
appCompatDelegateImpl3.mInvalidatePanelMenuPosted = false;
|
|
appCompatDelegateImpl3.mInvalidatePanelMenuFeatures = 0;
|
|
}
|
|
};
|
|
this.mContext = context;
|
|
this.mAppCompatCallback = appCompatCallback;
|
|
this.mHost = obj;
|
|
if (this.mLocalNightMode == -100 && (obj instanceof Dialog) && (tryUnwrapContext = tryUnwrapContext()) != null) {
|
|
this.mLocalNightMode = tryUnwrapContext.getDelegate().getLocalNightMode();
|
|
}
|
|
if (this.mLocalNightMode == -100 && (num = (simpleArrayMap = sLocalNightModes).get(obj.getClass().getName())) != null) {
|
|
this.mLocalNightMode = num.intValue();
|
|
simpleArrayMap.remove(obj.getClass().getName());
|
|
}
|
|
if (window != null) {
|
|
attachToWindow(window);
|
|
}
|
|
AppCompatDrawableManager.preload();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
@RequiresApi(33)
|
|
public void setOnBackInvokedDispatcher(@Nullable OnBackInvokedDispatcher onBackInvokedDispatcher) {
|
|
OnBackInvokedCallback onBackInvokedCallback;
|
|
super.setOnBackInvokedDispatcher(onBackInvokedDispatcher);
|
|
OnBackInvokedDispatcher onBackInvokedDispatcher2 = this.mDispatcher;
|
|
if (onBackInvokedDispatcher2 != null && (onBackInvokedCallback = this.mBackCallback) != null) {
|
|
Api33Impl.unregisterOnBackInvokedCallback(onBackInvokedDispatcher2, onBackInvokedCallback);
|
|
this.mBackCallback = null;
|
|
}
|
|
if (onBackInvokedDispatcher == null) {
|
|
Object obj = this.mHost;
|
|
if ((obj instanceof Activity) && ((Activity) obj).getWindow() != null) {
|
|
this.mDispatcher = Api33Impl.getOnBackInvokedDispatcher((Activity) this.mHost);
|
|
updateBackInvokedCallbackState();
|
|
}
|
|
}
|
|
this.mDispatcher = onBackInvokedDispatcher;
|
|
updateBackInvokedCallbackState();
|
|
}
|
|
|
|
public void updateBackInvokedCallbackState() {
|
|
OnBackInvokedCallback onBackInvokedCallback;
|
|
if (Build.VERSION.SDK_INT >= 33) {
|
|
boolean shouldRegisterBackInvokedCallback = shouldRegisterBackInvokedCallback();
|
|
if (shouldRegisterBackInvokedCallback && this.mBackCallback == null) {
|
|
this.mBackCallback = Api33Impl.registerOnBackPressedCallback(this.mDispatcher, this);
|
|
} else {
|
|
if (shouldRegisterBackInvokedCallback || (onBackInvokedCallback = this.mBackCallback) == null) {
|
|
return;
|
|
}
|
|
Api33Impl.unregisterOnBackInvokedCallback(this.mDispatcher, onBackInvokedCallback);
|
|
this.mBackCallback = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
@NonNull
|
|
@CallSuper
|
|
public Context attachBaseContext2(@NonNull Context context) {
|
|
this.mBaseContextAttached = true;
|
|
int mapNightMode = mapNightMode(context, calculateNightMode());
|
|
if (AppCompatDelegate.isAutoStorageOptedIn(context)) {
|
|
AppCompatDelegate.syncRequestedAndStoredLocales(context);
|
|
}
|
|
LocaleListCompat calculateApplicationLocales = calculateApplicationLocales(context);
|
|
if (context instanceof ContextThemeWrapper) {
|
|
try {
|
|
((ContextThemeWrapper) context).applyOverrideConfiguration(createOverrideAppConfiguration(context, mapNightMode, calculateApplicationLocales, null, false));
|
|
return context;
|
|
} catch (IllegalStateException unused) {
|
|
}
|
|
}
|
|
if (context instanceof androidx.appcompat.view.ContextThemeWrapper) {
|
|
try {
|
|
((androidx.appcompat.view.ContextThemeWrapper) context).applyOverrideConfiguration(createOverrideAppConfiguration(context, mapNightMode, calculateApplicationLocales, null, false));
|
|
return context;
|
|
} catch (IllegalStateException unused2) {
|
|
}
|
|
}
|
|
if (!sCanReturnDifferentContext) {
|
|
return super.attachBaseContext2(context);
|
|
}
|
|
Configuration configuration = new Configuration();
|
|
configuration.uiMode = -1;
|
|
configuration.fontScale = 0.0f;
|
|
Configuration configuration2 = context.createConfigurationContext(configuration).getResources().getConfiguration();
|
|
Configuration configuration3 = context.getResources().getConfiguration();
|
|
configuration2.uiMode = configuration3.uiMode;
|
|
Configuration createOverrideAppConfiguration = createOverrideAppConfiguration(context, mapNightMode, calculateApplicationLocales, !configuration2.equals(configuration3) ? generateConfigDelta(configuration2, configuration3) : null, true);
|
|
androidx.appcompat.view.ContextThemeWrapper contextThemeWrapper = new androidx.appcompat.view.ContextThemeWrapper(context, androidx.appcompat.R.style.Theme_AppCompat_Empty);
|
|
contextThemeWrapper.applyOverrideConfiguration(createOverrideAppConfiguration);
|
|
try {
|
|
if (context.getTheme() != null) {
|
|
ResourcesCompat.ThemeCompat.rebase(contextThemeWrapper.getTheme());
|
|
}
|
|
} catch (NullPointerException unused3) {
|
|
}
|
|
return super.attachBaseContext2(contextThemeWrapper);
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onCreate(Bundle bundle) {
|
|
String str;
|
|
this.mBaseContextAttached = true;
|
|
applyApplicationSpecificConfig(false);
|
|
ensureWindow();
|
|
Object obj = this.mHost;
|
|
if (obj instanceof Activity) {
|
|
try {
|
|
str = NavUtils.getParentActivityName((Activity) obj);
|
|
} catch (IllegalArgumentException unused) {
|
|
str = null;
|
|
}
|
|
if (str != null) {
|
|
ActionBar peekSupportActionBar = peekSupportActionBar();
|
|
if (peekSupportActionBar == null) {
|
|
this.mEnableDefaultActionBarUp = true;
|
|
} else {
|
|
peekSupportActionBar.setDefaultDisplayHomeAsUpEnabled(true);
|
|
}
|
|
}
|
|
AppCompatDelegate.addActiveDelegate(this);
|
|
}
|
|
this.mEffectiveConfiguration = new Configuration(this.mContext.getResources().getConfiguration());
|
|
this.mCreated = true;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onPostCreate(Bundle bundle) {
|
|
ensureSubDecor();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public ActionBar getSupportActionBar() {
|
|
initWindowDecorActionBar();
|
|
return this.mActionBar;
|
|
}
|
|
|
|
public final Window.Callback getWindowCallback() {
|
|
return this.mWindow.getCallback();
|
|
}
|
|
|
|
private void initWindowDecorActionBar() {
|
|
ensureSubDecor();
|
|
if (this.mHasActionBar && this.mActionBar == null) {
|
|
Object obj = this.mHost;
|
|
if (obj instanceof Activity) {
|
|
this.mActionBar = new WindowDecorActionBar((Activity) this.mHost, this.mOverlayActionBar);
|
|
} else if (obj instanceof Dialog) {
|
|
this.mActionBar = new WindowDecorActionBar((Dialog) this.mHost);
|
|
}
|
|
ActionBar actionBar = this.mActionBar;
|
|
if (actionBar != null) {
|
|
actionBar.setDefaultDisplayHomeAsUpEnabled(this.mEnableDefaultActionBarUp);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setSupportActionBar(Toolbar toolbar) {
|
|
if (this.mHost instanceof Activity) {
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
if (supportActionBar instanceof WindowDecorActionBar) {
|
|
throw new IllegalStateException("This Activity already has an action bar supplied by the window decor. Do not request Window.FEATURE_SUPPORT_ACTION_BAR and set windowActionBar to false in your theme to use a Toolbar instead.");
|
|
}
|
|
this.mMenuInflater = null;
|
|
if (supportActionBar != null) {
|
|
supportActionBar.onDestroy();
|
|
}
|
|
this.mActionBar = null;
|
|
if (toolbar != null) {
|
|
ToolbarActionBar toolbarActionBar = new ToolbarActionBar(toolbar, getTitle(), this.mAppCompatWindowCallback);
|
|
this.mActionBar = toolbarActionBar;
|
|
this.mAppCompatWindowCallback.setActionBarCallback(toolbarActionBar.mMenuCallback);
|
|
toolbar.setBackInvokedCallbackEnabled(true);
|
|
} else {
|
|
this.mAppCompatWindowCallback.setActionBarCallback(null);
|
|
}
|
|
invalidateOptionsMenu();
|
|
}
|
|
}
|
|
|
|
public final Context getActionBarThemedContext() {
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
Context themedContext = supportActionBar != null ? supportActionBar.getThemedContext() : null;
|
|
return themedContext == null ? this.mContext : themedContext;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public MenuInflater getMenuInflater() {
|
|
if (this.mMenuInflater == null) {
|
|
initWindowDecorActionBar();
|
|
ActionBar actionBar = this.mActionBar;
|
|
this.mMenuInflater = new SupportMenuInflater(actionBar != null ? actionBar.getThemedContext() : this.mContext);
|
|
}
|
|
return this.mMenuInflater;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
@Nullable
|
|
public <T extends View> T findViewById(@IdRes int i) {
|
|
ensureSubDecor();
|
|
return (T) this.mWindow.findViewById(i);
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onConfigurationChanged(Configuration configuration) {
|
|
ActionBar supportActionBar;
|
|
if (this.mHasActionBar && this.mSubDecorInstalled && (supportActionBar = getSupportActionBar()) != null) {
|
|
supportActionBar.onConfigurationChanged(configuration);
|
|
}
|
|
AppCompatDrawableManager.get().onConfigurationChanged(this.mContext);
|
|
this.mEffectiveConfiguration = new Configuration(this.mContext.getResources().getConfiguration());
|
|
applyApplicationSpecificConfig(false, false);
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onStart() {
|
|
applyApplicationSpecificConfig(true, false);
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onStop() {
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
supportActionBar.setShowHideAnimationEnabled(false);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void onPostResume() {
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
supportActionBar.setShowHideAnimationEnabled(true);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setContentView(View view) {
|
|
ensureSubDecor();
|
|
ViewGroup viewGroup = (ViewGroup) this.mSubDecor.findViewById(R.id.content);
|
|
viewGroup.removeAllViews();
|
|
viewGroup.addView(view);
|
|
this.mAppCompatWindowCallback.bypassOnContentChanged(this.mWindow.getCallback());
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setContentView(int i) {
|
|
ensureSubDecor();
|
|
ViewGroup viewGroup = (ViewGroup) this.mSubDecor.findViewById(R.id.content);
|
|
viewGroup.removeAllViews();
|
|
LayoutInflater.from(this.mContext).inflate(i, viewGroup);
|
|
this.mAppCompatWindowCallback.bypassOnContentChanged(this.mWindow.getCallback());
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setContentView(View view, ViewGroup.LayoutParams layoutParams) {
|
|
ensureSubDecor();
|
|
ViewGroup viewGroup = (ViewGroup) this.mSubDecor.findViewById(R.id.content);
|
|
viewGroup.removeAllViews();
|
|
viewGroup.addView(view, layoutParams);
|
|
this.mAppCompatWindowCallback.bypassOnContentChanged(this.mWindow.getCallback());
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void addContentView(View view, ViewGroup.LayoutParams layoutParams) {
|
|
ensureSubDecor();
|
|
((ViewGroup) this.mSubDecor.findViewById(R.id.content)).addView(view, layoutParams);
|
|
this.mAppCompatWindowCallback.bypassOnContentChanged(this.mWindow.getCallback());
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:16:0x0058 */
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void onDestroy() {
|
|
/*
|
|
r3 = this;
|
|
java.lang.Object r0 = r3.mHost
|
|
boolean r0 = r0 instanceof android.app.Activity
|
|
if (r0 == 0) goto L9
|
|
androidx.appcompat.app.AppCompatDelegate.removeActivityDelegate(r3)
|
|
L9:
|
|
boolean r0 = r3.mInvalidatePanelMenuPosted
|
|
if (r0 == 0) goto L18
|
|
android.view.Window r0 = r3.mWindow
|
|
android.view.View r0 = r0.getDecorView()
|
|
java.lang.Runnable r1 = r3.mInvalidatePanelMenuRunnable
|
|
r0.removeCallbacks(r1)
|
|
L18:
|
|
r0 = 1
|
|
r3.mDestroyed = r0
|
|
int r0 = r3.mLocalNightMode
|
|
r1 = -100
|
|
if (r0 == r1) goto L45
|
|
java.lang.Object r0 = r3.mHost
|
|
boolean r1 = r0 instanceof android.app.Activity
|
|
if (r1 == 0) goto L45
|
|
android.app.Activity r0 = (android.app.Activity) r0
|
|
boolean r0 = r0.isChangingConfigurations()
|
|
if (r0 == 0) goto L45
|
|
androidx.collection.SimpleArrayMap<java.lang.String, java.lang.Integer> r0 = androidx.appcompat.app.AppCompatDelegateImpl.sLocalNightModes
|
|
java.lang.Object r1 = r3.mHost
|
|
java.lang.Class r1 = r1.getClass()
|
|
java.lang.String r1 = r1.getName()
|
|
int r2 = r3.mLocalNightMode
|
|
java.lang.Integer r2 = java.lang.Integer.valueOf(r2)
|
|
r0.put(r1, r2)
|
|
goto L54
|
|
L45:
|
|
androidx.collection.SimpleArrayMap<java.lang.String, java.lang.Integer> r0 = androidx.appcompat.app.AppCompatDelegateImpl.sLocalNightModes
|
|
java.lang.Object r1 = r3.mHost
|
|
java.lang.Class r1 = r1.getClass()
|
|
java.lang.String r1 = r1.getName()
|
|
r0.remove(r1)
|
|
L54:
|
|
androidx.appcompat.app.ActionBar r0 = r3.mActionBar
|
|
if (r0 == 0) goto L5b
|
|
r0.onDestroy()
|
|
L5b:
|
|
r3.cleanupAutoManagers()
|
|
return
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.app.AppCompatDelegateImpl.onDestroy():void");
|
|
}
|
|
|
|
private void cleanupAutoManagers() {
|
|
AutoNightModeManager autoNightModeManager = this.mAutoTimeNightModeManager;
|
|
if (autoNightModeManager != null) {
|
|
autoNightModeManager.cleanup();
|
|
}
|
|
AutoNightModeManager autoNightModeManager2 = this.mAutoBatteryNightModeManager;
|
|
if (autoNightModeManager2 != null) {
|
|
autoNightModeManager2.cleanup();
|
|
}
|
|
}
|
|
|
|
private void ensureWindow() {
|
|
if (this.mWindow == null) {
|
|
Object obj = this.mHost;
|
|
if (obj instanceof Activity) {
|
|
attachToWindow(((Activity) obj).getWindow());
|
|
}
|
|
}
|
|
if (this.mWindow == null) {
|
|
throw new IllegalStateException("We have not been given a Window");
|
|
}
|
|
}
|
|
|
|
private void attachToWindow(@NonNull Window window) {
|
|
if (this.mWindow != null) {
|
|
throw new IllegalStateException("AppCompat has already installed itself into the Window");
|
|
}
|
|
Window.Callback callback = window.getCallback();
|
|
if (callback instanceof AppCompatWindowCallback) {
|
|
throw new IllegalStateException("AppCompat has already installed itself into the Window");
|
|
}
|
|
AppCompatWindowCallback appCompatWindowCallback = new AppCompatWindowCallback(callback);
|
|
this.mAppCompatWindowCallback = appCompatWindowCallback;
|
|
window.setCallback(appCompatWindowCallback);
|
|
TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(this.mContext, (AttributeSet) null, sWindowBackgroundStyleable);
|
|
Drawable drawableIfKnown = obtainStyledAttributes.getDrawableIfKnown(0);
|
|
if (drawableIfKnown != null) {
|
|
window.setBackgroundDrawable(drawableIfKnown);
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
this.mWindow = window;
|
|
if (Build.VERSION.SDK_INT < 33 || this.mDispatcher != null) {
|
|
return;
|
|
}
|
|
setOnBackInvokedDispatcher(null);
|
|
}
|
|
|
|
private void ensureSubDecor() {
|
|
if (this.mSubDecorInstalled) {
|
|
return;
|
|
}
|
|
this.mSubDecor = createSubDecor();
|
|
CharSequence title = getTitle();
|
|
if (!TextUtils.isEmpty(title)) {
|
|
DecorContentParent decorContentParent = this.mDecorContentParent;
|
|
if (decorContentParent != null) {
|
|
decorContentParent.setWindowTitle(title);
|
|
} else if (peekSupportActionBar() != null) {
|
|
peekSupportActionBar().setWindowTitle(title);
|
|
} else {
|
|
TextView textView = this.mTitleView;
|
|
if (textView != null) {
|
|
textView.setText(title);
|
|
}
|
|
}
|
|
}
|
|
applyFixedSizeWindow();
|
|
onSubDecorInstalled(this.mSubDecor);
|
|
this.mSubDecorInstalled = true;
|
|
PanelFeatureState panelState = getPanelState(0, false);
|
|
if (this.mDestroyed) {
|
|
return;
|
|
}
|
|
if (panelState == null || panelState.menu == null) {
|
|
invalidatePanelMenu(108);
|
|
}
|
|
}
|
|
|
|
private ViewGroup createSubDecor() {
|
|
ViewGroup viewGroup;
|
|
TypedArray obtainStyledAttributes = this.mContext.obtainStyledAttributes(androidx.appcompat.R.styleable.AppCompatTheme);
|
|
if (!obtainStyledAttributes.hasValue(androidx.appcompat.R.styleable.AppCompatTheme_windowActionBar)) {
|
|
obtainStyledAttributes.recycle();
|
|
throw new IllegalStateException("You need to use a Theme.AppCompat theme (or descendant) with this activity.");
|
|
}
|
|
if (obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.AppCompatTheme_windowNoTitle, false)) {
|
|
requestWindowFeature(1);
|
|
} else if (obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.AppCompatTheme_windowActionBar, false)) {
|
|
requestWindowFeature(108);
|
|
}
|
|
if (obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.AppCompatTheme_windowActionBarOverlay, false)) {
|
|
requestWindowFeature(109);
|
|
}
|
|
if (obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.AppCompatTheme_windowActionModeOverlay, false)) {
|
|
requestWindowFeature(10);
|
|
}
|
|
this.mIsFloating = obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.AppCompatTheme_android_windowIsFloating, false);
|
|
obtainStyledAttributes.recycle();
|
|
ensureWindow();
|
|
this.mWindow.getDecorView();
|
|
LayoutInflater from = LayoutInflater.from(this.mContext);
|
|
if (this.mWindowNoTitle) {
|
|
viewGroup = this.mOverlayActionMode ? (ViewGroup) from.inflate(androidx.appcompat.R.layout.abc_screen_simple_overlay_action_mode, (ViewGroup) null) : (ViewGroup) from.inflate(androidx.appcompat.R.layout.abc_screen_simple, (ViewGroup) null);
|
|
} else if (this.mIsFloating) {
|
|
viewGroup = (ViewGroup) from.inflate(androidx.appcompat.R.layout.abc_dialog_title_material, (ViewGroup) null);
|
|
this.mOverlayActionBar = false;
|
|
this.mHasActionBar = false;
|
|
} else if (this.mHasActionBar) {
|
|
TypedValue typedValue = new TypedValue();
|
|
this.mContext.getTheme().resolveAttribute(androidx.appcompat.R.attr.actionBarTheme, typedValue, true);
|
|
viewGroup = (ViewGroup) LayoutInflater.from(typedValue.resourceId != 0 ? new androidx.appcompat.view.ContextThemeWrapper(this.mContext, typedValue.resourceId) : this.mContext).inflate(androidx.appcompat.R.layout.abc_screen_toolbar, (ViewGroup) null);
|
|
DecorContentParent decorContentParent = (DecorContentParent) viewGroup.findViewById(androidx.appcompat.R.id.decor_content_parent);
|
|
this.mDecorContentParent = decorContentParent;
|
|
decorContentParent.setWindowCallback(getWindowCallback());
|
|
if (this.mOverlayActionBar) {
|
|
this.mDecorContentParent.initFeature(109);
|
|
}
|
|
if (this.mFeatureProgress) {
|
|
this.mDecorContentParent.initFeature(2);
|
|
}
|
|
if (this.mFeatureIndeterminateProgress) {
|
|
this.mDecorContentParent.initFeature(5);
|
|
}
|
|
} else {
|
|
viewGroup = null;
|
|
}
|
|
if (viewGroup == null) {
|
|
throw new IllegalArgumentException("AppCompat does not support the current theme features: { windowActionBar: " + this.mHasActionBar + ", windowActionBarOverlay: " + this.mOverlayActionBar + ", android:windowIsFloating: " + this.mIsFloating + ", windowActionModeOverlay: " + this.mOverlayActionMode + ", windowNoTitle: " + this.mWindowNoTitle + " }");
|
|
}
|
|
ViewCompat.setOnApplyWindowInsetsListener(viewGroup, new OnApplyWindowInsetsListener() { // from class: androidx.appcompat.app.AppCompatDelegateImpl.3
|
|
@Override // androidx.core.view.OnApplyWindowInsetsListener
|
|
public WindowInsetsCompat onApplyWindowInsets(View view, WindowInsetsCompat windowInsetsCompat) {
|
|
int systemWindowInsetTop = windowInsetsCompat.getSystemWindowInsetTop();
|
|
int updateStatusGuard = AppCompatDelegateImpl.this.updateStatusGuard(windowInsetsCompat, null);
|
|
if (systemWindowInsetTop != updateStatusGuard) {
|
|
windowInsetsCompat = windowInsetsCompat.replaceSystemWindowInsets(windowInsetsCompat.getSystemWindowInsetLeft(), updateStatusGuard, windowInsetsCompat.getSystemWindowInsetRight(), windowInsetsCompat.getSystemWindowInsetBottom());
|
|
}
|
|
return ViewCompat.onApplyWindowInsets(view, windowInsetsCompat);
|
|
}
|
|
});
|
|
if (this.mDecorContentParent == null) {
|
|
this.mTitleView = (TextView) viewGroup.findViewById(androidx.appcompat.R.id.title);
|
|
}
|
|
ViewUtils.makeOptionalFitsSystemWindows(viewGroup);
|
|
ContentFrameLayout contentFrameLayout = (ContentFrameLayout) viewGroup.findViewById(androidx.appcompat.R.id.action_bar_activity_content);
|
|
ViewGroup viewGroup2 = (ViewGroup) this.mWindow.findViewById(R.id.content);
|
|
if (viewGroup2 != null) {
|
|
while (viewGroup2.getChildCount() > 0) {
|
|
View childAt = viewGroup2.getChildAt(0);
|
|
viewGroup2.removeViewAt(0);
|
|
contentFrameLayout.addView(childAt);
|
|
}
|
|
viewGroup2.setId(-1);
|
|
contentFrameLayout.setId(R.id.content);
|
|
if (viewGroup2 instanceof FrameLayout) {
|
|
((FrameLayout) viewGroup2).setForeground(null);
|
|
}
|
|
}
|
|
this.mWindow.setContentView(viewGroup);
|
|
contentFrameLayout.setAttachListener(new ContentFrameLayout.OnAttachListener() { // from class: androidx.appcompat.app.AppCompatDelegateImpl.5
|
|
@Override // androidx.appcompat.widget.ContentFrameLayout.OnAttachListener
|
|
public void onAttachedFromWindow() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.ContentFrameLayout.OnAttachListener
|
|
public void onDetachedFromWindow() {
|
|
AppCompatDelegateImpl.this.dismissPopups();
|
|
}
|
|
});
|
|
return viewGroup;
|
|
}
|
|
|
|
/* renamed from: androidx.appcompat.app.AppCompatDelegateImpl$4, reason: invalid class name */
|
|
public class AnonymousClass4 implements FitWindowsViewGroup.OnFitSystemWindowsListener {
|
|
public AnonymousClass4() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.FitWindowsViewGroup.OnFitSystemWindowsListener
|
|
public void onFitSystemWindows(Rect rect) {
|
|
rect.top = AppCompatDelegateImpl.this.updateStatusGuard(null, rect);
|
|
}
|
|
}
|
|
|
|
private void applyFixedSizeWindow() {
|
|
ContentFrameLayout contentFrameLayout = (ContentFrameLayout) this.mSubDecor.findViewById(R.id.content);
|
|
View decorView = this.mWindow.getDecorView();
|
|
contentFrameLayout.setDecorPadding(decorView.getPaddingLeft(), decorView.getPaddingTop(), decorView.getPaddingRight(), decorView.getPaddingBottom());
|
|
TypedArray obtainStyledAttributes = this.mContext.obtainStyledAttributes(androidx.appcompat.R.styleable.AppCompatTheme);
|
|
obtainStyledAttributes.getValue(androidx.appcompat.R.styleable.AppCompatTheme_windowMinWidthMajor, contentFrameLayout.getMinWidthMajor());
|
|
obtainStyledAttributes.getValue(androidx.appcompat.R.styleable.AppCompatTheme_windowMinWidthMinor, contentFrameLayout.getMinWidthMinor());
|
|
if (obtainStyledAttributes.hasValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedWidthMajor)) {
|
|
obtainStyledAttributes.getValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedWidthMajor, contentFrameLayout.getFixedWidthMajor());
|
|
}
|
|
if (obtainStyledAttributes.hasValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedWidthMinor)) {
|
|
obtainStyledAttributes.getValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedWidthMinor, contentFrameLayout.getFixedWidthMinor());
|
|
}
|
|
if (obtainStyledAttributes.hasValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedHeightMajor)) {
|
|
obtainStyledAttributes.getValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedHeightMajor, contentFrameLayout.getFixedHeightMajor());
|
|
}
|
|
if (obtainStyledAttributes.hasValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedHeightMinor)) {
|
|
obtainStyledAttributes.getValue(androidx.appcompat.R.styleable.AppCompatTheme_windowFixedHeightMinor, contentFrameLayout.getFixedHeightMinor());
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
contentFrameLayout.requestLayout();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public boolean requestWindowFeature(int i) {
|
|
int sanitizeWindowFeatureId = sanitizeWindowFeatureId(i);
|
|
if (this.mWindowNoTitle && sanitizeWindowFeatureId == 108) {
|
|
return false;
|
|
}
|
|
if (this.mHasActionBar && sanitizeWindowFeatureId == 1) {
|
|
this.mHasActionBar = false;
|
|
}
|
|
if (sanitizeWindowFeatureId == 1) {
|
|
throwFeatureRequestIfSubDecorInstalled();
|
|
this.mWindowNoTitle = true;
|
|
return true;
|
|
}
|
|
if (sanitizeWindowFeatureId == 2) {
|
|
throwFeatureRequestIfSubDecorInstalled();
|
|
this.mFeatureProgress = true;
|
|
return true;
|
|
}
|
|
if (sanitizeWindowFeatureId == 5) {
|
|
throwFeatureRequestIfSubDecorInstalled();
|
|
this.mFeatureIndeterminateProgress = true;
|
|
return true;
|
|
}
|
|
if (sanitizeWindowFeatureId == 10) {
|
|
throwFeatureRequestIfSubDecorInstalled();
|
|
this.mOverlayActionMode = true;
|
|
return true;
|
|
}
|
|
if (sanitizeWindowFeatureId == 108) {
|
|
throwFeatureRequestIfSubDecorInstalled();
|
|
this.mHasActionBar = true;
|
|
return true;
|
|
}
|
|
if (sanitizeWindowFeatureId == 109) {
|
|
throwFeatureRequestIfSubDecorInstalled();
|
|
this.mOverlayActionBar = true;
|
|
return true;
|
|
}
|
|
return this.mWindow.requestFeature(sanitizeWindowFeatureId);
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:19:0x0036 A[ORIG_RETURN, RETURN] */
|
|
/* JADX WARN: Removed duplicated region for block: B:20:? A[RETURN, SYNTHETIC] */
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public boolean hasWindowFeature(int r4) {
|
|
/*
|
|
r3 = this;
|
|
int r0 = r3.sanitizeWindowFeatureId(r4)
|
|
r1 = 1
|
|
if (r0 == r1) goto L29
|
|
r2 = 2
|
|
if (r0 == r2) goto L26
|
|
r2 = 5
|
|
if (r0 == r2) goto L23
|
|
r2 = 10
|
|
if (r0 == r2) goto L20
|
|
r2 = 108(0x6c, float:1.51E-43)
|
|
if (r0 == r2) goto L1d
|
|
r2 = 109(0x6d, float:1.53E-43)
|
|
if (r0 == r2) goto L1a
|
|
goto L2d
|
|
L1a:
|
|
boolean r0 = r3.mOverlayActionBar
|
|
goto L2b
|
|
L1d:
|
|
boolean r0 = r3.mHasActionBar
|
|
goto L2b
|
|
L20:
|
|
boolean r0 = r3.mOverlayActionMode
|
|
goto L2b
|
|
L23:
|
|
boolean r0 = r3.mFeatureIndeterminateProgress
|
|
goto L2b
|
|
L26:
|
|
boolean r0 = r3.mFeatureProgress
|
|
goto L2b
|
|
L29:
|
|
boolean r0 = r3.mWindowNoTitle
|
|
L2b:
|
|
if (r0 != 0) goto L37
|
|
L2d:
|
|
android.view.Window r0 = r3.mWindow
|
|
boolean r4 = r0.hasFeature(r4)
|
|
if (r4 == 0) goto L36
|
|
goto L37
|
|
L36:
|
|
r1 = 0
|
|
L37:
|
|
return r1
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.app.AppCompatDelegateImpl.hasWindowFeature(int):boolean");
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public final void setTitle(CharSequence charSequence) {
|
|
this.mTitle = charSequence;
|
|
DecorContentParent decorContentParent = this.mDecorContentParent;
|
|
if (decorContentParent != null) {
|
|
decorContentParent.setWindowTitle(charSequence);
|
|
return;
|
|
}
|
|
if (peekSupportActionBar() != null) {
|
|
peekSupportActionBar().setWindowTitle(charSequence);
|
|
return;
|
|
}
|
|
TextView textView = this.mTitleView;
|
|
if (textView != null) {
|
|
textView.setText(charSequence);
|
|
}
|
|
}
|
|
|
|
public final CharSequence getTitle() {
|
|
Object obj = this.mHost;
|
|
return obj instanceof Activity ? ((Activity) obj).getTitle() : this.mTitle;
|
|
}
|
|
|
|
public void onPanelClosed(int i) {
|
|
if (i == 108) {
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
supportActionBar.dispatchMenuVisibilityChanged(false);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (i == 0) {
|
|
PanelFeatureState panelState = getPanelState(i, true);
|
|
if (panelState.isOpen) {
|
|
closePanel(panelState, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onMenuOpened(int i) {
|
|
ActionBar supportActionBar;
|
|
if (i != 108 || (supportActionBar = getSupportActionBar()) == null) {
|
|
return;
|
|
}
|
|
supportActionBar.dispatchMenuVisibilityChanged(true);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuBuilder.Callback
|
|
public boolean onMenuItemSelected(@NonNull MenuBuilder menuBuilder, @NonNull MenuItem menuItem) {
|
|
PanelFeatureState findMenuPanel;
|
|
Window.Callback windowCallback = getWindowCallback();
|
|
if (windowCallback == null || this.mDestroyed || (findMenuPanel = findMenuPanel(menuBuilder.getRootMenu())) == null) {
|
|
return false;
|
|
}
|
|
return windowCallback.onMenuItemSelected(findMenuPanel.featureId, menuItem);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuBuilder.Callback
|
|
public void onMenuModeChange(@NonNull MenuBuilder menuBuilder) {
|
|
reopenMenu(true);
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public ActionMode startSupportActionMode(@NonNull ActionMode.Callback callback) {
|
|
AppCompatCallback appCompatCallback;
|
|
if (callback == null) {
|
|
throw new IllegalArgumentException("ActionMode callback can not be null.");
|
|
}
|
|
ActionMode actionMode = this.mActionMode;
|
|
if (actionMode != null) {
|
|
actionMode.finish();
|
|
}
|
|
ActionModeCallbackWrapperV9 actionModeCallbackWrapperV9 = new ActionModeCallbackWrapperV9(callback);
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
ActionMode startActionMode = supportActionBar.startActionMode(actionModeCallbackWrapperV9);
|
|
this.mActionMode = startActionMode;
|
|
if (startActionMode != null && (appCompatCallback = this.mAppCompatCallback) != null) {
|
|
appCompatCallback.onSupportActionModeStarted(startActionMode);
|
|
}
|
|
}
|
|
if (this.mActionMode == null) {
|
|
this.mActionMode = startSupportActionModeFromWindow(actionModeCallbackWrapperV9);
|
|
}
|
|
updateBackInvokedCallbackState();
|
|
return this.mActionMode;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void invalidateOptionsMenu() {
|
|
if (peekSupportActionBar() == null || getSupportActionBar().invalidateOptionsMenu()) {
|
|
return;
|
|
}
|
|
invalidatePanelMenu(0);
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:14:0x0025 */
|
|
/* JADX WARN: Removed duplicated region for block: B:23:0x0029 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public androidx.appcompat.view.ActionMode startSupportActionModeFromWindow(@androidx.annotation.NonNull androidx.appcompat.view.ActionMode.Callback r8) {
|
|
/*
|
|
Method dump skipped, instructions count: 364
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.app.AppCompatDelegateImpl.startSupportActionModeFromWindow(androidx.appcompat.view.ActionMode$Callback):androidx.appcompat.view.ActionMode");
|
|
}
|
|
|
|
public final boolean shouldAnimateActionModeView() {
|
|
ViewGroup viewGroup;
|
|
return this.mSubDecorInstalled && (viewGroup = this.mSubDecor) != null && viewGroup.isLaidOut();
|
|
}
|
|
|
|
public void endOnGoingFadeAnimation() {
|
|
ViewPropertyAnimatorCompat viewPropertyAnimatorCompat = this.mFadeAnim;
|
|
if (viewPropertyAnimatorCompat != null) {
|
|
viewPropertyAnimatorCompat.cancel();
|
|
}
|
|
}
|
|
|
|
public boolean shouldRegisterBackInvokedCallback() {
|
|
if (this.mDispatcher == null) {
|
|
return false;
|
|
}
|
|
PanelFeatureState panelState = getPanelState(0, false);
|
|
return (panelState != null && panelState.isOpen) || this.mActionMode != null;
|
|
}
|
|
|
|
public boolean onBackPressed() {
|
|
boolean z = this.mLongPressBackDown;
|
|
this.mLongPressBackDown = false;
|
|
PanelFeatureState panelState = getPanelState(0, false);
|
|
if (panelState != null && panelState.isOpen) {
|
|
if (!z) {
|
|
closePanel(panelState, true);
|
|
}
|
|
return true;
|
|
}
|
|
ActionMode actionMode = this.mActionMode;
|
|
if (actionMode != null) {
|
|
actionMode.finish();
|
|
return true;
|
|
}
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
return supportActionBar != null && supportActionBar.collapseActionView();
|
|
}
|
|
|
|
public boolean onKeyShortcut(int i, KeyEvent keyEvent) {
|
|
ActionBar supportActionBar = getSupportActionBar();
|
|
if (supportActionBar != null && supportActionBar.onKeyShortcut(i, keyEvent)) {
|
|
return true;
|
|
}
|
|
PanelFeatureState panelFeatureState = this.mPreparedPanel;
|
|
if (panelFeatureState != null && performPanelShortcut(panelFeatureState, keyEvent.getKeyCode(), keyEvent, 1)) {
|
|
PanelFeatureState panelFeatureState2 = this.mPreparedPanel;
|
|
if (panelFeatureState2 != null) {
|
|
panelFeatureState2.isHandled = true;
|
|
}
|
|
return true;
|
|
}
|
|
if (this.mPreparedPanel == null) {
|
|
PanelFeatureState panelState = getPanelState(0, true);
|
|
preparePanel(panelState, keyEvent);
|
|
boolean performPanelShortcut = performPanelShortcut(panelState, keyEvent.getKeyCode(), keyEvent, 1);
|
|
panelState.isPrepared = false;
|
|
if (performPanelShortcut) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean dispatchKeyEvent(KeyEvent keyEvent) {
|
|
View decorView;
|
|
Object obj = this.mHost;
|
|
if (((obj instanceof KeyEventDispatcher.Component) || (obj instanceof AppCompatDialog)) && (decorView = this.mWindow.getDecorView()) != null && KeyEventDispatcher.dispatchBeforeHierarchy(decorView, keyEvent)) {
|
|
return true;
|
|
}
|
|
if (keyEvent.getKeyCode() == 82 && this.mAppCompatWindowCallback.bypassDispatchKeyEvent(this.mWindow.getCallback(), keyEvent)) {
|
|
return true;
|
|
}
|
|
int keyCode = keyEvent.getKeyCode();
|
|
return keyEvent.getAction() == 0 ? onKeyDown(keyCode, keyEvent) : onKeyUp(keyCode, keyEvent);
|
|
}
|
|
|
|
public boolean onKeyUp(int i, KeyEvent keyEvent) {
|
|
if (i != 4) {
|
|
if (i == 82) {
|
|
onKeyUpPanel(0, keyEvent);
|
|
return true;
|
|
}
|
|
} else if (onBackPressed()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean onKeyDown(int i, KeyEvent keyEvent) {
|
|
if (i == 4) {
|
|
this.mLongPressBackDown = (keyEvent.getFlags() & 128) != 0;
|
|
} else if (i == 82) {
|
|
onKeyDownPanel(0, keyEvent);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public View createView(View view, String str, @NonNull Context context, @NonNull AttributeSet attributeSet) {
|
|
boolean z;
|
|
boolean z2 = false;
|
|
if (this.mAppCompatViewInflater == null) {
|
|
TypedArray obtainStyledAttributes = this.mContext.obtainStyledAttributes(androidx.appcompat.R.styleable.AppCompatTheme);
|
|
String string = obtainStyledAttributes.getString(androidx.appcompat.R.styleable.AppCompatTheme_viewInflaterClass);
|
|
obtainStyledAttributes.recycle();
|
|
if (string == null) {
|
|
this.mAppCompatViewInflater = new AppCompatViewInflater();
|
|
} else {
|
|
try {
|
|
this.mAppCompatViewInflater = (AppCompatViewInflater) this.mContext.getClassLoader().loadClass(string).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
|
|
} catch (Throwable unused) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("Failed to instantiate custom view inflater ");
|
|
sb.append(string);
|
|
sb.append(". Falling back to default.");
|
|
this.mAppCompatViewInflater = new AppCompatViewInflater();
|
|
}
|
|
}
|
|
}
|
|
boolean z3 = IS_PRE_LOLLIPOP;
|
|
if (z3) {
|
|
if (this.mLayoutIncludeDetector == null) {
|
|
this.mLayoutIncludeDetector = new LayoutIncludeDetector();
|
|
}
|
|
if (!this.mLayoutIncludeDetector.detect(attributeSet)) {
|
|
if (attributeSet instanceof XmlPullParser) {
|
|
if (((XmlPullParser) attributeSet).getDepth() > 1) {
|
|
z2 = true;
|
|
}
|
|
} else {
|
|
z2 = shouldInheritContext((ViewParent) view);
|
|
}
|
|
} else {
|
|
z = true;
|
|
return this.mAppCompatViewInflater.createView(view, str, context, attributeSet, z, z3, true, VectorEnabledTintResources.shouldBeUsed());
|
|
}
|
|
}
|
|
z = z2;
|
|
return this.mAppCompatViewInflater.createView(view, str, context, attributeSet, z, z3, true, VectorEnabledTintResources.shouldBeUsed());
|
|
}
|
|
|
|
private boolean shouldInheritContext(ViewParent viewParent) {
|
|
if (viewParent == null) {
|
|
return false;
|
|
}
|
|
View decorView = this.mWindow.getDecorView();
|
|
while (viewParent != null) {
|
|
if (viewParent == decorView || !(viewParent instanceof View) || ((View) viewParent).isAttachedToWindow()) {
|
|
return false;
|
|
}
|
|
viewParent = viewParent.getParent();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void installViewFactory() {
|
|
LayoutInflater from = LayoutInflater.from(this.mContext);
|
|
if (from.getFactory() == null) {
|
|
LayoutInflaterCompat.setFactory2(from, this);
|
|
} else {
|
|
boolean z = from.getFactory2() instanceof AppCompatDelegateImpl;
|
|
}
|
|
}
|
|
|
|
@Override // android.view.LayoutInflater.Factory2
|
|
public final View onCreateView(View view, String str, Context context, AttributeSet attributeSet) {
|
|
return createView(view, str, context, attributeSet);
|
|
}
|
|
|
|
@Override // android.view.LayoutInflater.Factory
|
|
public View onCreateView(String str, Context context, AttributeSet attributeSet) {
|
|
return onCreateView(null, str, context, attributeSet);
|
|
}
|
|
|
|
@Nullable
|
|
private AppCompatActivity tryUnwrapContext() {
|
|
for (Context context = this.mContext; context != null; context = ((ContextWrapper) context).getBaseContext()) {
|
|
if (context instanceof AppCompatActivity) {
|
|
return (AppCompatActivity) context;
|
|
}
|
|
if (!(context instanceof ContextWrapper)) {
|
|
break;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:36:0x00ed */
|
|
/* JADX WARN: Removed duplicated region for block: B:38:? A[RETURN, SYNTHETIC] */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
private void openPanel(androidx.appcompat.app.AppCompatDelegateImpl.PanelFeatureState r12, android.view.KeyEvent r13) {
|
|
/*
|
|
Method dump skipped, instructions count: 244
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.app.AppCompatDelegateImpl.openPanel(androidx.appcompat.app.AppCompatDelegateImpl$PanelFeatureState, android.view.KeyEvent):void");
|
|
}
|
|
|
|
private boolean initializePanelDecor(PanelFeatureState panelFeatureState) {
|
|
panelFeatureState.setStyle(getActionBarThemedContext());
|
|
panelFeatureState.decorView = new ListMenuDecorView(panelFeatureState.listPresenterContext);
|
|
panelFeatureState.gravity = 81;
|
|
return true;
|
|
}
|
|
|
|
private void reopenMenu(boolean z) {
|
|
DecorContentParent decorContentParent = this.mDecorContentParent;
|
|
if (decorContentParent != null && decorContentParent.canShowOverflowMenu() && (!ViewConfiguration.get(this.mContext).hasPermanentMenuKey() || this.mDecorContentParent.isOverflowMenuShowPending())) {
|
|
Window.Callback windowCallback = getWindowCallback();
|
|
if (this.mDecorContentParent.isOverflowMenuShowing() && z) {
|
|
this.mDecorContentParent.hideOverflowMenu();
|
|
if (this.mDestroyed) {
|
|
return;
|
|
}
|
|
windowCallback.onPanelClosed(108, getPanelState(0, true).menu);
|
|
return;
|
|
}
|
|
if (windowCallback == null || this.mDestroyed) {
|
|
return;
|
|
}
|
|
if (this.mInvalidatePanelMenuPosted && (this.mInvalidatePanelMenuFeatures & 1) != 0) {
|
|
this.mWindow.getDecorView().removeCallbacks(this.mInvalidatePanelMenuRunnable);
|
|
this.mInvalidatePanelMenuRunnable.run();
|
|
}
|
|
PanelFeatureState panelState = getPanelState(0, true);
|
|
MenuBuilder menuBuilder = panelState.menu;
|
|
if (menuBuilder == null || panelState.refreshMenuContent || !windowCallback.onPreparePanel(0, panelState.createdPanelView, menuBuilder)) {
|
|
return;
|
|
}
|
|
windowCallback.onMenuOpened(108, panelState.menu);
|
|
this.mDecorContentParent.showOverflowMenu();
|
|
return;
|
|
}
|
|
PanelFeatureState panelState2 = getPanelState(0, true);
|
|
panelState2.refreshDecorView = true;
|
|
closePanel(panelState2, false);
|
|
openPanel(panelState2, null);
|
|
}
|
|
|
|
private boolean initializePanelMenu(PanelFeatureState panelFeatureState) {
|
|
Resources.Theme theme;
|
|
Context context = this.mContext;
|
|
int i = panelFeatureState.featureId;
|
|
if ((i == 0 || i == 108) && this.mDecorContentParent != null) {
|
|
TypedValue typedValue = new TypedValue();
|
|
Resources.Theme theme2 = context.getTheme();
|
|
theme2.resolveAttribute(androidx.appcompat.R.attr.actionBarTheme, typedValue, true);
|
|
if (typedValue.resourceId != 0) {
|
|
theme = context.getResources().newTheme();
|
|
theme.setTo(theme2);
|
|
theme.applyStyle(typedValue.resourceId, true);
|
|
theme.resolveAttribute(androidx.appcompat.R.attr.actionBarWidgetTheme, typedValue, true);
|
|
} else {
|
|
theme2.resolveAttribute(androidx.appcompat.R.attr.actionBarWidgetTheme, typedValue, true);
|
|
theme = null;
|
|
}
|
|
if (typedValue.resourceId != 0) {
|
|
if (theme == null) {
|
|
theme = context.getResources().newTheme();
|
|
theme.setTo(theme2);
|
|
}
|
|
theme.applyStyle(typedValue.resourceId, true);
|
|
}
|
|
if (theme != null) {
|
|
androidx.appcompat.view.ContextThemeWrapper contextThemeWrapper = new androidx.appcompat.view.ContextThemeWrapper(context, 0);
|
|
contextThemeWrapper.getTheme().setTo(theme);
|
|
context = contextThemeWrapper;
|
|
}
|
|
}
|
|
MenuBuilder menuBuilder = new MenuBuilder(context);
|
|
menuBuilder.setCallback(this);
|
|
panelFeatureState.setMenu(menuBuilder);
|
|
return true;
|
|
}
|
|
|
|
private boolean initializePanelContent(PanelFeatureState panelFeatureState) {
|
|
View view = panelFeatureState.createdPanelView;
|
|
if (view != null) {
|
|
panelFeatureState.shownPanelView = view;
|
|
return true;
|
|
}
|
|
if (panelFeatureState.menu == null) {
|
|
return false;
|
|
}
|
|
if (this.mPanelMenuPresenterCallback == null) {
|
|
this.mPanelMenuPresenterCallback = new PanelMenuPresenterCallback();
|
|
}
|
|
View view2 = (View) panelFeatureState.getListMenuView(this.mPanelMenuPresenterCallback);
|
|
panelFeatureState.shownPanelView = view2;
|
|
return view2 != null;
|
|
}
|
|
|
|
private boolean preparePanel(PanelFeatureState panelFeatureState, KeyEvent keyEvent) {
|
|
DecorContentParent decorContentParent;
|
|
DecorContentParent decorContentParent2;
|
|
DecorContentParent decorContentParent3;
|
|
if (this.mDestroyed) {
|
|
return false;
|
|
}
|
|
if (panelFeatureState.isPrepared) {
|
|
return true;
|
|
}
|
|
PanelFeatureState panelFeatureState2 = this.mPreparedPanel;
|
|
if (panelFeatureState2 != null && panelFeatureState2 != panelFeatureState) {
|
|
closePanel(panelFeatureState2, false);
|
|
}
|
|
Window.Callback windowCallback = getWindowCallback();
|
|
if (windowCallback != null) {
|
|
panelFeatureState.createdPanelView = windowCallback.onCreatePanelView(panelFeatureState.featureId);
|
|
}
|
|
int i = panelFeatureState.featureId;
|
|
boolean z = i == 0 || i == 108;
|
|
if (z && (decorContentParent3 = this.mDecorContentParent) != null) {
|
|
decorContentParent3.setMenuPrepared();
|
|
}
|
|
if (panelFeatureState.createdPanelView == null && (!z || !(peekSupportActionBar() instanceof ToolbarActionBar))) {
|
|
MenuBuilder menuBuilder = panelFeatureState.menu;
|
|
if (menuBuilder == null || panelFeatureState.refreshMenuContent) {
|
|
if (menuBuilder == null && (!initializePanelMenu(panelFeatureState) || panelFeatureState.menu == null)) {
|
|
return false;
|
|
}
|
|
if (z && this.mDecorContentParent != null) {
|
|
if (this.mActionMenuPresenterCallback == null) {
|
|
this.mActionMenuPresenterCallback = new ActionMenuPresenterCallback();
|
|
}
|
|
this.mDecorContentParent.setMenu(panelFeatureState.menu, this.mActionMenuPresenterCallback);
|
|
}
|
|
panelFeatureState.menu.stopDispatchingItemsChanged();
|
|
if (!windowCallback.onCreatePanelMenu(panelFeatureState.featureId, panelFeatureState.menu)) {
|
|
panelFeatureState.setMenu(null);
|
|
if (z && (decorContentParent = this.mDecorContentParent) != null) {
|
|
decorContentParent.setMenu(null, this.mActionMenuPresenterCallback);
|
|
}
|
|
return false;
|
|
}
|
|
panelFeatureState.refreshMenuContent = false;
|
|
}
|
|
panelFeatureState.menu.stopDispatchingItemsChanged();
|
|
Bundle bundle = panelFeatureState.frozenActionViewState;
|
|
if (bundle != null) {
|
|
panelFeatureState.menu.restoreActionViewStates(bundle);
|
|
panelFeatureState.frozenActionViewState = null;
|
|
}
|
|
if (!windowCallback.onPreparePanel(0, panelFeatureState.createdPanelView, panelFeatureState.menu)) {
|
|
if (z && (decorContentParent2 = this.mDecorContentParent) != null) {
|
|
decorContentParent2.setMenu(null, this.mActionMenuPresenterCallback);
|
|
}
|
|
panelFeatureState.menu.startDispatchingItemsChanged();
|
|
return false;
|
|
}
|
|
boolean z2 = KeyCharacterMap.load(keyEvent != null ? keyEvent.getDeviceId() : -1).getKeyboardType() != 1;
|
|
panelFeatureState.qwertyMode = z2;
|
|
panelFeatureState.menu.setQwertyMode(z2);
|
|
panelFeatureState.menu.startDispatchingItemsChanged();
|
|
}
|
|
panelFeatureState.isPrepared = true;
|
|
panelFeatureState.isHandled = false;
|
|
this.mPreparedPanel = panelFeatureState;
|
|
return true;
|
|
}
|
|
|
|
public void checkCloseActionMenu(@NonNull MenuBuilder menuBuilder) {
|
|
if (this.mClosingActionMenu) {
|
|
return;
|
|
}
|
|
this.mClosingActionMenu = true;
|
|
this.mDecorContentParent.dismissPopups();
|
|
Window.Callback windowCallback = getWindowCallback();
|
|
if (windowCallback != null && !this.mDestroyed) {
|
|
windowCallback.onPanelClosed(108, menuBuilder);
|
|
}
|
|
this.mClosingActionMenu = false;
|
|
}
|
|
|
|
public void closePanel(int i) {
|
|
closePanel(getPanelState(i, true), true);
|
|
}
|
|
|
|
public void closePanel(PanelFeatureState panelFeatureState, boolean z) {
|
|
ViewGroup viewGroup;
|
|
DecorContentParent decorContentParent;
|
|
if (z && panelFeatureState.featureId == 0 && (decorContentParent = this.mDecorContentParent) != null && decorContentParent.isOverflowMenuShowing()) {
|
|
checkCloseActionMenu(panelFeatureState.menu);
|
|
return;
|
|
}
|
|
WindowManager windowManager = (WindowManager) this.mContext.getSystemService("window");
|
|
if (windowManager != null && panelFeatureState.isOpen && (viewGroup = panelFeatureState.decorView) != null) {
|
|
windowManager.removeView(viewGroup);
|
|
if (z) {
|
|
callOnPanelClosed(panelFeatureState.featureId, panelFeatureState, null);
|
|
}
|
|
}
|
|
panelFeatureState.isPrepared = false;
|
|
panelFeatureState.isHandled = false;
|
|
panelFeatureState.isOpen = false;
|
|
panelFeatureState.shownPanelView = null;
|
|
panelFeatureState.refreshDecorView = true;
|
|
if (this.mPreparedPanel == panelFeatureState) {
|
|
this.mPreparedPanel = null;
|
|
}
|
|
if (panelFeatureState.featureId == 0) {
|
|
updateBackInvokedCallbackState();
|
|
}
|
|
}
|
|
|
|
private boolean onKeyDownPanel(int i, KeyEvent keyEvent) {
|
|
if (keyEvent.getRepeatCount() != 0) {
|
|
return false;
|
|
}
|
|
PanelFeatureState panelState = getPanelState(i, true);
|
|
if (panelState.isOpen) {
|
|
return false;
|
|
}
|
|
return preparePanel(panelState, keyEvent);
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:37:0x005a, code lost:
|
|
|
|
if (preparePanel(r2, r6) != false) goto L32;
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
private boolean onKeyUpPanel(int r5, android.view.KeyEvent r6) {
|
|
/*
|
|
r4 = this;
|
|
androidx.appcompat.view.ActionMode r0 = r4.mActionMode
|
|
r1 = 0
|
|
if (r0 == 0) goto L6
|
|
return r1
|
|
L6:
|
|
r0 = 1
|
|
androidx.appcompat.app.AppCompatDelegateImpl$PanelFeatureState r2 = r4.getPanelState(r5, r0)
|
|
if (r5 != 0) goto L43
|
|
androidx.appcompat.widget.DecorContentParent r5 = r4.mDecorContentParent
|
|
if (r5 == 0) goto L43
|
|
boolean r5 = r5.canShowOverflowMenu()
|
|
if (r5 == 0) goto L43
|
|
android.content.Context r5 = r4.mContext
|
|
android.view.ViewConfiguration r5 = android.view.ViewConfiguration.get(r5)
|
|
boolean r5 = r5.hasPermanentMenuKey()
|
|
if (r5 != 0) goto L43
|
|
androidx.appcompat.widget.DecorContentParent r5 = r4.mDecorContentParent
|
|
boolean r5 = r5.isOverflowMenuShowing()
|
|
if (r5 != 0) goto L3c
|
|
boolean r5 = r4.mDestroyed
|
|
if (r5 != 0) goto L60
|
|
boolean r5 = r4.preparePanel(r2, r6)
|
|
if (r5 == 0) goto L60
|
|
androidx.appcompat.widget.DecorContentParent r5 = r4.mDecorContentParent
|
|
boolean r0 = r5.showOverflowMenu()
|
|
goto L66
|
|
L3c:
|
|
androidx.appcompat.widget.DecorContentParent r5 = r4.mDecorContentParent
|
|
boolean r0 = r5.hideOverflowMenu()
|
|
goto L66
|
|
L43:
|
|
boolean r5 = r2.isOpen
|
|
if (r5 != 0) goto L62
|
|
boolean r3 = r2.isHandled
|
|
if (r3 == 0) goto L4c
|
|
goto L62
|
|
L4c:
|
|
boolean r5 = r2.isPrepared
|
|
if (r5 == 0) goto L60
|
|
boolean r5 = r2.refreshMenuContent
|
|
if (r5 == 0) goto L5c
|
|
r2.isPrepared = r1
|
|
boolean r5 = r4.preparePanel(r2, r6)
|
|
if (r5 == 0) goto L60
|
|
L5c:
|
|
r4.openPanel(r2, r6)
|
|
goto L66
|
|
L60:
|
|
r0 = r1
|
|
goto L66
|
|
L62:
|
|
r4.closePanel(r2, r0)
|
|
r0 = r5
|
|
L66:
|
|
if (r0 == 0) goto L83
|
|
android.content.Context r5 = r4.mContext
|
|
android.content.Context r5 = r5.getApplicationContext()
|
|
java.lang.String r6 = "audio"
|
|
java.lang.Object r5 = r5.getSystemService(r6)
|
|
android.media.AudioManager r5 = (android.media.AudioManager) r5
|
|
if (r5 == 0) goto L7c
|
|
r5.playSoundEffect(r1)
|
|
goto L83
|
|
L7c:
|
|
java.lang.String r5 = "AppCompatDelegate"
|
|
java.lang.String r6 = "Couldn't get audio manager"
|
|
android.util.Log.w(r5, r6)
|
|
L83:
|
|
return r0
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.app.AppCompatDelegateImpl.onKeyUpPanel(int, android.view.KeyEvent):boolean");
|
|
}
|
|
|
|
public void callOnPanelClosed(int i, PanelFeatureState panelFeatureState, Menu menu) {
|
|
if (menu == null) {
|
|
if (panelFeatureState == null && i >= 0) {
|
|
PanelFeatureState[] panelFeatureStateArr = this.mPanels;
|
|
if (i < panelFeatureStateArr.length) {
|
|
panelFeatureState = panelFeatureStateArr[i];
|
|
}
|
|
}
|
|
if (panelFeatureState != null) {
|
|
menu = panelFeatureState.menu;
|
|
}
|
|
}
|
|
if ((panelFeatureState == null || panelFeatureState.isOpen) && !this.mDestroyed) {
|
|
this.mAppCompatWindowCallback.bypassOnPanelClosed(this.mWindow.getCallback(), i, menu);
|
|
}
|
|
}
|
|
|
|
public PanelFeatureState findMenuPanel(Menu menu) {
|
|
PanelFeatureState[] panelFeatureStateArr = this.mPanels;
|
|
int length = panelFeatureStateArr != null ? panelFeatureStateArr.length : 0;
|
|
for (int i = 0; i < length; i++) {
|
|
PanelFeatureState panelFeatureState = panelFeatureStateArr[i];
|
|
if (panelFeatureState != null && panelFeatureState.menu == menu) {
|
|
return panelFeatureState;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public PanelFeatureState getPanelState(int i, boolean z) {
|
|
PanelFeatureState[] panelFeatureStateArr = this.mPanels;
|
|
if (panelFeatureStateArr == null || panelFeatureStateArr.length <= i) {
|
|
PanelFeatureState[] panelFeatureStateArr2 = new PanelFeatureState[i + 1];
|
|
if (panelFeatureStateArr != null) {
|
|
System.arraycopy(panelFeatureStateArr, 0, panelFeatureStateArr2, 0, panelFeatureStateArr.length);
|
|
}
|
|
this.mPanels = panelFeatureStateArr2;
|
|
panelFeatureStateArr = panelFeatureStateArr2;
|
|
}
|
|
PanelFeatureState panelFeatureState = panelFeatureStateArr[i];
|
|
if (panelFeatureState != null) {
|
|
return panelFeatureState;
|
|
}
|
|
PanelFeatureState panelFeatureState2 = new PanelFeatureState(i);
|
|
panelFeatureStateArr[i] = panelFeatureState2;
|
|
return panelFeatureState2;
|
|
}
|
|
|
|
private boolean performPanelShortcut(PanelFeatureState panelFeatureState, int i, KeyEvent keyEvent, int i2) {
|
|
MenuBuilder menuBuilder;
|
|
boolean z = false;
|
|
if (keyEvent.isSystem()) {
|
|
return false;
|
|
}
|
|
if ((panelFeatureState.isPrepared || preparePanel(panelFeatureState, keyEvent)) && (menuBuilder = panelFeatureState.menu) != null) {
|
|
z = menuBuilder.performShortcut(i, keyEvent, i2);
|
|
}
|
|
if (z && (i2 & 1) == 0 && this.mDecorContentParent == null) {
|
|
closePanel(panelFeatureState, true);
|
|
}
|
|
return z;
|
|
}
|
|
|
|
private void invalidatePanelMenu(int i) {
|
|
this.mInvalidatePanelMenuFeatures = (1 << i) | this.mInvalidatePanelMenuFeatures;
|
|
if (this.mInvalidatePanelMenuPosted) {
|
|
return;
|
|
}
|
|
ViewCompat.postOnAnimation(this.mWindow.getDecorView(), this.mInvalidatePanelMenuRunnable);
|
|
this.mInvalidatePanelMenuPosted = true;
|
|
}
|
|
|
|
public void doInvalidatePanelMenu(int i) {
|
|
PanelFeatureState panelState;
|
|
PanelFeatureState panelState2 = getPanelState(i, true);
|
|
if (panelState2.menu != null) {
|
|
Bundle bundle = new Bundle();
|
|
panelState2.menu.saveActionViewStates(bundle);
|
|
if (bundle.size() > 0) {
|
|
panelState2.frozenActionViewState = bundle;
|
|
}
|
|
panelState2.menu.stopDispatchingItemsChanged();
|
|
panelState2.menu.clear();
|
|
}
|
|
panelState2.refreshMenuContent = true;
|
|
panelState2.refreshDecorView = true;
|
|
if ((i != 108 && i != 0) || this.mDecorContentParent == null || (panelState = getPanelState(0, false)) == null) {
|
|
return;
|
|
}
|
|
panelState.isPrepared = false;
|
|
preparePanel(panelState, null);
|
|
}
|
|
|
|
public final int updateStatusGuard(@Nullable WindowInsetsCompat windowInsetsCompat, @Nullable Rect rect) {
|
|
int i;
|
|
boolean z;
|
|
boolean z2;
|
|
if (windowInsetsCompat != null) {
|
|
i = windowInsetsCompat.getSystemWindowInsetTop();
|
|
} else {
|
|
i = rect != null ? rect.top : 0;
|
|
}
|
|
ActionBarContextView actionBarContextView = this.mActionModeView;
|
|
if (actionBarContextView == null || !(actionBarContextView.getLayoutParams() instanceof ViewGroup.MarginLayoutParams)) {
|
|
z = false;
|
|
} else {
|
|
ViewGroup.MarginLayoutParams marginLayoutParams = (ViewGroup.MarginLayoutParams) this.mActionModeView.getLayoutParams();
|
|
if (this.mActionModeView.isShown()) {
|
|
if (this.mTempRect1 == null) {
|
|
this.mTempRect1 = new Rect();
|
|
this.mTempRect2 = new Rect();
|
|
}
|
|
Rect rect2 = this.mTempRect1;
|
|
Rect rect3 = this.mTempRect2;
|
|
if (windowInsetsCompat == null) {
|
|
rect2.set(rect);
|
|
} else {
|
|
rect2.set(windowInsetsCompat.getSystemWindowInsetLeft(), windowInsetsCompat.getSystemWindowInsetTop(), windowInsetsCompat.getSystemWindowInsetRight(), windowInsetsCompat.getSystemWindowInsetBottom());
|
|
}
|
|
ViewUtils.computeFitSystemWindows(this.mSubDecor, rect2, rect3);
|
|
int i2 = rect2.top;
|
|
int i3 = rect2.left;
|
|
int i4 = rect2.right;
|
|
WindowInsetsCompat rootWindowInsets = ViewCompat.getRootWindowInsets(this.mSubDecor);
|
|
int systemWindowInsetLeft = rootWindowInsets == null ? 0 : rootWindowInsets.getSystemWindowInsetLeft();
|
|
int systemWindowInsetRight = rootWindowInsets == null ? 0 : rootWindowInsets.getSystemWindowInsetRight();
|
|
if (marginLayoutParams.topMargin == i2 && marginLayoutParams.leftMargin == i3 && marginLayoutParams.rightMargin == i4) {
|
|
z2 = false;
|
|
} else {
|
|
marginLayoutParams.topMargin = i2;
|
|
marginLayoutParams.leftMargin = i3;
|
|
marginLayoutParams.rightMargin = i4;
|
|
z2 = true;
|
|
}
|
|
if (i2 <= 0 || this.mStatusGuard != null) {
|
|
View view = this.mStatusGuard;
|
|
if (view != null) {
|
|
ViewGroup.MarginLayoutParams marginLayoutParams2 = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
|
|
int i5 = marginLayoutParams2.height;
|
|
int i6 = marginLayoutParams.topMargin;
|
|
if (i5 != i6 || marginLayoutParams2.leftMargin != systemWindowInsetLeft || marginLayoutParams2.rightMargin != systemWindowInsetRight) {
|
|
marginLayoutParams2.height = i6;
|
|
marginLayoutParams2.leftMargin = systemWindowInsetLeft;
|
|
marginLayoutParams2.rightMargin = systemWindowInsetRight;
|
|
this.mStatusGuard.setLayoutParams(marginLayoutParams2);
|
|
}
|
|
}
|
|
} else {
|
|
View view2 = new View(this.mContext);
|
|
this.mStatusGuard = view2;
|
|
view2.setVisibility(8);
|
|
FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(-1, marginLayoutParams.topMargin, 51);
|
|
layoutParams.leftMargin = systemWindowInsetLeft;
|
|
layoutParams.rightMargin = systemWindowInsetRight;
|
|
this.mSubDecor.addView(this.mStatusGuard, -1, layoutParams);
|
|
}
|
|
View view3 = this.mStatusGuard;
|
|
r5 = view3 != null;
|
|
if (r5 && view3.getVisibility() != 0) {
|
|
updateStatusGuardColor(this.mStatusGuard);
|
|
}
|
|
if (!this.mOverlayActionMode && r5) {
|
|
i = 0;
|
|
}
|
|
z = r5;
|
|
r5 = z2;
|
|
} else if (marginLayoutParams.topMargin != 0) {
|
|
marginLayoutParams.topMargin = 0;
|
|
z = false;
|
|
} else {
|
|
z = false;
|
|
r5 = false;
|
|
}
|
|
if (r5) {
|
|
this.mActionModeView.setLayoutParams(marginLayoutParams);
|
|
}
|
|
}
|
|
View view4 = this.mStatusGuard;
|
|
if (view4 != null) {
|
|
view4.setVisibility(z ? 0 : 8);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
private void updateStatusGuardColor(View view) {
|
|
int color;
|
|
if ((ViewCompat.getWindowSystemUiVisibility(view) & 8192) != 0) {
|
|
color = ContextCompat.getColor(this.mContext, androidx.appcompat.R.color.abc_decor_view_status_guard_light);
|
|
} else {
|
|
color = ContextCompat.getColor(this.mContext, androidx.appcompat.R.color.abc_decor_view_status_guard);
|
|
}
|
|
view.setBackgroundColor(color);
|
|
}
|
|
|
|
private void throwFeatureRequestIfSubDecorInstalled() {
|
|
if (this.mSubDecorInstalled) {
|
|
throw new AndroidRuntimeException("Window feature must be requested before adding content");
|
|
}
|
|
}
|
|
|
|
public void dismissPopups() {
|
|
MenuBuilder menuBuilder;
|
|
DecorContentParent decorContentParent = this.mDecorContentParent;
|
|
if (decorContentParent != null) {
|
|
decorContentParent.dismissPopups();
|
|
}
|
|
if (this.mActionModePopup != null) {
|
|
this.mWindow.getDecorView().removeCallbacks(this.mShowActionModePopup);
|
|
if (this.mActionModePopup.isShowing()) {
|
|
try {
|
|
this.mActionModePopup.dismiss();
|
|
} catch (IllegalArgumentException unused) {
|
|
}
|
|
}
|
|
this.mActionModePopup = null;
|
|
}
|
|
endOnGoingFadeAnimation();
|
|
PanelFeatureState panelState = getPanelState(0, false);
|
|
if (panelState == null || (menuBuilder = panelState.menu) == null) {
|
|
return;
|
|
}
|
|
menuBuilder.close();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public boolean applyDayNight() {
|
|
return applyApplicationSpecificConfig(true);
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public boolean applyAppLocales() {
|
|
if (AppCompatDelegate.isAutoStorageOptedIn(this.mContext) && AppCompatDelegate.getRequestedAppLocales() != null && !AppCompatDelegate.getRequestedAppLocales().equals(AppCompatDelegate.getStoredAppLocales())) {
|
|
asyncExecuteSyncRequestedAndStoredLocales(this.mContext);
|
|
}
|
|
return applyApplicationSpecificConfig(true);
|
|
}
|
|
|
|
private boolean applyApplicationSpecificConfig(boolean z) {
|
|
return applyApplicationSpecificConfig(z, true);
|
|
}
|
|
|
|
private boolean applyApplicationSpecificConfig(boolean z, boolean z2) {
|
|
if (this.mDestroyed) {
|
|
return false;
|
|
}
|
|
int calculateNightMode = calculateNightMode();
|
|
int mapNightMode = mapNightMode(this.mContext, calculateNightMode);
|
|
LocaleListCompat calculateApplicationLocales = Build.VERSION.SDK_INT < 33 ? calculateApplicationLocales(this.mContext) : null;
|
|
if (!z2 && calculateApplicationLocales != null) {
|
|
calculateApplicationLocales = getConfigurationLocales(this.mContext.getResources().getConfiguration());
|
|
}
|
|
boolean updateAppConfiguration = updateAppConfiguration(mapNightMode, calculateApplicationLocales, z);
|
|
if (calculateNightMode == 0) {
|
|
getAutoTimeNightModeManager(this.mContext).setup();
|
|
} else {
|
|
AutoNightModeManager autoNightModeManager = this.mAutoTimeNightModeManager;
|
|
if (autoNightModeManager != null) {
|
|
autoNightModeManager.cleanup();
|
|
}
|
|
}
|
|
if (calculateNightMode == 3) {
|
|
getAutoBatteryNightModeManager(this.mContext).setup();
|
|
} else {
|
|
AutoNightModeManager autoNightModeManager2 = this.mAutoBatteryNightModeManager;
|
|
if (autoNightModeManager2 != null) {
|
|
autoNightModeManager2.cleanup();
|
|
}
|
|
}
|
|
return updateAppConfiguration;
|
|
}
|
|
|
|
@Nullable
|
|
public LocaleListCompat calculateApplicationLocales(@NonNull Context context) {
|
|
LocaleListCompat requestedAppLocales;
|
|
if (Build.VERSION.SDK_INT >= 33 || (requestedAppLocales = AppCompatDelegate.getRequestedAppLocales()) == null) {
|
|
return null;
|
|
}
|
|
LocaleListCompat configurationLocales = getConfigurationLocales(context.getApplicationContext().getResources().getConfiguration());
|
|
LocaleListCompat combineLocalesIfOverlayExists = LocaleOverlayHelper.combineLocalesIfOverlayExists(requestedAppLocales, configurationLocales);
|
|
return combineLocalesIfOverlayExists.isEmpty() ? configurationLocales : combineLocalesIfOverlayExists;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public void setLocalNightMode(int i) {
|
|
if (this.mLocalNightMode != i) {
|
|
this.mLocalNightMode = i;
|
|
if (this.mBaseContextAttached) {
|
|
applyDayNight();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int mapNightMode(@NonNull Context context, int i) {
|
|
if (i == -100) {
|
|
return -1;
|
|
}
|
|
if (i != -1) {
|
|
if (i == 0) {
|
|
if (((UiModeManager) context.getApplicationContext().getSystemService("uimode")).getNightMode() == 0) {
|
|
return -1;
|
|
}
|
|
return getAutoTimeNightModeManager(context).getApplyableNightMode();
|
|
}
|
|
if (i != 1 && i != 2) {
|
|
if (i == 3) {
|
|
return getAutoBatteryNightModeManager(context).getApplyableNightMode();
|
|
}
|
|
throw new IllegalStateException("Unknown value set for night mode. Please use one of the MODE_NIGHT values from AppCompatDelegate.");
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
private int calculateNightMode() {
|
|
int i = this.mLocalNightMode;
|
|
return i != -100 ? i : AppCompatDelegate.getDefaultNightMode();
|
|
}
|
|
|
|
public void setConfigurationLocales(Configuration configuration, @NonNull LocaleListCompat localeListCompat) {
|
|
Api24Impl.setLocales(configuration, localeListCompat);
|
|
}
|
|
|
|
public LocaleListCompat getConfigurationLocales(Configuration configuration) {
|
|
return Api24Impl.getLocales(configuration);
|
|
}
|
|
|
|
public void setDefaultLocalesForLocaleList(LocaleListCompat localeListCompat) {
|
|
Api24Impl.setDefaultLocales(localeListCompat);
|
|
}
|
|
|
|
@NonNull
|
|
private Configuration createOverrideAppConfiguration(@NonNull Context context, int i, @Nullable LocaleListCompat localeListCompat, @Nullable Configuration configuration, boolean z) {
|
|
int i2;
|
|
if (i == 1) {
|
|
i2 = 16;
|
|
} else if (i != 2) {
|
|
i2 = z ? 0 : context.getApplicationContext().getResources().getConfiguration().uiMode & 48;
|
|
} else {
|
|
i2 = 32;
|
|
}
|
|
Configuration configuration2 = new Configuration();
|
|
configuration2.fontScale = 0.0f;
|
|
if (configuration != null) {
|
|
configuration2.setTo(configuration);
|
|
}
|
|
configuration2.uiMode = i2 | (configuration2.uiMode & (-49));
|
|
if (localeListCompat != null) {
|
|
setConfigurationLocales(configuration2, localeListCompat);
|
|
}
|
|
return configuration2;
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:40:0x009d */
|
|
/* JADX WARN: Removed duplicated region for block: B:49:0x00b9 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
private boolean updateAppConfiguration(int r10, @androidx.annotation.Nullable androidx.core.os.LocaleListCompat r11, boolean r12) {
|
|
/*
|
|
r9 = this;
|
|
android.content.Context r1 = r9.mContext
|
|
r4 = 0
|
|
r5 = 0
|
|
r0 = r9
|
|
r2 = r10
|
|
r3 = r11
|
|
android.content.res.Configuration r0 = r0.createOverrideAppConfiguration(r1, r2, r3, r4, r5)
|
|
android.content.Context r1 = r9.mContext
|
|
int r1 = r9.getActivityHandlesConfigChangesFlags(r1)
|
|
android.content.res.Configuration r2 = r9.mEffectiveConfiguration
|
|
if (r2 != 0) goto L1f
|
|
android.content.Context r2 = r9.mContext
|
|
android.content.res.Resources r2 = r2.getResources()
|
|
android.content.res.Configuration r2 = r2.getConfiguration()
|
|
L1f:
|
|
int r3 = r2.uiMode
|
|
r3 = r3 & 48
|
|
int r4 = r0.uiMode
|
|
r4 = r4 & 48
|
|
androidx.core.os.LocaleListCompat r2 = r9.getConfigurationLocales(r2)
|
|
r5 = 0
|
|
if (r11 != 0) goto L30
|
|
r6 = r5
|
|
goto L34
|
|
L30:
|
|
androidx.core.os.LocaleListCompat r6 = r9.getConfigurationLocales(r0)
|
|
L34:
|
|
r7 = 0
|
|
if (r3 == r4) goto L3a
|
|
r3 = 512(0x200, float:7.17E-43)
|
|
goto L3b
|
|
L3a:
|
|
r3 = r7
|
|
L3b:
|
|
if (r6 == 0) goto L45
|
|
boolean r2 = r2.equals(r6)
|
|
if (r2 != 0) goto L45
|
|
r3 = r3 | 8196(0x2004, float:1.1485E-41)
|
|
L45:
|
|
int r2 = ~r1
|
|
r2 = r2 & r3
|
|
r8 = 1
|
|
if (r2 == 0) goto L8c
|
|
if (r12 == 0) goto L8c
|
|
boolean r12 = r9.mBaseContextAttached
|
|
if (r12 == 0) goto L8c
|
|
boolean r12 = androidx.appcompat.app.AppCompatDelegateImpl.sCanReturnDifferentContext
|
|
if (r12 != 0) goto L58
|
|
boolean r12 = r9.mCreated
|
|
if (r12 == 0) goto L8c
|
|
L58:
|
|
java.lang.Object r12 = r9.mHost
|
|
boolean r2 = r12 instanceof android.app.Activity
|
|
if (r2 == 0) goto L8c
|
|
android.app.Activity r12 = (android.app.Activity) r12
|
|
boolean r12 = r12.isChild()
|
|
if (r12 != 0) goto L8c
|
|
int r12 = android.os.Build.VERSION.SDK_INT
|
|
r2 = 31
|
|
if (r12 < r2) goto L83
|
|
r12 = r3 & 8192(0x2000, float:1.148E-41)
|
|
if (r12 == 0) goto L83
|
|
java.lang.Object r12 = r9.mHost
|
|
android.app.Activity r12 = (android.app.Activity) r12
|
|
android.view.Window r12 = r12.getWindow()
|
|
android.view.View r12 = r12.getDecorView()
|
|
int r0 = r0.getLayoutDirection()
|
|
r12.setLayoutDirection(r0)
|
|
L83:
|
|
java.lang.Object r12 = r9.mHost
|
|
android.app.Activity r12 = (android.app.Activity) r12
|
|
androidx.core.app.ActivityCompat.recreate(r12)
|
|
r12 = r8
|
|
goto L8d
|
|
L8c:
|
|
r12 = r7
|
|
L8d:
|
|
if (r12 != 0) goto L9a
|
|
if (r3 == 0) goto L9a
|
|
r12 = r3 & r1
|
|
if (r12 != r3) goto L96
|
|
r7 = r8
|
|
L96:
|
|
r9.updateResourcesConfiguration(r4, r6, r7, r5)
|
|
goto L9b
|
|
L9a:
|
|
r8 = r12
|
|
L9b:
|
|
if (r8 == 0) goto Lb7
|
|
java.lang.Object r12 = r9.mHost
|
|
boolean r0 = r12 instanceof androidx.appcompat.app.AppCompatActivity
|
|
if (r0 == 0) goto Lb7
|
|
r0 = r3 & 512(0x200, float:7.17E-43)
|
|
if (r0 == 0) goto Lac
|
|
androidx.appcompat.app.AppCompatActivity r12 = (androidx.appcompat.app.AppCompatActivity) r12
|
|
r12.onNightModeChanged(r10)
|
|
Lac:
|
|
r10 = r3 & 4
|
|
if (r10 == 0) goto Lb7
|
|
java.lang.Object r10 = r9.mHost
|
|
androidx.appcompat.app.AppCompatActivity r10 = (androidx.appcompat.app.AppCompatActivity) r10
|
|
r10.onLocalesChanged(r11)
|
|
Lb7:
|
|
if (r6 == 0) goto Lca
|
|
android.content.Context r10 = r9.mContext
|
|
android.content.res.Resources r10 = r10.getResources()
|
|
android.content.res.Configuration r10 = r10.getConfiguration()
|
|
androidx.core.os.LocaleListCompat r10 = r9.getConfigurationLocales(r10)
|
|
r9.setDefaultLocalesForLocaleList(r10)
|
|
Lca:
|
|
return r8
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.app.AppCompatDelegateImpl.updateAppConfiguration(int, androidx.core.os.LocaleListCompat, boolean):boolean");
|
|
}
|
|
|
|
private void updateResourcesConfiguration(int i, @Nullable LocaleListCompat localeListCompat, boolean z, @Nullable Configuration configuration) {
|
|
Resources resources = this.mContext.getResources();
|
|
Configuration configuration2 = new Configuration(resources.getConfiguration());
|
|
if (configuration != null) {
|
|
configuration2.updateFrom(configuration);
|
|
}
|
|
configuration2.uiMode = i | (resources.getConfiguration().uiMode & (-49));
|
|
if (localeListCompat != null) {
|
|
setConfigurationLocales(configuration2, localeListCompat);
|
|
}
|
|
resources.updateConfiguration(configuration2, null);
|
|
int i2 = this.mThemeResId;
|
|
if (i2 != 0) {
|
|
this.mContext.setTheme(i2);
|
|
this.mContext.getTheme().applyStyle(this.mThemeResId, true);
|
|
}
|
|
if (z && (this.mHost instanceof Activity)) {
|
|
updateActivityConfiguration(configuration2);
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
private void updateActivityConfiguration(Configuration configuration) {
|
|
Activity activity = (Activity) this.mHost;
|
|
if (activity instanceof LifecycleOwner) {
|
|
if (((LifecycleOwner) activity).getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.CREATED)) {
|
|
activity.onConfigurationChanged(configuration);
|
|
}
|
|
} else {
|
|
if (!this.mCreated || this.mDestroyed) {
|
|
return;
|
|
}
|
|
activity.onConfigurationChanged(configuration);
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
@VisibleForTesting
|
|
public final AutoNightModeManager getAutoTimeNightModeManager() {
|
|
return getAutoTimeNightModeManager(this.mContext);
|
|
}
|
|
|
|
private AutoNightModeManager getAutoTimeNightModeManager(@NonNull Context context) {
|
|
if (this.mAutoTimeNightModeManager == null) {
|
|
this.mAutoTimeNightModeManager = new AutoTimeNightModeManager(TwilightManager.getInstance(context));
|
|
}
|
|
return this.mAutoTimeNightModeManager;
|
|
}
|
|
|
|
private AutoNightModeManager getAutoBatteryNightModeManager(@NonNull Context context) {
|
|
if (this.mAutoBatteryNightModeManager == null) {
|
|
this.mAutoBatteryNightModeManager = new AutoBatteryNightModeManager(context);
|
|
}
|
|
return this.mAutoBatteryNightModeManager;
|
|
}
|
|
|
|
private int getActivityHandlesConfigChangesFlags(Context context) {
|
|
if (!this.mActivityHandlesConfigFlagsChecked && (this.mHost instanceof Activity)) {
|
|
PackageManager packageManager = context.getPackageManager();
|
|
if (packageManager == null) {
|
|
return 0;
|
|
}
|
|
try {
|
|
ActivityInfo activityInfo = packageManager.getActivityInfo(new ComponentName(context, this.mHost.getClass()), Build.VERSION.SDK_INT >= 29 ? 269221888 : 786432);
|
|
if (activityInfo != null) {
|
|
this.mActivityHandlesConfigFlags = activityInfo.configChanges;
|
|
}
|
|
} catch (PackageManager.NameNotFoundException unused) {
|
|
this.mActivityHandlesConfigFlags = 0;
|
|
}
|
|
}
|
|
this.mActivityHandlesConfigFlagsChecked = true;
|
|
return this.mActivityHandlesConfigFlags;
|
|
}
|
|
|
|
public class ActionModeCallbackWrapperV9 implements ActionMode.Callback {
|
|
private ActionMode.Callback mWrapped;
|
|
|
|
public ActionModeCallbackWrapperV9(ActionMode.Callback callback) {
|
|
this.mWrapped = callback;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.ActionMode.Callback
|
|
public boolean onCreateActionMode(ActionMode actionMode, Menu menu) {
|
|
return this.mWrapped.onCreateActionMode(actionMode, menu);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.ActionMode.Callback
|
|
public boolean onPrepareActionMode(ActionMode actionMode, Menu menu) {
|
|
ViewCompat.requestApplyInsets(AppCompatDelegateImpl.this.mSubDecor);
|
|
return this.mWrapped.onPrepareActionMode(actionMode, menu);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.ActionMode.Callback
|
|
public boolean onActionItemClicked(ActionMode actionMode, MenuItem menuItem) {
|
|
return this.mWrapped.onActionItemClicked(actionMode, menuItem);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.ActionMode.Callback
|
|
public void onDestroyActionMode(ActionMode actionMode) {
|
|
this.mWrapped.onDestroyActionMode(actionMode);
|
|
AppCompatDelegateImpl appCompatDelegateImpl = AppCompatDelegateImpl.this;
|
|
if (appCompatDelegateImpl.mActionModePopup != null) {
|
|
appCompatDelegateImpl.mWindow.getDecorView().removeCallbacks(AppCompatDelegateImpl.this.mShowActionModePopup);
|
|
}
|
|
AppCompatDelegateImpl appCompatDelegateImpl2 = AppCompatDelegateImpl.this;
|
|
if (appCompatDelegateImpl2.mActionModeView != null) {
|
|
appCompatDelegateImpl2.endOnGoingFadeAnimation();
|
|
AppCompatDelegateImpl appCompatDelegateImpl3 = AppCompatDelegateImpl.this;
|
|
appCompatDelegateImpl3.mFadeAnim = ViewCompat.animate(appCompatDelegateImpl3.mActionModeView).alpha(0.0f);
|
|
AppCompatDelegateImpl.this.mFadeAnim.setListener(new ViewPropertyAnimatorListenerAdapter() { // from class: androidx.appcompat.app.AppCompatDelegateImpl.ActionModeCallbackWrapperV9.1
|
|
@Override // androidx.core.view.ViewPropertyAnimatorListenerAdapter, androidx.core.view.ViewPropertyAnimatorListener
|
|
public void onAnimationEnd(View view) {
|
|
AppCompatDelegateImpl.this.mActionModeView.setVisibility(8);
|
|
AppCompatDelegateImpl appCompatDelegateImpl4 = AppCompatDelegateImpl.this;
|
|
PopupWindow popupWindow = appCompatDelegateImpl4.mActionModePopup;
|
|
if (popupWindow != null) {
|
|
popupWindow.dismiss();
|
|
} else if (appCompatDelegateImpl4.mActionModeView.getParent() instanceof View) {
|
|
ViewCompat.requestApplyInsets((View) AppCompatDelegateImpl.this.mActionModeView.getParent());
|
|
}
|
|
AppCompatDelegateImpl.this.mActionModeView.killMode();
|
|
AppCompatDelegateImpl.this.mFadeAnim.setListener(null);
|
|
AppCompatDelegateImpl appCompatDelegateImpl5 = AppCompatDelegateImpl.this;
|
|
appCompatDelegateImpl5.mFadeAnim = null;
|
|
ViewCompat.requestApplyInsets(appCompatDelegateImpl5.mSubDecor);
|
|
}
|
|
});
|
|
}
|
|
AppCompatDelegateImpl appCompatDelegateImpl4 = AppCompatDelegateImpl.this;
|
|
AppCompatCallback appCompatCallback = appCompatDelegateImpl4.mAppCompatCallback;
|
|
if (appCompatCallback != null) {
|
|
appCompatCallback.onSupportActionModeFinished(appCompatDelegateImpl4.mActionMode);
|
|
}
|
|
AppCompatDelegateImpl appCompatDelegateImpl5 = AppCompatDelegateImpl.this;
|
|
appCompatDelegateImpl5.mActionMode = null;
|
|
ViewCompat.requestApplyInsets(appCompatDelegateImpl5.mSubDecor);
|
|
AppCompatDelegateImpl.this.updateBackInvokedCallbackState();
|
|
}
|
|
}
|
|
|
|
public final class PanelMenuPresenterCallback implements MenuPresenter.Callback {
|
|
public PanelMenuPresenterCallback() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuPresenter.Callback
|
|
public void onCloseMenu(@NonNull MenuBuilder menuBuilder, boolean z) {
|
|
MenuBuilder rootMenu = menuBuilder.getRootMenu();
|
|
boolean z2 = rootMenu != menuBuilder;
|
|
AppCompatDelegateImpl appCompatDelegateImpl = AppCompatDelegateImpl.this;
|
|
if (z2) {
|
|
menuBuilder = rootMenu;
|
|
}
|
|
PanelFeatureState findMenuPanel = appCompatDelegateImpl.findMenuPanel(menuBuilder);
|
|
if (findMenuPanel != null) {
|
|
if (z2) {
|
|
AppCompatDelegateImpl.this.callOnPanelClosed(findMenuPanel.featureId, findMenuPanel, rootMenu);
|
|
AppCompatDelegateImpl.this.closePanel(findMenuPanel, true);
|
|
} else {
|
|
AppCompatDelegateImpl.this.closePanel(findMenuPanel, z);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuPresenter.Callback
|
|
public boolean onOpenSubMenu(@NonNull MenuBuilder menuBuilder) {
|
|
Window.Callback windowCallback;
|
|
if (menuBuilder != menuBuilder.getRootMenu()) {
|
|
return true;
|
|
}
|
|
AppCompatDelegateImpl appCompatDelegateImpl = AppCompatDelegateImpl.this;
|
|
if (!appCompatDelegateImpl.mHasActionBar || (windowCallback = appCompatDelegateImpl.getWindowCallback()) == null || AppCompatDelegateImpl.this.mDestroyed) {
|
|
return true;
|
|
}
|
|
windowCallback.onMenuOpened(108, menuBuilder);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public final class ActionMenuPresenterCallback implements MenuPresenter.Callback {
|
|
public ActionMenuPresenterCallback() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuPresenter.Callback
|
|
public boolean onOpenSubMenu(@NonNull MenuBuilder menuBuilder) {
|
|
Window.Callback windowCallback = AppCompatDelegateImpl.this.getWindowCallback();
|
|
if (windowCallback == null) {
|
|
return true;
|
|
}
|
|
windowCallback.onMenuOpened(108, menuBuilder);
|
|
return true;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.menu.MenuPresenter.Callback
|
|
public void onCloseMenu(@NonNull MenuBuilder menuBuilder, boolean z) {
|
|
AppCompatDelegateImpl.this.checkCloseActionMenu(menuBuilder);
|
|
}
|
|
}
|
|
|
|
public static final class PanelFeatureState {
|
|
int background;
|
|
View createdPanelView;
|
|
ViewGroup decorView;
|
|
int featureId;
|
|
Bundle frozenActionViewState;
|
|
Bundle frozenMenuState;
|
|
int gravity;
|
|
boolean isHandled;
|
|
boolean isOpen;
|
|
boolean isPrepared;
|
|
ListMenuPresenter listMenuPresenter;
|
|
Context listPresenterContext;
|
|
MenuBuilder menu;
|
|
public boolean qwertyMode;
|
|
boolean refreshDecorView = false;
|
|
boolean refreshMenuContent;
|
|
View shownPanelView;
|
|
boolean wasLastOpen;
|
|
int windowAnimations;
|
|
int x;
|
|
int y;
|
|
|
|
public PanelFeatureState(int i) {
|
|
this.featureId = i;
|
|
}
|
|
|
|
public boolean hasPanelItems() {
|
|
if (this.shownPanelView == null) {
|
|
return false;
|
|
}
|
|
return this.createdPanelView != null || this.listMenuPresenter.getAdapter().getCount() > 0;
|
|
}
|
|
|
|
public void clearMenuPresenters() {
|
|
MenuBuilder menuBuilder = this.menu;
|
|
if (menuBuilder != null) {
|
|
menuBuilder.removeMenuPresenter(this.listMenuPresenter);
|
|
}
|
|
this.listMenuPresenter = null;
|
|
}
|
|
|
|
public void setStyle(Context context) {
|
|
TypedValue typedValue = new TypedValue();
|
|
Resources.Theme newTheme = context.getResources().newTheme();
|
|
newTheme.setTo(context.getTheme());
|
|
newTheme.resolveAttribute(androidx.appcompat.R.attr.actionBarPopupTheme, typedValue, true);
|
|
int i = typedValue.resourceId;
|
|
if (i != 0) {
|
|
newTheme.applyStyle(i, true);
|
|
}
|
|
newTheme.resolveAttribute(androidx.appcompat.R.attr.panelMenuListTheme, typedValue, true);
|
|
int i2 = typedValue.resourceId;
|
|
if (i2 != 0) {
|
|
newTheme.applyStyle(i2, true);
|
|
} else {
|
|
newTheme.applyStyle(androidx.appcompat.R.style.Theme_AppCompat_CompactMenu, true);
|
|
}
|
|
androidx.appcompat.view.ContextThemeWrapper contextThemeWrapper = new androidx.appcompat.view.ContextThemeWrapper(context, 0);
|
|
contextThemeWrapper.getTheme().setTo(newTheme);
|
|
this.listPresenterContext = contextThemeWrapper;
|
|
TypedArray obtainStyledAttributes = contextThemeWrapper.obtainStyledAttributes(androidx.appcompat.R.styleable.AppCompatTheme);
|
|
this.background = obtainStyledAttributes.getResourceId(androidx.appcompat.R.styleable.AppCompatTheme_panelBackground, 0);
|
|
this.windowAnimations = obtainStyledAttributes.getResourceId(androidx.appcompat.R.styleable.AppCompatTheme_android_windowAnimationStyle, 0);
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
public void setMenu(MenuBuilder menuBuilder) {
|
|
ListMenuPresenter listMenuPresenter;
|
|
MenuBuilder menuBuilder2 = this.menu;
|
|
if (menuBuilder == menuBuilder2) {
|
|
return;
|
|
}
|
|
if (menuBuilder2 != null) {
|
|
menuBuilder2.removeMenuPresenter(this.listMenuPresenter);
|
|
}
|
|
this.menu = menuBuilder;
|
|
if (menuBuilder == null || (listMenuPresenter = this.listMenuPresenter) == null) {
|
|
return;
|
|
}
|
|
menuBuilder.addMenuPresenter(listMenuPresenter);
|
|
}
|
|
|
|
public MenuView getListMenuView(MenuPresenter.Callback callback) {
|
|
if (this.menu == null) {
|
|
return null;
|
|
}
|
|
if (this.listMenuPresenter == null) {
|
|
ListMenuPresenter listMenuPresenter = new ListMenuPresenter(this.listPresenterContext, androidx.appcompat.R.layout.abc_list_menu_item_layout);
|
|
this.listMenuPresenter = listMenuPresenter;
|
|
listMenuPresenter.setCallback(callback);
|
|
this.menu.addMenuPresenter(this.listMenuPresenter);
|
|
}
|
|
return this.listMenuPresenter.getMenuView(this.decorView);
|
|
}
|
|
|
|
public Parcelable onSaveInstanceState() {
|
|
SavedState savedState = new SavedState();
|
|
savedState.featureId = this.featureId;
|
|
savedState.isOpen = this.isOpen;
|
|
if (this.menu != null) {
|
|
Bundle bundle = new Bundle();
|
|
savedState.menuState = bundle;
|
|
this.menu.savePresenterStates(bundle);
|
|
}
|
|
return savedState;
|
|
}
|
|
|
|
public void onRestoreInstanceState(Parcelable parcelable) {
|
|
SavedState savedState = (SavedState) parcelable;
|
|
this.featureId = savedState.featureId;
|
|
this.wasLastOpen = savedState.isOpen;
|
|
this.frozenMenuState = savedState.menuState;
|
|
this.shownPanelView = null;
|
|
this.decorView = null;
|
|
}
|
|
|
|
public void applyFrozenState() {
|
|
Bundle bundle;
|
|
MenuBuilder menuBuilder = this.menu;
|
|
if (menuBuilder == null || (bundle = this.frozenMenuState) == null) {
|
|
return;
|
|
}
|
|
menuBuilder.restorePresenterStates(bundle);
|
|
this.frozenMenuState = null;
|
|
}
|
|
|
|
@SuppressLint({"BanParcelableUsage"})
|
|
public static class SavedState implements Parcelable {
|
|
public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.ClassLoaderCreator<SavedState>() { // from class: androidx.appcompat.app.AppCompatDelegateImpl.PanelFeatureState.SavedState.1
|
|
/* JADX WARN: Can't rename method to resolve collision */
|
|
@Override // android.os.Parcelable.ClassLoaderCreator
|
|
public SavedState createFromParcel(Parcel parcel, ClassLoader classLoader) {
|
|
return SavedState.readFromParcel(parcel, classLoader);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.Creator
|
|
public SavedState createFromParcel(Parcel parcel) {
|
|
return SavedState.readFromParcel(parcel, null);
|
|
}
|
|
|
|
@Override // android.os.Parcelable.Creator
|
|
public SavedState[] newArray(int i) {
|
|
return new SavedState[i];
|
|
}
|
|
};
|
|
int featureId;
|
|
boolean isOpen;
|
|
Bundle menuState;
|
|
|
|
@Override // android.os.Parcelable
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override // android.os.Parcelable
|
|
public void writeToParcel(Parcel parcel, int i) {
|
|
parcel.writeInt(this.featureId);
|
|
parcel.writeInt(this.isOpen ? 1 : 0);
|
|
if (this.isOpen) {
|
|
parcel.writeBundle(this.menuState);
|
|
}
|
|
}
|
|
|
|
public static SavedState readFromParcel(Parcel parcel, ClassLoader classLoader) {
|
|
SavedState savedState = new SavedState();
|
|
savedState.featureId = parcel.readInt();
|
|
boolean z = parcel.readInt() == 1;
|
|
savedState.isOpen = z;
|
|
if (z) {
|
|
savedState.menuState = parcel.readBundle(classLoader);
|
|
}
|
|
return savedState;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ListMenuDecorView extends ContentFrameLayout {
|
|
public ListMenuDecorView(Context context) {
|
|
super(context);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public boolean dispatchKeyEvent(KeyEvent keyEvent) {
|
|
return AppCompatDelegateImpl.this.dispatchKeyEvent(keyEvent) || super.dispatchKeyEvent(keyEvent);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean onInterceptTouchEvent(MotionEvent motionEvent) {
|
|
if (motionEvent.getAction() == 0 && isOutOfBounds((int) motionEvent.getX(), (int) motionEvent.getY())) {
|
|
AppCompatDelegateImpl.this.closePanel(0);
|
|
return true;
|
|
}
|
|
return super.onInterceptTouchEvent(motionEvent);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void setBackgroundResource(int i) {
|
|
setBackgroundDrawable(AppCompatResources.getDrawable(getContext(), i));
|
|
}
|
|
|
|
private boolean isOutOfBounds(int i, int i2) {
|
|
return i < -5 || i2 < -5 || i > getWidth() + 5 || i2 > getHeight() + 5;
|
|
}
|
|
}
|
|
|
|
public class AppCompatWindowCallback extends WindowCallbackWrapper {
|
|
private ActionBarMenuCallback mActionBarCallback;
|
|
private boolean mDispatchKeyEventBypassEnabled;
|
|
private boolean mOnContentChangedBypassEnabled;
|
|
private boolean mOnPanelClosedBypassEnabled;
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public android.view.ActionMode onWindowStartingActionMode(ActionMode.Callback callback) {
|
|
return null;
|
|
}
|
|
|
|
public void setActionBarCallback(@Nullable ActionBarMenuCallback actionBarMenuCallback) {
|
|
this.mActionBarCallback = actionBarMenuCallback;
|
|
}
|
|
|
|
public AppCompatWindowCallback(Window.Callback callback) {
|
|
super(callback);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public boolean dispatchKeyEvent(KeyEvent keyEvent) {
|
|
if (this.mDispatchKeyEventBypassEnabled) {
|
|
return getWrapped().dispatchKeyEvent(keyEvent);
|
|
}
|
|
return AppCompatDelegateImpl.this.dispatchKeyEvent(keyEvent) || super.dispatchKeyEvent(keyEvent);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public boolean dispatchKeyShortcutEvent(KeyEvent keyEvent) {
|
|
return super.dispatchKeyShortcutEvent(keyEvent) || AppCompatDelegateImpl.this.onKeyShortcut(keyEvent.getKeyCode(), keyEvent);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public boolean onCreatePanelMenu(int i, Menu menu) {
|
|
if (i != 0 || (menu instanceof MenuBuilder)) {
|
|
return super.onCreatePanelMenu(i, menu);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public View onCreatePanelView(int i) {
|
|
View onCreatePanelView;
|
|
ActionBarMenuCallback actionBarMenuCallback = this.mActionBarCallback;
|
|
return (actionBarMenuCallback == null || (onCreatePanelView = actionBarMenuCallback.onCreatePanelView(i)) == null) ? super.onCreatePanelView(i) : onCreatePanelView;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public void onContentChanged() {
|
|
if (this.mOnContentChangedBypassEnabled) {
|
|
getWrapped().onContentChanged();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public boolean onPreparePanel(int i, View view, Menu menu) {
|
|
MenuBuilder menuBuilder = menu instanceof MenuBuilder ? (MenuBuilder) menu : null;
|
|
if (i == 0 && menuBuilder == null) {
|
|
return false;
|
|
}
|
|
if (menuBuilder != null) {
|
|
menuBuilder.setOverrideVisibleItems(true);
|
|
}
|
|
ActionBarMenuCallback actionBarMenuCallback = this.mActionBarCallback;
|
|
boolean z = actionBarMenuCallback != null && actionBarMenuCallback.onPreparePanel(i);
|
|
if (!z) {
|
|
z = super.onPreparePanel(i, view, menu);
|
|
}
|
|
if (menuBuilder != null) {
|
|
menuBuilder.setOverrideVisibleItems(false);
|
|
}
|
|
return z;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public boolean onMenuOpened(int i, Menu menu) {
|
|
super.onMenuOpened(i, menu);
|
|
AppCompatDelegateImpl.this.onMenuOpened(i);
|
|
return true;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
public void onPanelClosed(int i, Menu menu) {
|
|
if (this.mOnPanelClosedBypassEnabled) {
|
|
getWrapped().onPanelClosed(i, menu);
|
|
} else {
|
|
super.onPanelClosed(i, menu);
|
|
AppCompatDelegateImpl.this.onPanelClosed(i);
|
|
}
|
|
}
|
|
|
|
public final android.view.ActionMode startAsSupportActionMode(ActionMode.Callback callback) {
|
|
SupportActionModeWrapper.CallbackWrapper callbackWrapper = new SupportActionModeWrapper.CallbackWrapper(AppCompatDelegateImpl.this.mContext, callback);
|
|
androidx.appcompat.view.ActionMode startSupportActionMode = AppCompatDelegateImpl.this.startSupportActionMode(callbackWrapper);
|
|
if (startSupportActionMode != null) {
|
|
return callbackWrapper.getActionModeWrapper(startSupportActionMode);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
@RequiresApi(23)
|
|
public android.view.ActionMode onWindowStartingActionMode(ActionMode.Callback callback, int i) {
|
|
if (AppCompatDelegateImpl.this.isHandleNativeActionModesEnabled() && i == 0) {
|
|
return startAsSupportActionMode(callback);
|
|
}
|
|
return super.onWindowStartingActionMode(callback, i);
|
|
}
|
|
|
|
@Override // androidx.appcompat.view.WindowCallbackWrapper, android.view.Window.Callback
|
|
@RequiresApi(24)
|
|
public void onProvideKeyboardShortcuts(List<KeyboardShortcutGroup> list, Menu menu, int i) {
|
|
MenuBuilder menuBuilder;
|
|
PanelFeatureState panelState = AppCompatDelegateImpl.this.getPanelState(0, true);
|
|
if (panelState != null && (menuBuilder = panelState.menu) != null) {
|
|
super.onProvideKeyboardShortcuts(list, menuBuilder, i);
|
|
} else {
|
|
super.onProvideKeyboardShortcuts(list, menu, i);
|
|
}
|
|
}
|
|
|
|
public void bypassOnContentChanged(Window.Callback callback) {
|
|
try {
|
|
this.mOnContentChangedBypassEnabled = true;
|
|
callback.onContentChanged();
|
|
} finally {
|
|
this.mOnContentChangedBypassEnabled = false;
|
|
}
|
|
}
|
|
|
|
public boolean bypassDispatchKeyEvent(Window.Callback callback, KeyEvent keyEvent) {
|
|
try {
|
|
this.mDispatchKeyEventBypassEnabled = true;
|
|
return callback.dispatchKeyEvent(keyEvent);
|
|
} finally {
|
|
this.mDispatchKeyEventBypassEnabled = false;
|
|
}
|
|
}
|
|
|
|
public void bypassOnPanelClosed(Window.Callback callback, int i, Menu menu) {
|
|
try {
|
|
this.mOnPanelClosedBypassEnabled = true;
|
|
callback.onPanelClosed(i, menu);
|
|
} finally {
|
|
this.mOnPanelClosedBypassEnabled = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
@VisibleForTesting
|
|
public abstract class AutoNightModeManager {
|
|
private BroadcastReceiver mReceiver;
|
|
|
|
@Nullable
|
|
public abstract IntentFilter createIntentFilterForBroadcastReceiver();
|
|
|
|
public abstract int getApplyableNightMode();
|
|
|
|
public boolean isListening() {
|
|
return this.mReceiver != null;
|
|
}
|
|
|
|
public abstract void onChange();
|
|
|
|
public AutoNightModeManager() {
|
|
}
|
|
|
|
public void setup() {
|
|
cleanup();
|
|
IntentFilter createIntentFilterForBroadcastReceiver = createIntentFilterForBroadcastReceiver();
|
|
if (createIntentFilterForBroadcastReceiver == null || createIntentFilterForBroadcastReceiver.countActions() == 0) {
|
|
return;
|
|
}
|
|
if (this.mReceiver == null) {
|
|
this.mReceiver = new BroadcastReceiver() { // from class: androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager.1
|
|
@Override // android.content.BroadcastReceiver
|
|
public void onReceive(Context context, Intent intent) {
|
|
AutoNightModeManager.this.onChange();
|
|
}
|
|
};
|
|
}
|
|
AppCompatDelegateImpl.this.mContext.registerReceiver(this.mReceiver, createIntentFilterForBroadcastReceiver);
|
|
}
|
|
|
|
public void cleanup() {
|
|
BroadcastReceiver broadcastReceiver = this.mReceiver;
|
|
if (broadcastReceiver != null) {
|
|
try {
|
|
AppCompatDelegateImpl.this.mContext.unregisterReceiver(broadcastReceiver);
|
|
} catch (IllegalArgumentException unused) {
|
|
}
|
|
this.mReceiver = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class AutoTimeNightModeManager extends AutoNightModeManager {
|
|
private final TwilightManager mTwilightManager;
|
|
|
|
public AutoTimeNightModeManager(@NonNull TwilightManager twilightManager) {
|
|
super();
|
|
this.mTwilightManager = twilightManager;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager
|
|
public int getApplyableNightMode() {
|
|
return this.mTwilightManager.isNight() ? 2 : 1;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager
|
|
public void onChange() {
|
|
AppCompatDelegateImpl.this.applyDayNight();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager
|
|
public IntentFilter createIntentFilterForBroadcastReceiver() {
|
|
IntentFilter intentFilter = new IntentFilter();
|
|
intentFilter.addAction("android.intent.action.TIME_SET");
|
|
intentFilter.addAction("android.intent.action.TIMEZONE_CHANGED");
|
|
intentFilter.addAction("android.intent.action.TIME_TICK");
|
|
return intentFilter;
|
|
}
|
|
}
|
|
|
|
public class AutoBatteryNightModeManager extends AutoNightModeManager {
|
|
private final PowerManager mPowerManager;
|
|
|
|
public AutoBatteryNightModeManager(@NonNull Context context) {
|
|
super();
|
|
this.mPowerManager = (PowerManager) context.getApplicationContext().getSystemService("power");
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager
|
|
public int getApplyableNightMode() {
|
|
return Api21Impl.isPowerSaveMode(this.mPowerManager) ? 2 : 1;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager
|
|
public void onChange() {
|
|
AppCompatDelegateImpl.this.applyDayNight();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegateImpl.AutoNightModeManager
|
|
public IntentFilter createIntentFilterForBroadcastReceiver() {
|
|
IntentFilter intentFilter = new IntentFilter();
|
|
intentFilter.addAction("android.os.action.POWER_SAVE_MODE_CHANGED");
|
|
return intentFilter;
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.AppCompatDelegate
|
|
public final ActionBarDrawerToggle.Delegate getDrawerToggleDelegate() {
|
|
return new ActionBarDrawableToggleImpl();
|
|
}
|
|
|
|
public class ActionBarDrawableToggleImpl implements ActionBarDrawerToggle.Delegate {
|
|
public ActionBarDrawableToggleImpl() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.ActionBarDrawerToggle.Delegate
|
|
public Drawable getThemeUpIndicator() {
|
|
TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(getActionBarThemedContext(), (AttributeSet) null, new int[]{androidx.appcompat.R.attr.homeAsUpIndicator});
|
|
Drawable drawable = obtainStyledAttributes.getDrawable(0);
|
|
obtainStyledAttributes.recycle();
|
|
return drawable;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.ActionBarDrawerToggle.Delegate
|
|
public Context getActionBarThemedContext() {
|
|
return AppCompatDelegateImpl.this.getActionBarThemedContext();
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.ActionBarDrawerToggle.Delegate
|
|
public boolean isNavigationVisible() {
|
|
ActionBar supportActionBar = AppCompatDelegateImpl.this.getSupportActionBar();
|
|
return (supportActionBar == null || (supportActionBar.getDisplayOptions() & 4) == 0) ? false : true;
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.ActionBarDrawerToggle.Delegate
|
|
public void setActionBarUpIndicator(Drawable drawable, int i) {
|
|
ActionBar supportActionBar = AppCompatDelegateImpl.this.getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
supportActionBar.setHomeAsUpIndicator(drawable);
|
|
supportActionBar.setHomeActionContentDescription(i);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.appcompat.app.ActionBarDrawerToggle.Delegate
|
|
public void setActionBarDescription(int i) {
|
|
ActionBar supportActionBar = AppCompatDelegateImpl.this.getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
supportActionBar.setHomeActionContentDescription(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
private static Configuration generateConfigDelta(@NonNull Configuration configuration, @Nullable Configuration configuration2) {
|
|
Configuration configuration3 = new Configuration();
|
|
configuration3.fontScale = 0.0f;
|
|
if (configuration2 != null && configuration.diff(configuration2) != 0) {
|
|
float f = configuration.fontScale;
|
|
float f2 = configuration2.fontScale;
|
|
if (f != f2) {
|
|
configuration3.fontScale = f2;
|
|
}
|
|
int i = configuration.mcc;
|
|
int i2 = configuration2.mcc;
|
|
if (i != i2) {
|
|
configuration3.mcc = i2;
|
|
}
|
|
int i3 = configuration.mnc;
|
|
int i4 = configuration2.mnc;
|
|
if (i3 != i4) {
|
|
configuration3.mnc = i4;
|
|
}
|
|
Api24Impl.generateConfigDelta_locale(configuration, configuration2, configuration3);
|
|
int i5 = configuration.touchscreen;
|
|
int i6 = configuration2.touchscreen;
|
|
if (i5 != i6) {
|
|
configuration3.touchscreen = i6;
|
|
}
|
|
int i7 = configuration.keyboard;
|
|
int i8 = configuration2.keyboard;
|
|
if (i7 != i8) {
|
|
configuration3.keyboard = i8;
|
|
}
|
|
int i9 = configuration.keyboardHidden;
|
|
int i10 = configuration2.keyboardHidden;
|
|
if (i9 != i10) {
|
|
configuration3.keyboardHidden = i10;
|
|
}
|
|
int i11 = configuration.navigation;
|
|
int i12 = configuration2.navigation;
|
|
if (i11 != i12) {
|
|
configuration3.navigation = i12;
|
|
}
|
|
int i13 = configuration.navigationHidden;
|
|
int i14 = configuration2.navigationHidden;
|
|
if (i13 != i14) {
|
|
configuration3.navigationHidden = i14;
|
|
}
|
|
int i15 = configuration.orientation;
|
|
int i16 = configuration2.orientation;
|
|
if (i15 != i16) {
|
|
configuration3.orientation = i16;
|
|
}
|
|
int i17 = configuration.screenLayout & 15;
|
|
int i18 = configuration2.screenLayout;
|
|
if (i17 != (i18 & 15)) {
|
|
configuration3.screenLayout |= i18 & 15;
|
|
}
|
|
int i19 = configuration.screenLayout & PsExtractor.AUDIO_STREAM;
|
|
int i20 = configuration2.screenLayout;
|
|
if (i19 != (i20 & PsExtractor.AUDIO_STREAM)) {
|
|
configuration3.screenLayout |= i20 & PsExtractor.AUDIO_STREAM;
|
|
}
|
|
int i21 = configuration.screenLayout & 48;
|
|
int i22 = configuration2.screenLayout;
|
|
if (i21 != (i22 & 48)) {
|
|
configuration3.screenLayout |= i22 & 48;
|
|
}
|
|
int i23 = configuration.screenLayout & 768;
|
|
int i24 = configuration2.screenLayout;
|
|
if (i23 != (i24 & 768)) {
|
|
configuration3.screenLayout |= i24 & 768;
|
|
}
|
|
Api26Impl.generateConfigDelta_colorMode(configuration, configuration2, configuration3);
|
|
int i25 = configuration.uiMode & 15;
|
|
int i26 = configuration2.uiMode;
|
|
if (i25 != (i26 & 15)) {
|
|
configuration3.uiMode |= i26 & 15;
|
|
}
|
|
int i27 = configuration.uiMode & 48;
|
|
int i28 = configuration2.uiMode;
|
|
if (i27 != (i28 & 48)) {
|
|
configuration3.uiMode |= i28 & 48;
|
|
}
|
|
int i29 = configuration.screenWidthDp;
|
|
int i30 = configuration2.screenWidthDp;
|
|
if (i29 != i30) {
|
|
configuration3.screenWidthDp = i30;
|
|
}
|
|
int i31 = configuration.screenHeightDp;
|
|
int i32 = configuration2.screenHeightDp;
|
|
if (i31 != i32) {
|
|
configuration3.screenHeightDp = i32;
|
|
}
|
|
int i33 = configuration.smallestScreenWidthDp;
|
|
int i34 = configuration2.smallestScreenWidthDp;
|
|
if (i33 != i34) {
|
|
configuration3.smallestScreenWidthDp = i34;
|
|
}
|
|
int i35 = configuration.densityDpi;
|
|
int i36 = configuration2.densityDpi;
|
|
if (i35 != i36) {
|
|
configuration3.densityDpi = i36;
|
|
}
|
|
}
|
|
return configuration3;
|
|
}
|
|
|
|
@RequiresApi(21)
|
|
public static class Api21Impl {
|
|
private Api21Impl() {
|
|
}
|
|
|
|
@DoNotInline
|
|
public static boolean isPowerSaveMode(PowerManager powerManager) {
|
|
return powerManager.isPowerSaveMode();
|
|
}
|
|
|
|
@DoNotInline
|
|
public static String toLanguageTag(Locale locale) {
|
|
return locale.toLanguageTag();
|
|
}
|
|
}
|
|
|
|
@RequiresApi(24)
|
|
public static class Api24Impl {
|
|
private Api24Impl() {
|
|
}
|
|
|
|
@DoNotInline
|
|
public static void generateConfigDelta_locale(@NonNull Configuration configuration, @NonNull Configuration configuration2, @NonNull Configuration configuration3) {
|
|
LocaleList locales = configuration.getLocales();
|
|
LocaleList locales2 = configuration2.getLocales();
|
|
if (locales.equals(locales2)) {
|
|
return;
|
|
}
|
|
configuration3.setLocales(locales2);
|
|
configuration3.locale = configuration2.locale;
|
|
}
|
|
|
|
@DoNotInline
|
|
public static LocaleListCompat getLocales(Configuration configuration) {
|
|
return LocaleListCompat.forLanguageTags(configuration.getLocales().toLanguageTags());
|
|
}
|
|
|
|
@DoNotInline
|
|
public static void setLocales(Configuration configuration, LocaleListCompat localeListCompat) {
|
|
configuration.setLocales(LocaleList.forLanguageTags(localeListCompat.toLanguageTags()));
|
|
}
|
|
|
|
@DoNotInline
|
|
public static void setDefaultLocales(LocaleListCompat localeListCompat) {
|
|
LocaleList.setDefault(LocaleList.forLanguageTags(localeListCompat.toLanguageTags()));
|
|
}
|
|
}
|
|
|
|
@RequiresApi(26)
|
|
public static class Api26Impl {
|
|
private Api26Impl() {
|
|
}
|
|
|
|
public static void generateConfigDelta_colorMode(@NonNull Configuration configuration, @NonNull Configuration configuration2, @NonNull Configuration configuration3) {
|
|
int i = configuration.colorMode & 3;
|
|
int i2 = configuration2.colorMode;
|
|
if (i != (i2 & 3)) {
|
|
configuration3.colorMode |= i2 & 3;
|
|
}
|
|
int i3 = configuration.colorMode & 12;
|
|
int i4 = configuration2.colorMode;
|
|
if (i3 != (i4 & 12)) {
|
|
configuration3.colorMode |= i4 & 12;
|
|
}
|
|
}
|
|
}
|
|
|
|
@RequiresApi(33)
|
|
public static class Api33Impl {
|
|
private Api33Impl() {
|
|
}
|
|
|
|
@DoNotInline
|
|
public static OnBackInvokedCallback registerOnBackPressedCallback(Object obj, final AppCompatDelegateImpl appCompatDelegateImpl) {
|
|
Objects.requireNonNull(appCompatDelegateImpl);
|
|
OnBackInvokedCallback onBackInvokedCallback = new OnBackInvokedCallback() { // from class: androidx.appcompat.app.AppCompatDelegateImpl$Api33Impl$$ExternalSyntheticLambda5
|
|
public final void onBackInvoked() {
|
|
AppCompatDelegateImpl.this.onBackPressed();
|
|
}
|
|
};
|
|
AppCompatDelegateImpl$Api33Impl$$ExternalSyntheticApiModelOutline2.m(obj).registerOnBackInvokedCallback(1000000, onBackInvokedCallback);
|
|
return onBackInvokedCallback;
|
|
}
|
|
|
|
@DoNotInline
|
|
public static void unregisterOnBackInvokedCallback(Object obj, Object obj2) {
|
|
AppCompatDelegateImpl$Api33Impl$$ExternalSyntheticApiModelOutline2.m(obj).unregisterOnBackInvokedCallback(AppCompatDelegateImpl$Api33Impl$$ExternalSyntheticApiModelOutline1.m(obj2));
|
|
}
|
|
|
|
@DoNotInline
|
|
public static OnBackInvokedDispatcher getOnBackInvokedDispatcher(Activity activity) {
|
|
OnBackInvokedDispatcher onBackInvokedDispatcher;
|
|
onBackInvokedDispatcher = activity.getOnBackInvokedDispatcher();
|
|
return onBackInvokedDispatcher;
|
|
}
|
|
}
|
|
}
|