From 239e759c480945ee5c164c7c75cb30ff164caa91 Mon Sep 17 00:00:00 2001
From: Yigit Boyar <yboyar@google.com>
Date: Wed, 3 Sep 2014 19:27:33 -0700
Subject: [PATCH] Add ability to disable drawer indicator in new ArrowDrawer

Bug: 17380258
Bug: 17378817
Change-Id: Ia38048abbf0c699c3ea2cda5212296477949164c
---
 v7/appcompat/res/values/styles_base.xml       |   2 +-
 .../support/v7/app/ActionBarActivity.java     |  12 +-
 .../v7/app/ActionBarActivityDelegate.java     |  15 +-
 .../support/v7/app/ActionBarDrawerToggle.java | 305 +++++++++++++++---
 .../app/ActionBarDrawerToggleHoneycomb.java   | 139 ++++++++
 5 files changed, 430 insertions(+), 43 deletions(-)
 create mode 100644 v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggleHoneycomb.java

diff --git a/v7/appcompat/res/values/styles_base.xml b/v7/appcompat/res/values/styles_base.xml
index 55f6fab67d4e..2a4c43d36c39 100644
--- a/v7/appcompat/res/values/styles_base.xml
+++ b/v7/appcompat/res/values/styles_base.xml
@@ -387,7 +387,7 @@
     </style>
 
     <style name="Base.Widget.AppCompat.DrawerArrowToggle" parent="">
-        <item name="color">?android:attr/textColorPrimary</item>
+        <item name="color">?android:attr/textColorSecondary</item>
         <item name="thickness">2dp</item>
         <item name="barSize">18dp</item>
         <item name="gapBetweenBars">3dp</item>
diff --git a/v7/appcompat/src/android/support/v7/app/ActionBarActivity.java b/v7/appcompat/src/android/support/v7/app/ActionBarActivity.java
index 551b00be0c66..95a250a6562b 100644
--- a/v7/appcompat/src/android/support/v7/app/ActionBarActivity.java
+++ b/v7/appcompat/src/android/support/v7/app/ActionBarActivity.java
@@ -54,7 +54,8 @@
  * </div>
  */
 public class ActionBarActivity extends FragmentActivity implements ActionBar.Callback,
