Android ActionBar的源代码分析（四）

上一篇已经对ActionBar的菜单项的执行过程进行了分析，有兴趣的朋友可以看一下android中ActionBar的源代码分析（三），本章对ActionBar的OverflowMenu的运行机制进行分析。

ActionBar的OverflowMenu，就是ActionBar右边的三个小点点，点击以后就出现一个下拉菜单项，如图

OverflowMenu是为了解决ActionBar的菜单项太多，在一个屏幕上显示不出来，而把过多的菜单项放到下拉菜单中显示的问题；在配置菜单属性的时候，把android:showAsAction设为ifRoom或者never，就会利用ActionBar的OverflowMenu特性在下拉菜单显示出来了，当然如果你的机器是带有物理menu键的，还需要进行特殊处理，这个可以看一下我之前写的一篇文章android2.x使用ActionBar-强制显示OverflowButton

溢出菜单按钮的构建

既然我们知道了如何使用OverflowMenu，那这个OverflowMenu在代码层次是如何实现的呢？从上几篇文章我们知道，类ActionMenuPresenter是负责ActionBar菜单项的绘制工作的，其中初始菜单参数的方法是initForMenu()，我们先看一下这个代码是如何实现的吧。

    @Override
    public void initForMenu(Context context, MenuBuilder menu) {
        super.initForMenu(context, menu);

        final Resources res = context.getResources();
<span style="white-space:pre">	</span>//是否显示溢出菜单按钮
        final ActionBarPolicy abp = ActionBarPolicy.get(context);
        if (!mReserveOverflowSet) {
            mReserveOverflow = abp.showsOverflowMenuButton();
        }
<span style="white-space:pre">	</span>//嵌入菜单最大宽度即放置ActionBar菜单项的最大宽度
        if (!mWidthLimitSet) {
            mWidthLimit = abp.getEmbeddedMenuWidthLimit();
        }
<span style="white-space:pre">	</span>//ActionBar最多显示的按钮数目
        // Measure for initial configuration
        if (!mMaxItemsSet) {
            mMaxItems = abp.getMaxActionButtons();
        }
<span style="white-space:pre">	</span>//初始化溢出菜单按钮，并计算溢出菜单按钮宽度
        int width = mWidthLimit;
        if (mReserveOverflow) {
            if (mOverflowButton == null) {
                mOverflowButton = new OverflowMenuButton(mSystemContext);
                final int spec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
                mOverflowButton.measure(spec, spec);
            }
            width -= mOverflowButton.getMeasuredWidth();  //显示的菜单按钮宽度需要减掉溢出菜单按钮的宽度
        } else {
            mOverflowButton = null;
        }

        mActionItemWidthLimit = width;

        mMinCellSize = (int) (ActionMenuView.MIN_CELL_SIZE * res.getDisplayMetrics().density);

        // Drop a scrap view as it may no longer reflect the proper context/config.
        mScrapActionButtonView = null;
    }

这段代码首先调用父类(BaseMenuPresenter)的initForMenu()方法，父类的这个方法无非就是一些赋值操作，代码就不贴出来了，然后就根据ActionBarPolicy确定是否显示溢出菜单按钮（OverflowButton）以及ActionBar最多显示的菜单数目，最后对溢出菜单按钮进行初始化操作并计算溢出菜单按钮的宽度。可以看到，这里涉及了很多宽度的获取，包括嵌入的菜单宽度、最大按钮显示数目和溢出菜单按钮的宽度，其实就是为了确定当菜单配置为android:showAsAction=ifRoom时，何时才显示在溢出菜单中（或者干脆就不显示出来），代码逻辑可以参考ActionMenuPresenter.flagActionItems()方法，这里就不贴出来了； 溢出菜单按钮的实现类为OverflowMenuButton，后面会重点进行介绍，这里先记住它就是溢出菜单按钮吧。

