NavigationMenuPresenter.java revision 33c086b170ad408746728df4a4b5d6d9f10e7508 
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            if (item != null && item.isCheckable()) {
194                mAdapter.setCheckedItem(item);
195            }
196            mMenu.performItemAction(item, this, 0);
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 int VIEW_TYPE_NORMAL = 0;
270        private static final int VIEW_TYPE_SUBHEADER = 1;
271        private static final int VIEW_TYPE_SEPARATOR = 2;
272
273        private final ArrayList<NavigationMenuItem> mItems = new ArrayList<>();
274        private MenuItemImpl mCheckedItem;
275        private ColorDrawable mTransparentIcon;
276        private boolean mUpdateSuspended;
277
278        NavigationMenuAdapter() {
279            prepareMenuItems();
280        }
281
282        @Override
283        public int getCount() {
284            return mItems.size();
285        }
286
287        @Override
288        public NavigationMenuItem getItem(int position) {
289            return mItems.get(position);
290        }
291
292        @Override
293        public long getItemId(int position) {
294            return position;
295        }
296
297        @Override
298        public int getViewTypeCount() {
299            return 3;
300        }
301
302        @Override
303        public int getItemViewType(int position) {
304            NavigationMenuItem item = getItem(position);
305            if (item.isSeparator()) {
306                return VIEW_TYPE_SEPARATOR;
307            } else if (item.getMenuItem().hasSubMenu()) {
308                return VIEW_TYPE_SUBHEADER;
309            } else {
310                return VIEW_TYPE_NORMAL;
311            }
312        }
313
314        @Override
315        public View getView(int position, View convertView, ViewGroup parent) {
316            NavigationMenuItem item = getItem(position);
317            int viewType = getItemViewType(position);
318            switch (viewType) {
319                case VIEW_TYPE_NORMAL:
320                    if (convertView == null) {
321                        convertView = mLayoutInflater.inflate(R.layout.design_navigation_item,
322                                parent, false);
323                    }
324                    NavigationMenuItemView itemView = (NavigationMenuItemView) convertView;
325                    itemView.setIconTintList(mIconTintList);
326                    if (mTextAppearanceSet) {
327                        itemView.setTextAppearance(itemView.getContext(), mTextAppearance);
328                    }
329                    if (mTextColor != null) {
330                        itemView.setTextColor(mTextColor);
331                    }
332                    itemView.setBackgroundDrawable(mItemBackground != null ?
333                            mItemBackground.getConstantState().newDrawable() : null);
334                    itemView.initialize(item.getMenuItem(), 0);
335                    break;
336                case VIEW_TYPE_SUBHEADER:
337                    if (convertView == null) {
338                        convertView = mLayoutInflater.inflate(
339                                R.layout.design_navigation_item_subheader, parent, false);
340                    }
341                    TextView subHeader = (TextView) convertView;
342                    subHeader.setText(item.getMenuItem().getTitle());
343                    break;
344                case VIEW_TYPE_SEPARATOR:
345                    if (convertView == null) {
346                        convertView = mLayoutInflater.inflate(
347                                R.layout.design_navigation_item_separator, parent, false);
348                    }
349                    convertView.setPadding(0, item.getPaddingTop(), 0,
350                            item.getPaddingBottom());
351                    break;
352            }
353            return convertView;
354        }
355
356        @Override
357        public boolean areAllItemsEnabled() {
358            return false;
359        }
360
361        @Override
362        public boolean isEnabled(int position) {
363            return getItem(position).isEnabled();
364        }
365
366        @Override
367        public void notifyDataSetChanged() {
368            prepareMenuItems();
369            super.notifyDataSetChanged();
370        }
371
372        /**
373         * Flattens the visible menu items of {@link #mMenu} into {@link #mItems},
374         * while inserting separators between items when necessary.
375         */
376        private void prepareMenuItems() {
377            if (mUpdateSuspended) {
378                return;
379            }
380            mItems.clear();
381            int currentGroupId = -1;
382            int currentGroupStart = 0;
383            boolean currentGroupHasIcon = false;
384            for (int i = 0, totalSize = mMenu.getVisibleItems().size(); i < totalSize; i++) {
385                MenuItemImpl item = mMenu.getVisibleItems().get(i);
386                if (item.isChecked()) {
387                    setCheckedItem(item);
388                }
389                if (item.isCheckable()) {
390                    item.setExclusiveCheckable(false);
391                }
392                if (item.hasSubMenu()) {
393                    SubMenu subMenu = item.getSubMenu();
394                    if (subMenu.hasVisibleItems()) {
395                        if (i != 0) {
396                            mItems.add(NavigationMenuItem.separator(mPaddingSeparator, 0));
397                        }
398                        mItems.add(NavigationMenuItem.of(item));
399                        boolean subMenuHasIcon = false;
400                        int subMenuStart = mItems.size();
401                        for (int j = 0, size = subMenu.size(); j < size; j++) {
402                            MenuItemImpl subMenuItem = (MenuItemImpl) subMenu.getItem(j);
403                            if (subMenuItem.isVisible()) {
404                                if (!subMenuHasIcon && subMenuItem.getIcon() != null) {
405                                    subMenuHasIcon = true;
406                                }
407                                if (subMenuItem.isCheckable()) {
408                                    subMenuItem.setExclusiveCheckable(false);
409                                }
410                                if (item.isChecked()) {
411                                    setCheckedItem(item);
412                                }
413                                mItems.add(NavigationMenuItem.of(subMenuItem));
414                            }
415                        }
416                        if (subMenuHasIcon) {
417                            appendTransparentIconIfMissing(subMenuStart, mItems.size());
418                        }
419                    }
420                } else {
421                    int groupId = item.getGroupId();
422                    if (groupId != currentGroupId) { // first item in group
423                        currentGroupStart = mItems.size();
424                        currentGroupHasIcon = item.getIcon() != null;
425                        if (i != 0) {
426                            currentGroupStart++;
427                            mItems.add(NavigationMenuItem.separator(
428                                    mPaddingSeparator, mPaddingSeparator));
429                        }
430                    } else if (!currentGroupHasIcon && item.getIcon() != null) {
431                        currentGroupHasIcon = true;
432                        appendTransparentIconIfMissing(currentGroupStart, mItems.size());
433                    }
434                    if (currentGroupHasIcon && item.getIcon() == null) {
435                        item.setIcon(android.R.color.transparent);
436                    }
437                    mItems.add(NavigationMenuItem.of(item));
438                    currentGroupId = groupId;
439                }
440            }
441        }
442
443        private void appendTransparentIconIfMissing(int startIndex, int endIndex) {
444            for (int i = startIndex; i < endIndex; i++) {
445                MenuItem item = mItems.get(i).getMenuItem();
446                if (item.getIcon() == null) {
447                    if (mTransparentIcon == null) {
448                        mTransparentIcon = new ColorDrawable(android.R.color.transparent);
449                    }
450                    item.setIcon(mTransparentIcon);
451                }
452            }
453        }
454
455        public void setCheckedItem(MenuItemImpl checkedItem) {
456            if (mCheckedItem == checkedItem || !checkedItem.isCheckable()) {
457                return;
458            }
459            if (mCheckedItem != null) {
460                mCheckedItem.setChecked(false);
461            }
462            mCheckedItem = checkedItem;
463            checkedItem.setChecked(true);
464        }
465
466        public Bundle createInstanceState() {
467            Bundle state = new Bundle();
468            if (mCheckedItem != null) {
469                state.putInt(STATE_CHECKED_ITEM, mCheckedItem.getItemId());
470            }
471            return state;
472        }
473
474        public void restoreInstanceState(Bundle state) {
475            int checkedItem = state.getInt(STATE_CHECKED_ITEM, 0);
476            if (checkedItem != 0) {
477                mUpdateSuspended = true;
478                for (NavigationMenuItem item : mItems) {
479                    MenuItemImpl menuItem = item.getMenuItem();
480                    if (menuItem !=  null && menuItem.getItemId() == checkedItem) {
481                        setCheckedItem(menuItem);
482                        break;
483                    }
484                }
485                mUpdateSuspended = false;
486                prepareMenuItems();
487            }
488        }
489
490        public void setUpdateSuspended(boolean updateSuspended) {
491            mUpdateSuspended = updateSuspended;
492        }
493
494    }
495
496    /**
497     * Wraps {@link MenuItemImpl}. This allows separators to be counted as items in list.
498     */
499    private static class NavigationMenuItem {
500
501        /** The item; null for separators */
502        private final MenuItemImpl mMenuItem;
503
504        /** Padding top; used only for separators */
505        private final int mPaddingTop;
506
507        /** Padding bottom; used only for separators */
508        private final int mPaddingBottom;
509
510        private NavigationMenuItem(MenuItemImpl item, int paddingTop, int paddingBottom) {
511            mMenuItem = item;
512            mPaddingTop = paddingTop;
513            mPaddingBottom = paddingBottom;
514        }
515
516        public static NavigationMenuItem of(MenuItemImpl item) {
517            return new NavigationMenuItem(item, 0, 0);
518        }
519
520        public static NavigationMenuItem separator(int paddingTop, int paddingBottom) {
521            return new NavigationMenuItem(null, paddingTop, paddingBottom);
522        }
523
524        public boolean isSeparator() {
525            return mMenuItem == null;
526        }
527
528        public int getPaddingTop() {
529            return mPaddingTop;
530        }
531
532        public int getPaddingBottom() {
533            return mPaddingBottom;
534        }
535
536        public MenuItemImpl getMenuItem() {
537            return mMenuItem;
538        }
539
540        public boolean isEnabled() {
541            // Separators and subheaders never respond to click
542            return mMenuItem != null && !mMenuItem.hasSubMenu() && mMenuItem.isEnabled();
543        }
544
545    }
546
547}
548