Java tutorial
/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.support.v7.internal.view.menu; import android.content.ActivityNotFoundException; import android.content.Context; import android.content.Intent; import android.graphics.drawable.Drawable; import android.os.Build; import android.support.v4.content.ContextCompat; import android.support.v4.view.ActionProvider; import android.support.v4.internal.view.SupportMenuItem; import android.support.v4.view.MenuItemCompat; import android.support.v7.internal.widget.TintManager; import android.util.Log; import android.view.ContextMenu.ContextMenuInfo; import android.view.LayoutInflater; import android.view.MenuItem; import android.view.SubMenu; import android.view.View; import android.view.ViewDebug; import android.widget.LinearLayout; /** * @hide */ public final class MenuItemImpl implements SupportMenuItem { private static final String TAG = "MenuItemImpl"; private static final int SHOW_AS_ACTION_MASK = SHOW_AS_ACTION_NEVER | SHOW_AS_ACTION_IF_ROOM | SHOW_AS_ACTION_ALWAYS; private final int mId; private final int mGroup; private final int mCategoryOrder; private final int mOrdering; private CharSequence mTitle; private CharSequence mTitleCondensed; private Intent mIntent; private char mShortcutNumericChar; private char mShortcutAlphabeticChar; /** The icon's drawable which is only created as needed */ private Drawable mIconDrawable; /** * The icon's resource ID which is used to get the Drawable when it is * needed (if the Drawable isn't already obtained--only one of the two is * needed). */ private int mIconResId = NO_ICON; /** The menu to which this item belongs */ private MenuBuilder mMenu; /** If this item should launch a sub menu, this is the sub menu to launch */ private SubMenuBuilder mSubMenu; private Runnable mItemCallback; private SupportMenuItem.OnMenuItemClickListener mClickListener; private int mFlags = ENABLED; private static final int CHECKABLE = 0x00000001; private static final int CHECKED = 0x00000002; private static final int EXCLUSIVE = 0x00000004; private static final int HIDDEN = 0x00000008; private static final int ENABLED = 0x00000010; private static final int IS_ACTION = 0x00000020; private int mShowAsAction = SHOW_AS_ACTION_NEVER; private View mActionView; private ActionProvider mActionProvider; private MenuItemCompat.OnActionExpandListener mOnActionExpandListener; private boolean mIsActionViewExpanded = false; /** Used for the icon resource ID if this item does not have an icon */ static final int NO_ICON = 0; /** * Current use case is for context menu: Extra information linked to the * View that added this item to the context menu. */ private ContextMenuInfo mMenuInfo; private static String sPrependShortcutLabel; private static String sEnterShortcutLabel; private static String sDeleteShortcutLabel; private static String sSpaceShortcutLabel; /** * Instantiates this menu item. * * @param menu * @param group Item ordering grouping control. The item will be added after * all other items whose order is <= this number, and before any * that are larger than it. This can also be used to define * groups of items for batch state changes. Normally use 0. * @param id Unique item ID. Use 0 if you do not need a unique ID. * @param categoryOrder The ordering for this item. * @param title The text to display for the item. */ MenuItemImpl(MenuBuilder menu, int group, int id, int categoryOrder, int ordering, CharSequence title, int showAsAction) { /*if (sPrependShortcutLabel == null) { // This is instantiated from the UI thread, so no chance of sync issues sPrependShortcutLabel = menu.getContext().getResources().getString( com.android.internal.R.string.prepend_shortcut_label); sEnterShortcutLabel = menu.getContext().getResources().getString( com.android.internal.R.string.menu_enter_shortcut_label); sDeleteShortcutLabel = menu.getContext().getResources().getString( com.android.internal.R.string.menu_delete_shortcut_label); sSpaceShortcutLabel = menu.getContext().getResources().getString( com.android.internal.R.string.menu_space_shortcut_label); }*/ mMenu = menu; mId = id; mGroup = group; mCategoryOrder = categoryOrder; mOrdering = ordering; mTitle = title; mShowAsAction = showAsAction; } /** * Invokes the item by calling various listeners or callbacks. * * @return true if the invocation was handled, false otherwise */ public boolean invoke() { if (mClickListener != null && mClickListener.onMenuItemClick(this)) { return true; } if (mMenu.dispatchMenuItemSelected(mMenu.getRootMenu(), this)) { return true; } if (mItemCallback != null) { mItemCallback.run(); return true; } if (mIntent != null) { try { mMenu.getContext().startActivity(mIntent); return true; } catch (ActivityNotFoundException e) { Log.e(TAG, "Can't find activity to handle intent; ignoring", e); } } if (mActionProvider != null && mActionProvider.onPerformDefaultAction()) { return true; } return false; } @Override public boolean isEnabled() { return (mFlags & ENABLED) != 0; } @Override public MenuItem setEnabled(boolean enabled) { if (enabled) { mFlags |= ENABLED; } else { mFlags &= ~ENABLED; } mMenu.onItemsChanged(false); return this; } @Override public int getGroupId() { return mGroup; } @Override @ViewDebug.CapturedViewProperty public int getItemId() { return mId; } @Override public int getOrder() { return mCategoryOrder; } public int getOrdering() { return mOrdering; } @Override public Intent getIntent() { return mIntent; } @Override public MenuItem setIntent(Intent intent) { mIntent = intent; return this; } Runnable getCallback() { return mItemCallback; } public MenuItem setCallback(Runnable callback) { mItemCallback = callback; return this; } @Override public char getAlphabeticShortcut() { return mShortcutAlphabeticChar; } @Override public MenuItem setAlphabeticShortcut(char alphaChar) { if (mShortcutAlphabeticChar == alphaChar) { return this; } mShortcutAlphabeticChar = Character.toLowerCase(alphaChar); mMenu.onItemsChanged(false); return this; } @Override public char getNumericShortcut() { return mShortcutNumericChar; } @Override public MenuItem setNumericShortcut(char numericChar) { if (mShortcutNumericChar == numericChar) { return this; } mShortcutNumericChar = numericChar; mMenu.onItemsChanged(false); return this; } @Override public MenuItem setShortcut(char numericChar, char alphaChar) { mShortcutNumericChar = numericChar; mShortcutAlphabeticChar = Character.toLowerCase(alphaChar); mMenu.onItemsChanged(false); return this; } /** * @return The active shortcut (based on QWERTY-mode of the menu). */ char getShortcut() { return (mMenu.isQwertyMode() ? mShortcutAlphabeticChar : mShortcutNumericChar); } /** * @return The label to show for the shortcut. This includes the chording key (for example * 'Menu+a'). Also, any non-human readable characters should be human readable (for * example 'Menu+enter'). */ String getShortcutLabel() { char shortcut = getShortcut(); if (shortcut == 0) { return ""; } StringBuilder sb = new StringBuilder(sPrependShortcutLabel); switch (shortcut) { case '\n': sb.append(sEnterShortcutLabel); break; case '\b': sb.append(sDeleteShortcutLabel); break; case ' ': sb.append(sSpaceShortcutLabel); break; default: sb.append(shortcut); break; } return sb.toString(); } /** * @return Whether this menu item should be showing shortcuts (depends on * whether the menu should show shortcuts and whether this item has * a shortcut defined) */ boolean shouldShowShortcut() { // Show shortcuts if the menu is supposed to show shortcuts AND this item has a shortcut return mMenu.isShortcutsVisible() && (getShortcut() != 0); } @Override public SubMenu getSubMenu() { return mSubMenu; } @Override public boolean hasSubMenu() { return mSubMenu != null; } void setSubMenu(SubMenuBuilder subMenu) { mSubMenu = subMenu; subMenu.setHeaderTitle(getTitle()); } @Override @ViewDebug.CapturedViewProperty public CharSequence getTitle() { return mTitle; } /** * Gets the title for a particular {@link MenuView.ItemView} * * @param itemView The ItemView that is receiving the title * @return Either the title or condensed title based on what the ItemView prefers */ CharSequence getTitleForItemView(MenuView.ItemView itemView) { return ((itemView != null) && itemView.prefersCondensedTitle()) ? getTitleCondensed() : getTitle(); } @Override public MenuItem setTitle(CharSequence title) { mTitle = title; mMenu.onItemsChanged(false); if (mSubMenu != null) { mSubMenu.setHeaderTitle(title); } return this; } @Override public MenuItem setTitle(int title) { return setTitle(mMenu.getContext().getString(title)); } @Override public CharSequence getTitleCondensed() { final CharSequence ctitle = mTitleCondensed != null ? mTitleCondensed : mTitle; if (Build.VERSION.SDK_INT < 18 && ctitle != null && !(ctitle instanceof String)) { // For devices pre-JB-MR2, where we have a non-String CharSequence, we need to // convert this to a String so that EventLog.writeEvent() does not throw an exception // in Activity.onMenuItemSelected() return ctitle.toString(); } else { // Else, we just return the condensed title return ctitle; } } @Override public MenuItem setTitleCondensed(CharSequence title) { mTitleCondensed = title; // Could use getTitle() in the loop below, but just cache what it would do here if (title == null) { title = mTitle; } mMenu.onItemsChanged(false); return this; } @Override public Drawable getIcon() { if (mIconDrawable != null) { return mIconDrawable; } if (mIconResId != NO_ICON) { Drawable icon = TintManager.getDrawable(mMenu.getContext(), mIconResId); mIconResId = NO_ICON; mIconDrawable = icon; return icon; } return null; } @Override public MenuItem setIcon(Drawable icon) { mIconResId = NO_ICON; mIconDrawable = icon; mMenu.onItemsChanged(false); return this; } @Override public MenuItem setIcon(int iconResId) { mIconDrawable = null; mIconResId = iconResId; // If we have a view, we need to push the Drawable to them mMenu.onItemsChanged(false); return this; } @Override public boolean isCheckable() { return (mFlags & CHECKABLE) == CHECKABLE; } @Override public MenuItem setCheckable(boolean checkable) { final int oldFlags = mFlags; mFlags = (mFlags & ~CHECKABLE) | (checkable ? CHECKABLE : 0); if (oldFlags != mFlags) { mMenu.onItemsChanged(false); } return this; } public void setExclusiveCheckable(boolean exclusive) { mFlags = (mFlags & ~EXCLUSIVE) | (exclusive ? EXCLUSIVE : 0); } public boolean isExclusiveCheckable() { return (mFlags & EXCLUSIVE) != 0; } @Override public boolean isChecked() { return (mFlags & CHECKED) == CHECKED; } @Override public MenuItem setChecked(boolean checked) { if ((mFlags & EXCLUSIVE) != 0) { // Call the method on the Menu since it knows about the others in this // exclusive checkable group mMenu.setExclusiveItemChecked(this); } else { setCheckedInt(checked); } return this; } void setCheckedInt(boolean checked) { final int oldFlags = mFlags; mFlags = (mFlags & ~CHECKED) | (checked ? CHECKED : 0); if (oldFlags != mFlags) { mMenu.onItemsChanged(false); } } @Override public boolean isVisible() { if (mActionProvider != null && mActionProvider.overridesItemVisibility()) { return (mFlags & HIDDEN) == 0 && mActionProvider.isVisible(); } return (mFlags & HIDDEN) == 0; } /** * Changes the visibility of the item. This method DOES NOT notify the parent menu of a change * in this item, so this should only be called from methods that will eventually trigger this * change. If unsure, use {@link #setVisible(boolean)} instead. * * @param shown Whether to show (true) or hide (false). * @return Whether the item's shown state was changed */ boolean setVisibleInt(boolean shown) { final int oldFlags = mFlags; mFlags = (mFlags & ~HIDDEN) | (shown ? 0 : HIDDEN); return oldFlags != mFlags; } @Override public MenuItem setVisible(boolean shown) { // Try to set the shown state to the given state. If the shown state was changed // (i.e. the previous state isn't the same as given state), notify the parent menu that // the shown state has changed for this item if (setVisibleInt(shown)) mMenu.onItemVisibleChanged(this); return this; } @Override public MenuItem setOnMenuItemClickListener(MenuItem.OnMenuItemClickListener clickListener) { mClickListener = clickListener; return this; } @Override public String toString() { return mTitle.toString(); } void setMenuInfo(ContextMenuInfo menuInfo) { mMenuInfo = menuInfo; } @Override public ContextMenuInfo getMenuInfo() { return mMenuInfo; } public void actionFormatChanged() { mMenu.onItemActionRequestChanged(this); } /** * @return Whether the menu should show icons for menu items. */ public boolean shouldShowIcon() { return mMenu.getOptionalIconsVisible(); } public boolean isActionButton() { return (mFlags & IS_ACTION) == IS_ACTION; } public boolean requestsActionButton() { return (mShowAsAction & SHOW_AS_ACTION_IF_ROOM) == SHOW_AS_ACTION_IF_ROOM; } public boolean requiresActionButton() { return (mShowAsAction & SHOW_AS_ACTION_ALWAYS) == SHOW_AS_ACTION_ALWAYS; } public void setIsActionButton(boolean isActionButton) { if (isActionButton) { mFlags |= IS_ACTION; } else { mFlags &= ~IS_ACTION; } } public boolean showsTextAsAction() { return (mShowAsAction & SHOW_AS_ACTION_WITH_TEXT) == SHOW_AS_ACTION_WITH_TEXT; } @Override public void setShowAsAction(int actionEnum) { switch (actionEnum & SHOW_AS_ACTION_MASK) { case SHOW_AS_ACTION_ALWAYS: case SHOW_AS_ACTION_IF_ROOM: case SHOW_AS_ACTION_NEVER: // Looks good! break; default: // Mutually exclusive options selected! throw new IllegalArgumentException("SHOW_AS_ACTION_ALWAYS, SHOW_AS_ACTION_IF_ROOM," + " and SHOW_AS_ACTION_NEVER are mutually exclusive."); } mShowAsAction = actionEnum; mMenu.onItemActionRequestChanged(this); } @Override public SupportMenuItem setActionView(View view) { mActionView = view; mActionProvider = null; if (view != null && view.getId() == View.NO_ID && mId > 0) { view.setId(mId); } mMenu.onItemActionRequestChanged(this); return this; } @Override public SupportMenuItem setActionView(int resId) { final Context context = mMenu.getContext(); final LayoutInflater inflater = LayoutInflater.from(context); setActionView(inflater.inflate(resId, new LinearLayout(context), false)); return this; } @Override public View getActionView() { if (mActionView != null) { return mActionView; } else if (mActionProvider != null) { mActionView = mActionProvider.onCreateActionView(this); return mActionView; } else { return null; } } @Override public MenuItem setActionProvider(android.view.ActionProvider actionProvider) { throw new UnsupportedOperationException("This is not supported, use MenuItemCompat.setActionProvider()"); } @Override public android.view.ActionProvider getActionProvider() { throw new UnsupportedOperationException("This is not supported, use MenuItemCompat.getActionProvider()"); } @Override public ActionProvider getSupportActionProvider() { return mActionProvider; } @Override public SupportMenuItem setSupportActionProvider(ActionProvider actionProvider) { if (mActionProvider != null) { mActionProvider.setVisibilityListener(null); } mActionView = null; mActionProvider = actionProvider; mMenu.onItemsChanged(true); // Measurement can be changed if (mActionProvider != null) { mActionProvider.setVisibilityListener(new ActionProvider.VisibilityListener() { @Override public void onActionProviderVisibilityChanged(boolean isVisible) { mMenu.onItemVisibleChanged(MenuItemImpl.this); } }); } return this; } @Override public SupportMenuItem setShowAsActionFlags(int actionEnum) { setShowAsAction(actionEnum); return this; } @Override public boolean expandActionView() { if (!hasCollapsibleActionView()) { return false; } if (mOnActionExpandListener == null || mOnActionExpandListener.onMenuItemActionExpand(this)) { return mMenu.expandItemActionView(this); } return false; } @Override public boolean collapseActionView() { if ((mShowAsAction & SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW) == 0) { return false; } if (mActionView == null) { // We're already collapsed if we have no action view. return true; } if (mOnActionExpandListener == null || mOnActionExpandListener.onMenuItemActionCollapse(this)) { return mMenu.collapseItemActionView(this); } return false; } @Override public SupportMenuItem setSupportOnActionExpandListener(MenuItemCompat.OnActionExpandListener listener) { mOnActionExpandListener = listener; return this; } public boolean hasCollapsibleActionView() { if ((mShowAsAction & SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW) != 0) { if (mActionView == null && mActionProvider != null) { mActionView = mActionProvider.onCreateActionView(this); } return mActionView != null; } return false; } public void setActionViewExpanded(boolean isExpanded) { mIsActionViewExpanded = isExpanded; mMenu.onItemsChanged(false); } @Override public boolean isActionViewExpanded() { return mIsActionViewExpanded; } @Override public MenuItem setOnActionExpandListener(MenuItem.OnActionExpandListener listener) { throw new UnsupportedOperationException( "This is not supported, use MenuItemCompat.setOnActionExpandListener()"); } }