溢出菜单按钮（OverflowMenuButton）什么时候放置到ActionBar上的呢？从android中ActionBar的源代码分析（二）我们可以看出，系统在创建菜单时，会调用ActionMenuPresenter的updateMenuView()方法，我们看一下这个方法的实现逻辑：

    @Override
    public void updateMenuView(boolean cleared) {
        final ViewGroup menuViewParent = (ViewGroup) ((View) mMenuView).getParent();
        if (menuViewParent != null) {
<span style="white-space:pre">	</span>    // 使用ActionBar的淡出淡入效果，其实系统本身并没有启用该效果
            ActionBarTransition.beginDelayedTransition(menuViewParent);
        }
        super.updateMenuView(cleared);  //使用父类的方法，构建ActionBar的按钮并添加到ActionMenuView上

        ((View) mMenuView).requestLayout();
<span style="white-space:pre">	</span>//判断菜单是否配置了ActionProvider，如果有则设置ActionProvider的子菜单侦听事件
        if (mMenu != null) {
            final ArrayList<MenuItemImpl> actionItems = mMenu.getActionItems();
            final int count = actionItems.size();
            for (int i = 0; i < count; i++) {
                final ActionProvider provider = actionItems.get(i).getActionProvider();
                if (provider != null) {
                    provider.setSubUiVisibilityListener(this);
                }
            }
        }

        final ArrayList<MenuItemImpl> nonActionItems = mMenu != null ?
                mMenu.getNonActionItems() : null;
<span style="white-space:pre">	</span>//判断是否存在溢出菜单
        boolean hasOverflow = false;
        if (mReserveOverflow && nonActionItems != null) {
            final int count = nonActionItems.size();
            if (count == 1) {
                hasOverflow = !nonActionItems.get(0).isActionViewExpanded();   //如果只有一个菜单按钮，并且该菜单按钮是个可扩展按钮，则不显示溢出菜单按钮
            } else {
                hasOverflow = count > 0;
            }
        }
<span style="white-space:pre">	</span>//如果需要显示溢出菜单，则初始化溢出菜单按钮，并添加到ActionMenuView中
        if (hasOverflow) {
            if (mOverflowButton == null) {
                mOverflowButton = new OverflowMenuButton(mSystemContext);
            }
            ViewGroup parent = (ViewGroup) mOverflowButton.getParent();
            if (parent != mMenuView) {
                if (parent != null) {
                    parent.removeView(mOverflowButton);
                }
                ActionMenuView menuView = (ActionMenuView) mMenuView;
                menuView.addView(mOverflowButton, menuView.generateOverflowButtonLayoutParams());
            }
        } else if (mOverflowButton != null && mOverflowButton.getParent() == mMenuView) {
            ((ViewGroup) mMenuView).removeView(mOverflowButton);
        }

        ((ActionMenuView) mMenuView).setOverflowReserved(mReserveOverflow);
    }

这段代码首先是设置显示ActionBar的淡出淡入效果，从类ActionBarTransition的代码中可以看出，淡出淡入的效果受TRANSITIONS_ENABLED的控制，而TRANSITIONS_ENABLED是等于false的，而且也没发现在哪能设置这个变量的值，所以按照目前来看，ActionBar的淡出淡入效果是没有启用的；然后调用父类（BaseMenuPresenter）的updateMenuView()方法构建ActionBar的菜单按钮并添加到ActionMenuView 上，接着判断菜单是否配置启用了ActionProvider，如果启用了，就设置侦听其子菜单可见行改变的事件；最后判断是否显示溢出菜单，如果显示溢出菜单则调用溢出菜单按钮的初始化方法，并把它添加到ActionMenuView上显示出来；这样溢出菜单按钮就完成了整个的构建过程；

溢出菜单弹出执行过程分析

