1 /*
2  * Copyright (C) 2014 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 
17 
18 package com.android.internal.widget;
19 
20 import android.animation.Animator;
21 import android.animation.AnimatorListenerAdapter;
22 import android.animation.ObjectAnimator;
23 import android.app.ActionBar;
24 import android.content.Context;
25 import android.content.res.TypedArray;
26 import android.graphics.drawable.Drawable;
27 import android.os.Parcelable;
28 import android.text.TextUtils;
29 import android.util.Log;
30 import android.util.SparseArray;
31 import android.view.Gravity;
32 import android.view.LayoutInflater;
33 import android.view.Menu;
34 import android.view.View;
35 import android.view.ViewGroup;
36 import android.view.Window;
37 import android.widget.ActionMenuPresenter;
38 import android.widget.AdapterView;
39 import android.widget.Spinner;
40 import android.widget.SpinnerAdapter;
41 import android.widget.Toolbar;
42 import com.android.internal.R;
43 import com.android.internal.view.menu.ActionMenuItem;
44 import com.android.internal.view.menu.MenuBuilder;
45 import com.android.internal.view.menu.MenuPresenter;
46 
47 /**
48  * Internal class used to interact with the Toolbar widget without
49  * exposing interface methods to the public API.
50  *
51  * <p>ToolbarWidgetWrapper manages the differences between Toolbar and ActionBarView
52  * so that either variant acting as a
53  * {@link com.android.internal.app.WindowDecorActionBar WindowDecorActionBar} can behave
54  * in the same way.</p>
55  *
56  * @hide
57  */
58 public class ToolbarWidgetWrapper implements DecorToolbar {
59     private static final String TAG = "ToolbarWidgetWrapper";
60 
61     private static final int AFFECTS_LOGO_MASK =
62             ActionBar.DISPLAY_SHOW_HOME | ActionBar.DISPLAY_USE_LOGO;
63     // Default fade duration for fading in/out tool bar.
64     private static final long DEFAULT_FADE_DURATION_MS = 200;
65 
66     private Toolbar mToolbar;
67 
68     private int mDisplayOpts;
69     private View mTabView;
70     private Spinner mSpinner;
71     private View mCustomView;
72 
73     private Drawable mIcon;
74     private Drawable mLogo;
75     private Drawable mNavIcon;
76 
77     private boolean mTitleSet;
78     private CharSequence mTitle;
79     private CharSequence mSubtitle;
80     private CharSequence mHomeDescription;
81 
82     private Window.Callback mWindowCallback;
83     private boolean mMenuPrepared;
84     private ActionMenuPresenter mActionMenuPresenter;
85 
86     private int mNavigationMode = ActionBar.NAVIGATION_MODE_STANDARD;
87     private int mDefaultNavigationContentDescription = 0;
88     private Drawable mDefaultNavigationIcon;
89 
ToolbarWidgetWrapper(Toolbar toolbar, boolean style)90     public ToolbarWidgetWrapper(Toolbar toolbar, boolean style) {
91         this(toolbar, style, R.string.action_bar_up_description);
92     }
93 
ToolbarWidgetWrapper(Toolbar toolbar, boolean style, int defaultNavigationContentDescription)94     public ToolbarWidgetWrapper(Toolbar toolbar, boolean style,
95             int defaultNavigationContentDescription) {
96         mToolbar = toolbar;
97 
98         mTitle = toolbar.getTitle();
99         mSubtitle = toolbar.getSubtitle();
100         mTitleSet = mTitle != null;
101         mNavIcon = mToolbar.getNavigationIcon();
102         final TypedArray a = toolbar.getContext().obtainStyledAttributes(null,
103                 R.styleable.ActionBar, R.attr.actionBarStyle, 0);
104         mDefaultNavigationIcon = a.getDrawable(R.styleable.ActionBar_homeAsUpIndicator);
105         if (style) {
106             final CharSequence title = a.getText(R.styleable.ActionBar_title);
107             if (!TextUtils.isEmpty(title)) {
108                 setTitle(title);
109             }
110 
111             final CharSequence subtitle = a.getText(R.styleable.ActionBar_subtitle);
112             if (!TextUtils.isEmpty(subtitle)) {
113                 setSubtitle(subtitle);
114             }
115 
116             final Drawable logo = a.getDrawable(R.styleable.ActionBar_logo);
117             if (logo != null) {
118                 setLogo(logo);
119             }
120 
121             final Drawable icon = a.getDrawable(R.styleable.ActionBar_icon);
122             if (icon != null) {
123                 setIcon(icon);
124             }
125             if (mNavIcon == null && mDefaultNavigationIcon != null) {
126                 setNavigationIcon(mDefaultNavigationIcon);
127             }
128             setDisplayOptions(a.getInt(R.styleable.ActionBar_displayOptions, 0));
129 
130             final int customNavId = a.getResourceId(
131                     R.styleable.ActionBar_customNavigationLayout, 0);
132             if (customNavId != 0) {
133                 setCustomView(LayoutInflater.from(mToolbar.getContext()).inflate(customNavId,
134                         mToolbar, false));
135                 setDisplayOptions(mDisplayOpts | ActionBar.DISPLAY_SHOW_CUSTOM);
136             }
137 
138             final int height = a.getLayoutDimension(R.styleable.ActionBar_height, 0);
139             if (height > 0) {
140                 final ViewGroup.LayoutParams lp = mToolbar.getLayoutParams();
141                 lp.height = height;
142                 mToolbar.setLayoutParams(lp);
143             }
144 
145             final int contentInsetStart = a.getDimensionPixelOffset(
146                     R.styleable.ActionBar_contentInsetStart, -1);
147             final int contentInsetEnd = a.getDimensionPixelOffset(
148                     R.styleable.ActionBar_contentInsetEnd, -1);
149             if (contentInsetStart >= 0 || contentInsetEnd >= 0) {
150                 mToolbar.setContentInsetsRelative(Math.max(contentInsetStart, 0),
151                         Math.max(contentInsetEnd, 0));
152             }
153 
154             final int titleTextStyle = a.getResourceId(R.styleable.ActionBar_titleTextStyle, 0);
155             if (titleTextStyle != 0) {
156                 mToolbar.setTitleTextAppearance(mToolbar.getContext(), titleTextStyle);
157             }
158 
159             final int subtitleTextStyle = a.getResourceId(
160                     R.styleable.ActionBar_subtitleTextStyle, 0);
161             if (subtitleTextStyle != 0) {
162                 mToolbar.setSubtitleTextAppearance(mToolbar.getContext(), subtitleTextStyle);
163             }
164 
165             final int popupTheme = a.getResourceId(R.styleable.ActionBar_popupTheme, 0);
166             if (popupTheme != 0) {
167                 mToolbar.setPopupTheme(popupTheme);
168             }
169         } else {
170             mDisplayOpts = detectDisplayOptions();
171         }
172         a.recycle();
173 
174         setDefaultNavigationContentDescription(defaultNavigationContentDescription);
175         mHomeDescription = mToolbar.getNavigationContentDescription();
176 
177         mToolbar.setNavigationOnClickListener(new View.OnClickListener() {
178             final ActionMenuItem mNavItem = new ActionMenuItem(mToolbar.getContext(),
179                     0, android.R.id.home, 0, 0, mTitle);
180             @Override
181             public void onClick(View v) {
182                 if (mWindowCallback != null && mMenuPrepared) {
183                     mWindowCallback.onMenuItemSelected(Window.FEATURE_OPTIONS_PANEL, mNavItem);
184                 }
185             }
186         });
187     }
188 
189     @Override
setDefaultNavigationContentDescription(int defaultNavigationContentDescription)190     public void setDefaultNavigationContentDescription(int defaultNavigationContentDescription) {
191         if (defaultNavigationContentDescription == mDefaultNavigationContentDescription) {
192             return;
193         }
194         mDefaultNavigationContentDescription = defaultNavigationContentDescription;
195         if (TextUtils.isEmpty(mToolbar.getNavigationContentDescription())) {
196             setNavigationContentDescription(mDefaultNavigationContentDescription);
197         }
198     }
199 
detectDisplayOptions()200     private int detectDisplayOptions() {
201         int opts = ActionBar.DISPLAY_SHOW_TITLE | ActionBar.DISPLAY_SHOW_HOME |
202                 ActionBar.DISPLAY_USE_LOGO;
203         if (mToolbar.getNavigationIcon() != null) {
204             opts |= ActionBar.DISPLAY_HOME_AS_UP;
205             mDefaultNavigationIcon = mToolbar.getNavigationIcon();
206         }
207         return opts;
208     }
209 
210     @Override
getViewGroup()211     public ViewGroup getViewGroup() {
212         return mToolbar;
213     }
214 
215     @Override
getContext()216     public Context getContext() {
217         return mToolbar.getContext();
218     }
219 
220     @Override
isSplit()221     public boolean isSplit() {
222         return false;
223     }
224 
225     @Override
hasExpandedActionView()226     public boolean hasExpandedActionView() {
227         return mToolbar.hasExpandedActionView();
228     }
229 
230     @Override
collapseActionView()231     public void collapseActionView() {
232         mToolbar.collapseActionView();
233     }
234 
235     @Override
setWindowCallback(Window.Callback cb)236     public void setWindowCallback(Window.Callback cb) {
237         mWindowCallback = cb;
238     }
239 
240     @Override
setWindowTitle(CharSequence title)241     public void setWindowTitle(CharSequence title) {
242         // "Real" title always trumps window title.
243         if (!mTitleSet) {
244             setTitleInt(title);
245         }
246     }
247 
248     @Override
getTitle()249     public CharSequence getTitle() {
250         return mToolbar.getTitle();
251     }
252 
253     @Override
setTitle(CharSequence title)254     public void setTitle(CharSequence title) {
255         mTitleSet = true;
256         setTitleInt(title);
257     }
258 
setTitleInt(CharSequence title)259     private void setTitleInt(CharSequence title) {
260         mTitle = title;
261         if ((mDisplayOpts & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
262             mToolbar.setTitle(title);
263         }
264     }
265 
266     @Override
getSubtitle()267     public CharSequence getSubtitle() {
268         return mToolbar.getSubtitle();
269     }
270 
271     @Override
setSubtitle(CharSequence subtitle)272     public void setSubtitle(CharSequence subtitle) {
273         mSubtitle = subtitle;
274         if ((mDisplayOpts & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
275             mToolbar.setSubtitle(subtitle);
276         }
277     }
278 
279     @Override
initProgress()280     public void initProgress() {
281         Log.i(TAG, "Progress display unsupported");
282     }
283 
284     @Override
initIndeterminateProgress()285     public void initIndeterminateProgress() {
286         Log.i(TAG, "Progress display unsupported");
287     }
288 
289     @Override
canSplit()290     public boolean canSplit() {
291         return false;
292     }
293 
294     @Override
setSplitView(ViewGroup splitView)295     public void setSplitView(ViewGroup splitView) {
296     }
297 
298     @Override
setSplitToolbar(boolean split)299     public void setSplitToolbar(boolean split) {
300         if (split) {
301             throw new UnsupportedOperationException("Cannot split an android.widget.Toolbar");
302         }
303     }
304 
305     @Override
setSplitWhenNarrow(boolean splitWhenNarrow)306     public void setSplitWhenNarrow(boolean splitWhenNarrow) {
307         // Ignore.
308     }
309 
310     @Override
hasIcon()311     public boolean hasIcon() {
312         return mIcon != null;
313     }
314 
315     @Override
hasLogo()316     public boolean hasLogo() {
317         return mLogo != null;
318     }
319 
320     @Override
setIcon(int resId)321     public void setIcon(int resId) {
322         setIcon(resId != 0 ? getContext().getDrawable(resId) : null);
323     }
324 
325     @Override
setIcon(Drawable d)326     public void setIcon(Drawable d) {
327         mIcon = d;
328         updateToolbarLogo();
329     }
330 
331     @Override
setLogo(int resId)332     public void setLogo(int resId) {
333         setLogo(resId != 0 ? getContext().getDrawable(resId) : null);
334     }
335 
336     @Override
setLogo(Drawable d)337     public void setLogo(Drawable d) {
338         mLogo = d;
339         updateToolbarLogo();
340     }
341 
updateToolbarLogo()342     private void updateToolbarLogo() {
343         Drawable logo = null;
344         if ((mDisplayOpts & ActionBar.DISPLAY_SHOW_HOME) != 0) {
345             if ((mDisplayOpts & ActionBar.DISPLAY_USE_LOGO) != 0) {
346                 logo = mLogo != null ? mLogo : mIcon;
347             } else {
348                 logo = mIcon;
349             }
350         }
351         mToolbar.setLogo(logo);
352     }
353 
354     @Override
canShowOverflowMenu()355     public boolean canShowOverflowMenu() {
356         return mToolbar.canShowOverflowMenu();
357     }
358 
359     @Override
isOverflowMenuShowing()360     public boolean isOverflowMenuShowing() {
361         return mToolbar.isOverflowMenuShowing();
362     }
363 
364     @Override
isOverflowMenuShowPending()365     public boolean isOverflowMenuShowPending() {
366         return mToolbar.isOverflowMenuShowPending();
367     }
368 
369     @Override
showOverflowMenu()370     public boolean showOverflowMenu() {
371         return mToolbar.showOverflowMenu();
372     }
373 
374     @Override
hideOverflowMenu()375     public boolean hideOverflowMenu() {
376         return mToolbar.hideOverflowMenu();
377     }
378 
379     @Override
setMenuPrepared()380     public void setMenuPrepared() {
381         mMenuPrepared = true;
382     }
383 
384     @Override
setMenu(Menu menu, MenuPresenter.Callback cb)385     public void setMenu(Menu menu, MenuPresenter.Callback cb) {
386         if (mActionMenuPresenter == null) {
387             mActionMenuPresenter = new ActionMenuPresenter(mToolbar.getContext());
388             mActionMenuPresenter.setId(com.android.internal.R.id.action_menu_presenter);
389         }
390         mActionMenuPresenter.setCallback(cb);
391         mToolbar.setMenu((MenuBuilder) menu, mActionMenuPresenter);
392     }
393 
394     @Override
dismissPopupMenus()395     public void dismissPopupMenus() {
396         mToolbar.dismissPopupMenus();
397     }
398 
399     @Override
getDisplayOptions()400     public int getDisplayOptions() {
401         return mDisplayOpts;
402     }
403 
404     @Override
setDisplayOptions(int newOpts)405     public void setDisplayOptions(int newOpts) {
406         final int oldOpts = mDisplayOpts;
407         final int changed = oldOpts ^ newOpts;
408         mDisplayOpts = newOpts;
409         if (changed != 0) {
410             if ((changed & ActionBar.DISPLAY_HOME_AS_UP) != 0) {
411                 if ((newOpts & ActionBar.DISPLAY_HOME_AS_UP) != 0) {
412                     updateHomeAccessibility();
413                 }
414                 updateNavigationIcon();
415             }
416 
417             if ((changed & AFFECTS_LOGO_MASK) != 0) {
418                 updateToolbarLogo();
419             }
420 
421             if ((changed & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
422                 if ((newOpts & ActionBar.DISPLAY_SHOW_TITLE) != 0) {
423                     mToolbar.setTitle(mTitle);
424                     mToolbar.setSubtitle(mSubtitle);
425                 } else {
426                     mToolbar.setTitle(null);
427                     mToolbar.setSubtitle(null);
428                 }
429             }
430 
431             if ((changed & ActionBar.DISPLAY_SHOW_CUSTOM) != 0 && mCustomView != null) {
432                 if ((newOpts & ActionBar.DISPLAY_SHOW_CUSTOM) != 0) {
433                     mToolbar.addView(mCustomView);
434                 } else {
435                     mToolbar.removeView(mCustomView);
436                 }
437             }
438         }
439     }
440 
441     @Override
setEmbeddedTabView(ScrollingTabContainerView tabView)442     public void setEmbeddedTabView(ScrollingTabContainerView tabView) {
443         if (mTabView != null && mTabView.getParent() == mToolbar) {
444             mToolbar.removeView(mTabView);
445         }
446         mTabView = tabView;
447         if (tabView != null && mNavigationMode == ActionBar.NAVIGATION_MODE_TABS) {
448             mToolbar.addView(mTabView, 0);
449             Toolbar.LayoutParams lp = (Toolbar.LayoutParams) mTabView.getLayoutParams();
450             lp.width = ViewGroup.LayoutParams.WRAP_CONTENT;
451             lp.height = ViewGroup.LayoutParams.WRAP_CONTENT;
452             lp.gravity = Gravity.START | Gravity.BOTTOM;
453             tabView.setAllowCollapse(true);
454         }
455     }
456 
457     @Override
hasEmbeddedTabs()458     public boolean hasEmbeddedTabs() {
459         return mTabView != null;
460     }
461 
462     @Override
isTitleTruncated()463     public boolean isTitleTruncated() {
464         return mToolbar.isTitleTruncated();
465     }
466 
467     @Override
setCollapsible(boolean collapsible)468     public void setCollapsible(boolean collapsible) {
469         mToolbar.setCollapsible(collapsible);
470     }
471 
472     @Override
setHomeButtonEnabled(boolean enable)473     public void setHomeButtonEnabled(boolean enable) {
474         // Ignore
475     }
476 
477     @Override
getNavigationMode()478     public int getNavigationMode() {
479         return mNavigationMode;
480     }
481 
482     @Override
setNavigationMode(int mode)483     public void setNavigationMode(int mode) {
484         final int oldMode = mNavigationMode;
485         if (mode != oldMode) {
486             switch (oldMode) {
487                 case ActionBar.NAVIGATION_MODE_LIST:
488                     if (mSpinner != null && mSpinner.getParent() == mToolbar) {
489                         mToolbar.removeView(mSpinner);
490                     }
491                     break;
492                 case ActionBar.NAVIGATION_MODE_TABS:
493                     if (mTabView != null && mTabView.getParent() == mToolbar) {
494                         mToolbar.removeView(mTabView);
495                     }
496                     break;
497             }
498 
499             mNavigationMode = mode;
500 
501             switch (mode) {
502                 case ActionBar.NAVIGATION_MODE_STANDARD:
503                     break;
504                 case ActionBar.NAVIGATION_MODE_LIST:
505                     ensureSpinner();
506                     mToolbar.addView(mSpinner, 0);
507                     break;
508                 case ActionBar.NAVIGATION_MODE_TABS:
509                     if (mTabView != null) {
510                         mToolbar.addView(mTabView, 0);
511                         Toolbar.LayoutParams lp = (Toolbar.LayoutParams) mTabView.getLayoutParams();
512                         lp.width = ViewGroup.LayoutParams.WRAP_CONTENT;
513                         lp.height = ViewGroup.LayoutParams.WRAP_CONTENT;
514                         lp.gravity = Gravity.START | Gravity.BOTTOM;
515                     }
516                     break;
517                 default:
518                     throw new IllegalArgumentException("Invalid navigation mode " + mode);
519             }
520         }
521     }
522 
ensureSpinner()523     private void ensureSpinner() {
524         if (mSpinner == null) {
525             mSpinner = new Spinner(getContext(), null, R.attr.actionDropDownStyle);
526             Toolbar.LayoutParams lp = new Toolbar.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
527                     ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.START | Gravity.CENTER_VERTICAL);
528             mSpinner.setLayoutParams(lp);
529         }
530     }
531 
532     @Override
setDropdownParams(SpinnerAdapter adapter, AdapterView.OnItemSelectedListener listener)533     public void setDropdownParams(SpinnerAdapter adapter,
534             AdapterView.OnItemSelectedListener listener) {
535         ensureSpinner();
536         mSpinner.setAdapter(adapter);
537         mSpinner.setOnItemSelectedListener(listener);
538     }
539 
540     @Override
setDropdownSelectedPosition(int position)541     public void setDropdownSelectedPosition(int position) {
542         if (mSpinner == null) {
543             throw new IllegalStateException(
544                     "Can't set dropdown selected position without an adapter");
545         }
546         mSpinner.setSelection(position);
547     }
548 
549     @Override
getDropdownSelectedPosition()550     public int getDropdownSelectedPosition() {
551         return mSpinner != null ? mSpinner.getSelectedItemPosition() : 0;
552     }
553 
554     @Override
getDropdownItemCount()555     public int getDropdownItemCount() {
556         return mSpinner != null ? mSpinner.getCount() : 0;
557     }
558 
559     @Override
setCustomView(View view)560     public void setCustomView(View view) {
561         if (mCustomView != null && (mDisplayOpts & ActionBar.DISPLAY_SHOW_CUSTOM) != 0) {
562             mToolbar.removeView(mCustomView);
563         }
564         mCustomView = view;
565         if (view != null && (mDisplayOpts & ActionBar.DISPLAY_SHOW_CUSTOM) != 0) {
566             mToolbar.addView(mCustomView);
567         }
568     }
569 
570     @Override
getCustomView()571     public View getCustomView() {
572         return mCustomView;
573     }
574 
575     @Override
animateToVisibility(int visibility)576     public void animateToVisibility(int visibility) {
577         Animator anim = setupAnimatorToVisibility(visibility, DEFAULT_FADE_DURATION_MS);
578         if (anim != null) {
579             anim.start();
580         }
581     }
582 
583     @Override
setupAnimatorToVisibility(int visibility, long duration)584     public Animator setupAnimatorToVisibility(int visibility, long duration) {
585 
586         if (visibility == View.GONE) {
587             ObjectAnimator anim = ObjectAnimator.ofFloat(mToolbar, View.ALPHA, 1, 0);
588             anim.setDuration(duration);
589             anim.addListener(new AnimatorListenerAdapter() {
590                         private boolean mCanceled = false;
591                         @Override
592                         public void onAnimationEnd(Animator animation) {
593                             if (!mCanceled) {
594                                 mToolbar.setVisibility(View.GONE);
595                             }
596                         }
597 
598                         @Override
599                         public void onAnimationCancel(Animator animation) {
600                             mCanceled = true;
601                         }
602                     });
603             return anim;
604         } else if (visibility == View.VISIBLE) {
605             ObjectAnimator anim = ObjectAnimator.ofFloat(mToolbar, View.ALPHA, 0, 1);
606             anim.setDuration(duration);
607             anim.addListener(new AnimatorListenerAdapter() {
608                         @Override
609                         public void onAnimationStart(Animator animation) {
610                             mToolbar.setVisibility(View.VISIBLE);
611                         }
612                     });
613             return anim;
614         }
615         return null;
616     }
617 
618     @Override
setNavigationIcon(Drawable icon)619     public void setNavigationIcon(Drawable icon) {
620         mNavIcon = icon;
621         updateNavigationIcon();
622     }
623 
624     @Override
setNavigationIcon(int resId)625     public void setNavigationIcon(int resId) {
626         setNavigationIcon(resId != 0 ? mToolbar.getContext().getDrawable(resId) : null);
627     }
628 
629     @Override
setDefaultNavigationIcon(Drawable defaultNavigationIcon)630     public void setDefaultNavigationIcon(Drawable defaultNavigationIcon) {
631         if (mDefaultNavigationIcon != defaultNavigationIcon) {
632             mDefaultNavigationIcon = defaultNavigationIcon;
633             updateNavigationIcon();
634         }
635     }
636 
updateNavigationIcon()637     private void updateNavigationIcon() {
638         if ((mDisplayOpts & ActionBar.DISPLAY_HOME_AS_UP) != 0) {
639             mToolbar.setNavigationIcon(mNavIcon != null ? mNavIcon : mDefaultNavigationIcon);
640         } else {
641             mToolbar.setNavigationIcon(null);
642         }
643     }
644 
645     @Override
setNavigationContentDescription(CharSequence description)646     public void setNavigationContentDescription(CharSequence description) {
647         mHomeDescription = description;
648         updateHomeAccessibility();
649     }
650 
651     @Override
setNavigationContentDescription(int resId)652     public void setNavigationContentDescription(int resId) {
653         setNavigationContentDescription(resId == 0 ? null : getContext().getString(resId));
654     }
655 
updateHomeAccessibility()656     private void updateHomeAccessibility() {
657         if ((mDisplayOpts & ActionBar.DISPLAY_HOME_AS_UP) != 0) {
658             if (TextUtils.isEmpty(mHomeDescription)) {
659                 mToolbar.setNavigationContentDescription(mDefaultNavigationContentDescription);
660             } else {
661                 mToolbar.setNavigationContentDescription(mHomeDescription);
662             }
663         }
664     }
665 
666     @Override
saveHierarchyState(SparseArray<Parcelable> toolbarStates)667     public void saveHierarchyState(SparseArray<Parcelable> toolbarStates) {
668         mToolbar.saveHierarchyState(toolbarStates);
669     }
670 
671     @Override
restoreHierarchyState(SparseArray<Parcelable> toolbarStates)672     public void restoreHierarchyState(SparseArray<Parcelable> toolbarStates) {
673         mToolbar.restoreHierarchyState(toolbarStates);
674     }
675 
676     @Override
setBackgroundDrawable(Drawable d)677     public void setBackgroundDrawable(Drawable d) {
678         //noinspection deprecation
679         mToolbar.setBackgroundDrawable(d);
680     }
681 
682     @Override
getHeight()683     public int getHeight() {
684         return mToolbar.getHeight();
685     }
686 
687     @Override
setVisibility(int visible)688     public void setVisibility(int visible) {
689         mToolbar.setVisibility(visible);
690     }
691 
692     @Override
getVisibility()693     public int getVisibility() {
694         return mToolbar.getVisibility();
695     }
696 
697     @Override
setMenuCallbacks(MenuPresenter.Callback presenterCallback, MenuBuilder.Callback menuBuilderCallback)698     public void setMenuCallbacks(MenuPresenter.Callback presenterCallback,
699             MenuBuilder.Callback menuBuilderCallback) {
700         mToolbar.setMenuCallbacks(presenterCallback, menuBuilderCallback);
701     }
702 
703     @Override
getMenu()704     public Menu getMenu() {
705         return mToolbar.getMenu();
706     }
707 
708 }
709