NavigationMenuPresenter.java revision ca2f07c9cc83b98d73a18da7177044ee147ffb94 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.support.design.internal;
18
19import android.content.Context;
20import android.content.res.ColorStateList;
21import android.content.res.Resources;
22import android.graphics.drawable.ColorDrawable;
23import android.graphics.drawable.Drawable;
24import android.os.Bundle;
25import android.os.Parcelable;
26import android.support.annotation.LayoutRes;
27import android.support.annotation.NonNull;
28import android.support.annotation.Nullable;
29import android.support.annotation.StyleRes;
30import android.support.design.R;
31import android.support.v7.internal.view.menu.MenuBuilder;
32import android.support.v7.internal.view.menu.MenuItemImpl;
33import android.support.v7.internal.view.menu.MenuPresenter;
34import android.support.v7.internal.view.menu.MenuView;
35import android.support.v7.internal.view.menu.SubMenuBuilder;
36import android.util.SparseArray;
37import android.view.LayoutInflater;
38import android.view.MenuItem;
39import android.view.SubMenu;
40import android.view.View;
41import android.view.ViewGroup;
42import android.widget.AdapterView;
43import android.widget.BaseAdapter;
44import android.widget.LinearLayout;
45import android.widget.TextView;
46
47import java.util.ArrayList;
48
49/**
50 * @hide
51 */
52public class NavigationMenuPresenter implements MenuPresenter, AdapterView.OnItemClickListener {
53
54    private static final String STATE_HIERARCHY = "android:menu:list";
55    private static final String STATE_ADAPTER = "android:menu:adapter";
56
57    private NavigationMenuView mMenuView;
58    private LinearLayout mHeader;
59
60    private Callback mCallback;
61    private MenuBuilder mMenu;
62    private int mId;
63
64    private NavigationMenuAdapter mAdapter;
65    private LayoutInflater mLayoutInflater;
66
67    private int mTextAppearance;
68    private boolean mTextAppearanceSet;
69    private ColorStateList mTextColor;
70    private ColorStateList mIconTintList;
71    private Drawable mItemBackground;
72
73    /**
74     * Padding to be inserted at the top of the list to avoid the first menu item
75     * from being placed underneath the status bar.
76     */
77    private int mPaddingTopDefault;
78
79    /**
80     * Padding for separators between items
81     */
82    private int mPaddingSeparator;
83
84    @Override
85    public void initForMenu(Context context, MenuBuilder menu) {
86        mLayoutInflater = LayoutInflater.from(context);
87        mMenu = menu;
88        Resources res = context.getResources();
89        mPaddingTopDefault = res.getDimensionPixelOffset(
90                R.dimen.design_navigation_padding_top_default);
91        mPaddingSeparator = res.getDimensionPixelOffset(
92                R.dimen.design_navigation_separator_vertical_padding);
93    }
94
95    @Override
96    public MenuView getMenuView(ViewGroup root) {
97        if (mMenuView == null) {
98            mMenuView = (NavigationMenuView) mLayoutInflater.inflate(
99                    R.layout.design_navigation_menu, root, false);
100            if (mAdapter == null) {
101                mAdapter = new NavigationMenuAdapter();
102            }
103            mHeader = (LinearLayout) mLayoutInflater.inflate(R.layout.design_navigation_item_header,
104                    mMenuView, false);
105            mMenuView.addHeaderView(mHeader, null, false);
106            mMenuView.setAdapter(mAdapter);
107            mMenuView.setOnItemClickListener(this);
108        }
109        return mMenuView;
110    }
111
112    @Override
113    public void updateMenuView(boolean cleared) {
114        if (mAdapter != null) {
115            mAdapter.notifyDataSetChanged();
116        }
117    }
118
119    @Override
120    public void setCallback(Callback cb) {
121        mCallback = cb;
122    }
123
124    @Override
125    public boolean onSubMenuSelected(SubMenuBuilder subMenu) {
126        return false;
127    }
128
129    @Override
130    public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
131        if (mCallback != null) {
132            mCallback.onCloseMenu(menu, allMenusAreClosing);
133        }
134    }
135
136    @Override
137    public boolean flagActionItems() {
138        return false;
139    }
140
141    @Override
142    public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) {
143        return false;
144    }
145
146    @Override
147    public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) {
148        return false;
149    }
150
151    @Override
152    public int getId() {
153        return mId;
154    }
155
156    public void setId(int id) {
157        mId = id;
158    }
159
160    @Override
161    public Parcelable onSaveInstanceState() {
162        Bundle state = new Bundle();
163        if (mMenuView != null) {
164            SparseArray<Parcelable> hierarchy = new SparseArray<>();
165            mMenuView.saveHierarchyState(hierarchy);
166            state.putSparseParcelableArray(STATE_HIERARCHY, hierarchy);
167        }
168        if (mAdapter != null) {
169            state.putBundle(STATE_ADAPTER, mAdapter.createInstanceState());
170        }
171        return state;
172    }
173
174    @Override
175    public void onRestoreInstanceState(Parcelable parcelable) {
176        Bundle state = (Bundle) parcelable;
177        SparseArray<Parcelable> hierarchy = state.getSparseParcelableArray(STATE_HIERARCHY);
178        if (hierarchy != null) {
179            mMenuView.restoreHierarchyState(hierarchy);
180        }
181        Bundle adapterState = state.getBundle(STATE_ADAPTER);
182        if (adapterState != null) {
183            mAdapter.restoreInstanceState(adapterState);
184        }
185    }
186
187    @Override
188    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
189        int positionInAdapter = position - mMenuView.getHeaderViewsCount();
190        if (positionInAdapter >= 0) {
191            setUpdateSuspended(true);
192            MenuItemImpl item = mAdapter.getItem(positionInAdapter).getMenuItem();
193            boolean result = mMenu.performItemAction(item, this, 0);
194            if (item != null && item.isCheckable() && result) {
195                mAdapter.setCheckedItem(item);
196            }
197            setUpdateSuspended(false);
198            updateMenuView(false);
199        }
200    }
201
202    public void setCheckedItem(MenuItemImpl item) {
203        mAdapter.setCheckedItem(item);
204    }
205
206    public View inflateHeaderView(@LayoutRes int res) {
207        View view = mLayoutInflater.inflate(res, mHeader, false);
208        addHeaderView(view);
209        return view;
210    }
211
212    public void addHeaderView(@NonNull View view) {
213        mHeader.addView(view);
214        // The padding on top should be cleared.
215        mMenuView.setPadding(0, 0, 0, mMenuView.getPaddingBottom());
216    }
217
218    public void removeHeaderView(@NonNull View view) {
219        mHeader.removeView(view);
220        if (mHeader.getChildCount() == 0) {
221            mMenuView.setPadding(0, mPaddingTopDefault, 0, mMenuView.getPaddingBottom());
222        }
223    }
224
225    @Nullable
226    public ColorStateList getItemTintList() {
227        return mIconTintList;
228    }
229
230    public void setItemIconTintList(@Nullable ColorStateList tint) {
231        mIconTintList = tint;
232        updateMenuView(false);
233    }
234
235    @Nullable
236    public ColorStateList getItemTextColor() {
237        return mTextColor;
238    }
239
240    public void setItemTextColor(@Nullable ColorStateList textColor) {
241        mTextColor = textColor;
242        updateMenuView(false);
243    }
244
245    public void setItemTextAppearance(@StyleRes int resId) {
246        mTextAppearance = resId;
247        mTextAppearanceSet = true;
248        updateMenuView(false);
249    }
250
251    public Drawable getItemBackground() {
252        return mItemBackground;
253    }
254
255    public void setItemBackground(Drawable itemBackground) {
256        mItemBackground = itemBackground;
257    }
258
259    public void setUpdateSuspended(boolean updateSuspended) {
260        if (mAdapter != null) {
261            mAdapter.setUpdateSuspended(updateSuspended);
262        }
263    }
264
265    private class NavigationMenuAdapter extends BaseAdapter {
266
267        private static final String STATE_CHECKED_ITEM = "android:menu:checked";
268
269        private static final String STATE_ACTION_VIEWS = "android:menu:action_views";
270        private static final int VIEW_TYPE_NORMAL = 0;
271        private static final int VIEW_TYPE_SUBHEADER = 1;
272        private static final int VIEW_TYPE_SEPARATOR = 2;
273
274        private final ArrayList<NavigationMenuItem> mItems = new ArrayList<>();
275        private MenuItemImpl mCheckedItem;
276        private ColorDrawable mTransparentIcon;
277        private boolean mUpdateSuspended;
278
279        NavigationMenuAdapter() {
280            prepareMenuItems();
281        }
282
283        @Override
284        public int getCount() {
285            return mItems.size();
286        }
287
288        @Override
289        public NavigationMenuItem getItem(int position) {
290            return mItems.get(position);
291        }
292
293        @Override
294        public long getItemId(int position) {
295            return position;
296        }
297
298        @Override
299        public int getViewTypeCount() {
300            return 3;
301        }
302
303        @Override
304        public int getItemViewType(int position) {
305            NavigationMenuItem item = getItem(position);
306            if (item.isSeparator()) {
307                return VIEW_TYPE_SEPARATOR;
308            } else if (item.getMenuItem().hasSubMenu()) {
309                return VIEW_TYPE_SUBHEADER;
310            } else {
311                return VIEW_TYPE_NORMAL;
312            }
313        }
314
315        @Override
316        public View getView(int position, View convertView, ViewGroup parent) {
317            NavigationMenuItem item = getItem(position);
318            int viewType = getItemViewType(position);
319            switch (viewType) {
320                case VIEW_TYPE_NORMAL:
321                    if (convertView == null) {
322                        convertView = mLayoutInflater.inflate(R.layout.design_navigation_item,
323                                parent, false);
324                    }
325                    NavigationMenuItemView itemView = (NavigationMenuItemView) convertView;
326                    itemView.setIconTintList(mIconTintList);
327                    if (mTextAppearanceSet) {
328                        itemView.setTextAppearance(itemView.getContext(), mTextAppearance);
329                    }
330                    if (mTextColor != null) {
331                        itemView.setTextColor(mTextColor);
332                    }
333                    itemView.setBackgroundDrawable(mItemBackground != null ?
334                            mItemBackground.getConstantState().newDrawable() : null);
335                    itemView.initialize(item.getMenuItem(), 0);
336                    break;
337                case VIEW_TYPE_SUBHEADER:
338                    if (convertView == null) {
339                        convertView = mLayoutInflater.inflate(
340                                R.layout.design_navigation_item_subheader, parent, false);
341                    }
342                    TextView subHeader = (TextView) convertView;
343                    subHeader.setText(item.getMenuItem().getTitle());
344                    break;
345                case VIEW_TYPE_SEPARATOR:
346                    if (convertView == null) {
347                        convertView = mLayoutInflater.inflate(
348                                R.layout.design_navigation_item_separator, parent, false);
349                    }
350                    convertView.setPadding(0, item.getPaddingTop(), 0,
351                            item.getPaddingBottom());
352                    break;
353            }
354            return convertView;
355        }
356
357        @Override
358        public boolean areAllItemsEnabled() {
359            return false;
360        }
361
362        @Override
363        public boolean isEnabled(int position) {
364            return getItem(position).isEnabled();
365        }
366
367        @Override
368        public void notifyDataSetChanged() {
369            prepareMenuItems();
370            super.notifyDataSetChanged();
371        }
372
373        /**
374         * Flattens the visible menu items of {@link #mMenu} into {@link #mItems},
375         * while inserting separators between items when necessary.
376         */
377        private void prepareMenuItems() {
378            if (mUpdateSuspended) {
379                return;
380            }
381            mUpdateSuspended = true;
382            mItems.clear();
383            int currentGroupId = -1;
384            int currentGroupStart = 0;
385            boolean currentGroupHasIcon = false;
386            for (int i = 0, totalSize = mMenu.getVisibleItems().size(); i < totalSize; i++) {
387                MenuItemImpl item = mMenu.getVisibleItems().get(i);
388                if (item.isChecked()) {
389                    setCheckedItem(item);
390                }
391                if (item.isCheckable()) {
392                    item.setExclusiveCheckable(false);
393                }
394                if (item.hasSubMenu()) {
395                    SubMenu subMenu = item.getSubMenu();
396                    if (subMenu.hasVisibleItems()) {
397                        if (i != 0) {
398                            mItems.add(NavigationMenuItem.separator(mPaddingSeparator, 0));
399                        }
400                        mItems.add(NavigationMenuItem.of(item));
401                        boolean subMenuHasIcon = false;
402                        int subMenuStart = mItems.size();
403                        for (int j = 0, size = subMenu.size(); j < size; j++) {
404                            MenuItemImpl subMenuItem = (MenuItemImpl) subMenu.getItem(j);
405                            if (subMenuItem.isVisible()) {
406                                if (!subMenuHasIcon && subMenuItem.getIcon() != null) {
407                                    subMenuHasIcon = true;
408                                }
409                                if (subMenuItem.isCheckable()) {
410                                    subMenuItem.setExclusiveCheckable(false);
411                                }
412                                if (item.isChecked()) {
413                                    setCheckedItem(item);
414                                }
415                                mItems.add(NavigationMenuItem.of(subMenuItem));
416                            }
417                        }
418                        if (subMenuHasIcon) {
419                            appendTransparentIconIfMissing(subMenuStart, mItems.size());
420                        }
421                    }
422                } else {
423                    int groupId = item.getGroupId();
424                    if (groupId != currentGroupId) { // first item in group
425                        currentGroupStart = mItems.size();
426                        currentGroupHasIcon = item.getIcon() != null;
427                        if (i != 0) {
428                            currentGroupStart++;
429                            mItems.add(NavigationMenuItem.separator(
430                                    mPaddingSeparator, mPaddingSeparator));
431                        }
432                    } else if (!currentGroupHasIcon && item.getIcon() != null) {
433                        currentGroupHasIcon = true;
434                        appendTransparentIconIfMissing(currentGroupStart, mItems.size());
435                    }
436                    if (currentGroupHasIcon && item.getIcon() == null) {
437                        item.setIcon(android.R.color.transparent);
438                    }
439                    mItems.add(NavigationMenuItem.of(item));
440                    currentGroupId = groupId;
441                }
442            }
443            mUpdateSuspended = false;
444        }
445
446        private void appendTransparentIconIfMissing(int startIndex, int endIndex) {
447            for (int i = startIndex; i < endIndex; i++) {
448                MenuItem item = mItems.get(i).getMenuItem();
449                if (item.getIcon() == null) {
450                    if (mTransparentIcon == null) {
451                        mTransparentIcon = new ColorDrawable(android.R.color.transparent);
452                    }
453                    item.setIcon(mTransparentIcon);
454                }
455            }
456        }
457
458        public void setCheckedItem(MenuItemImpl checkedItem) {
459            if (mCheckedItem == checkedItem || !checkedItem.isCheckable()) {
460                return;
461            }
462            if (mCheckedItem != null) {
463                mCheckedItem.setChecked(false);
464            }
465            mCheckedItem = checkedItem;
466            checkedItem.setChecked(true);
467        }
468
469        public Bundle createInstanceState() {
470            Bundle state = new Bundle();
471            if (mCheckedItem != null) {
472                state.putInt(STATE_CHECKED_ITEM, mCheckedItem.getItemId());
473            }
474            // Store the states of the action views.
475            SparseArray<ParcelableSparseArray> actionViewStates = new SparseArray<>();
476            for (NavigationMenuItem navigationMenuItem : mItems) {
477                MenuItemImpl item = navigationMenuItem.getMenuItem();
478                View actionView = item != null ? item.getActionView() : null;
479                if (actionView != null) {
480                    ParcelableSparseArray container = new ParcelableSparseArray();
481                    actionView.saveHierarchyState(container);
482                    actionViewStates.put(item.getItemId(), container);
483                }
484            }
485            state.putSparseParcelableArray(STATE_ACTION_VIEWS, actionViewStates);
486            return state;
487        }
488
489        public void restoreInstanceState(Bundle state) {
490            int checkedItem = state.getInt(STATE_CHECKED_ITEM, 0);
491            if (checkedItem != 0) {
492                mUpdateSuspended = true;
493                for (NavigationMenuItem item : mItems) {
494                    MenuItemImpl menuItem = item.getMenuItem();
495                    if (menuItem != null && menuItem.getItemId() == checkedItem) {
496                        setCheckedItem(menuItem);
497                        break;
498                    }
499                }
500                mUpdateSuspended = false;
501                prepareMenuItems();
502            }
503            // Restore the states of the action views.
504            SparseArray<ParcelableSparseArray> actionViewStates = state
505                    .getSparseParcelableArray(STATE_ACTION_VIEWS);
506            for (NavigationMenuItem navigationMenuItem : mItems) {
507                MenuItemImpl item = navigationMenuItem.getMenuItem();
508                View actionView = item != null ? item.getActionView() : null;
509                if (actionView != null) {
510                    actionView.restoreHierarchyState(actionViewStates.get(item.getItemId()));
511                }
512            }
513        }
514
515        public void setUpdateSuspended(boolean updateSuspended) {
516            mUpdateSuspended = updateSuspended;
517        }
518
519    }
520
521    /**
522     * Wraps {@link MenuItemImpl}. This allows separators to be counted as items in list.
523     */
524    private static class NavigationMenuItem {
525
526        /** The item; null for separators */
527        private final MenuItemImpl mMenuItem;
528
529        /** Padding top; used only for separators */
530        private final int mPaddingTop;
531
532        /** Padding bottom; used only for separators */
533        private final int mPaddingBottom;
534
535        private NavigationMenuItem(MenuItemImpl item, int paddingTop, int paddingBottom) {
536            mMenuItem = item;
537            mPaddingTop = paddingTop;
538            mPaddingBottom = paddingBottom;
539        }
540
541        public static NavigationMenuItem of(MenuItemImpl item) {
542            return new NavigationMenuItem(item, 0, 0);
543        }
544
545        public static NavigationMenuItem separator(int paddingTop, int paddingBottom) {
546            return new NavigationMenuItem(null, paddingTop, paddingBottom);
547        }
548
549        public boolean isSeparator() {
550            return mMenuItem == null;
551        }
552
553        public int getPaddingTop() {
554            return mPaddingTop;
555        }
556
557        public int getPaddingBottom() {
558            return mPaddingBottom;
559        }
560
561        public MenuItemImpl getMenuItem() {
562            return mMenuItem;
563        }
564
565        public boolean isEnabled() {
566            // Separators and subheaders never respond to click
567            return mMenuItem != null && !mMenuItem.hasSubMenu() && mMenuItem.isEnabled();
568        }
569
570    }
571
572}
573