溢出菜单按钮点击以后，就会弹出下拉菜单来，这个过程在代码层次上具体是怎么实现的呢？这就需要我们看一下类OverflowMenuButton的具体实现了，OverflowMenuButton继承于类ImageButton，也就是说它实际就是一个图片按钮；我们先看一下OverflowMenuButton的构造方法吧

        public OverflowMenuButton(Context context) {
            super(context, null, com.android.internal.R.attr.actionOverflowButtonStyle);
<span style="white-space:pre">	</span>    //设置控件可点击、可设置焦点、可用和可见性
            setClickable(true);
            setFocusable(true);
            setVisibility(VISIBLE);
            setEnabled(true);
<span style="white-space:pre">	</span>    //侦听控件本身的touch事件
            setOnTouchListener(new ForwardingListener(this) {
                @Override
                public ListPopupWindow getPopup() {
                    if (mOverflowPopup == null) {
                        return null;
                    }

                    return mOverflowPopup.getPopup();
                }

                @Override
                public boolean onForwardingStarted() {   // touch事件转发开始后，显示溢出菜单
                    showOverflowMenu();
                    return true;
                }

                @Override
                public boolean onForwardingStopped() {   // 溢出菜单显示后再次touch该控件，则隐藏溢出菜单
                    // Displaying the popup occurs asynchronously, so wait for
                    // the runnable to finish before deciding whether to stop
                    // forwarding.
                    if (mPostedOpenRunnable != null) {
                        return false;
                    }

                    hideOverflowMenu();
                    return true;
                }
            });
        }

OverflowMenuButton的构造方法，首先设置控件可点击、可设置焦点、可用和可见性，然后设置侦听控件的触摸事件，这里用到了ListPopupWindow.ForwardingListener类，该类其实是实现了View.OnTouchListener接口的，有几个方法需要重写：

• onForwardingStarted()表示当手指在触摸溢出菜单按钮时回调该方法，这里是执行了showOverflowMenu()方法，按照字面的意思应该就是显示溢出菜单了，至于代码实现如何，一会再进行分析；
• onForwardingStopped()表示当溢出菜单仍然显示，再次触摸溢出菜单按钮时回调该方法，这里首先判断mPostOpenRunnable是否为空，也即是否采用了Post Runnable的处理方式，如果没有则执行hideOverflowMenu()方法，按照字面的意思就是隐藏溢出菜单，至于代码实现如何，一会再进行分析；
• getPopup()表示获取弹出菜单窗口，也即指定需要控制的弹出窗口，这里设置为溢出菜单按钮关联的PopupWindow

类OverflowMenuButton也重写了View的performClick()方法，代码如下：

        @Override
        public boolean performClick() {
            if (super.performClick()) {
                return true;
            }

            playSoundEffect(SoundEffectConstants.CLICK);
            showOverflowMenu();
            return true;
        }

代码很简单，就是先判断是否父类的performClick()方法的返回值是否为true，如果为true则退出，换句话讲就是判断外部调用的onClick的侦听事件是否返回true，如果没有设置onClick事件的侦听或者侦听回调方法返回值为false，则继续执行后面的showOverflowMenu()方法，本例中由于没有侦听OverflowMenuButton的onClick事件，因此必然要走showOverflowMenu()方法。

从上面分析可以看出，showOverflowMenu()方法是咱们分析溢出菜单显示的关键，那我们就来看一下这个方法的实现逻辑吧

    public boolean showOverflowMenu() {
        if (mReserveOverflow && !isOverflowMenuShowing() && mMenu != null && mMenuView != null &&
                mPostedOpenRunnable == null && !mMenu.getNonActionItems().isEmpty()) {
            OverflowPopup popup = new OverflowPopup(mContext, mMenu, mOverflowButton, true);
            mPostedOpenRunnable = new OpenOverflowRunnable(popup);
            // Post this for later; we might still need a layout for the anchor to be right.
            ((View) mMenuView).post(mPostedOpenRunnable);

            // ActionMenuPresenter uses null as a callback argument here
            // to indicate overflow is opening.
            super.onSubMenuSelected(null);

            return true;
        }
        return false;
    }

代码很简单，首先判断溢出菜单是否已经显示，如果没有显示，则实例化类OverflowPopup和OpenOverflowRunnable，并延后执行OpenOverflowRunnable中run()方法，最后调用父类的onSubMenuSelected()方法。这里的类OverflowPopup是菜单弹出的辅助类，继承于类MenuPopupHelper，负责管理弹出窗体(PopupWindow)的生命周期；而类OpenOverflowRunnable负责PopupWindow的显示，我们看一下OpenOverflowRunnable的代码逻辑：

    private class OpenOverflowRunnable implements Runnable {
        private OverflowPopup mPopup;

        public OpenOverflowRunnable(OverflowPopup popup) {
            mPopup = popup;
        }

        public void run() {
            mMenu.changeMenuMode();
            final View menuView = (View) mMenuView;
            if (menuView != null && menuView.getWindowToken() != null && mPopup.tryShow()) {
                mOverflowPopup = mPopup;
            }
            mPostedOpenRunnable = null;
        }
    }

