devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

2021-10-20 Android 实现动态更换系统底部导航栏图标Icon方案_替换android 12 导航栏的 图标

作者：从前慢现在也慢 | 2024-05-12 09:29:15

赞

踩

替换android 12 导航栏的 图标

一、实现思路是接收广播，然后更换图标。

二、修改SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java 里面的代码，调用setImageDrawable函数来更换图标。

  1、添加的代码

  1. diff --git a/vendor/mediatek/proprietary/packages/apps/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java b/vendor/mediatek/proprietary/packages/apps/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java
  2. old mode 100644
  3. new mode 100755
  4. index 1eab427..c125ab7
  5. --- a/vendor/mediatek/proprietary/packages/apps/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java
  6. +++ b/vendor/mediatek/proprietary/packages/apps/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java
  7. @@ -86,6 +86,12 @@ import java.io.FileDescriptor;
  8.  import java.io.PrintWriter;
  9.  import java.util.function.Consumer;
  10.  
  11. +import android.content.BroadcastReceiver;
  12. +import android.content.Context;
  13. +import android.content.Intent;
  14. +import android.content.IntentFilter;
  15. +import com.android.systemui.broadcast.BroadcastDispatcher;
  16. +import com.android.systemui.Dependency;
  17.  public class NavigationBarView extends FrameLayout implements
  18.          NavigationModeController.ModeChangedListener {
  19.      final static boolean DEBUG = false;
  20. @@ -154,6 +160,8 @@ public class NavigationBarView extends FrameLayout implements
  21.      private FloatingRotationButton mFloatingRotationButton;
  22.      private RotationButtonController mRotationButtonController;
  23.  
  24. +	private final BroadcastDispatcher mBroadcastDispatcher = Dependency.get(BroadcastDispatcher.class);
  25. +
  26.      /**
  27.       * Helper that is responsible for showing the right toast when a disallowed activity operation
  28.       * occurred. In pinned mode, we show instructions on how to break out of this mode, whilst in
  29. @@ -224,6 +232,22 @@ public class NavigationBarView extends FrameLayout implements
  30.                      true /* showAuxiliarySubtypes */, getContext().getDisplayId());
  31.          }
  32.      };
  33. +	private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
  34. +		 @Override
  35. +		 public void onReceive(Context context, Intent intent) {
  36. +			  Log.d(TAG, "BroadcastReceiver mReceiver  change icon!!");
  37. +			  boolean state = intent.getIntExtra("state", 0) != 0;
  38. +			  if(state){
  39. +			     getHomeButton().setImageDrawable(mBackIcon);
  40. +                 getBackButton().setImageDrawable(mHomeDefaultIcon);
  41. +			     getBackButton().setVisibility(View.VISIBLE);
  42. +                 getHomeButton().setVisibility(View.VISIBLE);
  43. +			  }else{
  44. +                 getHomeButton().setImageDrawable(mHomeDefaultIcon);
  45. +                 getBackButton().setImageDrawable(mBackIcon);
  46. +			 }
  47. +		 }
  48. +	 };
  49.  
  50.      private final AccessibilityDelegate mQuickStepAccessibilityDelegate =
  51.              new AccessibilityDelegate() {
  52. @@ -300,6 +324,10 @@ public class NavigationBarView extends FrameLayout implements
  53.          }
  54.          mContextualButtonGroup.addButton(accessibilityButton);
  55.  
  56. +		IntentFilter filter = new IntentFilter();
  57. +        filter.addAction("android.intent.action.TESTHINT");
  58. +		mBroadcastDispatcher.registerReceiver(mReceiver, filter);
  59. +		
  60.          mOverviewProxyService = Dependency.get(OverviewProxyService.class);
  61.          mRecentsOnboarding = new RecentsOnboarding(context, mOverviewProxyService);
  62.          mFloatingRotationButton = new FloatingRotationButton(context);

  2、修改后完整NavigationBarView.java代码

  1. /*
  2.  * Copyright (C) 2008 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.  */
  17. package com.android.systemui.statusbar.phone;
  18.  
  19. import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL;
  20.  
  21. import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;
  22. import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;
  23. import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
  24. import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
  25. import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_PINNING;
  26. import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SEARCH_DISABLED;
  27. import static com.android.systemui.shared.system.QuickStepContract.isGesturalMode;
  28. import static com.android.systemui.statusbar.phone.BarTransitions.MODE_OPAQUE;
  29. import static com.android.systemui.util.Utils.isGesturalModeOnDefaultDisplay;
  30.  
  31. import android.animation.LayoutTransition;
  32. import android.animation.LayoutTransition.TransitionListener;
  33. import android.animation.ObjectAnimator;
  34. import android.animation.PropertyValuesHolder;
  35. import android.animation.TimeInterpolator;
  36. import android.animation.ValueAnimator;
  37. import android.annotation.DrawableRes;
  38. import android.annotation.Nullable;
  39. import android.app.StatusBarManager;
  40. import android.content.Context;
  41. import android.content.res.Configuration;
  42. import android.graphics.Canvas;
  43. import android.graphics.Point;
  44. import android.graphics.Rect;
  45. import android.graphics.Region;
  46. import android.graphics.Region.Op;
  47. import android.os.Bundle;
  48. import android.util.AttributeSet;
  49. import android.util.Log;
  50. import android.util.SparseArray;
  51. import android.view.Display;
  52. import android.view.MotionEvent;
  53. import android.view.Surface;
  54. import android.view.View;
  55. import android.view.ViewGroup;
  56. import android.view.ViewTreeObserver.InternalInsetsInfo;
  57. import android.view.ViewTreeObserver.OnComputeInternalInsetsListener;
  58. import android.view.WindowInsets;
  59. import android.view.WindowManager;
  60. import android.view.accessibility.AccessibilityNodeInfo;
  61. import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
  62. import android.view.inputmethod.InputMethodManager;
  63. import android.widget.FrameLayout;
  64.  
  65. import com.android.internal.annotations.VisibleForTesting;
  66. import com.android.systemui.Dependency;
  67. import com.android.systemui.Interpolators;
  68. import com.android.systemui.R;
  69. import com.android.systemui.assist.AssistHandleViewController;
  70. import com.android.systemui.model.SysUiState;
  71. import com.android.systemui.recents.OverviewProxyService;
  72. import com.android.systemui.recents.Recents;
  73. import com.android.systemui.recents.RecentsOnboarding;
  74. import com.android.systemui.shared.plugins.PluginManager;
  75. import com.android.systemui.shared.system.ActivityManagerWrapper;
  76. import com.android.systemui.shared.system.QuickStepContract;
  77. import com.android.systemui.shared.system.SysUiStatsLog;
  78. import com.android.systemui.shared.system.WindowManagerWrapper;
  79. import com.android.systemui.stackdivider.Divider;
  80. import com.android.systemui.statusbar.CommandQueue;
  81. import com.android.systemui.statusbar.NavigationBarController;
  82. import com.android.systemui.statusbar.policy.DeadZone;
  83. import com.android.systemui.statusbar.policy.KeyButtonDrawable;
  84.  
  85. import java.io.FileDescriptor;
  86. import java.io.PrintWriter;
  87. import java.util.function.Consumer;
  88.  
  89. import android.content.BroadcastReceiver;
  90. import android.content.Context;
  91. import android.content.Intent;
  92. import android.content.IntentFilter;
  93. import com.android.systemui.broadcast.BroadcastDispatcher;
  94. import com.android.systemui.Dependency;
  95. public class NavigationBarView extends FrameLayout implements
  96.         NavigationModeController.ModeChangedListener {
  97.     final static boolean DEBUG = false;
  98.     final static String TAG = "StatusBar/NavBarView";
  99.  
  100.     // slippery nav bar when everything is disabled, e.g. during setup
  101.     final static boolean SLIPPERY_WHEN_DISABLED = true;
  102.  
  103.     final static boolean ALTERNATE_CAR_MODE_UI = false;
  104.     private final RegionSamplingHelper mRegionSamplingHelper;
  105.     private final int mNavColorSampleMargin;
  106.     private final SysUiState mSysUiFlagContainer;
  107.     private final PluginManager mPluginManager;
  108.  
  109.     View mCurrentView = null;
  110.     private View mVertical;
  111.     private View mHorizontal;
  112.  
  113.     /** Indicates that navigation bar is vertical. */
  114.     private boolean mIsVertical;
  115.     private int mCurrentRotation = -1;
  116.  
  117.     boolean mLongClickableAccessibilityButton;
  118.     int mDisabledFlags = 0;
  119.     int mNavigationIconHints = 0;
  120.     private int mNavBarMode;
  121.  
  122.     private Rect mHomeButtonBounds = new Rect();
  123.     private Rect mBackButtonBounds = new Rect();
  124.     private Rect mRecentsButtonBounds = new Rect();
  125.     private Rect mRotationButtonBounds = new Rect();
  126.     private final Region mActiveRegion = new Region();
  127.     private int[] mTmpPosition = new int[2];
  128.  
  129.     private KeyButtonDrawable mBackIcon;
  130.     private KeyButtonDrawable mHomeDefaultIcon;
  131.     private KeyButtonDrawable mRecentIcon;
  132.     private KeyButtonDrawable mDockedIcon;
  133.  
  134.     private EdgeBackGestureHandler mEdgeBackGestureHandler;
  135.     private final DeadZone mDeadZone;
  136.     private boolean mDeadZoneConsuming = false;
  137.     private final NavigationBarTransitions mBarTransitions;
  138.     private final OverviewProxyService mOverviewProxyService;
  139.  
  140.     // performs manual animation in sync with layout transitions
  141.     private final NavTransitionListener mTransitionListener = new NavTransitionListener();
  142.  
  143.     private OnVerticalChangedListener mOnVerticalChangedListener;
  144.     private boolean mLayoutTransitionsEnabled = true;
  145.     private boolean mWakeAndUnlocking;
  146.     private boolean mUseCarModeUi = false;
  147.     private boolean mInCarMode = false;
  148.     private boolean mDockedStackExists;
  149.     private boolean mImeVisible;
  150.     private boolean mScreenOn = true;
  151.  
  152.     private final SparseArray<ButtonDispatcher> mButtonDispatchers = new SparseArray<>();
  153.     private final ContextualButtonGroup mContextualButtonGroup;
  154.     private Configuration mConfiguration;
  155.     private Configuration mTmpLastConfiguration;
  156.  
  157.     private NavigationBarInflaterView mNavigationInflaterView;
  158.     private RecentsOnboarding mRecentsOnboarding;
  159.     private NotificationPanelViewController mPanelView;
  160.     private FloatingRotationButton mFloatingRotationButton;
  161.     private RotationButtonController mRotationButtonController;
  162.  
  163. 	private final BroadcastDispatcher mBroadcastDispatcher = Dependency.get(BroadcastDispatcher.class);
  164.  
  165.     /**
  166.      * Helper that is responsible for showing the right toast when a disallowed activity operation
  167.      * occurred. In pinned mode, we show instructions on how to break out of this mode, whilst in
  168.      * fully locked mode we only show that unlocking is blocked.
  169.      */
  170.     private ScreenPinningNotify mScreenPinningNotify;
  171.     private Rect mSamplingBounds = new Rect();
  172.     /**
  173.      * When quickswitching between apps of different orientations, we draw a secondary home handle
  174.      * in the position of the first app's orientation. This rect represents the region of that
  175.      * home handle so we can apply the correct light/dark luma on that.
  176.      * @see {@link NavigationBarFragment#mOrientationHandle}
  177.      */
  178.     @Nullable
  179.     private Rect mOrientedHandleSamplingRegion;
  180.  
  181.     private class NavTransitionListener implements TransitionListener {
  182.         private boolean mBackTransitioning;
  183.         private boolean mHomeAppearing;
  184.         private long mStartDelay;
  185.         private long mDuration;
  186.         private TimeInterpolator mInterpolator;
  187.  
  188.         @Override
  189.         public void startTransition(LayoutTransition transition, ViewGroup container,
  190.                 View view, int transitionType) {
  191.             if (view.getId() == R.id.back) {
  192.                 mBackTransitioning = true;
  193.             } else if (view.getId() == R.id.home && transitionType == LayoutTransition.APPEARING) {
  194.                 mHomeAppearing = true;
  195.                 mStartDelay = transition.getStartDelay(transitionType);
  196.                 mDuration = transition.getDuration(transitionType);
  197.                 mInterpolator = transition.getInterpolator(transitionType);
  198.             }
  199.         }
  200.  
  201.         @Override
  202.         public void endTransition(LayoutTransition transition, ViewGroup container,
  203.                 View view, int transitionType) {
  204.             if (view.getId() == R.id.back) {
  205.                 mBackTransitioning = false;
  206.             } else if (view.getId() == R.id.home && transitionType == LayoutTransition.APPEARING) {
  207.                 mHomeAppearing = false;
  208.             }
  209.         }
  210.  
  211.         public void onBackAltCleared() {
  212.             ButtonDispatcher backButton = getBackButton();
  213.  
  214.             // When dismissing ime during unlock, force the back button to run the same appearance
  215.             // animation as home (if we catch this condition early enough).
  216.             if (!mBackTransitioning && backButton.getVisibility() == VISIBLE
  217.                     && mHomeAppearing && getHomeButton().getAlpha() == 0) {
  218.                 getBackButton().setAlpha(0);
  219.                 ValueAnimator a = ObjectAnimator.ofFloat(backButton, "alpha", 0, 1);
  220.                 a.setStartDelay(mStartDelay);
  221.                 a.setDuration(mDuration);
  222.                 a.setInterpolator(mInterpolator);
  223.                 a.start();
  224.             }
  225.         }
  226.     }
  227.  
  228.     private final OnClickListener mImeSwitcherClickListener = new OnClickListener() {
  229.         @Override
  230.         public void onClick(View view) {
  231.             mContext.getSystemService(InputMethodManager.class).showInputMethodPickerFromSystem(
  232.                     true /* showAuxiliarySubtypes */, getContext().getDisplayId());
  233.         }
  234.     };
  235. 	private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
  236. 		 @Override
  237. 		 public void onReceive(Context context, Intent intent) {
  238. 			  Log.d(TAG, "BroadcastReceiver mReceiver  change icon!!");
  239. 			  boolean state = intent.getIntExtra("state", 0) != 0;
  240. 			  if(state){
  241. 			     getHomeButton().setImageDrawable(mBackIcon);
  242.                  getBackButton().setImageDrawable(mHomeDefaultIcon);
  243. 			     getBackButton().setVisibility(View.VISIBLE);
  244.                  getHomeButton().setVisibility(View.VISIBLE);
  245. 			  }else{
  246.                  getHomeButton().setImageDrawable(mHomeDefaultIcon);
  247.                  getBackButton().setImageDrawable(mBackIcon);
  248. 			 }
  249. 		 }
  250. 	 };
  251.  
  252.     private final AccessibilityDelegate mQuickStepAccessibilityDelegate =
  253.             new AccessibilityDelegate() {
  254.                 private AccessibilityAction mToggleOverviewAction;
  255.  
  256.                 @Override
  257.                 public void onInitializeAccessibilityNodeInfo(View host,
  258.                         AccessibilityNodeInfo info) {
  259.                     super.onInitializeAccessibilityNodeInfo(host, info);
  260.                     if (mToggleOverviewAction == null) {
  261.                         mToggleOverviewAction = new AccessibilityAction(
  262.                                 R.id.action_toggle_overview, getContext().getString(
  263.                                 R.string.quick_step_accessibility_toggle_overview));
  264.                     }
  265.                     info.addAction(mToggleOverviewAction);
  266.                 }
  267.  
  268.                 @Override
  269.                 public boolean performAccessibilityAction(View host, int action, Bundle args) {
  270.                     if (action == R.id.action_toggle_overview) {
  271.                         Dependency.get(Recents.class).toggleRecentApps();
  272.                     } else {
  273.                         return super.performAccessibilityAction(host, action, args);
  274.                     }
  275.                     return true;
  276.                 }
  277.             };
  278.  
  279.     private final OnComputeInternalInsetsListener mOnComputeInternalInsetsListener = info -> {
  280.         // When the nav bar is in 2-button or 3-button mode, or when IME is visible in fully
  281.         // gestural mode, the entire nav bar should be touchable.
  282.         if (!mEdgeBackGestureHandler.isHandlingGestures() || mImeVisible) {
  283.             info.setTouchableInsets(InternalInsetsInfo.TOUCHABLE_INSETS_FRAME);
  284.             return;
  285.         }
  286.  
  287.         info.setTouchableInsets(InternalInsetsInfo.TOUCHABLE_INSETS_REGION);
  288.         ButtonDispatcher imeSwitchButton = getImeSwitchButton();
  289.         if (imeSwitchButton.getVisibility() == VISIBLE) {
  290.             // If the IME is not up, but the ime switch button is visible, then make sure that
  291.             // button is touchable
  292.             int[] loc = new int[2];
  293.             View buttonView = imeSwitchButton.getCurrentView();
  294.             buttonView.getLocationInWindow(loc);
  295.             info.touchableRegion.set(loc[0], loc[1], loc[0] + buttonView.getWidth(),
  296.                     loc[1] + buttonView.getHeight());
  297.             return;
  298.         }
  299.         info.touchableRegion.setEmpty();
  300.     };
  301.  
  302.     public NavigationBarView(Context context, AttributeSet attrs) {
  303.         super(context, attrs);
  304.  
  305.         mIsVertical = false;
  306.         mLongClickableAccessibilityButton = false;
  307.         mNavBarMode = Dependency.get(NavigationModeController.class).addListener(this);
  308.         boolean isGesturalMode = isGesturalMode(mNavBarMode);
  309.  
  310.         mSysUiFlagContainer = Dependency.get(SysUiState.class);
  311.         mPluginManager = Dependency.get(PluginManager.class);
  312.         // Set up the context group of buttons
  313.         mContextualButtonGroup = new ContextualButtonGroup(R.id.menu_container);
  314.         final ContextualButton imeSwitcherButton = new ContextualButton(R.id.ime_switcher,
  315.                 R.drawable.ic_ime_switcher_default);
  316.         final RotationContextButton rotateSuggestionButton = new RotationContextButton(
  317.                 R.id.rotate_suggestion, R.drawable.ic_sysbar_rotate_button);
  318.         final ContextualButton accessibilityButton =
  319.                 new ContextualButton(R.id.accessibility_button,
  320.                         R.drawable.ic_sysbar_accessibility_button);
  321.         mContextualButtonGroup.addButton(imeSwitcherButton);
  322.         if (!isGesturalMode) {
  323.             mContextualButtonGroup.addButton(rotateSuggestionButton);
  324.         }
  325.         mContextualButtonGroup.addButton(accessibilityButton);
  326.  
  327. 		IntentFilter filter = new IntentFilter();
  328.         filter.addAction("android.intent.action.TESTHINT");
  329. 		mBroadcastDispatcher.registerReceiver(mReceiver, filter);
  330. 		
  331.         mOverviewProxyService = Dependency.get(OverviewProxyService.class);
  332.         mRecentsOnboarding = new RecentsOnboarding(context, mOverviewProxyService);
  333.         mFloatingRotationButton = new FloatingRotationButton(context);
  334.         mRotationButtonController = new RotationButtonController(context,
  335.                 R.style.RotateButtonCCWStart90,
  336.                 isGesturalMode ? mFloatingRotationButton : rotateSuggestionButton);
  337.  
  338.         mConfiguration = new Configuration();
  339.         mTmpLastConfiguration = new Configuration();
  340.         mConfiguration.updateFrom(context.getResources().getConfiguration());
  341.  
  342.         mScreenPinningNotify = new ScreenPinningNotify(mContext);
  343.         mBarTransitions = new NavigationBarTransitions(this, Dependency.get(CommandQueue.class));
  344.  
  345.         mButtonDispatchers.put(R.id.back, new ButtonDispatcher(R.id.back));
  346.         mButtonDispatchers.put(R.id.home, new ButtonDispatcher(R.id.home));
  347.         mButtonDispatchers.put(R.id.home_handle, new ButtonDispatcher(R.id.home_handle));
  348.         mButtonDispatchers.put(R.id.recent_apps, new ButtonDispatcher(R.id.recent_apps));
  349.         mButtonDispatchers.put(R.id.ime_switcher, imeSwitcherButton);
  350.         mButtonDispatchers.put(R.id.accessibility_button, accessibilityButton);
  351.         mButtonDispatchers.put(R.id.rotate_suggestion, rotateSuggestionButton);
  352.         mButtonDispatchers.put(R.id.menu_container, mContextualButtonGroup);
  353.         mDeadZone = new DeadZone(this);
  354.  
  355.         mNavColorSampleMargin = getResources()
  356.                         .getDimensionPixelSize(R.dimen.navigation_handle_sample_horizontal_margin);
  357.         mEdgeBackGestureHandler = new EdgeBackGestureHandler(context, mOverviewProxyService,
  358.                 mSysUiFlagContainer, mPluginManager, this::updateStates);
  359.         mRegionSamplingHelper = new RegionSamplingHelper(this,
  360.                 new RegionSamplingHelper.SamplingCallback() {
  361.                     @Override
  362.                     public void onRegionDarknessChanged(boolean isRegionDark) {
  363.                         getLightTransitionsController().setIconsDark(!isRegionDark ,
  364.                                 true /* animate */);
  365.                     }
  366.  
  367.                     @Override
  368.                     public Rect getSampledRegion(View sampledView) {
  369.                         if (mOrientedHandleSamplingRegion != null) {
  370.                             return mOrientedHandleSamplingRegion;
  371.                         }
  372.  
  373.                         updateSamplingRect();
  374.                         return mSamplingBounds;
  375.                     }
  376.  
  377.                     @Override
  378.                     public boolean isSamplingEnabled() {
  379.                         return isGesturalModeOnDefaultDisplay(getContext(), mNavBarMode);
  380.                     }
  381.                 });
  382.     }
  383.  
  384.     public NavigationBarTransitions getBarTransitions() {
  385.         return mBarTransitions;
  386.     }
  387.  
  388.     public LightBarTransitionsController getLightTransitionsController() {
  389.         return mBarTransitions.getLightTransitionsController();
  390.     }
  391.  
  392.     public void setComponents(NotificationPanelViewController panel) {
  393.         mPanelView = panel;
  394.         updatePanelSystemUiStateFlags();
  395.     }
  396.  
  397.     public void setOnVerticalChangedListener(OnVerticalChangedListener onVerticalChangedListener) {
  398.         mOnVerticalChangedListener = onVerticalChangedListener;
  399.         notifyVerticalChangedListener(mIsVertical);
  400.     }
  401.  
  402.     @Override
  403.     public boolean onInterceptTouchEvent(MotionEvent event) {
  404.         if (isGesturalMode(mNavBarMode) && mImeVisible
  405.                 && event.getAction() == MotionEvent.ACTION_DOWN) {
  406.             SysUiStatsLog.write(SysUiStatsLog.IME_TOUCH_REPORTED,
  407.                     (int) event.getX(), (int) event.getY());
  408.         }
  409.         return shouldDeadZoneConsumeTouchEvents(event) || super.onInterceptTouchEvent(event);
  410.     }
  411.  
  412.     @Override
  413.     public boolean onTouchEvent(MotionEvent event) {
  414.         shouldDeadZoneConsumeTouchEvents(event);
  415.         return super.onTouchEvent(event);
  416.     }
  417.  
  418.     void onTransientStateChanged(boolean isTransient) {
  419.         mEdgeBackGestureHandler.onNavBarTransientStateChanged(isTransient);
  420.     }
  421.  
  422.     void onBarTransition(int newMode) {
  423.         if (newMode == MODE_OPAQUE) {
  424.             // If the nav bar background is opaque, stop auto tinting since we know the icons are
  425.             // showing over a dark background
  426.             mRegionSamplingHelper.stop();
  427.             getLightTransitionsController().setIconsDark(false /* dark */, true /* animate */);
  428.         } else {
  429.             mRegionSamplingHelper.start(mSamplingBounds);
  430.         }
  431.     }
  432.  
  433.     private boolean shouldDeadZoneConsumeTouchEvents(MotionEvent event) {
  434.         int action = event.getActionMasked();
  435.         if (action == MotionEvent.ACTION_DOWN) {
  436.             mDeadZoneConsuming = false;
  437.         }
  438.         if (mDeadZone.onTouchEvent(event) || mDeadZoneConsuming) {
  439.             switch (action) {
  440.                 case MotionEvent.ACTION_DOWN:
  441.                     // Allow gestures starting in the deadzone to be slippery
  442.                     setSlippery(true);
  443.                     mDeadZoneConsuming = true;
  444.                     break;
  445.                 case MotionEvent.ACTION_CANCEL:
  446.                 case MotionEvent.ACTION_UP:
  447.                     // When a gesture started in the deadzone is finished, restore slippery state
  448.                     updateSlippery();
  449.                     mDeadZoneConsuming = false;
  450.                     break;
  451.             }
  452.             return true;
  453.         }
  454.         return false;
  455.     }
  456.  
  457.     public void abortCurrentGesture() {
  458.         getHomeButton().abortCurrentGesture();
  459.     }
  460.  
  461.     public View getCurrentView() {
  462.         return mCurrentView;
  463.     }
  464.  
  465.     public RotationButtonController getRotationButtonController() {
  466.         return mRotationButtonController;
  467.     }
  468.  
  469.     public FloatingRotationButton getFloatingRotationButton() {
  470.         return mFloatingRotationButton;
  471.     }
  472.  
  473.     public ButtonDispatcher getRecentsButton() {
  474.         return mButtonDispatchers.get(R.id.recent_apps);
  475.     }
  476.  
  477.     public ButtonDispatcher getBackButton() {
  478.         return mButtonDispatchers.get(R.id.back);
  479.     }
  480.  
  481.     public ButtonDispatcher getHomeButton() {
  482.         return mButtonDispatchers.get(R.id.home);
  483.     }
  484.  
  485.     public ButtonDispatcher getImeSwitchButton() {
  486.         return mButtonDispatchers.get(R.id.ime_switcher);
  487.     }
  488.  
  489.     public ButtonDispatcher getAccessibilityButton() {
  490.         return mButtonDispatchers.get(R.id.accessibility_button);
  491.     }
  492.  
  493.     public RotationContextButton getRotateSuggestionButton() {
  494.         return (RotationContextButton) mButtonDispatchers.get(R.id.rotate_suggestion);
  495.     }
  496.  
  497.     public ButtonDispatcher getHomeHandle() {
  498.         return mButtonDispatchers.get(R.id.home_handle);
  499.     }
  500.  
  501.     public SparseArray<ButtonDispatcher> getButtonDispatchers() {
  502.         return mButtonDispatchers;
  503.     }
  504.  
  505.     public boolean isRecentsButtonVisible() {
  506.         return getRecentsButton().getVisibility() == View.VISIBLE;
  507.     }
  508.  
  509.     public boolean isOverviewEnabled() {
  510.         return (mDisabledFlags & View.STATUS_BAR_DISABLE_RECENT) == 0;
  511.     }
  512.  
  513.     public boolean isQuickStepSwipeUpEnabled() {
  514.         return mOverviewProxyService.shouldShowSwipeUpUI() && isOverviewEnabled();
  515.     }
  516.  
  517.     private void reloadNavIcons() {
  518.         updateIcons(Configuration.EMPTY);
  519.     }
  520.  
  521.     private void updateIcons(Configuration oldConfig) {
  522.         final boolean orientationChange = oldConfig.orientation != mConfiguration.orientation;
  523.         final boolean densityChange = oldConfig.densityDpi != mConfiguration.densityDpi;
  524.         final boolean dirChange = oldConfig.getLayoutDirection() != mConfiguration.getLayoutDirection();
  525.  
  526.         if (orientationChange || densityChange) {
  527.             mDockedIcon = getDrawable(R.drawable.ic_sysbar_docked);
  528.             mHomeDefaultIcon = getHomeDrawable();
  529.         }
  530.         if (densityChange || dirChange) {
  531.             mRecentIcon = getDrawable(R.drawable.ic_sysbar_recent);
  532.             mContextualButtonGroup.updateIcons();
  533.         }
  534.         if (orientationChange || densityChange || dirChange) {
  535.             mBackIcon = getBackDrawable();
  536.         }
  537.     }
  538.  
  539.     public KeyButtonDrawable getBackDrawable() {
  540.         KeyButtonDrawable drawable = getDrawable(getBackDrawableRes());
  541.         orientBackButton(drawable);
  542.         return drawable;
  543.     }
  544.  
  545.     public @DrawableRes int getBackDrawableRes() {
  546.         return chooseNavigationIconDrawableRes(R.drawable.ic_sysbar_back,
  547.                 R.drawable.ic_sysbar_back_quick_step);
  548.     }
  549.  
  550.     public KeyButtonDrawable getHomeDrawable() {
  551.         final boolean quickStepEnabled = mOverviewProxyService.shouldShowSwipeUpUI();
  552.         KeyButtonDrawable drawable = quickStepEnabled
  553.                 ? getDrawable(R.drawable.ic_sysbar_home_quick_step)
  554.                 : getDrawable(R.drawable.ic_sysbar_home);
  555.         orientHomeButton(drawable);
  556.         return drawable;
  557.     }
  558.  
  559.     private void orientBackButton(KeyButtonDrawable drawable) {
  560.         final boolean useAltBack =
  561.                 (mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) != 0;
  562.         final boolean isRtl = mConfiguration.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
  563.         float degrees = useAltBack ? (isRtl ? 90 : -90) : 0;
  564.         if (drawable.getRotation() == degrees) {
  565.             return;
  566.         }
  567.  
  568.         if (isGesturalMode(mNavBarMode)) {
  569.             drawable.setRotation(degrees);
  570.             return;
  571.         }
  572.  
  573.         // Animate the back button's rotation to the new degrees and only in portrait move up the
  574.         // back button to line up with the other buttons
  575.         float targetY = !mOverviewProxyService.shouldShowSwipeUpUI() && !mIsVertical && useAltBack
  576.                 ? - getResources().getDimension(R.dimen.navbar_back_button_ime_offset)
  577.                 : 0;
  578.         ObjectAnimator navBarAnimator = ObjectAnimator.ofPropertyValuesHolder(drawable,
  579.                 PropertyValuesHolder.ofFloat(KeyButtonDrawable.KEY_DRAWABLE_ROTATE, degrees),
  580.                 PropertyValuesHolder.ofFloat(KeyButtonDrawable.KEY_DRAWABLE_TRANSLATE_Y, targetY));
  581.         navBarAnimator.setInterpolator(Interpolators.FAST_OUT_SLOW_IN);
  582.         navBarAnimator.setDuration(200);
  583.         navBarAnimator.start();
  584.     }
  586.     private void orientHomeButton(KeyButtonDrawable drawable) {
  587.         drawable.setRotation(mIsVertical ? 90 : 0);
  588.     }
  590.     private KeyButtonDrawable chooseNavigationIconDrawable(@DrawableRes int icon,
  591.             @DrawableRes int quickStepIcon) {
  592.         return getDrawable(chooseNavigationIconDrawableRes(icon, quickStepIcon));
  593.     }
  595.     private @DrawableRes int chooseNavigationIconDrawableRes(@DrawableRes int icon,
  596.             @DrawableRes int quickStepIcon) {
  597.         final boolean quickStepEnabled = mOverviewProxyService.shouldShowSwipeUpUI();
  598.         return quickStepEnabled ? quickStepIcon : icon;
  599.     }
  601.     private KeyButtonDrawable getDrawable(@DrawableRes int icon) {
  602.         return KeyButtonDrawable.create(mContext, icon, true /* hasShadow */);
  603.     }
  605.     private KeyButtonDrawable getDrawable(@DrawableRes int icon, boolean hasShadow) {
  606.         return KeyButtonDrawable.create(mContext, icon, hasShadow);
  607.     }
  609.     /** To be called when screen lock/unlock state changes */
  610.     public void onScreenStateChanged(boolean isScreenOn) {
  611.         mScreenOn = isScreenOn;
  612.         if (isScreenOn) {
  613.             if (isGesturalModeOnDefaultDisplay(getContext(), mNavBarMode)) {
  614.                 mRegionSamplingHelper.start(mSamplingBounds);
  615.             }
  616.         } else {
  617.             mRegionSamplingHelper.stop();
  618.         }
  619.     }
  621.     public void setWindowVisible(boolean visible) {
  622.         mRegionSamplingHelper.setWindowVisible(visible);
  623.         mRotationButtonController.onNavigationBarWindowVisibilityChange(visible);
  624.     }
  626.     @Override
  627.     public void setLayoutDirection(int layoutDirection) {
  628.         reloadNavIcons();
  630.         super.setLayoutDirection(layoutDirection);
  631.     }
  633.     public void setNavigationIconHints(int hints) {
  634.         if (hints == mNavigationIconHints) return;
  635.         final boolean newBackAlt = (hints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) != 0;
  636.         final boolean oldBackAlt =
  637.                 (mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) != 0;
  638.         if (newBackAlt != oldBackAlt) {
  639.             onImeVisibilityChanged(newBackAlt);
  640.         }
  642.         if (DEBUG) {
  643.             android.widget.Toast.makeText(getContext(),
  644.                 "Navigation icon hints = " + hints,
  645.                 500).show();
  646.         }
  647.         mNavigationIconHints = hints;
  648.         updateNavButtonIcons();
  649.     }
  651.     private void onImeVisibilityChanged(boolean visible) {
  652.         if (!visible) {
  653.             mTransitionListener.onBackAltCleared();
  654.         }
  655.         mImeVisible = visible;
  656.         mRotationButtonController.getRotationButton().setCanShowRotationButton(!mImeVisible);
  657.     }
  659.     public void setDisabledFlags(int disabledFlags) {
  660.         if (mDisabledFlags == disabledFlags) return;
  662.         final boolean overviewEnabledBefore = isOverviewEnabled();
  663.         mDisabledFlags = disabledFlags;
  665.         // Update icons if overview was just enabled to ensure the correct icons are present
  666.         if (!overviewEnabledBefore && isOverviewEnabled()) {
  667.             reloadNavIcons();
  668.         }
  670.         updateNavButtonIcons();
  671.         updateSlippery();
  672.         setUpSwipeUpOnboarding(isQuickStepSwipeUpEnabled());
  673.         updateDisabledSystemUiStateFlags();
  674.     }
  676.     public void updateNavButtonIcons() {
  677.         // We have to replace or restore the back and home button icons when exiting or entering
  678.         // carmode, respectively. Recents are not available in CarMode in nav bar so change
  679.         // to recent icon is not required.
  680.         final boolean useAltBack =
  681.                 (mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) != 0;
  682.         KeyButtonDrawable backIcon = mBackIcon;
  683.         orientBackButton(backIcon);
  684.         KeyButtonDrawable homeIcon = mHomeDefaultIcon;
  685.         if (!mUseCarModeUi) {
  686.             orientHomeButton(homeIcon);
  687.         }
  688.         getHomeButton().setImageDrawable(homeIcon);
  689.         getBackButton().setImageDrawable(backIcon);
  691.         updateRecentsIcon();
  693.         // Update IME button visibility, a11y and rotate button always overrides the appearance
  694.         mContextualButtonGroup.setButtonVisibility(R.id.ime_switcher,
  695.                 (mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_IME_SHOWN) != 0);
  697.         mBarTransitions.reapplyDarkIntensity();
  699.         boolean disableHome = isGesturalMode(mNavBarMode)
  700.                 || ((mDisabledFlags & View.STATUS_BAR_DISABLE_HOME) != 0);
  702.         // Always disable recents when alternate car mode UI is active and for secondary displays.
  703.         boolean disableRecent = isRecentsButtonDisabled();
  705.         // Disable the home handle if both hone and recents are disabled
  706.         boolean disableHomeHandle = disableRecent
  707.                 && ((mDisabledFlags & View.STATUS_BAR_DISABLE_HOME) != 0);
  709.         boolean disableBack = !useAltBack && (mEdgeBackGestureHandler.isHandlingGestures()
  710.                 || ((mDisabledFlags & View.STATUS_BAR_DISABLE_BACK) != 0));
  712.         // When screen pinning, don't hide back and home when connected service or back and
  713.         // recents buttons when disconnected from launcher service in screen pinning mode,
  714.         // as they are used for exiting.
  715.         final boolean pinningActive = ActivityManagerWrapper.getInstance().isScreenPinningActive();
  716.         if (mOverviewProxyService.isEnabled()) {
  717.             // Force disable recents when not in legacy mode
  718.             disableRecent |= !QuickStepContract.isLegacyMode(mNavBarMode);
  719.             if (pinningActive && !QuickStepContract.isGesturalMode(mNavBarMode)) {
  720.                 disableBack = disableHome = false;
  721.             }
  722.         } else if (pinningActive) {
  723.             disableBack = disableRecent = false;
  724.         }
  725.  
  726.         ViewGroup navButtons = getCurrentView().findViewById(R.id.nav_buttons);
  727.         if (navButtons != null) {
  728.             LayoutTransition lt = navButtons.getLayoutTransition();
  729.             if (lt != null) {
  730.                 if (!lt.getTransitionListeners().contains(mTransitionListener)) {
  731.                     lt.addTransitionListener(mTransitionListener);
  732.                 }
  733.             }
  734.         }
  735.  
  736.         getBackButton().setVisibility(disableBack       ? View.INVISIBLE : View.VISIBLE);
  737.         getHomeButton().setVisibility(disableHome       ? View.INVISIBLE : View.VISIBLE);
  738.         getRecentsButton().setVisibility(disableRecent  ? View.INVISIBLE : View.VISIBLE);
  739.         getHomeHandle().setVisibility(disableHomeHandle ? View.INVISIBLE : View.VISIBLE);
  740.     }
  741.  
  742.     @VisibleForTesting
  743.     boolean isRecentsButtonDisabled() {
  744.         return mUseCarModeUi || !isOverviewEnabled()
  745.                 || getContext().getDisplayId() != Display.DEFAULT_DISPLAY;
  746.     }
  747.  
  748.     private Display getContextDisplay() {
  749.         return getContext().getDisplay();
  750.     }
  751.  
  752.     public void setLayoutTransitionsEnabled(boolean enabled) {
  753.         mLayoutTransitionsEnabled = enabled;
  754.         updateLayoutTransitionsEnabled();
  755.     }
  756.  
  757.     public void setWakeAndUnlocking(boolean wakeAndUnlocking) {
  758.         setUseFadingAnimations(wakeAndUnlocking);
  759.         mWakeAndUnlocking = wakeAndUnlocking;
  760.         updateLayoutTransitionsEnabled();
  761.     }
  762.  
  763.     private void updateLayoutTransitionsEnabled() {
  764.         boolean enabled = !mWakeAndUnlocking && mLayoutTransitionsEnabled;
  765.         ViewGroup navButtons = (ViewGroup) getCurrentView().findViewById(R.id.nav_buttons);
  766.         LayoutTransition lt = navButtons.getLayoutTransition();
  767.         if (lt != null) {
  768.             if (enabled) {
  769.                 lt.enableTransitionType(LayoutTransition.APPEARING);
  770.                 lt.enableTransitionType(LayoutTransition.DISAPPEARING);
  771.                 lt.enableTransitionType(LayoutTransition.CHANGE_APPEARING);
  772.                 lt.enableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
  773.             } else {
  774.                 lt.disableTransitionType(LayoutTransition.APPEARING);
  775.                 lt.disableTransitionType(LayoutTransition.DISAPPEARING);
  776.                 lt.disableTransitionType(LayoutTransition.CHANGE_APPEARING);
  777.                 lt.disableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
  778.             }
  779.         }
  780.     }
  781.  
  782.     private void setUseFadingAnimations(boolean useFadingAnimations) {
  783.         WindowManager.LayoutParams lp = (WindowManager.LayoutParams) ((ViewGroup) getParent())
  784.                 .getLayoutParams();
  785.         if (lp != null) {
  786.             boolean old = lp.windowAnimations != 0;
  787.             if (!old && useFadingAnimations) {
  788.                 lp.windowAnimations = R.style.Animation_NavigationBarFadeIn;
  789.             } else if (old && !useFadingAnimations) {
  790.                 lp.windowAnimations = 0;
  791.             } else {
  792.                 return;
  793.             }
  794.             WindowManager wm = (WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
  795.             wm.updateViewLayout((View) getParent(), lp);
  796.         }
  797.     }
  798.  
  799.     public void onStatusBarPanelStateChanged() {
  800.         updateSlippery();
  801.         updatePanelSystemUiStateFlags();
  802.     }
  803.  
  804.     public void updateDisabledSystemUiStateFlags() {
  805.         int displayId = mContext.getDisplayId();
  806.  
  807.         mSysUiFlagContainer.setFlag(SYSUI_STATE_SCREEN_PINNING,
  808.                         ActivityManagerWrapper.getInstance().isScreenPinningActive())
  809.                 .setFlag(SYSUI_STATE_OVERVIEW_DISABLED,
  810.                         (mDisabledFlags & View.STATUS_BAR_DISABLE_RECENT) != 0)
  811.                 .setFlag(SYSUI_STATE_HOME_DISABLED,
  812.                         (mDisabledFlags & View.STATUS_BAR_DISABLE_HOME) != 0)
  813.                 .setFlag(SYSUI_STATE_SEARCH_DISABLED,
  814.                         (mDisabledFlags & View.STATUS_BAR_DISABLE_SEARCH) != 0)
  815.                 .commitUpdate(displayId);
  816.     }
  817.  
  818.     public void updatePanelSystemUiStateFlags() {
  819.         int displayId = mContext.getDisplayId();
  820.         if (SysUiState.DEBUG) {
  821.             Log.d(TAG, "Updating panel sysui state flags: panelView=" + mPanelView);
  822.         }
  823.         if (mPanelView != null) {
  824.             if (SysUiState.DEBUG) {
  825.                 Log.d(TAG, "Updating panel sysui state flags: fullyExpanded="
  826.                         + mPanelView.isFullyExpanded() + " inQs=" + mPanelView.isInSettings());
  827.             }
  828.             mSysUiFlagContainer.setFlag(SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED,
  829.                     mPanelView.isFullyExpanded() && !mPanelView.isInSettings())
  830.                     .setFlag(SYSUI_STATE_QUICK_SETTINGS_EXPANDED,
  831.                             mPanelView.isInSettings())
  832.                     .commitUpdate(displayId);
  833.         }
  834.     }
  835.  
  836.     public void updateStates() {
  837.         final boolean showSwipeUpUI = mOverviewProxyService.shouldShowSwipeUpUI();
  838.  
  839.         if (mNavigationInflaterView != null) {
  840.             // Reinflate the navbar if needed, no-op unless the swipe up state changes
  841.             mNavigationInflaterView.onLikelyDefaultLayoutChange();
  842.         }
  843.  
  844.         updateSlippery();
  845.         reloadNavIcons();
  846.         updateNavButtonIcons();
  847.         setUpSwipeUpOnboarding(isQuickStepSwipeUpEnabled());
  848.         WindowManagerWrapper.getInstance().setNavBarVirtualKeyHapticFeedbackEnabled(!showSwipeUpUI);
  849.         getHomeButton().setAccessibilityDelegate(
  850.                 showSwipeUpUI ? mQuickStepAccessibilityDelegate : null);
  851.     }
  852.  
  853.     /**
  854.      * Updates the {@link WindowManager.LayoutParams.FLAG_SLIPPERY} state dependent on if swipe up
  855.      * is enabled, or the notifications is fully opened without being in an animated state. If
  856.      * slippery is enabled, touch events will leave the nav bar window and enter into the fullscreen
  857.      * app/home window, if not nav bar will receive a cancelled touch event once gesture leaves bar.
  858.      */
  859.     public void updateSlippery() {
  860.         setSlippery(!isQuickStepSwipeUpEnabled() ||
  861.                 (mPanelView != null && mPanelView.isFullyExpanded() && !mPanelView.isCollapsing()));
  862.     }
  863.  
  864.     private void setSlippery(boolean slippery) {
  865.         setWindowFlag(WindowManager.LayoutParams.FLAG_SLIPPERY, slippery);
  866.     }
  867.  
  868.     private void setWindowFlag(int flags, boolean enable) {
  869.         final ViewGroup navbarView = ((ViewGroup) getParent());
  870.         if (navbarView == null) {
  871.             return;
  872.         }
  873.         WindowManager.LayoutParams lp = (WindowManager.LayoutParams) navbarView.getLayoutParams();
  874.         if (lp == null || enable == ((lp.flags & flags) != 0)) {
  875.             return;
  876.         }
  877.         if (enable) {
  878.             lp.flags |= flags;
  879.         } else {
  880.             lp.flags &= ~flags;
  881.         }
  882.         WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
  883.         wm.updateViewLayout(navbarView, lp);
  884.     }
  885.  
  886.     @Override
  887.     public void onNavigationModeChanged(int mode) {
  888.         mNavBarMode = mode;
  889.         mBarTransitions.onNavigationModeChanged(mNavBarMode);
  890.         mEdgeBackGestureHandler.onNavigationModeChanged(mNavBarMode);
  891.         mRecentsOnboarding.onNavigationModeChanged(mNavBarMode);
  892.         getRotateSuggestionButton().onNavigationModeChanged(mNavBarMode);
  893.  
  894.         if (isGesturalMode(mNavBarMode)) {
  895.             mRegionSamplingHelper.start(mSamplingBounds);
  896.         } else {
  897.             mRegionSamplingHelper.stop();
  898.         }
  899.     }
  900.  
  901.     public void setAccessibilityButtonState(final boolean visible, final boolean longClickable) {
  902.         mLongClickableAccessibilityButton = longClickable;
  903.         getAccessibilityButton().setLongClickable(longClickable);
  904.         mContextualButtonGroup.setButtonVisibility(R.id.accessibility_button, visible);
  905.     }
  906.  
  907.     void hideRecentsOnboarding() {
  908.         mRecentsOnboarding.hide(true);
  909.     }
  910.  
  911.     @Override
  912.     public void onFinishInflate() {
  913.         super.onFinishInflate();
  914.         mNavigationInflaterView = findViewById(R.id.navigation_inflater);
  915.         mNavigationInflaterView.setButtonDispatchers(mButtonDispatchers);
  916.  
  917.         getImeSwitchButton().setOnClickListener(mImeSwitcherClickListener);
  918.  
  919.         Divider divider = Dependency.get(Divider.class);
  920.         divider.registerInSplitScreenListener(mDockedListener);
  921.         updateOrientationViews();
  922.         reloadNavIcons();
  923.     }
  924.  
  925.     @Override
  926.     protected void onDraw(Canvas canvas) {
  927.         mDeadZone.onDraw(canvas);
  928.         super.onDraw(canvas);
  929.     }
  930.  
  931.     private void updateSamplingRect() {
  932.         mSamplingBounds.setEmpty();
  933.         // TODO: Extend this to 2/3 button layout as well
  934.         View view = getHomeHandle().getCurrentView();
  935.  
  936.         if (view != null) {
  937.             int[] pos = new int[2];
  938.             view.getLocationOnScreen(pos);
  939.             Point displaySize = new Point();
  940.             view.getContext().getDisplay().getRealSize(displaySize);
  941.             final Rect samplingBounds = new Rect(pos[0] - mNavColorSampleMargin,
  942.                     displaySize.y - getNavBarHeight(),
  943.                     pos[0] + view.getWidth() + mNavColorSampleMargin,
  944.                     displaySize.y);
  945.             mSamplingBounds.set(samplingBounds);
  946.         }
  947.     }
  948.  
  949.     void setOrientedHandleSamplingRegion(Rect orientedHandleSamplingRegion) {
  950.         mOrientedHandleSamplingRegion = orientedHandleSamplingRegion;
  951.         mRegionSamplingHelper.updateSamplingRect();
  952.     }
  953.  
  954.     @Override
  955.     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  956.         super.onLayout(changed, left, top, right, bottom);
  957.  
  958.         mActiveRegion.setEmpty();
  959.         updateButtonLocation(getBackButton(), mBackButtonBounds, true);
  960.         updateButtonLocation(getHomeButton(), mHomeButtonBounds, false);
  961.         updateButtonLocation(getRecentsButton(), mRecentsButtonBounds, false);
  962.         updateButtonLocation(getRotateSuggestionButton(), mRotationButtonBounds, true);
  963.         // TODO: Handle button visibility changes
  964.         mOverviewProxyService.onActiveNavBarRegionChanges(mActiveRegion);
  965.         mRecentsOnboarding.setNavBarHeight(getMeasuredHeight());
  966.     }
  967.  
  968.     private void updateButtonLocation(ButtonDispatcher button, Rect buttonBounds,
  969.             boolean isActive) {
  970.         View view = button.getCurrentView();
  971.         if (view == null) {
  972.             buttonBounds.setEmpty();
  973.             return;
  974.         }
  975.         // Temporarily reset the translation back to origin to get the position in window
  976.         final float posX = view.getTranslationX();
  977.         final float posY = view.getTranslationY();
  978.         view.setTranslationX(0);
  979.         view.setTranslationY(0);
  980.  
  981.         if (isActive) {
  982.             view.getLocationOnScreen(mTmpPosition);
  983.             buttonBounds.set(mTmpPosition[0], mTmpPosition[1],
  984.                     mTmpPosition[0] + view.getMeasuredWidth(),
  985.                     mTmpPosition[1] + view.getMeasuredHeight());
  986.             mActiveRegion.op(buttonBounds, Op.UNION);
  987.         }
  988.         view.getLocationInWindow(mTmpPosition);
  989.         buttonBounds.set(mTmpPosition[0], mTmpPosition[1],
  990.                 mTmpPosition[0] + view.getMeasuredWidth(),
  991.                 mTmpPosition[1] + view.getMeasuredHeight());
  992.         view.setTranslationX(posX);
  993.         view.setTranslationY(posY);
  994.     }
  995.  
  996.     private void updateOrientationViews() {
  997.         mHorizontal = findViewById(R.id.horizontal);
  998.         mVertical = findViewById(R.id.vertical);
  999.  
  1000.         updateCurrentView();
  1001.     }
  1002.  
  1003.     boolean needsReorient(int rotation) {
  1004.         return mCurrentRotation != rotation;
  1005.     }
  1006.  
  1007.     private void updateCurrentView() {
  1008.         resetViews();
  1009.         mCurrentView = mIsVertical ? mVertical : mHorizontal;
  1010.         mCurrentView.setVisibility(View.VISIBLE);
  1011.         mNavigationInflaterView.setVertical(mIsVertical);
  1012.         mCurrentRotation = getContextDisplay().getRotation();
  1013.         mNavigationInflaterView.setAlternativeOrder(mCurrentRotation == Surface.ROTATION_90);
  1014.         mNavigationInflaterView.updateButtonDispatchersCurrentView();
  1015.         updateLayoutTransitionsEnabled();
  1016.     }
  1017.  
  1018.     private void resetViews() {
  1019.         mHorizontal.setVisibility(View.GONE);
  1020.         mVertical.setVisibility(View.GONE);
  1021.     }
  1022.  
  1023.     private void updateRecentsIcon() {
  1024.         mDockedIcon.setRotation(mDockedStackExists && mIsVertical ? 90 : 0);
  1025.         getRecentsButton().setImageDrawable(mDockedStackExists ? mDockedIcon : mRecentIcon);
  1026.         mBarTransitions.reapplyDarkIntensity();
  1027.     }
  1028.  
  1029.     public void showPinningEnterExitToast(boolean entering) {
  1030.         if (entering) {
  1031.             mScreenPinningNotify.showPinningStartToast();
  1032.         } else {
  1033.             mScreenPinningNotify.showPinningExitToast();
  1034.         }
  1035.     }
  1036.  
  1037.     public void showPinningEscapeToast() {
  1038.         mScreenPinningNotify.showEscapeToast(
  1039.                 mNavBarMode == NAV_BAR_MODE_GESTURAL, isRecentsButtonVisible());
  1040.     }
  1041.  
  1042.     public boolean isVertical() {
  1043.         return mIsVertical;
  1044.     }
  1045.  
  1046.     public void reorient() {
  1047.         updateCurrentView();
  1048.  
  1049.         ((NavigationBarFrame) getRootView()).setDeadZone(mDeadZone);
  1050.         mDeadZone.onConfigurationChanged(mCurrentRotation);
  1051.  
  1052.         // force the low profile & disabled states into compliance
  1053.         mBarTransitions.init();
  1054.  
  1055.         if (DEBUG) {
  1056.             Log.d(TAG, "reorient(): rot=" + mCurrentRotation);
  1057.         }
  1058.  
  1059.         // Resolve layout direction if not resolved since components changing layout direction such
  1060.         // as changing languages will recreate this view and the direction will be resolved later
  1061.         if (!isLayoutDirectionResolved()) {
  1062.             resolveLayoutDirection();
  1063.         }
  1064.         updateNavButtonIcons();
  1065.  
  1066.         getHomeButton().setVertical(mIsVertical);
  1067.     }
  1068.  
  1069.     @Override
  1070.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  1071.         int w = MeasureSpec.getSize(widthMeasureSpec);
  1072.         int h = MeasureSpec.getSize(heightMeasureSpec);
  1073.         if (DEBUG) Log.d(TAG, String.format(
  1074.                 "onMeasure: (%dx%d) old: (%dx%d)", w, h, getMeasuredWidth(), getMeasuredHeight()));
  1075.  
  1076.         final boolean newVertical = w > 0 && h > w
  1077.                 && !isGesturalMode(mNavBarMode);
  1078.         if (newVertical != mIsVertical) {
  1079.             mIsVertical = newVertical;
  1080.             if (DEBUG) {
  1081.                 Log.d(TAG, String.format("onMeasure: h=%d, w=%d, vert=%s", h, w,
  1082.                         mIsVertical ? "y" : "n"));
  1083.             }
  1084.             reorient();
  1085.             notifyVerticalChangedListener(newVertical);
  1086.         }
  1087.  
  1088.         if (isGesturalMode(mNavBarMode)) {
  1089.             // Update the nav bar background to match the height of the visible nav bar
  1090.             int height = mIsVertical
  1091.                     ? getResources().getDimensionPixelSize(
  1092.                             com.android.internal.R.dimen.navigation_bar_height_landscape)
  1093.                     : getResources().getDimensionPixelSize(
  1094.                             com.android.internal.R.dimen.navigation_bar_height);
  1095.             int frameHeight = getResources().getDimensionPixelSize(
  1096.                     com.android.internal.R.dimen.navigation_bar_frame_height);
  1097.             mBarTransitions.setBackgroundFrame(new Rect(0, frameHeight - height, w, h));
  1098.         }
  1099.  
  1100.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  1101.     }
  1102.  
  1103.     private int getNavBarHeight() {
  1104.         return mIsVertical
  1105.                 ? getResources().getDimensionPixelSize(
  1106.                 com.android.internal.R.dimen.navigation_bar_height_landscape)
  1107.                 : getResources().getDimensionPixelSize(
  1108.                         com.android.internal.R.dimen.navigation_bar_height);
  1109.     }
  1110.  
  1111.     private void notifyVerticalChangedListener(boolean newVertical) {
  1112.         if (mOnVerticalChangedListener != null) {
  1113.             mOnVerticalChangedListener.onVerticalChanged(newVertical);
  1114.         }
  1115.     }
  1116.  
  1117.     @Override
  1118.     protected void onConfigurationChanged(Configuration newConfig) {
  1119.         super.onConfigurationChanged(newConfig);
  1120.         mTmpLastConfiguration.updateFrom(mConfiguration);
  1121.         mConfiguration.updateFrom(newConfig);
  1122.         boolean uiCarModeChanged = updateCarMode();
  1123.         updateIcons(mTmpLastConfiguration);
  1124.         updateRecentsIcon();
  1125.         mRecentsOnboarding.onConfigurationChanged(mConfiguration);
  1126.         if (uiCarModeChanged || mTmpLastConfiguration.densityDpi != mConfiguration.densityDpi
  1127.                 || mTmpLastConfiguration.getLayoutDirection() != mConfiguration.getLayoutDirection()) {
  1128.             // If car mode or density changes, we need to reset the icons.
  1129.             updateNavButtonIcons();
  1130.         }
  1131.     }
  1132.  
  1133.     /**
  1134.      * If the configuration changed, update the carmode and return that it was updated.
  1135.      */
  1136.     private boolean updateCarMode() {
  1137.         boolean uiCarModeChanged = false;
  1138.         if (mConfiguration != null) {
  1139.             int uiMode = mConfiguration.uiMode & Configuration.UI_MODE_TYPE_MASK;
  1140.             final boolean isCarMode = (uiMode == Configuration.UI_MODE_TYPE_CAR);
  1141.  
  1142.             if (isCarMode != mInCarMode) {
  1143.                 mInCarMode = isCarMode;
  1144.                 if (ALTERNATE_CAR_MODE_UI) {
  1145.                     mUseCarModeUi = isCarMode;
  1146.                     uiCarModeChanged = true;
  1147.                 } else {
  1148.                     // Don't use car mode behavior if ALTERNATE_CAR_MODE_UI not set.
  1149.                     mUseCarModeUi = false;
  1150.                 }
  1151.             }
  1152.         }
  1153.         return uiCarModeChanged;
  1154.     }
  1156.     private String getResourceName(int resId) {
  1157.         if (resId != 0) {
  1158.             final android.content.res.Resources res = getContext().getResources();
  1159.             try {
  1160.                 return res.getResourceName(resId);
  1161.             } catch (android.content.res.Resources.NotFoundException ex) {
  1162.                 return "(unknown)";
  1163.             }
  1164.         } else {
  1165.             return "(null)";
  1166.         }
  1167.     }
  1169.     private static String visibilityToString(int vis) {
  1170.         switch (vis) {
  1171.             case View.INVISIBLE:
  1172.                 return "INVISIBLE";
  1173.             case View.GONE:
  1174.                 return "GONE";
  1175.             default:
  1176.                 return "VISIBLE";
  1177.         }
  1178.     }
  1180.     @Override
  1181.     protected void onAttachedToWindow() {
  1182.         super.onAttachedToWindow();
  1183.         requestApplyInsets();
  1184.         reorient();
  1185.         onNavigationModeChanged(mNavBarMode);
  1186.         setUpSwipeUpOnboarding(isQuickStepSwipeUpEnabled());
  1187.         if (mRotationButtonController != null) {
  1188.             mRotationButtonController.registerListeners();
  1189.         }
  1191.         mEdgeBackGestureHandler.onNavBarAttached();
  1192.         getViewTreeObserver().addOnComputeInternalInsetsListener(mOnComputeInternalInsetsListener);
  1193.     }
  1195.     @Override
  1196.     protected void onDetachedFromWindow() {
  1197.         super.onDetachedFromWindow();
  1198.         Dependency.get(NavigationModeController.class).removeListener(this);
  1199.         setUpSwipeUpOnboarding(false);
  1200.         for (int i = 0; i < mButtonDispatchers.size(); ++i) {
  1201.             mButtonDispatchers.valueAt(i).onDestroy();
  1202.         }
  1203.         if (mRotationButtonController != null) {
  1204.             mRotationButtonController.unregisterListeners();
  1205.         }
  1207.         mEdgeBackGestureHandler.onNavBarDetached();
  1208.         getViewTreeObserver().removeOnComputeInternalInsetsListener(
  1209.                 mOnComputeInternalInsetsListener);
  1210.     }
  1212.     private void setUpSwipeUpOnboarding(boolean connectedToOverviewProxy) {
  1213.         if (connectedToOverviewProxy) {
  1214.             mRecentsOnboarding.onConnectedToLauncher();
  1215.         } else {
  1216.             mRecentsOnboarding.onDisconnectedFromLauncher();
  1217.         }
  1218.     }
  1220.     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
  1221.         pw.println("NavigationBarView {");
  1222.         final Rect r = new Rect();
  1223.         final Point size = new Point();
  1224.         getContextDisplay().getRealSize(size);
  1226.         pw.println(String.format("      this: " + StatusBar.viewInfo(this)
  1227.                         + " " + visibilityToString(getVisibility())));
  1229.         getWindowVisibleDisplayFrame(r);
  1230.         final boolean offscreen = r.right > size.x || r.bottom > size.y;
  1231.         pw.println("      window: "
  1232.                 + r.toShortString()
  1233.                 + " " + visibilityToString(getWindowVisibility())
  1234.                 + (offscreen ? " OFFSCREEN!" : ""));
  1236.         pw.println(String.format("      mCurrentView: id=%s (%dx%d) %s %f",
  1237.                         getResourceName(getCurrentView().getId()),
  1238.                         getCurrentView().getWidth(), getCurrentView().getHeight(),
  1239.                         visibilityToString(getCurrentView().getVisibility()),
  1240.                         getCurrentView().getAlpha()));
  1242.         pw.println(String.format("      disabled=0x%08x vertical=%s darkIntensity=%.2f",
  1243.                         mDisabledFlags,
  1244.                         mIsVertical ? "true" : "false",
  1245.                         getLightTransitionsController().getCurrentDarkIntensity()));
  1247.         pw.println("      mOrientedHandleSamplingRegion: " + mOrientedHandleSamplingRegion);
  1249.         dumpButton(pw, "back", getBackButton());
  1250.         dumpButton(pw, "home", getHomeButton());
  1251.         dumpButton(pw, "rcnt", getRecentsButton());
  1252.         dumpButton(pw, "rota", getRotateSuggestionButton());
  1253.         dumpButton(pw, "a11y", getAccessibilityButton());
  1255.         pw.println("    }");
  1256.         pw.println("    mScreenOn: " + mScreenOn);
  1258.         if (mNavigationInflaterView != null) {
  1259.             mNavigationInflaterView.dump(pw);
  1260.         }
  1261.         mContextualButtonGroup.dump(pw);
  1262.         mRecentsOnboarding.dump(pw);
  1263.         mRegionSamplingHelper.dump(pw);
  1264.         mEdgeBackGestureHandler.dump(pw);
  1265.     }
  1267.     @Override
  1268.     public WindowInsets onApplyWindowInsets(WindowInsets insets) {
  1269.         int leftInset = insets.getSystemWindowInsetLeft();
  1270.         int rightInset = insets.getSystemWindowInsetRight();
  1271.         setPadding(leftInset, insets.getSystemWindowInsetTop(), rightInset,
  1272.                 insets.getSystemWindowInsetBottom());
  1273.         // we're passing the insets onto the gesture handler since the back arrow is only
  1274.         // conditionally added and doesn't always get all the insets.
  1275.         mEdgeBackGestureHandler.setInsets(leftInset, rightInset);
  1277.         // this allows assist handle to be drawn outside its bound so that it can align screen
  1278.         // bottom by translating its y position.
  1279.         final boolean shouldClip =
  1280.                 !isGesturalMode(mNavBarMode) || insets.getSystemWindowInsetBottom() == 0;
  1281.         setClipChildren(shouldClip);
  1282.         setClipToPadding(shouldClip);
  1284.         NavigationBarController navigationBarController =
  1285.                 Dependency.get(NavigationBarController.class);
  1286.         AssistHandleViewController controller =
  1287.                 navigationBarController == null
  1288.                         ? null : navigationBarController.getAssistHandlerViewController();
  1289.         if (controller != null) {
  1290.             controller.setBottomOffset(insets.getSystemWindowInsetBottom());
  1291.         }
  1292.         return super.onApplyWindowInsets(insets);
  1293.     }
  1295.     private static void dumpButton(PrintWriter pw, String caption, ButtonDispatcher button) {
  1296.         pw.print("      " + caption + ": ");
  1297.         if (button == null) {
  1298.             pw.print("null");
  1299.         } else {
  1300.             pw.print(visibilityToString(button.getVisibility())
  1301.                     + " alpha=" + button.getAlpha()
  1302.                     );
  1303.         }
  1304.         pw.println();
  1305.     }
  1307.     public interface OnVerticalChangedListener {
  1308.         void onVerticalChanged(boolean isVertical);
  1309.     }
  1311.     private final Consumer<Boolean> mDockedListener = exists -> post(() -> {
  1312.         mDockedStackExists = exists;
  1313.         updateRecentsIcon();
  1314.     });
  1315. }

三，adb 模拟发送广播，然后底部的导航栏的图标会改变，测试效果图。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/558441
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号