967 lines
34 KiB
Java
967 lines
34 KiB
Java
package androidx.appcompat.view.menu;
|
|
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.content.res.Resources;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Bundle;
|
|
import android.os.Parcelable;
|
|
import android.util.SparseArray;
|
|
import android.view.ContextMenu;
|
|
import android.view.KeyCharacterMap;
|
|
import android.view.KeyEvent;
|
|
import android.view.MenuItem;
|
|
import android.view.SubMenu;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.core.content.ContextCompat;
|
|
import androidx.core.internal.view.SupportMenu;
|
|
import androidx.core.view.ActionProvider;
|
|
import androidx.core.view.ViewConfigurationCompat;
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public class MenuBuilder implements SupportMenu {
|
|
private static final String ACTION_VIEW_STATES_KEY = "android:menu:actionviewstates";
|
|
private static final String EXPANDED_ACTION_VIEW_ID = "android:menu:expandedactionview";
|
|
private static final String PRESENTER_KEY = "android:menu:presenters";
|
|
private static final String TAG = "MenuBuilder";
|
|
private static final int[] sCategoryToOrder = {1, 4, 5, 3, 2, 0};
|
|
private ArrayList<MenuItemImpl> mActionItems;
|
|
private Callback mCallback;
|
|
private final Context mContext;
|
|
private ContextMenu.ContextMenuInfo mCurrentMenuInfo;
|
|
private int mDefaultShowAsAction = 0;
|
|
private MenuItemImpl mExpandedItem;
|
|
private boolean mGroupDividerEnabled = false;
|
|
public Drawable mHeaderIcon;
|
|
public CharSequence mHeaderTitle;
|
|
public View mHeaderView;
|
|
private boolean mIsActionItemsStale;
|
|
private boolean mIsClosing = false;
|
|
private boolean mIsVisibleItemsStale;
|
|
private ArrayList<MenuItemImpl> mItems;
|
|
private boolean mItemsChangedWhileDispatchPrevented = false;
|
|
private ArrayList<MenuItemImpl> mNonActionItems;
|
|
private boolean mOptionalIconsVisible = false;
|
|
private boolean mOverrideVisibleItems;
|
|
private CopyOnWriteArrayList<WeakReference<MenuPresenter>> mPresenters = new CopyOnWriteArrayList<>();
|
|
private boolean mPreventDispatchingItemsChanged = false;
|
|
private boolean mQwertyMode;
|
|
private final Resources mResources;
|
|
private boolean mShortcutsVisible;
|
|
private boolean mStructureChangedWhileDispatchPrevented = false;
|
|
private ArrayList<MenuItemImpl> mTempShortcutItemList = new ArrayList<>();
|
|
private ArrayList<MenuItemImpl> mVisibleItems;
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public interface Callback {
|
|
boolean onMenuItemSelected(@NonNull MenuBuilder menuBuilder, @NonNull MenuItem menuItem);
|
|
|
|
void onMenuModeChange(@NonNull MenuBuilder menuBuilder);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public interface ItemInvoker {
|
|
boolean invokeItem(MenuItemImpl menuItemImpl);
|
|
}
|
|
|
|
public MenuBuilder(Context context) {
|
|
this.mContext = context;
|
|
this.mResources = context.getResources();
|
|
this.mItems = new ArrayList<>();
|
|
this.mVisibleItems = new ArrayList<>();
|
|
this.mIsVisibleItemsStale = true;
|
|
this.mActionItems = new ArrayList<>();
|
|
this.mNonActionItems = new ArrayList<>();
|
|
this.mIsActionItemsStale = true;
|
|
setShortcutsVisibleInner(true);
|
|
}
|
|
|
|
private MenuItemImpl createNewMenuItem(int i, int i2, int i3, int i4, CharSequence charSequence, int i5) {
|
|
return new MenuItemImpl(this, i, i2, i3, i4, charSequence, i5);
|
|
}
|
|
|
|
private void dispatchPresenterUpdate(boolean z2) {
|
|
if (!this.mPresenters.isEmpty()) {
|
|
stopDispatchingItemsChanged();
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
menuPresenter.updateMenuView(z2);
|
|
}
|
|
}
|
|
startDispatchingItemsChanged();
|
|
}
|
|
}
|
|
|
|
private void dispatchRestoreInstanceState(Bundle bundle) {
|
|
Parcelable parcelable;
|
|
SparseArray sparseParcelableArray = bundle.getSparseParcelableArray(PRESENTER_KEY);
|
|
if (sparseParcelableArray != null && !this.mPresenters.isEmpty()) {
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
int id2 = menuPresenter.getId();
|
|
if (id2 > 0 && (parcelable = (Parcelable) sparseParcelableArray.get(id2)) != null) {
|
|
menuPresenter.onRestoreInstanceState(parcelable);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void dispatchSaveInstanceState(Bundle bundle) {
|
|
Parcelable onSaveInstanceState;
|
|
if (!this.mPresenters.isEmpty()) {
|
|
SparseArray<? extends Parcelable> sparseArray = new SparseArray<>();
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
int id2 = menuPresenter.getId();
|
|
if (id2 > 0 && (onSaveInstanceState = menuPresenter.onSaveInstanceState()) != null) {
|
|
sparseArray.put(id2, onSaveInstanceState);
|
|
}
|
|
}
|
|
}
|
|
bundle.putSparseParcelableArray(PRESENTER_KEY, sparseArray);
|
|
}
|
|
}
|
|
|
|
private boolean dispatchSubMenuSelected(SubMenuBuilder subMenuBuilder, MenuPresenter menuPresenter) {
|
|
boolean z2 = false;
|
|
if (this.mPresenters.isEmpty()) {
|
|
return false;
|
|
}
|
|
if (menuPresenter != null) {
|
|
z2 = menuPresenter.onSubMenuSelected(subMenuBuilder);
|
|
}
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter2 = next.get();
|
|
if (menuPresenter2 == null) {
|
|
this.mPresenters.remove(next);
|
|
} else if (!z2) {
|
|
z2 = menuPresenter2.onSubMenuSelected(subMenuBuilder);
|
|
}
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
private static int findInsertIndex(ArrayList<MenuItemImpl> arrayList, int i) {
|
|
for (int size = arrayList.size() - 1; size >= 0; size--) {
|
|
if (arrayList.get(size).getOrdering() <= i) {
|
|
return size + 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private static int getOrdering(int i) {
|
|
int i2 = (-65536 & i) >> 16;
|
|
if (i2 >= 0) {
|
|
int[] iArr = sCategoryToOrder;
|
|
if (i2 < iArr.length) {
|
|
return (i & 65535) | (iArr[i2] << 16);
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("order does not contain a valid category.");
|
|
}
|
|
|
|
private void removeItemAtInt(int i, boolean z2) {
|
|
if (i >= 0 && i < this.mItems.size()) {
|
|
this.mItems.remove(i);
|
|
if (z2) {
|
|
onItemsChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setHeaderInternal(int i, CharSequence charSequence, int i2, Drawable drawable, View view) {
|
|
Resources resources = getResources();
|
|
if (view != null) {
|
|
this.mHeaderView = view;
|
|
this.mHeaderTitle = null;
|
|
this.mHeaderIcon = null;
|
|
} else {
|
|
if (i > 0) {
|
|
this.mHeaderTitle = resources.getText(i);
|
|
} else if (charSequence != null) {
|
|
this.mHeaderTitle = charSequence;
|
|
}
|
|
if (i2 > 0) {
|
|
this.mHeaderIcon = ContextCompat.getDrawable(getContext(), i2);
|
|
} else if (drawable != null) {
|
|
this.mHeaderIcon = drawable;
|
|
}
|
|
this.mHeaderView = null;
|
|
}
|
|
onItemsChanged(false);
|
|
}
|
|
|
|
private void setShortcutsVisibleInner(boolean z2) {
|
|
boolean z3 = true;
|
|
if (!z2 || this.mResources.getConfiguration().keyboard == 1 || !ViewConfigurationCompat.shouldShowMenuShortcutsWhenKeyboardPresent(ViewConfiguration.get(this.mContext), this.mContext)) {
|
|
z3 = false;
|
|
}
|
|
this.mShortcutsVisible = z3;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public MenuItem add(int i) {
|
|
return addInternal(0, 0, 0, this.mResources.getString(i));
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public MenuItem add(int i, int i2, int i3, int i4) {
|
|
return addInternal(i, i2, i3, this.mResources.getString(i4));
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public MenuItem add(int i, int i2, int i3, CharSequence charSequence) {
|
|
return addInternal(i, i2, i3, charSequence);
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public MenuItem add(CharSequence charSequence) {
|
|
return addInternal(0, 0, 0, charSequence);
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public int addIntentOptions(int i, int i2, int i3, ComponentName componentName, Intent[] intentArr, Intent intent, int i4, MenuItem[] menuItemArr) {
|
|
int i5;
|
|
PackageManager packageManager = this.mContext.getPackageManager();
|
|
List<ResolveInfo> queryIntentActivityOptions = packageManager.queryIntentActivityOptions(componentName, intentArr, intent, 0);
|
|
int size = queryIntentActivityOptions != null ? queryIntentActivityOptions.size() : 0;
|
|
if ((i4 & 1) == 0) {
|
|
removeGroup(i);
|
|
}
|
|
for (int i6 = 0; i6 < size; i6++) {
|
|
ResolveInfo resolveInfo = queryIntentActivityOptions.get(i6);
|
|
int i7 = resolveInfo.specificIndex;
|
|
Intent intent2 = new Intent(i7 < 0 ? intent : intentArr[i7]);
|
|
ActivityInfo activityInfo = resolveInfo.activityInfo;
|
|
intent2.setComponent(new ComponentName(activityInfo.applicationInfo.packageName, activityInfo.name));
|
|
MenuItem intent3 = add(i, i2, i3, resolveInfo.loadLabel(packageManager)).setIcon(resolveInfo.loadIcon(packageManager)).setIntent(intent2);
|
|
if (menuItemArr != null && (i5 = resolveInfo.specificIndex) >= 0) {
|
|
menuItemArr[i5] = intent3;
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public MenuItem addInternal(int i, int i2, int i3, CharSequence charSequence) {
|
|
int ordering = getOrdering(i3);
|
|
MenuItemImpl createNewMenuItem = createNewMenuItem(i, i2, i3, ordering, charSequence, this.mDefaultShowAsAction);
|
|
ContextMenu.ContextMenuInfo contextMenuInfo = this.mCurrentMenuInfo;
|
|
if (contextMenuInfo != null) {
|
|
createNewMenuItem.setMenuInfo(contextMenuInfo);
|
|
}
|
|
ArrayList<MenuItemImpl> arrayList = this.mItems;
|
|
arrayList.add(findInsertIndex(arrayList, ordering), createNewMenuItem);
|
|
onItemsChanged(true);
|
|
return createNewMenuItem;
|
|
}
|
|
|
|
public void addMenuPresenter(MenuPresenter menuPresenter) {
|
|
addMenuPresenter(menuPresenter, this.mContext);
|
|
}
|
|
|
|
public void addMenuPresenter(MenuPresenter menuPresenter, Context context) {
|
|
this.mPresenters.add(new WeakReference<>(menuPresenter));
|
|
menuPresenter.initForMenu(context, this);
|
|
this.mIsActionItemsStale = true;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public SubMenu addSubMenu(int i) {
|
|
return addSubMenu(0, 0, 0, this.mResources.getString(i));
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public SubMenu addSubMenu(int i, int i2, int i3, int i4) {
|
|
return addSubMenu(i, i2, i3, this.mResources.getString(i4));
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public SubMenu addSubMenu(int i, int i2, int i3, CharSequence charSequence) {
|
|
MenuItemImpl menuItemImpl = (MenuItemImpl) addInternal(i, i2, i3, charSequence);
|
|
SubMenuBuilder subMenuBuilder = new SubMenuBuilder(this.mContext, this, menuItemImpl);
|
|
menuItemImpl.setSubMenu(subMenuBuilder);
|
|
return subMenuBuilder;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public SubMenu addSubMenu(CharSequence charSequence) {
|
|
return addSubMenu(0, 0, 0, charSequence);
|
|
}
|
|
|
|
public void changeMenuMode() {
|
|
Callback callback = this.mCallback;
|
|
if (callback != null) {
|
|
callback.onMenuModeChange(this);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void clear() {
|
|
MenuItemImpl menuItemImpl = this.mExpandedItem;
|
|
if (menuItemImpl != null) {
|
|
collapseItemActionView(menuItemImpl);
|
|
}
|
|
this.mItems.clear();
|
|
onItemsChanged(true);
|
|
}
|
|
|
|
public void clearAll() {
|
|
this.mPreventDispatchingItemsChanged = true;
|
|
clear();
|
|
clearHeader();
|
|
this.mPresenters.clear();
|
|
this.mPreventDispatchingItemsChanged = false;
|
|
this.mItemsChangedWhileDispatchPrevented = false;
|
|
this.mStructureChangedWhileDispatchPrevented = false;
|
|
onItemsChanged(true);
|
|
}
|
|
|
|
public void clearHeader() {
|
|
this.mHeaderIcon = null;
|
|
this.mHeaderTitle = null;
|
|
this.mHeaderView = null;
|
|
onItemsChanged(false);
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void close() {
|
|
close(true);
|
|
}
|
|
|
|
public final void close(boolean z2) {
|
|
if (!this.mIsClosing) {
|
|
this.mIsClosing = true;
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
menuPresenter.onCloseMenu(this, z2);
|
|
}
|
|
}
|
|
this.mIsClosing = false;
|
|
}
|
|
}
|
|
|
|
public boolean collapseItemActionView(MenuItemImpl menuItemImpl) {
|
|
boolean z2 = false;
|
|
if (!this.mPresenters.isEmpty() && this.mExpandedItem == menuItemImpl) {
|
|
stopDispatchingItemsChanged();
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
z2 = menuPresenter.collapseItemActionView(this, menuItemImpl);
|
|
if (z2) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
startDispatchingItemsChanged();
|
|
if (z2) {
|
|
this.mExpandedItem = null;
|
|
}
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
public boolean dispatchMenuItemSelected(@NonNull MenuBuilder menuBuilder, @NonNull MenuItem menuItem) {
|
|
Callback callback = this.mCallback;
|
|
return callback != null && callback.onMenuItemSelected(menuBuilder, menuItem);
|
|
}
|
|
|
|
public boolean expandItemActionView(MenuItemImpl menuItemImpl) {
|
|
boolean z2 = false;
|
|
if (this.mPresenters.isEmpty()) {
|
|
return false;
|
|
}
|
|
stopDispatchingItemsChanged();
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
z2 = menuPresenter.expandItemActionView(this, menuItemImpl);
|
|
if (z2) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
startDispatchingItemsChanged();
|
|
if (z2) {
|
|
this.mExpandedItem = menuItemImpl;
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
public int findGroupIndex(int i) {
|
|
return findGroupIndex(i, 0);
|
|
}
|
|
|
|
public int findGroupIndex(int i, int i2) {
|
|
int size = size();
|
|
if (i2 < 0) {
|
|
i2 = 0;
|
|
}
|
|
while (i2 < size) {
|
|
if (this.mItems.get(i2).getGroupId() == i) {
|
|
return i2;
|
|
}
|
|
i2++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public MenuItem findItem(int i) {
|
|
MenuItem findItem;
|
|
int size = size();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i2);
|
|
if (menuItemImpl.getItemId() == i) {
|
|
return menuItemImpl;
|
|
}
|
|
if (menuItemImpl.hasSubMenu() && (findItem = menuItemImpl.getSubMenu().findItem(i)) != null) {
|
|
return findItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int findItemIndex(int i) {
|
|
int size = size();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
if (this.mItems.get(i2).getItemId() == i) {
|
|
return i2;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public MenuItemImpl findItemWithShortcutForKey(int i, KeyEvent keyEvent) {
|
|
ArrayList<MenuItemImpl> arrayList = this.mTempShortcutItemList;
|
|
arrayList.clear();
|
|
findItemsWithShortcutForKey(arrayList, i, keyEvent);
|
|
if (arrayList.isEmpty()) {
|
|
return null;
|
|
}
|
|
int metaState = keyEvent.getMetaState();
|
|
KeyCharacterMap.KeyData keyData = new KeyCharacterMap.KeyData();
|
|
keyEvent.getKeyData(keyData);
|
|
int size = arrayList.size();
|
|
if (size == 1) {
|
|
return arrayList.get(0);
|
|
}
|
|
boolean isQwertyMode = isQwertyMode();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
MenuItemImpl menuItemImpl = arrayList.get(i2);
|
|
char alphabeticShortcut = isQwertyMode ? menuItemImpl.getAlphabeticShortcut() : menuItemImpl.getNumericShortcut();
|
|
char[] cArr = keyData.meta;
|
|
if ((alphabeticShortcut == cArr[0] && (metaState & 2) == 0) || ((alphabeticShortcut == cArr[2] && (metaState & 2) != 0) || (isQwertyMode && alphabeticShortcut == '\b' && i == 67))) {
|
|
return menuItemImpl;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void findItemsWithShortcutForKey(List<MenuItemImpl> list, int i, KeyEvent keyEvent) {
|
|
boolean isQwertyMode = isQwertyMode();
|
|
int modifiers = keyEvent.getModifiers();
|
|
KeyCharacterMap.KeyData keyData = new KeyCharacterMap.KeyData();
|
|
if (keyEvent.getKeyData(keyData) || i == 67) {
|
|
int size = this.mItems.size();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i2);
|
|
if (menuItemImpl.hasSubMenu()) {
|
|
((MenuBuilder) menuItemImpl.getSubMenu()).findItemsWithShortcutForKey(list, i, keyEvent);
|
|
}
|
|
char alphabeticShortcut = isQwertyMode ? menuItemImpl.getAlphabeticShortcut() : menuItemImpl.getNumericShortcut();
|
|
if (((modifiers & SupportMenu.SUPPORTED_MODIFIERS_MASK) == ((isQwertyMode ? menuItemImpl.getAlphabeticModifiers() : menuItemImpl.getNumericModifiers()) & SupportMenu.SUPPORTED_MODIFIERS_MASK)) && alphabeticShortcut != 0) {
|
|
char[] cArr = keyData.meta;
|
|
if ((alphabeticShortcut == cArr[0] || alphabeticShortcut == cArr[2] || (isQwertyMode && alphabeticShortcut == '\b' && i == 67)) && menuItemImpl.isEnabled()) {
|
|
list.add(menuItemImpl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void flagActionItems() {
|
|
ArrayList<MenuItemImpl> visibleItems = getVisibleItems();
|
|
if (this.mIsActionItemsStale) {
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
boolean z2 = false;
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter = next.get();
|
|
if (menuPresenter == null) {
|
|
this.mPresenters.remove(next);
|
|
} else {
|
|
z2 |= menuPresenter.flagActionItems();
|
|
}
|
|
}
|
|
if (z2) {
|
|
this.mActionItems.clear();
|
|
this.mNonActionItems.clear();
|
|
int size = visibleItems.size();
|
|
for (int i = 0; i < size; i++) {
|
|
MenuItemImpl menuItemImpl = visibleItems.get(i);
|
|
if (menuItemImpl.isActionButton()) {
|
|
this.mActionItems.add(menuItemImpl);
|
|
} else {
|
|
this.mNonActionItems.add(menuItemImpl);
|
|
}
|
|
}
|
|
} else {
|
|
this.mActionItems.clear();
|
|
this.mNonActionItems.clear();
|
|
this.mNonActionItems.addAll(getVisibleItems());
|
|
}
|
|
this.mIsActionItemsStale = false;
|
|
}
|
|
}
|
|
|
|
public ArrayList<MenuItemImpl> getActionItems() {
|
|
flagActionItems();
|
|
return this.mActionItems;
|
|
}
|
|
|
|
public String getActionViewStatesKey() {
|
|
return ACTION_VIEW_STATES_KEY;
|
|
}
|
|
|
|
public Context getContext() {
|
|
return this.mContext;
|
|
}
|
|
|
|
public MenuItemImpl getExpandedItem() {
|
|
return this.mExpandedItem;
|
|
}
|
|
|
|
public Drawable getHeaderIcon() {
|
|
return this.mHeaderIcon;
|
|
}
|
|
|
|
public CharSequence getHeaderTitle() {
|
|
return this.mHeaderTitle;
|
|
}
|
|
|
|
public View getHeaderView() {
|
|
return this.mHeaderView;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public MenuItem getItem(int i) {
|
|
return this.mItems.get(i);
|
|
}
|
|
|
|
public ArrayList<MenuItemImpl> getNonActionItems() {
|
|
flagActionItems();
|
|
return this.mNonActionItems;
|
|
}
|
|
|
|
public boolean getOptionalIconsVisible() {
|
|
return this.mOptionalIconsVisible;
|
|
}
|
|
|
|
public Resources getResources() {
|
|
return this.mResources;
|
|
}
|
|
|
|
public MenuBuilder getRootMenu() {
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public ArrayList<MenuItemImpl> getVisibleItems() {
|
|
if (!this.mIsVisibleItemsStale) {
|
|
return this.mVisibleItems;
|
|
}
|
|
this.mVisibleItems.clear();
|
|
int size = this.mItems.size();
|
|
for (int i = 0; i < size; i++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i);
|
|
if (menuItemImpl.isVisible()) {
|
|
this.mVisibleItems.add(menuItemImpl);
|
|
}
|
|
}
|
|
this.mIsVisibleItemsStale = false;
|
|
this.mIsActionItemsStale = true;
|
|
return this.mVisibleItems;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public boolean hasVisibleItems() {
|
|
if (this.mOverrideVisibleItems) {
|
|
return true;
|
|
}
|
|
int size = size();
|
|
for (int i = 0; i < size; i++) {
|
|
if (this.mItems.get(i).isVisible()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isGroupDividerEnabled() {
|
|
return this.mGroupDividerEnabled;
|
|
}
|
|
|
|
public boolean isQwertyMode() {
|
|
return this.mQwertyMode;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public boolean isShortcutKey(int i, KeyEvent keyEvent) {
|
|
return findItemWithShortcutForKey(i, keyEvent) != null;
|
|
}
|
|
|
|
public boolean isShortcutsVisible() {
|
|
return this.mShortcutsVisible;
|
|
}
|
|
|
|
public void onItemActionRequestChanged(MenuItemImpl menuItemImpl) {
|
|
this.mIsActionItemsStale = true;
|
|
onItemsChanged(true);
|
|
}
|
|
|
|
public void onItemVisibleChanged(MenuItemImpl menuItemImpl) {
|
|
this.mIsVisibleItemsStale = true;
|
|
onItemsChanged(true);
|
|
}
|
|
|
|
public void onItemsChanged(boolean z2) {
|
|
if (!this.mPreventDispatchingItemsChanged) {
|
|
if (z2) {
|
|
this.mIsVisibleItemsStale = true;
|
|
this.mIsActionItemsStale = true;
|
|
}
|
|
dispatchPresenterUpdate(z2);
|
|
return;
|
|
}
|
|
this.mItemsChangedWhileDispatchPrevented = true;
|
|
if (z2) {
|
|
this.mStructureChangedWhileDispatchPrevented = true;
|
|
}
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public boolean performIdentifierAction(int i, int i2) {
|
|
return performItemAction(findItem(i), i2);
|
|
}
|
|
|
|
public boolean performItemAction(MenuItem menuItem, int i) {
|
|
return performItemAction(menuItem, null, i);
|
|
}
|
|
|
|
public boolean performItemAction(MenuItem menuItem, MenuPresenter menuPresenter, int i) {
|
|
MenuItemImpl menuItemImpl = (MenuItemImpl) menuItem;
|
|
if (menuItemImpl == null || !menuItemImpl.isEnabled()) {
|
|
return false;
|
|
}
|
|
boolean invoke = menuItemImpl.invoke();
|
|
ActionProvider supportActionProvider = menuItemImpl.getSupportActionProvider();
|
|
boolean z2 = supportActionProvider != null && supportActionProvider.hasSubMenu();
|
|
if (menuItemImpl.hasCollapsibleActionView()) {
|
|
invoke |= menuItemImpl.expandActionView();
|
|
if (invoke) {
|
|
close(true);
|
|
}
|
|
} else if (menuItemImpl.hasSubMenu() || z2) {
|
|
if ((i & 4) == 0) {
|
|
close(false);
|
|
}
|
|
if (!menuItemImpl.hasSubMenu()) {
|
|
menuItemImpl.setSubMenu(new SubMenuBuilder(getContext(), this, menuItemImpl));
|
|
}
|
|
SubMenuBuilder subMenuBuilder = (SubMenuBuilder) menuItemImpl.getSubMenu();
|
|
if (z2) {
|
|
supportActionProvider.onPrepareSubMenu(subMenuBuilder);
|
|
}
|
|
invoke |= dispatchSubMenuSelected(subMenuBuilder, menuPresenter);
|
|
if (!invoke) {
|
|
close(true);
|
|
}
|
|
} else if ((i & 1) == 0) {
|
|
close(true);
|
|
}
|
|
return invoke;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public boolean performShortcut(int i, KeyEvent keyEvent, int i2) {
|
|
MenuItemImpl findItemWithShortcutForKey = findItemWithShortcutForKey(i, keyEvent);
|
|
boolean performItemAction = findItemWithShortcutForKey != null ? performItemAction(findItemWithShortcutForKey, i2) : false;
|
|
if ((i2 & 2) != 0) {
|
|
close(true);
|
|
}
|
|
return performItemAction;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void removeGroup(int i) {
|
|
int findGroupIndex = findGroupIndex(i);
|
|
if (findGroupIndex >= 0) {
|
|
int size = this.mItems.size() - findGroupIndex;
|
|
int i2 = 0;
|
|
while (true) {
|
|
int i3 = i2 + 1;
|
|
if (i2 >= size || this.mItems.get(findGroupIndex).getGroupId() != i) {
|
|
break;
|
|
}
|
|
removeItemAtInt(findGroupIndex, false);
|
|
i2 = i3;
|
|
}
|
|
onItemsChanged(true);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void removeItem(int i) {
|
|
removeItemAtInt(findItemIndex(i), true);
|
|
}
|
|
|
|
public void removeItemAt(int i) {
|
|
removeItemAtInt(i, true);
|
|
}
|
|
|
|
public void removeMenuPresenter(MenuPresenter menuPresenter) {
|
|
Iterator<WeakReference<MenuPresenter>> it = this.mPresenters.iterator();
|
|
while (it.hasNext()) {
|
|
WeakReference<MenuPresenter> next = it.next();
|
|
MenuPresenter menuPresenter2 = next.get();
|
|
if (menuPresenter2 == null || menuPresenter2 == menuPresenter) {
|
|
this.mPresenters.remove(next);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void restoreActionViewStates(Bundle bundle) {
|
|
MenuItem findItem;
|
|
if (bundle != null) {
|
|
SparseArray<Parcelable> sparseParcelableArray = bundle.getSparseParcelableArray(getActionViewStatesKey());
|
|
int size = size();
|
|
for (int i = 0; i < size; i++) {
|
|
MenuItem item = getItem(i);
|
|
View actionView = item.getActionView();
|
|
if (!(actionView == null || actionView.getId() == -1)) {
|
|
actionView.restoreHierarchyState(sparseParcelableArray);
|
|
}
|
|
if (item.hasSubMenu()) {
|
|
((SubMenuBuilder) item.getSubMenu()).restoreActionViewStates(bundle);
|
|
}
|
|
}
|
|
int i2 = bundle.getInt(EXPANDED_ACTION_VIEW_ID);
|
|
if (i2 > 0 && (findItem = findItem(i2)) != null) {
|
|
findItem.expandActionView();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void restorePresenterStates(Bundle bundle) {
|
|
dispatchRestoreInstanceState(bundle);
|
|
}
|
|
|
|
public void saveActionViewStates(Bundle bundle) {
|
|
int size = size();
|
|
SparseArray<? extends Parcelable> sparseArray = null;
|
|
for (int i = 0; i < size; i++) {
|
|
MenuItem item = getItem(i);
|
|
View actionView = item.getActionView();
|
|
if (!(actionView == null || actionView.getId() == -1)) {
|
|
if (sparseArray == null) {
|
|
sparseArray = new SparseArray<>();
|
|
}
|
|
actionView.saveHierarchyState(sparseArray);
|
|
if (item.isActionViewExpanded()) {
|
|
bundle.putInt(EXPANDED_ACTION_VIEW_ID, item.getItemId());
|
|
}
|
|
}
|
|
if (item.hasSubMenu()) {
|
|
((SubMenuBuilder) item.getSubMenu()).saveActionViewStates(bundle);
|
|
}
|
|
}
|
|
if (sparseArray != null) {
|
|
bundle.putSparseParcelableArray(getActionViewStatesKey(), sparseArray);
|
|
}
|
|
}
|
|
|
|
public void savePresenterStates(Bundle bundle) {
|
|
dispatchSaveInstanceState(bundle);
|
|
}
|
|
|
|
public void setCallback(Callback callback) {
|
|
this.mCallback = callback;
|
|
}
|
|
|
|
public void setCurrentMenuInfo(ContextMenu.ContextMenuInfo contextMenuInfo) {
|
|
this.mCurrentMenuInfo = contextMenuInfo;
|
|
}
|
|
|
|
public MenuBuilder setDefaultShowAsAction(int i) {
|
|
this.mDefaultShowAsAction = i;
|
|
return this;
|
|
}
|
|
|
|
public void setExclusiveItemChecked(MenuItem menuItem) {
|
|
int groupId = menuItem.getGroupId();
|
|
int size = this.mItems.size();
|
|
stopDispatchingItemsChanged();
|
|
for (int i = 0; i < size; i++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i);
|
|
if (menuItemImpl.getGroupId() == groupId && menuItemImpl.isExclusiveCheckable() && menuItemImpl.isCheckable()) {
|
|
menuItemImpl.setCheckedInt(menuItemImpl == menuItem);
|
|
}
|
|
}
|
|
startDispatchingItemsChanged();
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void setGroupCheckable(int i, boolean z2, boolean z3) {
|
|
int size = this.mItems.size();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i2);
|
|
if (menuItemImpl.getGroupId() == i) {
|
|
menuItemImpl.setExclusiveCheckable(z3);
|
|
menuItemImpl.setCheckable(z2);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.core.internal.view.SupportMenu, android.view.Menu
|
|
public void setGroupDividerEnabled(boolean z2) {
|
|
this.mGroupDividerEnabled = z2;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void setGroupEnabled(int i, boolean z2) {
|
|
int size = this.mItems.size();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i2);
|
|
if (menuItemImpl.getGroupId() == i) {
|
|
menuItemImpl.setEnabled(z2);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void setGroupVisible(int i, boolean z2) {
|
|
int size = this.mItems.size();
|
|
boolean z3 = false;
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
MenuItemImpl menuItemImpl = this.mItems.get(i2);
|
|
if (menuItemImpl.getGroupId() == i && menuItemImpl.setVisibleInt(z2)) {
|
|
z3 = true;
|
|
}
|
|
}
|
|
if (z3) {
|
|
onItemsChanged(true);
|
|
}
|
|
}
|
|
|
|
public MenuBuilder setHeaderIconInt(int i) {
|
|
setHeaderInternal(0, null, i, null, null);
|
|
return this;
|
|
}
|
|
|
|
public MenuBuilder setHeaderIconInt(Drawable drawable) {
|
|
setHeaderInternal(0, null, 0, drawable, null);
|
|
return this;
|
|
}
|
|
|
|
public MenuBuilder setHeaderTitleInt(int i) {
|
|
setHeaderInternal(i, null, 0, null, null);
|
|
return this;
|
|
}
|
|
|
|
public MenuBuilder setHeaderTitleInt(CharSequence charSequence) {
|
|
setHeaderInternal(0, charSequence, 0, null, null);
|
|
return this;
|
|
}
|
|
|
|
public MenuBuilder setHeaderViewInt(View view) {
|
|
setHeaderInternal(0, null, 0, null, view);
|
|
return this;
|
|
}
|
|
|
|
public void setOptionalIconsVisible(boolean z2) {
|
|
this.mOptionalIconsVisible = z2;
|
|
}
|
|
|
|
public void setOverrideVisibleItems(boolean z2) {
|
|
this.mOverrideVisibleItems = z2;
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public void setQwertyMode(boolean z2) {
|
|
this.mQwertyMode = z2;
|
|
onItemsChanged(false);
|
|
}
|
|
|
|
public void setShortcutsVisible(boolean z2) {
|
|
if (this.mShortcutsVisible != z2) {
|
|
setShortcutsVisibleInner(z2);
|
|
onItemsChanged(false);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.Menu
|
|
public int size() {
|
|
return this.mItems.size();
|
|
}
|
|
|
|
public void startDispatchingItemsChanged() {
|
|
this.mPreventDispatchingItemsChanged = false;
|
|
if (this.mItemsChangedWhileDispatchPrevented) {
|
|
this.mItemsChangedWhileDispatchPrevented = false;
|
|
onItemsChanged(this.mStructureChangedWhileDispatchPrevented);
|
|
}
|
|
}
|
|
|
|
public void stopDispatchingItemsChanged() {
|
|
if (!this.mPreventDispatchingItemsChanged) {
|
|
this.mPreventDispatchingItemsChanged = true;
|
|
this.mItemsChangedWhileDispatchPrevented = false;
|
|
this.mStructureChangedWhileDispatchPrevented = false;
|
|
}
|
|
}
|
|
}
|