我们主要看run()方法，在该方法中，首先调用MenuBuilder.changeMenuMode()方法切换菜单模式，也就是说如果菜单已经弹出则隐藏，否则就弹出显示；接着调用OverflowPopup的tryShow()方法弹出溢出菜单窗体。也许有朋友就问，MenuBuilder.changeMenuMode()方法不是已经显示过一次溢出菜单了吗，这里再次显示会不会重复显示呢？当然不会，系统通过设置变量mPostedOpenRunnable是否为空来进行区分，保证只会执行一次显示溢出菜单窗体的代码。

OverflowPopup.tryShow()方法又是如何显示溢出菜单窗体的呢？查找类OverflowPopup并没有tryShow()方法，那么调用的应该就是父类（MenuPopupHelper）的tryShow()方法了，代码如下：

   public boolean tryShow() {
        mPopup = new ListPopupWindow(mContext, null, com.android.internal.R.attr.popupMenuStyle);
        mPopup.setOnDismissListener(this);
        mPopup.setOnItemClickListener(this);
        mPopup.setAdapter(mAdapter);
        mPopup.setModal(true);

        View anchor = mAnchorView;
        if (anchor != null) {
            final boolean addGlobalListener = mTreeObserver == null;
            mTreeObserver = anchor.getViewTreeObserver(); // Refresh to latest
            if (addGlobalListener) mTreeObserver.addOnGlobalLayoutListener(this);
            anchor.addOnAttachStateChangeListener(this);
            mPopup.setAnchorView(anchor);
            mPopup.setDropDownGravity(mDropDownGravity);
        } else {
            return false;
        }

        if (!mHasContentWidth) {
            mContentWidth = measureContentWidth();
            mHasContentWidth = true;
        }

        mPopup.setContentWidth(mContentWidth);
        mPopup.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED);
        mPopup.show();
        mPopup.getListView().setOnKeyListener(this);
        return true;
    }

在这个代码中，首先是实例化ListPopupWindow，然后对这个ListPopupWindow对象进行各种属性赋值操作，最后调用show方法显示出来。这里的类ListPopupWindow通俗来讲就是一个包含一个ListView的PopupWindow，其具体的用法百度上有一大堆，有兴趣的朋友可以研究一下哈，这里就不过多赘述。使用ListPopupWindow时，有三个方法要注意：

• setDismissListener() 负责侦听弹出窗体关闭的事件；这里把this传入，也就是说OverflowPopup的父类MenuPopupHelper是实现了接口PopupWindow.OnDismissListener的，也即实现了接口方法onDismiss()的，关于onDismiss()方法，稍后在分析溢出菜单隐藏时再进行介绍；
• setOnItemClickListener() 负责侦听弹出窗体的菜单项点击事件；这里把this传入，也就是说OverflowPopup的父类MenuPopupHelper是实现了接口AdapterView.OnItemClickListener的，也就是实现了接口方法onItemClick()的，在这个方法中，会调用MenuBuilder的performItemAction()方法，这个方法在上一章已经进行过介绍，有兴趣的朋友可以看android中ActionBar的源代码分析（三）
• setAdapter() 这个就是设置ListView的数据适配类；这里传入的是mAdapter，其实现类为MenuPopupHelper.MenuAdapter，实现代码如下：

    private class MenuAdapter extends BaseAdapter {
        private MenuBuilder mAdapterMenu;
        private int mExpandedIndex = -1;

        public MenuAdapter(MenuBuilder menu) {
            mAdapterMenu = menu;
            findExpandedIndex();
        }

        public int getCount() {
            ArrayList<MenuItemImpl> items = mOverflowOnly ?
                    mAdapterMenu.getNonActionItems() : mAdapterMenu.getVisibleItems();
            if (mExpandedIndex < 0) {
                return items.size();
            }
            return items.size() - 1;
        }

        public MenuItemImpl getItem(int position) {
            ArrayList<MenuItemImpl> items = mOverflowOnly ?
                    mAdapterMenu.getNonActionItems() : mAdapterMenu.getVisibleItems();
            if (mExpandedIndex >= 0 && position >= mExpandedIndex) {
                position++;
            }
            return items.get(position);
        }

        public long getItemId(int position) {
            // Since a menu item's ID is optional, we'll use the position as an
            // ID for the item in the AdapterView
            return position;
        }

        public View getView(int position, View convertView, ViewGroup parent) {
            if (convertView == null) {
                convertView = mInflater.inflate(ITEM_LAYOUT, parent, false);
            }

            MenuView.ItemView itemView = (MenuView.ItemView) convertView;
            if (mForceShowIcon) {
                ((ListMenuItemView) convertView).setForceShowIcon(true);
            }
            itemView.initialize(getItem(position), 0);
            return convertView;
        }

        void findExpandedIndex() {
            final MenuItemImpl expandedItem = mMenu.getExpandedItem();
            if (expandedItem != null) {
                final ArrayList<MenuItemImpl> items = mMenu.getNonActionItems();
                final int count = items.size();
                for (int i = 0; i < count; i++) {
                    final MenuItemImpl item = items.get(i);
                    if (item == expandedItem) {
                        mExpandedIndex = i;
                        return;
                    }
                }
            }
            mExpandedIndex = -1;
        }

        @Override
        public void notifyDataSetChanged() {
            findExpandedIndex();
            super.notifyDataSetChanged();
        }
    }