-        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {
+        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider,
+        android.support.v7.app.ActionBarDrawerToggle.TmpDelegateProvider {
 
     private ActionBarActivityDelegate mDelegate;
 
@@ -482,6 +483,15 @@ public final ActionBarDrawerToggle.Delegate getDrawerToggleDelegate() {
         return getDelegate().getDrawerToggleDelegate();
     }
 
+    @Nullable
+    @Override
+    /**
+     * Temporary method until ActionBarDrawerToggle transition from v4 to v7 is complete.
+     */
+    public android.support.v7.app.ActionBarDrawerToggle.Delegate getV7DrawerToggleDelegate() {
+        return getDelegate().getV7DrawerToggleDelegate();
+    }
+
     /**
      * Use {@link #onSupportContentChanged()} instead.
      */
diff --git a/v7/appcompat/src/android/support/v7/app/ActionBarActivityDelegate.java b/v7/appcompat/src/android/support/v7/app/ActionBarActivityDelegate.java
index 930d0177f6eb..664fc8e333c4 100644
--- a/v7/appcompat/src/android/support/v7/app/ActionBarActivityDelegate.java
+++ b/v7/appcompat/src/android/support/v7/app/ActionBarActivityDelegate.java
@@ -191,6 +191,10 @@ final ActionBarDrawerToggle.Delegate getDrawerToggleDelegate() {
         return new ActionBarDrawableToggleImpl();
     }
 
+    final android.support.v7.app.ActionBarDrawerToggle.Delegate getV7DrawerToggleDelegate() {
+        return new ActionBarDrawableToggleImpl();
+    }
+
     abstract int getHomeAsUpIndicatorAttrId();
 
     abstract void onContentChanged();
@@ -224,16 +228,23 @@ protected final Context getActionBarThemedContext() {
         return context;
     }
 
-    private class ActionBarDrawableToggleImpl implements ActionBarDrawerToggle.Delegate {
+    private class ActionBarDrawableToggleImpl implements
+            android.support.v7.app.ActionBarDrawerToggle.Delegate,
+            ActionBarDrawerToggle.Delegate {
         @Override
         public Drawable getThemeUpIndicator() {
-            final TypedArray a = getActionBarThemedContext()
+            final TypedArray a = ActionBarActivityDelegate.this.getActionBarThemedContext()
                     .obtainStyledAttributes(new int[]{ getHomeAsUpIndicatorAttrId() });
             final Drawable result = a.getDrawable(0);
             a.recycle();
             return result;
         }
 
+        @Override
+        public Context getActionBarThemedContext() {
+            return ActionBarActivityDelegate.this.getActionBarThemedContext();
+        }
+
         @Override
         public void setActionBarUpIndicator(Drawable upDrawable, int contentDescRes) {
             ActionBar ab = getSupportActionBar();
diff --git a/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggle.java b/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggle.java
index 2a01bc75eb0d..81c8abaef6ca 100644
--- a/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggle.java
+++ b/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggle.java
@@ -16,7 +16,10 @@
 package android.support.v7.app;
 
 import android.app.Activity;
+import android.app.ActionBar;
+import android.content.Context;
 import android.content.res.Configuration;
+import android.content.res.TypedArray;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.support.annotation.Nullable;
@@ -69,6 +72,15 @@ public interface DelegateProvider {
         Delegate getDrawerToggleDelegate();
     }
 
+    /**
+     * @deprecated Temporary class for the transition from old drawer toggle to new drawer toggle.
+     */
+    interface TmpDelegateProvider {
+
+        @Nullable
+        Delegate getV7DrawerToggleDelegate();
+    }
+
     public interface Delegate {
 
         /**
@@ -85,14 +97,29 @@ public interface Delegate {
          * @param contentDescRes - Content description to set
          */
         void setActionBarDescription(@StringRes int contentDescRes);
+
+        /**
+         * Returns the drawable to be set as up button when DrawerToggle is disabled
+         */
+        Drawable getThemeUpIndicator();
+
+        /**
+         * Returns the context of ActionBar
+         */
+        Context getActionBarThemedContext();
     }
 
     private final Delegate mActivityImpl;
     private final DrawerLayout mDrawerLayout;
 
     private DrawerToggle mSlider;
+    private Drawable mHomeAsUpIndicator;
+    private boolean mDrawerIndicatorEnabled = true;
+    private boolean mHasCustomUpIndicator;
     private final int mOpenDrawerContentDescRes;
     private final int mCloseDrawerContentDescRes;
+    // used in toolbar mode when DrawerToggle is disabled
+    private View.OnClickListener mToolbarNavigationClickListener;
 
     /**
      * Construct a new ActionBarDrawerToggle.
@@ -115,8 +142,8 @@ public interface Delegate {
     public ActionBarDrawerToggle(Activity activity, DrawerLayout drawerLayout,
             @StringRes int openDrawerContentDescRes,
             @StringRes int closeDrawerContentDescRes) {
-        this(activity, null, drawerLayout, new DrawerArrowDrawableToggle(activity)
-                , openDrawerContentDescRes, closeDrawerContentDescRes);
+        this(activity, null, drawerLayout, null, openDrawerContentDescRes,
+                closeDrawerContentDescRes);
     }
 
     /**
@@ -146,8 +173,8 @@ public ActionBarDrawerToggle(Activity activity, DrawerLayout drawerLayout,
     public ActionBarDrawerToggle(Activity activity, DrawerLayout drawerLayout,
             Toolbar toolbar, @StringRes int openDrawerContentDescRes,
             @StringRes int closeDrawerContentDescRes) {
-        this(activity, toolbar, drawerLayout, new DrawerArrowDrawableToggle(activity)
-                , openDrawerContentDescRes, closeDrawerContentDescRes);
+        this(activity, toolbar, drawerLayout, null, openDrawerContentDescRes,
+                closeDrawerContentDescRes);
     }
 
     /**
@@ -164,23 +191,36 @@ <T extends Drawable & DrawerToggle> ActionBarDrawerToggle(Activity activity, Too
             toolbar.setNavigationOnClickListener(new View.OnClickListener() {
                 @Override
                 public void onClick(View v) {
-                    toggle();
+                    if (mDrawerIndicatorEnabled) {
+                        toggle();
+                    } else if (mToolbarNavigationClickListener != null) {
+                        mToolbarNavigationClickListener.onClick(v);
+                    }
                 }
             });
         } else if (activity instanceof DelegateProvider) { // Allow the Activity to provide an impl
             mActivityImpl = ((DelegateProvider) activity).getDrawerToggleDelegate();
-        } else if (activity instanceof ActionBarActivity) {
-            mActivityImpl = new AppCompatDelegate((ActionBarActivity) activity);
+        } else if (activity instanceof TmpDelegateProvider) {// tmp interface for transition
+            mActivityImpl = ((TmpDelegateProvider) activity).getV7DrawerToggleDelegate();
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            mActivityImpl = new JellybeanMr2Delegate(activity);
         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
             mActivityImpl = new HoneycombDelegate(activity);
         } else {
-            mActivityImpl = new DummyDelegate();
+            mActivityImpl = new DummyDelegate(activity);
         }
 
         mDrawerLayout = drawerLayout;
         mOpenDrawerContentDescRes = openDrawerContentDescRes;
         mCloseDrawerContentDescRes = closeDrawerContentDescRes;
-        mSlider = slider;
+        if (slider == null) {
+            mSlider = new DrawerArrowDrawableToggle(activity,
+                    mActivityImpl.getActionBarThemedContext());
+        } else {
+            mSlider = slider;
+        }
+
+        mHomeAsUpIndicator = getThemeUpIndicator();
     }
 
     /**
@@ -198,10 +238,11 @@ public void syncState() {
         } else {
             mSlider.setPosition(0);
         }
-
-        setActionBarUpIndicator((Drawable) mSlider,
-                mDrawerLayout.isDrawerOpen(GravityCompat.START) ?
-                        mCloseDrawerContentDescRes : mOpenDrawerContentDescRes);
+        if (mDrawerIndicatorEnabled) {
+            setActionBarUpIndicator((Drawable) mSlider,
+                    mDrawerLayout.isDrawerOpen(GravityCompat.START) ?
+                            mCloseDrawerContentDescRes : mOpenDrawerContentDescRes);
+        }
     }
 
     /**
@@ -213,6 +254,10 @@ public void syncState() {
      * @param newConfig The new configuration
      */
     public void onConfigurationChanged(Configuration newConfig) {
+        // Reload drawables that can change with configuration
+        if (!mHasCustomUpIndicator) {
+            mHomeAsUpIndicator = getThemeUpIndicator();
+        }
         syncState();
     }
 
@@ -226,7 +271,7 @@ public void onConfigurationChanged(Configuration newConfig) {
      * @return true if the event was handled and further processing should not occur
      */
     public boolean onOptionsItemSelected(MenuItem item) {
-        if (item != null && item.getItemId() == android.R.id.home) {
+        if (item != null && item.getItemId() == android.R.id.home && mDrawerIndicatorEnabled) {
             toggle();
             return true;
         }
@@ -241,6 +286,82 @@ private void toggle() {
         }
     }
 
+    /**
+     * Set the up indicator to display when the drawer indicator is not
+     * enabled.
+     * <p>
+     * If you pass <code>null</code> to this method, the default drawable from
+     * the theme will be used.
+     *
+     * @param indicator A drawable to use for the up indicator, or null to use
+     *                  the theme's default
+     * @see #setDrawerIndicatorEnabled(boolean)
+     */
+    public void setHomeAsUpIndicator(Drawable indicator) {
+        if (indicator == null) {
+            mHomeAsUpIndicator = getThemeUpIndicator();
+            mHasCustomUpIndicator = false;
+        } else {
+            mHomeAsUpIndicator = indicator;
+            mHasCustomUpIndicator = true;
+        }
+
+        if (!mDrawerIndicatorEnabled) {
+            setActionBarUpIndicator(mHomeAsUpIndicator, 0);
+        }
+    }
+
+    /**
+     * Set the up indicator to display when the drawer indicator is not
+     * enabled.
+     * <p>
+     * If you pass 0 to this method, the default drawable from the theme will
+     * be used.
+     *
+     * @param resId Resource ID of a drawable to use for the up indicator, or 0
+     *              to use the theme's default
+     * @see #setDrawerIndicatorEnabled(boolean)
+     */
+    public void setHomeAsUpIndicator(int resId) {
+        Drawable indicator = null;
+        if (resId != 0) {
+            indicator = mDrawerLayout.getResources().getDrawable(resId);
+        }
+        setHomeAsUpIndicator(indicator);
+    }
+
+    /**
+     * @return true if the enhanced drawer indicator is enabled, false otherwise
+     * @see #setDrawerIndicatorEnabled(boolean)
+     */
+    public boolean isDrawerIndicatorEnabled() {
+        return mDrawerIndicatorEnabled;
+    }
+
+    /**
+     * Enable or disable the drawer indicator. The indicator defaults to enabled.
+     *
+     * <p>When the indicator is disabled, the <code>ActionBar</code> will revert to displaying
+     * the home-as-up indicator provided by the <code>Activity</code>'s theme in the
+     * <code>android.R.attr.homeAsUpIndicator</code> attribute instead of the animated
+     * drawer glyph.</p>
+     *
+     * @param enable true to enable, false to disable
+     */
+    public void setDrawerIndicatorEnabled(boolean enable) {
+        if (enable != mDrawerIndicatorEnabled) {
+            if (enable) {
+                setActionBarUpIndicator((Drawable) mSlider,
+                        mDrawerLayout.isDrawerOpen(GravityCompat.START) ?
+                                mCloseDrawerContentDescRes : mOpenDrawerContentDescRes);
+            } else {
+                setActionBarUpIndicator(mHomeAsUpIndicator, 0);
+            }
+            mDrawerIndicatorEnabled = enable;
+        }
+    }
+
+
     /**
      * {@link DrawerLayout.DrawerListener} callback method. If you do not use your
      * ActionBarDrawerToggle instance directly as your DrawerLayout's listener, you should call
@@ -264,7 +385,9 @@ public void onDrawerSlide(View drawerView, float slideOffset) {
     @Override
     public void onDrawerOpened(View drawerView) {
         mSlider.setPosition(1);
-        setActionBarDescription(mCloseDrawerContentDescRes);
+        if (mDrawerIndicatorEnabled) {
+            setActionBarDescription(mCloseDrawerContentDescRes);
+        }
     }
 
     /**
@@ -277,7 +400,9 @@ public void onDrawerOpened(View drawerView) {
     @Override
     public void onDrawerClosed(View drawerView) {
         mSlider.setPosition(0);
-        setActionBarDescription(mOpenDrawerContentDescRes);
+        if (mDrawerIndicatorEnabled) {
+            setActionBarDescription(mOpenDrawerContentDescRes);
+        }
     }
 
     /**
@@ -291,6 +416,33 @@ public void onDrawerClosed(View drawerView) {
     public void onDrawerStateChanged(int newState) {
     }
 
+    /**
+     * Returns the fallback listener for Navigation icon click events.
+     *
+     * @return The click listener which receives Navigation click events from Toolbar when
+     * drawer indicator is disabled.
+     * @see #setToolbarNavigationClickListener(android.view.View.OnClickListener)
+     * @see #setDrawerIndicatorEnabled(boolean)
+     * @see #isDrawerIndicatorEnabled()
+     */
+    public View.OnClickListener getToolbarNavigationClickListener() {
+        return mToolbarNavigationClickListener;
+    }
+
+    /**
+     * When DrawerToggle is constructed with a Toolbar, it sets the click listener on
+     * the Navigation icon. If you want to listen for clicks on the Navigation icon when
+     * DrawerToggle is disabled ({@link #setDrawerIndicatorEnabled(boolean)}, you should call this
+     * method with your listener and DrawerToggle will forward click events to that listener
+     * when drawer indicator is disabled.
+     *
+     * @see #setDrawerIndicatorEnabled(boolean)
+     */
+    public void setToolbarNavigationClickListener(
+            View.OnClickListener onToolbarNavigationClickListener) {
+        mToolbarNavigationClickListener = onToolbarNavigationClickListener;
+    }
+
     void setActionBarUpIndicator(Drawable upDrawable, int contentDescRes) {
         mActivityImpl.setActionBarUpIndicator(upDrawable, contentDescRes);
     }
@@ -299,14 +451,17 @@ void setActionBarDescription(int contentDescRes) {
         mActivityImpl.setActionBarDescription(contentDescRes);
     }
 
+    Drawable getThemeUpIndicator() {
+        return mActivityImpl.getThemeUpIndicator();
+    }
 
     static class DrawerArrowDrawableToggle extends DrawerArrowDrawable
             implements DrawerToggle {
 
         private final Activity mActivity;
 
-        public DrawerArrowDrawableToggle(Activity activity) {
-            super(activity);
+        public DrawerArrowDrawableToggle(Activity activity, Context themedContext) {
+            super(themedContext);
             mActivity = activity;
         }
 
@@ -341,61 +496,104 @@ static interface DrawerToggle {
     }
 
     /**
-     * ActionBarDrawerToggle delegate for Activities which extend ActionBarActivity.
+     * Delegate if SDK version is between honeycomb and JBMR2
      */
-    static class AppCompatDelegate implements Delegate {
+    private static class HoneycombDelegate implements Delegate {
 
-        final ActionBarActivity mActivity;
+        final Activity mActivity;
+        ActionBarDrawerToggleHoneycomb.SetIndicatorInfo mSetIndicatorInfo;
 
-        AppCompatDelegate(ActionBarActivity activity) {
+        private HoneycombDelegate(Activity activity) {
             mActivity = activity;
         }
 
         @Override
-        public void setActionBarUpIndicator(Drawable upDrawable, @StringRes int contentDescRes) {
-            final ActionBar supportActionBar = mActivity.getSupportActionBar();
-            supportActionBar.setHomeAsUpIndicator(upDrawable);
-            supportActionBar.setHomeActionContentDescription(contentDescRes);
+        public Drawable getThemeUpIndicator() {
+            return ActionBarDrawerToggleHoneycomb.getThemeUpIndicator(mActivity);
         }
 
         @Override
-        public void setActionBarDescription(@StringRes int contentDescRes) {
-            mActivity.getSupportActionBar().setHomeActionContentDescription(contentDescRes);
+        public Context getActionBarThemedContext() {
+            final ActionBar actionBar = mActivity.getActionBar();
+            final Context context;
+            if (actionBar != null) {
+                context = actionBar.getThemedContext();
+            } else {
+                context = mActivity;
+            }
+            return context;
+        }
+
+        @Override
+        public void setActionBarUpIndicator(Drawable themeImage, int contentDescRes) {
+            mActivity.getActionBar().setDisplayShowHomeEnabled(true);
+            mSetIndicatorInfo = ActionBarDrawerToggleHoneycomb.setActionBarUpIndicator(
+                    mSetIndicatorInfo, mActivity, themeImage, contentDescRes);
+            mActivity.getActionBar().setDisplayShowHomeEnabled(false);
+        }
+
+        @Override
+        public void setActionBarDescription(int contentDescRes) {
+            mSetIndicatorInfo = ActionBarDrawerToggleHoneycomb.setActionBarDescription(
+                    mSetIndicatorInfo, mActivity, contentDescRes);
         }
     }
 
     /**
-     * ActionbarDrawerToggle delegate for Activities which don't extend ActionBarActivity but can
-     * use
-     * Framework's ActionBar.
+     * Delegate if SDK version is JB MR2 or newer
      */
-    static class HoneycombDelegate implements Delegate {
+    private static class JellybeanMr2Delegate implements Delegate {
 
         final Activity mActivity;
 
-        HoneycombDelegate(Activity activity) {
+        private JellybeanMr2Delegate(Activity activity) {
             mActivity = activity;
         }
 
         @Override
-        public void setActionBarUpIndicator(Drawable upDrawable, @StringRes int contentDescRes) {
-            final android.app.ActionBar actionBar = mActivity.getActionBar();
+        public Drawable getThemeUpIndicator() {
+            final TypedArray a = getActionBarThemedContext().obtainStyledAttributes(null,
+                    new int[]{android.R.attr.homeAsUpIndicator}, android.R.attr.actionBarStyle, 0);
+            final Drawable result = a.getDrawable(0);
+            a.recycle();
+            return result;
+        }
+
+        @Override
+        public Context getActionBarThemedContext() {
+            final ActionBar actionBar = mActivity.getActionBar();
+            final Context context;
             if (actionBar != null) {
-                actionBar.setHomeAsUpIndicator(upDrawable);
+                context = actionBar.getThemedContext();
+            } else {
+                context = mActivity;
+            }
+            return context;
+        }
+
+        @Override
+        public void setActionBarUpIndicator(Drawable drawable, int contentDescRes) {
+            final ActionBar actionBar = mActivity.getActionBar();
+            if (actionBar != null) {
+                actionBar.setHomeAsUpIndicator(drawable);
                 actionBar.setHomeActionContentDescription(contentDescRes);
             }
         }
 
         @Override
-        public void setActionBarDescription(@StringRes int contentDescRes) {
-            final android.app.ActionBar actionBar = mActivity.getActionBar();
+        public void setActionBarDescription(int contentDescRes) {
+            final ActionBar actionBar = mActivity.getActionBar();
             if (actionBar != null) {
                 actionBar.setHomeActionContentDescription(contentDescRes);
             }
         }
     }
 
+    /**
+     * Used when DrawerToggle is initialized with a Toolbar
+     */
     static class ToolbarCompatDelegate implements Delegate {
+
         final Toolbar mToolbar;
 
         ToolbarCompatDelegate(Toolbar toolbar) {
@@ -412,12 +610,31 @@ public void setActionBarUpIndicator(Drawable upDrawable, @StringRes int contentD
         public void setActionBarDescription(@StringRes int contentDescRes) {
             mToolbar.setNavigationContentDescription(contentDescRes);
         }
+
+        @Override
+        public Drawable getThemeUpIndicator() {
+            final TypedArray a = mToolbar.getContext()
+                    .obtainStyledAttributes(new int[]{android.R.id.home});
+            final Drawable result = a.getDrawable(0);
+            a.recycle();
+            return result;
+        }
+
+        @Override
+        public Context getActionBarThemedContext() {
+            return mToolbar.getContext();
+        }
     }
 
     /**
-     * Delegate for activities without an actionbar.
+     * Fallback delegate
      */
     static class DummyDelegate implements Delegate {
+        final Activity mActivity;
+
+        DummyDelegate(Activity activity) {
+            mActivity = activity;
+        }
 
         @Override
         public void setActionBarUpIndicator(Drawable upDrawable, @StringRes int contentDescRes) {
@@ -428,5 +645,15 @@ public void setActionBarUpIndicator(Drawable upDrawable, @StringRes int contentD
         public void setActionBarDescription(@StringRes int contentDescRes) {
 
         }
+
+        @Override
+        public Drawable getThemeUpIndicator() {
+            return null;
+        }
+
+        @Override
+        public Context getActionBarThemedContext() {
+            return mActivity;
+        }
     }
 }
diff --git a/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggleHoneycomb.java b/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggleHoneycomb.java
new file mode 100644
index 000000000000..f25365ee1d51
--- /dev/null
+++ b/v7/appcompat/src/android/support/v7/app/ActionBarDrawerToggleHoneycomb.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package android.support.v7.app;
+
+import android.R;
+import android.app.ActionBar;
+import android.app.Activity;
+import android.content.res.TypedArray;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import java.lang.reflect.Method;
+
+/**
+ * This class encapsulates some awful hacks.
+ *
+ * Before JB-MR2 (API 18) it was not possible to change the home-as-up indicator glyph
+ * in an action bar without some really gross hacks. Since the MR2 SDK is not published as of
+ * this writing, the new API is accessed via reflection here if available.
+ *
+ * Moved from Support-v4
+ */
+class ActionBarDrawerToggleHoneycomb {
+    private static final String TAG = "ActionBarDrawerToggleHoneycomb";
+
+    private static final int[] THEME_ATTRS = new int[] {
+            R.attr.homeAsUpIndicator
+    };
+
+    public static SetIndicatorInfo setActionBarUpIndicator(SetIndicatorInfo info, Activity activity,
+            Drawable drawable, int contentDescRes) {
+        if (true || info == null) {
+            info = new SetIndicatorInfo(activity);
+        }
+        if (info.setHomeAsUpIndicator != null) {
+            try {
+                final ActionBar actionBar = activity.getActionBar();
+                info.setHomeAsUpIndicator.invoke(actionBar, drawable);
+                info.setHomeActionContentDescription.invoke(actionBar, contentDescRes);
+            } catch (Exception e) {
+                Log.w(TAG, "Couldn't set home-as-up indicator via JB-MR2 API", e);
+            }
+        } else if (info.upIndicatorView != null) {
+            info.upIndicatorView.setImageDrawable(drawable);
+        } else {
+            Log.w(TAG, "Couldn't set home-as-up indicator");
+        }
+        return info;
+    }
+
+    public static SetIndicatorInfo setActionBarDescription(SetIndicatorInfo info, Activity activity,
+            int contentDescRes) {
+        if (info == null) {
+            info = new SetIndicatorInfo(activity);
+        }
+        if (info.setHomeAsUpIndicator != null) {
+            try {
+                final ActionBar actionBar = activity.getActionBar();
+                info.setHomeActionContentDescription.invoke(actionBar, contentDescRes);
+                if (Build.VERSION.SDK_INT <= 19) {
+                    // For API 19 and earlier, we need to manually force the
+                    // action bar to generate a new content description.
+                    actionBar.setSubtitle(actionBar.getSubtitle());
+                }
+            } catch (Exception e) {
+                Log.w(TAG, "Couldn't set content description via JB-MR2 API", e);
+            }
+        }
+        return info;
+    }
+
+    public static Drawable getThemeUpIndicator(Activity activity) {
+        final TypedArray a = activity.obtainStyledAttributes(THEME_ATTRS);
+        final Drawable result = a.getDrawable(0);
+        a.recycle();
+        return result;
+    }
+
+    static class SetIndicatorInfo {
+        public Method setHomeAsUpIndicator;
+        public Method setHomeActionContentDescription;
+        public ImageView upIndicatorView;
+
+        SetIndicatorInfo(Activity activity) {
+            try {
+                setHomeAsUpIndicator = ActionBar.class.getDeclaredMethod("setHomeAsUpIndicator",
+                        Drawable.class);
+                setHomeActionContentDescription = ActionBar.class.getDeclaredMethod(
+                        "setHomeActionContentDescription", Integer.TYPE);
+
+                // If we got the method we won't need the stuff below.
+                return;
+            } catch (NoSuchMethodException e) {
+                // Oh well. We'll use the other mechanism below instead.
+            }
+
+            final View home = activity.findViewById(android.R.id.home);
+            if (home == null) {
+                // Action bar doesn't have a known configuration, an OEM messed with things.
+                return;
+            }
+
+            final ViewGroup parent = (ViewGroup) home.getParent();
+            final int childCount = parent.getChildCount();
+            if (childCount != 2) {
+                // No idea which one will be the right one, an OEM messed with things.
+                return;
+            }
+
+            final View first = parent.getChildAt(0);
+            final View second = parent.getChildAt(1);
+            final View up = first.getId() == android.R.id.home ? second : first;
+
+            if (up instanceof ImageView) {
+                // Jackpot! (Probably...)
+                upIndicatorView = (ImageView) up;
+            }
+        }
+    }
+}