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