我们重点看getCount()和getView()方法即可，在getCount()方法中，获取ActionBar的不可见菜单项，然后判断在这些不可见菜单项中是否有可扩展折叠菜单项，如果有则排除掉，换句话讲就是可扩展折叠的菜单项是不会显示在溢出菜单中的；在getView()方法中通过inflater布局文件framework\data\res\layout\popup_menu_item_layout.xml来创建视图，并对菜单项进行初始化操作，下面是popup_menu_item_layout.xml的内容

<com.android.internal.view.menu.ListMenuItemView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="?android:attr/dropdownListPreferredItemHeight"
    android:minWidth="196dip"
    android:paddingEnd="16dip">
    
    <!-- Icon will be inserted here. -->
    
    <!-- The title and summary have some gap between them, and this 'group' should be centered vertically. -->
    <RelativeLayout
        android:layout_width="0dip"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:layout_gravity="center_vertical"
        android:layout_marginStart="16dip"
        android:duplicateParentState="true">
        
        <TextView 
            android:id="@+id/title"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignParentTop="true"
            android:layout_alignParentStart="true"
            android:textAppearance="?android:attr/textAppearanceLargePopupMenu"
            android:singleLine="true"
            android:duplicateParentState="true"
            android:ellipsize="marquee"
            android:fadingEdge="horizontal"
            android:textAlignment="viewStart" />

        <TextView
            android:id="@+id/shortcut"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_below="@id/title"
            android:layout_alignParentStart="true"
            android:textAppearance="?android:attr/textAppearanceSmallPopupMenu"
            android:singleLine="true"
            android:duplicateParentState="true"
            android:textAlignment="viewStart" />

    </RelativeLayout>

    <!-- Checkbox, and/or radio button will be inserted here. -->
    
</com.android.internal.view.menu.ListMenuItemView>

可以看到，其实每一个溢出菜单的菜单项的实现类为ListMenuItemView，它继承于LinearLayout；ListMenuItemView包含三个子视图：一个ImageView，负责显示菜单图标；一个TextView，负责显示菜单标题；一个TextView，负责显示菜单的快捷方式，默认情况下快捷方式是不显示的。其中两个TextView是在布局文件中列出，还有一个ImageView，是通过代码来创建的，可以看一下ListMenuItemView的setIcon()方法如下：

    public void setIcon(Drawable icon) {
<span style="white-space:pre">	</span>//判断图标是否需要显示
        final boolean showIcon = mItemData.shouldShowIcon() || mForceShowIcon;
        if (!showIcon && !mPreserveIconSpacing) {
            return;
        }
        
        if (mIconView == null && icon == null && !mPreserveIconSpacing) {
            return;
        }
        //如果需要显示图标，则创建控件并添加进来
        if (mIconView == null) {
            insertIconView();
        }
        //设置可见性
        if (icon != null || mPreserveIconSpacing) {
            mIconView.setImageDrawable(showIcon ? icon : null);

            if (mIconView.getVisibility() != VISIBLE) {
                mIconView.setVisibility(VISIBLE);
            }
        } else {
            mIconView.setVisibility(GONE);
        }
    }

