packages/SystemUI/src/com/android/systemui/statusbar/phone/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  */
  16
  17 package com.android.systemui.statusbar.phone;
  18
  19 import android.animation.LayoutTransition;
  20 import android.animation.LayoutTransition.TransitionListener;
  21 import android.animation.ObjectAnimator;
  22 import android.animation.TimeInterpolator;
  23 import android.animation.ValueAnimator;
  24 import android.app.ActivityManagerNative;
  25 import android.app.StatusBarManager;
  26 import android.content.Context;
  27 import android.content.res.Configuration;
  28 import android.graphics.Point;
  29 import android.graphics.Rect;
  30 import android.graphics.drawable.Drawable;
  31 import android.os.Handler;
  32 import android.os.Message;
  33 import android.os.RemoteException;
  34 import android.util.AttributeSet;
  35 import android.util.Log;
  36 import android.util.SparseArray;
  37 import android.view.Display;
  38 import android.view.IDockedStackListener.Stub;
  39 import android.view.MotionEvent;
  40 import android.view.Surface;
  41 import android.view.View;
  42 import android.view.ViewGroup;
  43 import android.view.WindowManager;
  44 import android.view.WindowManagerGlobal;
  45 import android.view.inputmethod.InputMethodManager;
  46 import android.widget.LinearLayout;
  47 import com.android.systemui.R;
  48 import com.android.systemui.RecentsComponent;
  49 import com.android.systemui.stackdivider.Divider;
  50 import com.android.systemui.statusbar.policy.DeadZone;
  51
  52 import java.io.FileDescriptor;
  53 import java.io.PrintWriter;
  54
  55 public class NavigationBarView extends LinearLayout {
  56     final static boolean DEBUG = false;
  57     final static String TAG = "StatusBar/NavBarView";
  58
  59     // slippery nav bar when everything is disabled, e.g. during setup
  60     final static boolean SLIPPERY_WHEN_DISABLED = true;
  61
  62     final Display mDisplay;
  63     View mCurrentView = null;
  64     View[] mRotatedViews = new View[4];
  65
  66     boolean mVertical;
  67     boolean mScreenOn;
  68     private int mCurrentRotation = -1;
  69
  70     boolean mShowMenu;
  71     int mDisabledFlags = 0;
  72     int mNavigationIconHints = 0;
  73
  74     private Drawable mBackIcon, mBackLandIcon, mBackAltIcon, mBackAltLandIcon;
  75     private Drawable mBackCarModeIcon, mBackLandCarModeIcon;
  76     private Drawable mBackAltCarModeIcon, mBackAltLandCarModeIcon;
  77     private Drawable mHomeDefaultIcon, mHomeCarModeIcon;
  78     private Drawable mRecentIcon;
  79     private Drawable mDockedIcon;
  80     private Drawable mImeIcon;
  81     private Drawable mMenuIcon;
  82
  83     private NavigationBarGestureHelper mGestureHelper;
  84     private DeadZone mDeadZone;
  85     private final NavigationBarTransitions mBarTransitions;
  86
  87     // workaround for LayoutTransitions leaving the nav buttons in a weird state (bug 5549288)
  88     final static boolean WORKAROUND_INVALID_LAYOUT = true;
  89     final static int MSG_CHECK_INVALID_LAYOUT = 8686;
  90
  91     // performs manual animation in sync with layout transitions
  92     private final NavTransitionListener mTransitionListener = new NavTransitionListener();
  93
  94     private OnVerticalChangedListener mOnVerticalChangedListener;
  95     private boolean mLayoutTransitionsEnabled = true;
  96     private boolean mWakeAndUnlocking;
  97     private boolean mCarMode = false;
  98     private boolean mDockedStackExists;
  99
 100     private final SparseArray<ButtonDispatcher> mButtonDisatchers = new SparseArray<>();
 101     private Configuration mConfiguration;
 102
 103     private NavigationBarInflaterView mNavigationInflaterView;
 104
 105     private class NavTransitionListener implements TransitionListener {
 106         private boolean mBackTransitioning;
 107         private boolean mHomeAppearing;
 108         private long mStartDelay;
 109         private long mDuration;
 110         private TimeInterpolator mInterpolator;
 111
 112         @Override
 113         public void startTransition(LayoutTransition transition, ViewGroup container,
 114                 View view, int transitionType) {
 115             if (view.getId() == R.id.back) {
 116                 mBackTransitioning = true;
 117             } else if (view.getId() == R.id.home && transitionType == LayoutTransition.APPEARING) {
 118                 mHomeAppearing = true;
 119                 mStartDelay = transition.getStartDelay(transitionType);
 120                 mDuration = transition.getDuration(transitionType);
 121                 mInterpolator = transition.getInterpolator(transitionType);
 122             }
 123         }
 124
 125         @Override
 126         public void endTransition(LayoutTransition transition, ViewGroup container,
 127                 View view, int transitionType) {
 128             if (view.getId() == R.id.back) {
 129                 mBackTransitioning = false;
 130             } else if (view.getId() == R.id.home && transitionType == LayoutTransition.APPEARING) {
 131                 mHomeAppearing = false;
 132             }
 133         }
 134
 135         public void onBackAltCleared() {
 136             ButtonDispatcher backButton = getBackButton();
 137
 138             // When dismissing ime during unlock, force the back button to run the same appearance
 139             // animation as home (if we catch this condition early enough).
 140             if (!mBackTransitioning && backButton.getVisibility() == VISIBLE
 141                     && mHomeAppearing && getHomeButton().getAlpha() == 0) {
 142                 getBackButton().setAlpha(0);
 143                 ValueAnimator a = ObjectAnimator.ofFloat(backButton, "alpha", 0, 1);
 144                 a.setStartDelay(mStartDelay);
 145                 a.setDuration(mDuration);
 146                 a.setInterpolator(mInterpolator);
 147                 a.start();
 148             }
 149         }
 150     }
 151
 152     private final OnClickListener mImeSwitcherClickListener = new OnClickListener() {
 153         @Override
 154         public void onClick(View view) {
 155             mContext.getSystemService(InputMethodManager.class)
 156                     .showInputMethodPicker(true /* showAuxiliarySubtypes */);
 157         }
 158     };
 159
 160     private class H extends Handler {
 161         public void handleMessage(Message m) {
 162             switch (m.what) {
 163                 case MSG_CHECK_INVALID_LAYOUT:
 164                     final String how = "" + m.obj;
 165                     final int w = getWidth();
 166                     final int h = getHeight();
 167                     final int vw = getCurrentView().getWidth();
 168                     final int vh = getCurrentView().getHeight();
 169
 170                     if (h != vh || w != vw) {
 171                         Log.w(TAG, String.format(
 172                             "*** Invalid layout in navigation bar (%s this=%dx%d cur=%dx%d)",
 173                             how, w, h, vw, vh));
 174                         if (WORKAROUND_INVALID_LAYOUT) {
 175                             requestLayout();
 176                         }
 177                     }
 178                     break;
 179             }
 180         }
 181     }
 182
 183     public NavigationBarView(Context context, AttributeSet attrs) {
 184         super(context, attrs);
 185
 186         mDisplay = ((WindowManager) context.getSystemService(
 187                 Context.WINDOW_SERVICE)).getDefaultDisplay();
 188
 189         mVertical = false;
 190         mShowMenu = false;
 191         mGestureHelper = new NavigationBarGestureHelper(context);
 192
 193         mConfiguration = new Configuration();
 194         mConfiguration.updateFrom(context.getResources().getConfiguration());
 195         updateIcons(context, Configuration.EMPTY, mConfiguration);
 196
 197         mBarTransitions = new NavigationBarTransitions(this);
 198
 199         mButtonDisatchers.put(R.id.back, new ButtonDispatcher(R.id.back));
 200         mButtonDisatchers.put(R.id.home, new ButtonDispatcher(R.id.home));
 201         mButtonDisatchers.put(R.id.recent_apps, new ButtonDispatcher(R.id.recent_apps));
 202         mButtonDisatchers.put(R.id.menu, new ButtonDispatcher(R.id.menu));
 203         mButtonDisatchers.put(R.id.ime_switcher, new ButtonDispatcher(R.id.ime_switcher));
 204     }
 205
 206     public BarTransitions getBarTransitions() {
 207         return mBarTransitions;
 208     }
 209
 210     public void setComponents(RecentsComponent recentsComponent, Divider divider) {
 211         mGestureHelper.setComponents(recentsComponent, divider, this);
 212     }
 213
 214     public void setOnVerticalChangedListener(OnVerticalChangedListener onVerticalChangedListener) {
 215         mOnVerticalChangedListener = onVerticalChangedListener;
 216         notifyVerticalChangedListener(mVertical);
 217     }
 218
 219     @Override
 220     public boolean onTouchEvent(MotionEvent event) {
 221         if (mGestureHelper.onTouchEvent(event)) {
 222             return true;
 223         }
 224         if (mDeadZone != null && event.getAction() == MotionEvent.ACTION_OUTSIDE) {
 225             mDeadZone.poke(event);
 226         }
 227         return super.onTouchEvent(event);
 228     }
 229
 230     @Override
 231     public boolean onInterceptTouchEvent(MotionEvent event) {
 232         return mGestureHelper.onInterceptTouchEvent(event);
 233     }
 234
 235     public void abortCurrentGesture() {
 236         getHomeButton().abortCurrentGesture();
 237     }
 238
 239     private H mHandler = new H();
 240
 241     public View getCurrentView() {
 242         return mCurrentView;
 243     }
 244
 245     public View[] getAllViews() {
 246         return mRotatedViews;
 247     }
 248
 249     public ButtonDispatcher getRecentsButton() {
 250         return mButtonDisatchers.get(R.id.recent_apps);
 251     }
 252
 253     public ButtonDispatcher getMenuButton() {
 254         return mButtonDisatchers.get(R.id.menu);
 255     }
 256
 257     public ButtonDispatcher getBackButton() {
 258         return mButtonDisatchers.get(R.id.back);
 259     }
 260
 261     public ButtonDispatcher getHomeButton() {
 262         return mButtonDisatchers.get(R.id.home);
 263     }
 264
 265     public ButtonDispatcher getImeSwitchButton() {
 266         return mButtonDisatchers.get(R.id.ime_switcher);
 267     }
 268
 269     private void updateCarModeIcons(Context ctx) {
 270         mBackCarModeIcon = ctx.getDrawable(R.drawable.ic_sysbar_back_carmode);
 271         mBackLandCarModeIcon = mBackCarModeIcon;
 272         mBackAltCarModeIcon = ctx.getDrawable(R.drawable.ic_sysbar_back_ime_carmode);
 273         mBackAltLandCarModeIcon = mBackAltCarModeIcon;
 274         mHomeCarModeIcon = ctx.getDrawable(R.drawable.ic_sysbar_home_carmode);
 275     }
 276
 277     private void updateIcons(Context ctx, Configuration oldConfig, Configuration newConfig) {
 278         if (oldConfig.orientation != newConfig.orientation
 279                 || oldConfig.densityDpi != newConfig.densityDpi) {
 280             mDockedIcon = ctx.getDrawable(R.drawable.ic_sysbar_docked);
 281         }
 282         if (oldConfig.densityDpi != newConfig.densityDpi) {
 283             mBackIcon = ctx.getDrawable(R.drawable.ic_sysbar_back);
 284             mBackLandIcon = mBackIcon;
 285             mBackAltIcon = ctx.getDrawable(R.drawable.ic_sysbar_back_ime);
 286             mBackAltLandIcon = mBackAltIcon;
 287
 288             mHomeDefaultIcon = ctx.getDrawable(R.drawable.ic_sysbar_home);
 289             mRecentIcon = ctx.getDrawable(R.drawable.ic_sysbar_recent);
 290             mMenuIcon = ctx.getDrawable(R.drawable.ic_sysbar_menu);
 291             mImeIcon = ctx.getDrawable(R.drawable.ic_ime_switcher_default);
 292
 293             updateCarModeIcons(ctx);
 294         }
 295     }
 296
 297     @Override
 298     public void setLayoutDirection(int layoutDirection) {
 299         // Reload all the icons
 300         updateIcons(getContext(), Configuration.EMPTY, mConfiguration);
 301
 302         super.setLayoutDirection(layoutDirection);
 303     }
 304
 305     public void notifyScreenOn(boolean screenOn) {
 306         mScreenOn = screenOn;
 307         setDisabledFlags(mDisabledFlags, true);
 308     }
 309
 310     public void setNavigationIconHints(int hints) {
 311         setNavigationIconHints(hints, false);
 312     }
 313
 314     private Drawable getBackIconWithAlt(boolean carMode, boolean landscape) {
 315         return landscape
 316                 ? carMode ? mBackAltLandCarModeIcon : mBackAltLandIcon
 317                 : carMode ? mBackAltCarModeIcon : mBackAltIcon;
 318     }
 319
 320     private Drawable getBackIcon(boolean carMode, boolean landscape) {
 321         return landscape
 322                 ? carMode ? mBackLandCarModeIcon : mBackLandIcon
 323                 : carMode ? mBackCarModeIcon : mBackIcon;
 324     }
 325
 326     public void setNavigationIconHints(int hints, boolean force) {
 327         if (!force && hints == mNavigationIconHints) return;
 328         final boolean backAlt = (hints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) != 0;
 329         if ((mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) != 0 && !backAlt) {
 330             mTransitionListener.onBackAltCleared();
 331         }
 332         if (DEBUG) {
 333             android.widget.Toast.makeText(getContext(),
 334                 "Navigation icon hints = " + hints,
 335                 500).show();
 336         }
 337
 338         mNavigationIconHints = hints;
 339
 340         // We have to replace or restore the back and home button icons when exiting or entering
 341         // carmode, respectively. Recents are not available in CarMode in nav bar so change
 342         // to recent icon is not required.
 343         Drawable backIcon = (backAlt)
 344                 ? getBackIconWithAlt(mCarMode, mVertical)
 345                 : getBackIcon(mCarMode, mVertical);
 346
 347         getBackButton().setImageDrawable(backIcon);
 348
 349         updateRecentsIcon();
 350
 351         if (mCarMode) {
 352             getHomeButton().setImageDrawable(mHomeCarModeIcon);
 353         } else {
 354             getHomeButton().setImageDrawable(mHomeDefaultIcon);
 355         }
 356
 357         final boolean showImeButton = ((hints & StatusBarManager.NAVIGATION_HINT_IME_SHOWN) != 0);
 358         getImeSwitchButton().setVisibility(showImeButton ? View.VISIBLE : View.INVISIBLE);
 359         getImeSwitchButton().setImageDrawable(mImeIcon);
 360
 361         // Update menu button in case the IME state has changed.
 362         setMenuVisibility(mShowMenu, true);
 363         getMenuButton().setImageDrawable(mMenuIcon);
 364
 365         setDisabledFlags(mDisabledFlags, true);
 366     }
 367
 368     public void setDisabledFlags(int disabledFlags) {
 369         setDisabledFlags(disabledFlags, false);
 370     }
 371
 372     public void setDisabledFlags(int disabledFlags, boolean force) {
 373         if (!force && mDisabledFlags == disabledFlags) return;
 374
 375         mDisabledFlags = disabledFlags;
 376
 377         final boolean disableHome = ((disabledFlags & View.STATUS_BAR_DISABLE_HOME) != 0);
 378
 379         // Disable recents always in car mode.
 380         boolean disableRecent = (
 381                 mCarMode || (disabledFlags & View.STATUS_BAR_DISABLE_RECENT) != 0);
 382         final boolean disableBack = ((disabledFlags & View.STATUS_BAR_DISABLE_BACK) != 0)
 383                 && ((mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_BACK_ALT) == 0);
 384         final boolean disableSearch = ((disabledFlags & View.STATUS_BAR_DISABLE_SEARCH) != 0);
 385
 386         ViewGroup navButtons = (ViewGroup) getCurrentView().findViewById(R.id.nav_buttons);
 387         if (navButtons != null) {
 388             LayoutTransition lt = navButtons.getLayoutTransition();
 389             if (lt != null) {
 390                 if (!lt.getTransitionListeners().contains(mTransitionListener)) {
 391                     lt.addTransitionListener(mTransitionListener);
 392                 }
 393             }
 394         }
 395         if (inLockTask() && disableRecent && !disableHome) {
 396             // Don't hide recents when in lock task, it is used for exiting.
 397             // Unless home is hidden, then in DPM locked mode and no exit available.
 398             disableRecent = false;
 399         }
 400
 401         getBackButton().setVisibility(disableBack      ? View.INVISIBLE : View.VISIBLE);
 402         getHomeButton().setVisibility(disableHome      ? View.INVISIBLE : View.VISIBLE);
 403         getRecentsButton().setVisibility(disableRecent ? View.INVISIBLE : View.VISIBLE);
 404     }
 405
 406     private boolean inLockTask() {
 407         try {
 408             return ActivityManagerNative.getDefault().isInLockTaskMode();
 409         } catch (RemoteException e) {
 410             return false;
 411         }
 412     }
 413
 414     public void setLayoutTransitionsEnabled(boolean enabled) {
 415         mLayoutTransitionsEnabled = enabled;
 416         updateLayoutTransitionsEnabled();
 417     }
 418
 419     public void setWakeAndUnlocking(boolean wakeAndUnlocking) {
 420         setUseFadingAnimations(wakeAndUnlocking);
 421         mWakeAndUnlocking = wakeAndUnlocking;
 422         updateLayoutTransitionsEnabled();
 423     }
 424
 425     private void updateLayoutTransitionsEnabled() {
 426         boolean enabled = !mWakeAndUnlocking && mLayoutTransitionsEnabled;
 427         ViewGroup navButtons = (ViewGroup) getCurrentView().findViewById(R.id.nav_buttons);
 428         LayoutTransition lt = navButtons.getLayoutTransition();
 429         if (lt != null) {
 430             if (enabled) {
 431                 lt.enableTransitionType(LayoutTransition.APPEARING);
 432                 lt.enableTransitionType(LayoutTransition.DISAPPEARING);
 433                 lt.enableTransitionType(LayoutTransition.CHANGE_APPEARING);
 434                 lt.enableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
 435             } else {
 436                 lt.disableTransitionType(LayoutTransition.APPEARING);
 437                 lt.disableTransitionType(LayoutTransition.DISAPPEARING);
 438                 lt.disableTransitionType(LayoutTransition.CHANGE_APPEARING);
 439                 lt.disableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
 440             }
 441         }
 442     }
 443
 444     private void setUseFadingAnimations(boolean useFadingAnimations) {
 445         WindowManager.LayoutParams lp = (WindowManager.LayoutParams) getLayoutParams();
 446         if (lp != null) {
 447             boolean old = lp.windowAnimations != 0;
 448             if (!old && useFadingAnimations) {
 449                 lp.windowAnimations = R.style.Animation_NavigationBarFadeIn;
 450             } else if (old && !useFadingAnimations) {
 451                 lp.windowAnimations = 0;
 452             } else {
 453                 return;
 454             }
 455             WindowManager wm = (WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
 456             wm.updateViewLayout(this, lp);
 457         }
 458     }
 459
 460     public void setMenuVisibility(final boolean show) {
 461         setMenuVisibility(show, false);
 462     }
 463
 464     public void setMenuVisibility(final boolean show, final boolean force) {
 465         if (!force && mShowMenu == show) return;
 466
 467         mShowMenu = show;
 468
 469         // Only show Menu if IME switcher not shown.
 470         final boolean shouldShow = mShowMenu &&
 471                 ((mNavigationIconHints & StatusBarManager.NAVIGATION_HINT_IME_SHOWN) == 0);
 472
 473         getMenuButton().setVisibility(shouldShow ? View.VISIBLE : View.INVISIBLE);
 474     }
 475
 476     @Override
 477     public void onFinishInflate() {
 478         mNavigationInflaterView = (NavigationBarInflaterView) findViewById(
 479                 R.id.navigation_inflater);
 480         updateRotatedViews();
 481         mNavigationInflaterView.setButtonDispatchers(mButtonDisatchers);
 482
 483         getImeSwitchButton().setOnClickListener(mImeSwitcherClickListener);
 484
 485         try {
 486             WindowManagerGlobal.getWindowManagerService().registerDockedStackListener(new Stub() {
 487                 @Override
 488                 public void onDividerVisibilityChanged(boolean visible) throws RemoteException {
 489                 }
 490
 491                 @Override
 492                 public void onDockedStackExistsChanged(final boolean exists) throws RemoteException {
 493                     mHandler.post(new Runnable() {
 494                         @Override
 495                         public void run() {
 496                             mDockedStackExists = exists;
 497                             updateRecentsIcon();
 498                         }
 499                     });
 500                 }
 501
 502                 @Override
 503                 public void onDockedStackMinimizedChanged(boolean minimized, long animDuration)
 504                         throws RemoteException {
 505                 }
 506
 507                 @Override
 508                 public void onAdjustedForImeChanged(boolean adjustedForIme, long animDuration)
 509                         throws RemoteException {
 510                 }
 511
 512                 @Override
 513                 public void onDockSideChanged(int newDockSide) throws RemoteException {
 514                 }
 515             });
 516         } catch (RemoteException e) {
 517             Log.e(TAG, "Failed registering docked stack exists listener", e);
 518         }
 519     }
 520
 521     void updateRotatedViews() {
 522         mRotatedViews[Surface.ROTATION_0] =
 523                 mRotatedViews[Surface.ROTATION_180] = findViewById(R.id.rot0);
 524         mRotatedViews[Surface.ROTATION_270] =
 525                 mRotatedViews[Surface.ROTATION_90] = findViewById(R.id.rot90);
 526
 527         updateCurrentView();
 528     }
 529
 530     public boolean needsReorient(int rotation) {
 531         return mCurrentRotation != rotation;
 532     }
 533
 534     private void updateCurrentView() {
 535         final int rot = mDisplay.getRotation();
 536         for (int i=0; i<4; i++) {
 537             mRotatedViews[i].setVisibility(View.GONE);
 538         }
 539         mCurrentView = mRotatedViews[rot];
 540         mCurrentView.setVisibility(View.VISIBLE);
 541         mNavigationInflaterView.setAlternativeOrder(rot == Surface.ROTATION_90);
 542         for (int i = 0; i < mButtonDisatchers.size(); i++) {
 543             mButtonDisatchers.valueAt(i).setCurrentView(mCurrentView);
 544         }
 545         updateLayoutTransitionsEnabled();
 546         mCurrentRotation = rot;
 547     }
 548
 549     private void updateRecentsIcon() {
 550         getRecentsButton().setImageDrawable(mDockedStackExists ? mDockedIcon : mRecentIcon);
 551     }
 552
 553     public boolean isVertical() {
 554         return mVertical;
 555     }
 556
 557     public void reorient() {
 558         updateCurrentView();
 559
 560         getImeSwitchButton().setOnClickListener(mImeSwitcherClickListener);
 561
 562         mDeadZone = (DeadZone) mCurrentView.findViewById(R.id.deadzone);
 563
 564         // force the low profile & disabled states into compliance
 565         mBarTransitions.init();
 566         setDisabledFlags(mDisabledFlags, true /* force */);
 567         setMenuVisibility(mShowMenu, true /* force */);
 568
 569         if (DEBUG) {
 570             Log.d(TAG, "reorient(): rot=" + mCurrentRotation);
 571         }
 572
 573         updateTaskSwitchHelper();
 574         setNavigationIconHints(mNavigationIconHints, true);
 575     }
 576
 577     private void updateTaskSwitchHelper() {
 578         boolean isRtl = (getLayoutDirection() == View.LAYOUT_DIRECTION_RTL);
 579         mGestureHelper.setBarState(mVertical, isRtl);
 580     }
 581
 582     @Override
 583     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
 584         if (DEBUG) Log.d(TAG, String.format(
 585                     "onSizeChanged: (%dx%d) old: (%dx%d)", w, h, oldw, oldh));
 586
 587         final boolean newVertical = w > 0 && h > w;
 588         if (newVertical != mVertical) {
 589             mVertical = newVertical;
 590             //Log.v(TAG, String.format("onSizeChanged: h=%d, w=%d, vert=%s", h, w, mVertical?"y":"n"));
 591             reorient();
 592             notifyVerticalChangedListener(newVertical);
 593         }
 594
 595         postCheckForInvalidLayout("sizeChanged");
 596         super.onSizeChanged(w, h, oldw, oldh);
 597     }
 598
 599     private void notifyVerticalChangedListener(boolean newVertical) {
 600         if (mOnVerticalChangedListener != null) {
 601             mOnVerticalChangedListener.onVerticalChanged(newVertical);
 602         }
 603     }
 604
 605     @Override
 606     protected void onConfigurationChanged(Configuration newConfig) {
 607         super.onConfigurationChanged(newConfig);
 608         boolean uiCarModeChanged = updateCarMode(newConfig);
 609         updateTaskSwitchHelper();
 610         updateIcons(getContext(), mConfiguration, newConfig);
 611         updateRecentsIcon();
 612         if (uiCarModeChanged || mConfiguration.densityDpi != newConfig.densityDpi) {
 613             // If car mode or density changes, we need to reset the icons.
 614             setNavigationIconHints(mNavigationIconHints, true);
 615         }
 616         mConfiguration.updateFrom(newConfig);
 617     }
 618
 619     /**
 620      * If the configuration changed, update the carmode and return that it was updated.
 621      */
 622     private boolean updateCarMode(Configuration newConfig) {
 623         boolean uiCarModeChanged = false;
 624         if (newConfig != null) {
 625             int uiMode = newConfig.uiMode & Configuration.UI_MODE_TYPE_MASK;
 626             if (mCarMode && uiMode != Configuration.UI_MODE_TYPE_CAR) {
 627                 mCarMode = false;
 628                 uiCarModeChanged = true;
 629                 getHomeButton().setCarMode(mCarMode);
 630             } else if (uiMode == Configuration.UI_MODE_TYPE_CAR) {
 631                 mCarMode = true;
 632                 uiCarModeChanged = true;
 633                 getHomeButton().setCarMode(mCarMode);
 634             }
 635         }
 636         return uiCarModeChanged;
 637     }
 638
 639     /*
 640     @Override
 641     protected void onLayout (boolean changed, int left, int top, int right, int bottom) {
 642         if (DEBUG) Log.d(TAG, String.format(
 643                     "onLayout: %s (%d,%d,%d,%d)",
 644                     changed?"changed":"notchanged", left, top, right, bottom));
 645         super.onLayout(changed, left, top, right, bottom);
 646     }
 647
 648     // uncomment this for extra defensiveness in WORKAROUND_INVALID_LAYOUT situations: if all else
 649     // fails, any touch on the display will fix the layout.
 650     @Override
 651     public boolean onInterceptTouchEvent(MotionEvent ev) {
 652         if (DEBUG) Log.d(TAG, "onInterceptTouchEvent: " + ev.toString());
 653         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
 654             postCheckForInvalidLayout("touch");
 655         }
 656         return super.onInterceptTouchEvent(ev);
 657     }
 658     */
 659
 660
 661     private String getResourceName(int resId) {
 662         if (resId != 0) {
 663             final android.content.res.Resources res = getContext().getResources();
 664             try {
 665                 return res.getResourceName(resId);
 666             } catch (android.content.res.Resources.NotFoundException ex) {
 667                 return "(unknown)";
 668             }
 669         } else {
 670             return "(null)";
 671         }
 672     }
 673
 674     private void postCheckForInvalidLayout(final String how) {
 675         mHandler.obtainMessage(MSG_CHECK_INVALID_LAYOUT, 0, 0, how).sendToTarget();
 676     }
 677
 678     private static String visibilityToString(int vis) {
 679         switch (vis) {
 680             case View.INVISIBLE:
 681                 return "INVISIBLE";
 682             case View.GONE:
 683                 return "GONE";
 684             default:
 685                 return "VISIBLE";
 686         }
 687     }
 688
 689     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
 690         pw.println("NavigationBarView {");
 691         final Rect r = new Rect();
 692         final Point size = new Point();
 693         mDisplay.getRealSize(size);
 694
 695         pw.println(String.format("      this: " + PhoneStatusBar.viewInfo(this)
 696                         + " " + visibilityToString(getVisibility())));
 697
 698         getWindowVisibleDisplayFrame(r);
 699         final boolean offscreen = r.right > size.x || r.bottom > size.y;
 700         pw.println("      window: "
 701                 + r.toShortString()
 702                 + " " + visibilityToString(getWindowVisibility())
 703                 + (offscreen ? " OFFSCREEN!" : ""));
 704
 705         pw.println(String.format("      mCurrentView: id=%s (%dx%d) %s",
 706                         getResourceName(getCurrentView().getId()),
 707                         getCurrentView().getWidth(), getCurrentView().getHeight(),
 708                         visibilityToString(getCurrentView().getVisibility())));
 709
 710         pw.println(String.format("      disabled=0x%08x vertical=%s menu=%s",
 711                         mDisabledFlags,
 712                         mVertical ? "true" : "false",
 713                         mShowMenu ? "true" : "false"));
 714
 715         dumpButton(pw, "back", getBackButton());
 716         dumpButton(pw, "home", getHomeButton());
 717         dumpButton(pw, "rcnt", getRecentsButton());
 718         dumpButton(pw, "menu", getMenuButton());
 719
 720         pw.println("    }");
 721     }
 722
 723     private static void dumpButton(PrintWriter pw, String caption, ButtonDispatcher button) {
 724         pw.print("      " + caption + ": ");
 725         if (button == null) {
 726             pw.print("null");
 727         } else {
 728             pw.print(visibilityToString(button.getVisibility())
 729                     + " alpha=" + button.getAlpha()
 730                     );
 731         }
 732         pw.println();
 733     }
 734
 735     public interface OnVerticalChangedListener {
 736         void onVerticalChanged(boolean isVertical);
 737     }
 738
 739 }