NavigationMenuPresenter.java revision 153fa9a03422419cd56b7d17def1ae907fc7b5cf 
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(R.dimen.navigation_padding_top_default);
90        mPaddingSeparator = res.getDimensionPixelOffset(
91                R.dimen.navigation_separator_vertical_padding);
92    }
93
94    @Override
95    public MenuView getMenuView(ViewGroup root) {
96        if (mMenuView == null) {
97            mMenuView = (NavigationMenuView) mLayoutInflater.inflate(
98                    R.layout.design_navigation_menu, root, false);
99            if (mAdapter == null) {
100                mAdapter = new NavigationMenuAdapter();
101            }
102            mHeader = (LinearLayout) mLayoutInflater.inflate(R.layout.design_navigation_item_header,
103                    mMenuView, false);
104            mMenuView.addHeaderView(mHeader);
105            mMenuView.setAdapter(mAdapter);
106            mMenuView.setOnItemClickListener(this);
107        }
108        return mMenuView;
109    }
110
111    @Override
112    public void updateMenuView(boolean cleared) {
113        if (mAdapter != null) {
114            mAdapter.notifyDataSetChanged();
115        }
116    }
117
118    @Override
119    public void setCallback(Callback cb) {
120        mCallback = cb;
121    }
122
123    @Override
124    public boolean onSubMenuSelected(SubMenuBuilder subMenu) {
125        return false;
126    }
127
128    @Override
129    public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) {
130        if (mCallback != null) {
131            mCallback.onCloseMenu(menu, allMenusAreClosing);
132        }
133    }
134
135    @Override
136    public boolean flagActionItems() {
137        return false;
138    }
139
140    @Override
141    public boolean expandItemActionView(MenuBuilder menu, MenuItemImpl item) {
142        return false;
143    }
144
145    @Override
146    public boolean collapseItemActionView(MenuBuilder menu, MenuItemImpl item) {
147        return false;
148    }
149
150    @Override
151    public int getId() {
152        return mId;
153    }
154
155    public void setId(int id) {
156        mId = id;
157    }
158
159    @Override
160    public Parcelable onSaveInstanceState() {
161        Bundle state = new Bundle();
162        if (mMenuView != null) {
163            SparseArray<Parcelable> hierarchy = new SparseArray<>();
164            mMenuView.saveHierarchyState(hierarchy);
165            state.putSparseParcelableArray(STATE_HIERARCHY, hierarchy);
166        }
167        if (mAdapter != null) {
168            state.putBundle(STATE_ADAPTER, mAdapter.createInstanceState());
169        }
170        return state;
171    }
172
173    @Override
174    public void onRestoreInstanceState(Parcelable parcelable) {
175        Bundle state = (Bundle) parcelable;
176        SparseArray<Parcelable> hierarchy = state.getSparseParcelableArray(STATE_HIERARCHY);
177        if (hierarchy != null) {
178            mMenuView.restoreHierarchyState(hierarchy);
179        }
180        Bundle adapterState = state.getBundle(STATE_ADAPTER);
181        if (adapterState != null) {
182            mAdapter.restoreInstanceState(adapterState);
183        }
184    }
185
186    @Override
187    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
188        int positionInAdapter = position - mMenuView.getHeaderViewsCount();
189        if (positionInAdapter >= 0) {
190            setUpdateSuspended(true);
191            MenuItemImpl item = mAdapter.getItem(positionInAdapter).getMenuItem();
192            if (item != null && item.isCheckable()) {
193                setCheckedItem(item);
194            }
195            mMenu.performItemAction(item, this, 0);
196            setUpdateSuspended(false);
197            updateMenuView(false);
198        }
199    }
200
201    public void setCheckedItem(MenuItemImpl item) {
202        mAdapter.setCheckedItem(item);
203    }
204
205    public View inflateHeaderView(@LayoutRes int res) {
206        View view = mLayoutInflater.inflate(res, mHeader, false);
207        addHeaderView(view);
208        return view;
209    }
210
211    public void addHeaderView(@NonNull View view) {
212        mHeader.addView(view);
213        // The padding on top should be cleared.
214        mMenuView.setPadding(0, 0, 0, mMenuView.getPaddingBottom());
215    }
216
217    public void removeHeaderView(@NonNull View view) {
218        mHeader.removeView(view);
219        if (mHeader.getChildCount() == 0) {
220            mMenuView.setPadding(0, mPaddingTopDefault, 0, mMenuView.getPaddingBottom());
221        }
222    }
223
224    @Nullable
225    public ColorStateList getItemTintList() {
226        return mIconTintList;
227    }
228
229    public void setItemIconTintList(@Nullable ColorStateList tint) {
230        mIconTintList = tint;
231        updateMenuView(false);
232    }
233
234    @Nullable
235    public ColorStateList getItemTextColor() {
236        return mTextColor;
237    }
238
239    public void setItemTextColor(@Nullable ColorStateList textColor) {
240        mTextColor = textColor;
241        updateMenuView(false);
242    }
243
244    public void setItemTextAppearance(@StyleRes int resId) {
245        mTextAppearance = resId;
246        mTextAppearanceSet = true;
247        updateMenuView(false);
248    }
249
250    public Drawable getItemBackground() {
251        return mItemBackground;
252    }
253
254    public void setItemBackground(Drawable itemBackground) {
255        mItemBackground = itemBackground;
256    }
257
258    public void setUpdateSuspended(boolean updateSuspended) {
259        if (mAdapter != null) {
260            mAdapter.setUpdateSuspended(updateSuspended);
261        }
262    }
263
264    private class NavigationMenuAdapter extends BaseAdapter {
265
266        private static final String STATE_CHECKED_ITEM = "android:menu:checked";
267
268        private static final int VIEW_TYPE_NORMAL = 0;
269        private static final int VIEW_TYPE_SUBHEADER = 1;
270        private static final int VIEW_TYPE_SEPARATOR = 2;
271
272        private final ArrayList<NavigationMenuItem> mItems = new ArrayList<>();
273        private MenuItemImpl mCheckedItem;
274        private ColorDrawable mTransparentIcon;
275        private boolean mUpdateSuspended;
276
277        NavigationMenuAdapter() {
278            prepareMenuItems();
279        }
280
281        @Override
282        public int getCount() {
283            return mItems.size();
284        }
285
286        @Override
287        public NavigationMenuItem getItem(int position) {
288            return mItems.get(position);
289        }
290
291        @Override
292        public long getItemId(int position) {
293            return position;
294        }
295
296        @Override
297        public int getViewTypeCount() {
298            return 3;
299        }
300
301        @Override
302        public int getItemViewType(int position) {
303            NavigationMenuItem item = getItem(position);
304            if (item.isSeparator()) {
305                return VIEW_TYPE_SEPARATOR;
306            } else if (item.getMenuItem().hasSubMenu()) {
307                return VIEW_TYPE_SUBHEADER;
308            } else {
309                return VIEW_TYPE_NORMAL;
310            }
311        }
312
313        @Override
314        public View getView(int position, View convertView, ViewGroup parent) {
315            NavigationMenuItem item = getItem(position);
316            int viewType = getItemViewType(position);
317            switch (viewType) {
318                case VIEW_TYPE_NORMAL:
319                    if (convertView == null) {
320                        convertView = mLayoutInflater.inflate(R.layout.design_navigation_item,
321                                parent, false);
322                    }
323                    NavigationMenuItemView itemView = (NavigationMenuItemView) convertView;
324                    itemView.setIconTintList(mIconTintList);
325                    if (mTextAppearanceSet) {
326                        itemView.setTextAppearance(itemView.getContext(), mTextAppearance);
327                    }
328                    if (mTextColor != null) {
329                        itemView.setTextColor(mTextColor);
330                    }
331                    itemView.setBackgroundDrawable(mItemBackground);
332                    itemView.initialize(item.getMenuItem(), 0);
333                    break;
334                case VIEW_TYPE_SUBHEADER:
335                    if (convertView == null) {
336                        convertView = mLayoutInflater.inflate(
337                                R.layout.design_navigation_item_subheader, parent, false);
338                    }
339                    TextView subHeader = (TextView) convertView;
340                    subHeader.setText(item.getMenuItem().getTitle());
341                    break;
342                case VIEW_TYPE_SEPARATOR:
343                    if (convertView == null) {
344                        convertView = mLayoutInflater.inflate(
345                                R.layout.design_navigation_item_separator, parent, false);
346                    }
347                    convertView.setPadding(0, item.getPaddingTop(), 0,
348                            item.getPaddingBottom());
349                    break;
350            }
351            return convertView;
352        }
353
354        @Override
355        public boolean areAllItemsEnabled() {
356            return false;
357        }
358
359        @Override
360        public boolean isEnabled(int position) {
361            return getItem(position).isEnabled();
362        }
363
364        @Override
365        public void notifyDataSetChanged() {
366            prepareMenuItems();
367            super.notifyDataSetChanged();
368        }
369
370        /**
371         * Flattens the visible menu items of {@link #mMenu} into {@link #mItems},
372         * while inserting separators between items when necessary.
373         */
374        private void prepareMenuItems() {
375            if (mUpdateSuspended) {
376                return;
377            }
378            mItems.clear();
379            int currentGroupId = -1;
380            int currentGroupStart = 0;
381            boolean currentGroupHasIcon = false;
382            for (int i = 0, totalSize = mMenu.getVisibleItems().size(); i < totalSize; i++) {
383                MenuItemImpl item = mMenu.getVisibleItems().get(i);
384                if (item.isChecked()) {
385                    setCheckedItem(item);
386                }
387                if (item.isCheckable()) {
388                    item.setExclusiveCheckable(false);
389                }
390                if (item.hasSubMenu()) {
391                    SubMenu subMenu = item.getSubMenu();
392                    if (subMenu.hasVisibleItems()) {
393                        if (i != 0) {
394                            mItems.add(NavigationMenuItem.separator(mPaddingSeparator, 0));
395                        }
396                        mItems.add(NavigationMenuItem.of(item));
397                        boolean subMenuHasIcon = false;
398                        int subMenuStart = mItems.size();
399                        for (int j = 0, size = subMenu.size(); j < size; j++) {
400                            MenuItemImpl subMenuItem = (MenuItemImpl) subMenu.getItem(j);
401                            if (subMenuItem.isVisible()) {
402                                if (!subMenuHasIcon && subMenuItem.getIcon() != null) {
403                                    subMenuHasIcon = true;
404                                }
405                                if (subMenuItem.isCheckable()) {
406                                    subMenuItem.setExclusiveCheckable(false);
407                                }
408                                if (item.isChecked()) {
409                                    setCheckedItem(item);
410                                }
411                                mItems.add(NavigationMenuItem.of(subMenuItem));
412                            }
413                        }
414                        if (subMenuHasIcon) {
415                            appendTransparentIconIfMissing(subMenuStart, mItems.size());
416                        }
417                    }
418                } else {
419                    int groupId = item.getGroupId();
420                    if (groupId != currentGroupId) { // first item in group
421                        currentGroupStart = mItems.size();
422                        currentGroupHasIcon = item.getIcon() != null;
423                        if (i != 0) {
424                            currentGroupStart++;
425                            mItems.add(NavigationMenuItem.separator(
426                                    mPaddingSeparator, mPaddingSeparator));
427                        }
428                    } else if (!currentGroupHasIcon && item.getIcon() != null) {
429                        currentGroupHasIcon = true;
430                        appendTransparentIconIfMissing(currentGroupStart, mItems.size());
431                    }
432                    if (currentGroupHasIcon && item.getIcon() == null) {
433                        item.setIcon(android.R.color.transparent);
434                    }
435                    mItems.add(NavigationMenuItem.of(item));
436                    currentGroupId = groupId;
437                }
438            }
439        }
440
441        private void appendTransparentIconIfMissing(int startIndex, int endIndex) {
442            for (int i = startIndex; i < endIndex; i++) {
443                MenuItem item = mItems.get(i).getMenuItem();
444                if (item.getIcon() == null) {
445                    if (mTransparentIcon == null) {
446                        mTransparentIcon = new ColorDrawable(android.R.color.transparent);
447                    }
448                    item.setIcon(mTransparentIcon);
449                }
450            }
451        }
452
453        public void setCheckedItem(MenuItemImpl checkedItem) {
454            if (mCheckedItem == checkedItem || !checkedItem.isCheckable()) {
455                return;
456            }
457            if (mCheckedItem != null) {
458                mCheckedItem.setChecked(false);
459            }
460            mCheckedItem = checkedItem;
461            checkedItem.setChecked(true);
462        }
463
464        public Bundle createInstanceState() {
465            Bundle state = new Bundle();
466            state.putInt(STATE_CHECKED_ITEM, mCheckedItem.getItemId());
467            return state;
468        }
469
470        public void restoreInstanceState(Bundle state) {
471            int checkedItem = state.getInt(STATE_CHECKED_ITEM, 0);
472            if (checkedItem != 0) {
473                mUpdateSuspended = true;
474                for (NavigationMenuItem item : mItems) {
475                    MenuItemImpl menuItem = item.getMenuItem();
476                    if (menuItem !=  null && menuItem.getItemId() == checkedItem) {
477                        setCheckedItem(menuItem);
478                        break;
479                    }
480                }
481                mUpdateSuspended = false;
482                prepareMenuItems();
483            }
484        }
485
486        public void setUpdateSuspended(boolean updateSuspended) {
487            mUpdateSuspended = updateSuspended;
488        }
489
490    }
491
492    /**
493     * Wraps {@link MenuItemImpl}. This allows separators to be counted as items in list.
494     */
495    private static class NavigationMenuItem {
496
497        /** The item; null for separators */
498        private final MenuItemImpl mMenuItem;
499
500        /** Padding top; used only for separators */
501        private final int mPaddingTop;
502
503        /** Padding bottom; used only for separators */
504        private final int mPaddingBottom;
505
506        private NavigationMenuItem(MenuItemImpl item, int paddingTop, int paddingBottom) {
507            mMenuItem = item;
508            mPaddingTop = paddingTop;
509            mPaddingBottom = paddingBottom;
510        }
511
512        public static NavigationMenuItem of(MenuItemImpl item) {
513            return new NavigationMenuItem(item, 0, 0);
514        }
515
516        public static NavigationMenuItem separator(int paddingTop, int paddingBottom) {
517            return new NavigationMenuItem(null, paddingTop, paddingBottom);
518        }
519
520        public boolean isSeparator() {
521            return mMenuItem == null;
522        }
523
524        public int getPaddingTop() {
525            return mPaddingTop;
526        }
527
528        public int getPaddingBottom() {
529            return mPaddingBottom;
530        }
531
532        public MenuItemImpl getMenuItem() {
533            return mMenuItem;
534        }
535
536        public boolean isEnabled() {
537            // Separators and subheaders never respond to click
538            return mMenuItem != null && !mMenuItem.hasSubMenu() && mMenuItem.isEnabled();
539        }
540
541    }
542
543}
544