声明一下，setIcon()方法是在ListMenuItemView.initialize()方法中调用的，而ListMenuItemView.initialize()又是由类MenuPopupHelper.MenuAdapter在方法getView()中调用的；

在setIcon()方法中，首先判断图标是否需要显示，如果不需要显示则直接退出，否则就创建ImageView来显示图标，最后设置ImageView的可见性，这里我们注意到，菜单图标的可见性受mItemData.shouldShowIcon()的控制，这里的mItemData的实现类为MenuItemImpl，我们看一下MenuItemImpl.shouldShowIcon()的实现代码：

    public boolean shouldShowIcon() {
        return mMenu.getOptionalIconsVisible();
    }

很简单，就是直接调用MenuBuilder.getOptionalIconsVisible()的方法进行判断，而getOptionalIconsVisible()是直接返回mOptionalIconsVisible的值，mOptionalIconsVisible的默认值为false，它是通过setOptionalIconsVisible()设置进来的，不幸的是setOptionalIconsVisible()的方法修饰符为Internal，外部是无法访问的，只能通过反射的方式来修改；这就是为什么在默认情况下，溢出菜单显示的菜单项只有文字没有图标的原因了！

溢出菜单隐藏执行过程分析

上面提到ListPopupWindow是一个包含ListView的PopupWindow，OverflowPopup在创建ListPopupWindow时，调用ListPopupWindow.setDismiss()去侦听弹出窗体关闭的事件，而传入参数为this，也就是OverflowPopup的父类MenuPopupHelper是实现了接口PopupWindow.OnDismissListener的，也即实现了接口方法onDismiss()的，onDismiss()方法的代码如下：

    public void onDismiss() {
        mPopup = null;
        mMenu.close();
        if (mTreeObserver != null) {
            if (!mTreeObserver.isAlive()) mTreeObserver = mAnchorView.getViewTreeObserver();
            mTreeObserver.removeGlobalOnLayoutListener(this);
            mTreeObserver = null;
        }
        mAnchorView.removeOnAttachStateChangeListener(this);
    }

这里调用了MenuBuilder.close()方法进行关闭弹出菜单操作，下面是MenuBuilder.close()方法的实现代码：

    public void close() {
        close(true);
    }

    final void close(boolean allMenusAreClosing) {
        if (mIsClosing) return;

        mIsClosing = true;
        for (WeakReference<MenuPresenter> ref : mPresenters) {
            final MenuPresenter presenter = ref.get();
            if (presenter == null) {
                mPresenters.remove(ref);
            } else {
                presenter.onCloseMenu(this, allMenusAreClosing);
            }
        }
        mIsClosing = false;
    }

其实就是调用了ActionMenuPresenter.onCloseMenu()方法执行关闭操作：

    public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
        dismissPopupMenus();
        super.onCloseMenu(menu, allMenusAreClosing);
    }

    public boolean dismissPopupMenus() {
        boolean result = hideOverflowMenu();
        result |= hideSubMenus();
        return result;
    }

可以看到执行关闭菜单的操作，都是执行了hideOverflowMenu()方法来实现的：

    public boolean hideOverflowMenu() {
        if (mPostedOpenRunnable != null && mMenuView != null) {
            ((View) mMenuView).removeCallbacks(mPostedOpenRunnable);
            mPostedOpenRunnable = null;
            return true;
        }

        MenuPopupHelper popup = mOverflowPopup;
        if (popup != null) {
            popup.dismiss();
            return true;
        }
        return false;
    }

hideOverflowMenu()方法实现逻辑很简单，其实就是调用了PopupWindow的dismiss方法进行的。

关于ActionBar的OverflowMenu的执行过程分析到此为止，如有需要交流，欢迎留言！