Fixing Toolbar flakiness in Android client.

remoting/android/java/src/org/chromium/chromoting/Desktop.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chromoting;
 
 import android.annotation.SuppressLint;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
@@ skipping 44 matching lines @@
 
     /**
      * Preference used for displaying an interestitial dialog only when the user first accesses the
      * Cardboard function.
      */
     private static final String PREFERENCE_CARDBOARD_DIALOG_SEEN = "cardboard_dialog_seen";
 
     /** Preference used to track the last input mode selected by the user. */
     private static final String PREFERENCE_INPUT_MODE = "input_mode";
 
-    /** The amount of time to wait to hide the Actionbar after user input is seen. */
+    /** The amount of time to wait to hide the ActionBar after user input is seen. */
     private static final int ACTIONBAR_AUTO_HIDE_DELAY_MS = 3000;
 
     private final Event.Raisable<SoftInputMethodVisibilityChangedEventParameter>
             mOnSoftInputMethodVisibilityChanged = new Event.Raisable<>();
 
     private final Event.Raisable<InputModeChangedEventParameter> mOnInputModeChanged =
             new Event.Raisable<>();
 
     private Client mClient;
 
     /** Set of pressed keys for which we've sent TextEvent. */
     private Set<Integer> mPressedTextKeys = new TreeSet<Integer>();
 
     private ActivityLifecycleListener mActivityLifecycleListener;
 
     /** Flag to indicate whether the current activity is switching to Cardboard desktop activity. */
     private boolean mSwitchToCardboardDesktopActivity;
 
-    /** Flag to indicate whether to manually hide the system UI when the OSK is dismissed. */
-    private boolean mHideSystemUIOnSoftKeyboardDismiss = false;
-
     /** Indicates whether a Soft Input UI (such as a keyboard) is visible. */
     private boolean mSoftInputVisible = false;
 
     /** Holds the scheduled task object which will be called to hide the ActionBar. */
     private Runnable mActionBarAutoHideTask;
 
     /** The Toolbar instance backing our SupportActionBar. */
     private Toolbar mToolbar;
 
     /** Tracks the current input mode (e.g. trackpad/touch). */
@@ skipping 21 matching lines @@
         getSupportActionBar().setDisplayShowTitleEnabled(false);
         getSupportActionBar().setDisplayHomeAsUpEnabled(true);
 
         // For this Activity, the home button in the action bar acts as a Disconnect button, so
         // set the description for accessibility/screen readers.
         getSupportActionBar().setHomeActionContentDescription(R.string.disconnect_myself_button);
 
         // The action bar is already shown when the activity is started however calling the
         // function below will set our preferred system UI flags which will adjust the layout
         // size of the canvas and we can avoid an initial resize event.
-        showActionBar();
+        showSystemUi();
 
         View decorView = getWindow().getDecorView();
         decorView.setOnSystemUiVisibilityChangeListener(this);
 
         mActivityLifecycleListener = mClient.getCapabilityManager().onActivityAcceptingListener(
                 this, Capabilities.CAST_CAPABILITY);
         mActivityLifecycleListener.onActivityCreated(this, savedInstanceState);
 
         mInputMode = getInitialInputModeValue();
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
             attachKeyboardVisibilityListener();
 
             // Only create an Autohide task if the system supports immersive fullscreen mode.  Older
             // versions of the OS benefit less from this functionality and we don't want to change
             // the experience for them.
             mActionBarAutoHideTask = new Runnable() {
                 public void run() {
                     if (!mToolbar.isOverflowMenuShowing()) {
-                        hideActionBar();
+                        hideSystemUi();
                     }
                 }
             };
 
             // Suspend the ActionBar timer when the user interacts with the options menu.
             getSupportActionBar().addOnMenuVisibilityListener(new OnMenuVisibilityListener() {
                 public void onMenuVisibilityChanged(boolean isVisible) {
                     if (isVisible) {
                         stopActionBarAutoHideTimer();
                     } else {
@@ skipping 24 matching lines @@
             mClient.enableVideoChannel(false);
         }
         stopActionBarAutoHideTimer();
     }
 
     @Override
     public void onResume() {
         super.onResume();
         mActivityLifecycleListener.onActivityResumed(this);
         mClient.enableVideoChannel(true);
-        startActionBarAutoHideTimer();
+        syncActionBarToSystemUiState();
     }
 
     @Override
     protected void onStop() {
         mClient.getCapabilityManager().removeListener(this);
         mActivityLifecycleListener.onActivityStopped(this);
         super.onStop();
         if (mSwitchToCardboardDesktopActivity) {
             mSwitchToCardboardDesktopActivity = false;
         } else {
@@ skipping 157 matching lines @@
         }
     }
 
     // Clear all existing delayed tasks to prevent the ActionBar from being hidden.
     private void stopActionBarAutoHideTimer() {
         if (mActionBarAutoHideTask != null) {
             getWindow().getDecorView().removeCallbacks(mActionBarAutoHideTask);
         }
     }
 
+    // Updates the ActionBar visibility to match the System UI elements.  This is useful after a
+    // power or activity lifecycle event in which the current System UI state has changed but we
+    // never received the notification.
+    private void syncActionBarToSystemUiState() {
+        onSystemUiVisibilityChange(getWindow().getDecorView().getSystemUiVisibility());
+    }
+
+    private boolean isActionBarVisible() {
+        return getSupportActionBar() != null && getSupportActionBar().isShowing();
+    }
+
     /** Called whenever the visibility of the system status bar or navigation bar changes. */
     @Override
     public void onSystemUiVisibilityChange(int visibility) {
         // Ensure the action-bar's visibility matches that of the system controls. This
         // minimizes the number of states the UI can be in, to keep things simple for the user.
 
-        // Determine if the system is in fullscreen/lights-out mode. LOW_PROFILE is needed since
-        // it's the only flag supported in 4.0. But it is not sufficient in itself; when
-        // IMMERSIVE_STICKY mode is used, the system clears this flag (leaving the FULLSCREEN flag
-        // set) when the user swipes the edge to reveal the bars temporarily. When this happens,
-        // the action-bar should remain hidden.
+        // Check if the system is in fullscreen/lights-out mode then update the ActionBar to match.
         int fullscreenFlags = getFullscreenFlags();
         if ((visibility & fullscreenFlags) != 0) {
-            hideActionBarWithoutSystemUi();
+            hideActionBar();
         } else {
-            showActionBarWithoutSystemUi();
+            showActionBar();
         }
     }
 
     @SuppressLint("InlinedApi")
     private static int getFullscreenFlags() {
+        // LOW_PROFILE gives the status and navigation bars a "lights-out" appearance.
+        // FULLSCREEN hides the status bar on supported devices (4.1 and above).
         int flags = View.SYSTEM_UI_FLAG_LOW_PROFILE;
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
             flags |= View.SYSTEM_UI_FLAG_FULLSCREEN;
         }
         return flags;
     }
 
     @SuppressLint("InlinedApi")
-    private static int getImmersiveLayoutFlags() {
+    private static int getLayoutFlags() {
         int flags = 0;
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
             flags |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
             flags |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
             flags |= View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
         }
         return flags;
     }
 
-    public void showActionBar() {
-        mHideSystemUIOnSoftKeyboardDismiss = false;
-
+    public void showSystemUi() {
         // Request exit from any fullscreen mode. The action-bar controls will be shown in response
         // to the SystemUiVisibility notification. The visibility of the action-bar should be tied
         // to the fullscreen state of the system, so there's no need to explicitly show it here.
-        int flags = View.SYSTEM_UI_FLAG_VISIBLE | getImmersiveLayoutFlags();
+        int flags = View.SYSTEM_UI_FLAG_VISIBLE | getLayoutFlags();
         getWindow().getDecorView().setSystemUiVisibility(flags);
 
-        // The OS will not call onSystemUiVisibilityChange() if the keyboard is visible which means
-        // our ActionBar will not be visible until then.  This check allows us to work around this
-        // issue and still allow the system to show the ActionBar normally with the soft keyboard.
+        // The OS will not call onSystemUiVisibilityChange() if the soft keyboard is visible which
+        // means our ActionBar will not be shown if this function is called in that scenario.
         if (mSoftInputVisible) {
-            showActionBarWithoutSystemUi();
+            showActionBar();
         }
     }
 
     /** Shows the action bar without changing SystemUiVisibility. */
-    private void showActionBarWithoutSystemUi() {
+    private void showActionBar() {
         getSupportActionBar().show();
         startActionBarAutoHideTimer();
     }
 
     @SuppressLint("InlinedApi")
-    public void hideActionBar() {
+    public void hideSystemUi() {
+        // If a soft input device is present, then hide the ActionBar but do not hide the rest of
+        // system UI.  A second call will be made once the soft input device is hidden.
+        if (mSoftInputVisible) {
+            hideActionBar();
+            return;
+        }
+
         // Request the device to enter fullscreen mode. Don't hide the controls yet, because the
         // system might not honor the fullscreen request immediately (for example, if the
         // keyboard is visible, the system might delay fullscreen until the keyboard is hidden).
         // The controls will be hidden in response to the SystemUiVisibility notification.
         // This helps ensure that the visibility of the controls is synchronized with the
         // fullscreen state.
-
-        // LOW_PROFILE gives the status and navigation bars a "lights-out" appearance.
-        // FULLSCREEN hides the status bar on supported devices (4.1 and above).
         int flags = getFullscreenFlags();
 
         // HIDE_NAVIGATION hides the navigation bar. However, if the user touches the screen, the
         // event is not seen by the application and instead the navigation bar is re-shown.
-        // IMMERSIVE(_STICKY) fixes this problem and allows the user to interact with the app while
+        // IMMERSIVE fixes this problem and allows the user to interact with the app while
         // keeping the navigation controls hidden. This flag was introduced in 4.4, later than
         // HIDE_NAVIGATION, and so a runtime check is needed before setting either of these flags.
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
             flags |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
             flags |= View.SYSTEM_UI_FLAG_IMMERSIVE;
-            flags |= getImmersiveLayoutFlags();
         }
+        flags |= getLayoutFlags();
 
         getWindow().getDecorView().setSystemUiVisibility(flags);
-
-        // The OS will not call onSystemUiVisibilityChange() until the keyboard has been dismissed
-        // which means our ActionBar will still be visible.  This check allows us to work around
-        // this issue when the keyboard is visible and the user wants additional space on the screen
-        // and still allow the system to hide the ActionBar normally when no keyboard is present.
-        if (mSoftInputVisible) {
-            hideActionBarWithoutSystemUi();
-
-            // Android OSes prior to Marshmallow do not call onSystemUiVisibilityChange after the
-            // OSK is dismissed if the user has interacted with the status bar.
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-                mHideSystemUIOnSoftKeyboardDismiss = true;
-            }
-        }
     }
 
     /** Hides the action bar without changing SystemUiVisibility. */
-    private void hideActionBarWithoutSystemUi() {
+    private void hideActionBar() {
         getSupportActionBar().hide();
         stopActionBarAutoHideTimer();
     }
 
     /** Called whenever an action bar button is pressed. */
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         int id = item.getItemId();
 
         mActivityLifecycleListener.onActivityOptionsItemSelected(this, item);
@@ skipping 10 matching lines @@
         if (id == R.id.actionbar_touch_mode) {
             // When the touch icon is tapped, we want to switch the input mode to trackpad.
             setInputMode(InputMode.TRACKPAD);
             return true;
         }
         if (id == R.id.actionbar_keyboard) {
             ((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)).toggleSoftInput(0, 0);
             return true;
         }
         if (id == R.id.actionbar_hide) {
-            hideActionBar();
+            hideSystemUi();
             return true;
         }
         if (id == R.id.actionbar_disconnect || id == android.R.id.home) {
             mClient.destroy();
             return true;
         }
         if (id == R.id.actionbar_send_ctrl_alt_del) {
             int[] keys = {
                 KeyEvent.KEYCODE_CTRL_LEFT,
                 KeyEvent.KEYCODE_ALT_LEFT,
@@ skipping 31 matching lines @@
                 // are transitioning from another activity/orientation, then there may be several
                 // layout change events as the view is updated (i.e. the OSK might have been
                 // displayed previously but is being dismissed).  Therefore we want to track the
                 // largest value we have seen and use it to determine if a new system UI (such as
                 // the OSK) is being displayed.
                 if (mMaxBottomValue < bottom) {
                     mMaxBottomValue = bottom;
                     return;
                 }
 
-                // If the delta between lowest bound we have seen (should be a systemUI such as
+                // If the delta between lowest bound we have seen (should be a System UI such as
                 // the navigation bar) and the current bound does not match, then we have a form
                 // of soft input displayed.  Note that the size of a soft input device can change
                 // when the input method is changed so we want to send updates to the image canvas
                 // whenever they occur.
+                boolean oldSoftInputVisible = mSoftInputVisible;
                 mSoftInputVisible = (bottom < mMaxBottomValue);
                 mOnSoftInputMethodVisibilityChanged.raise(
                         new SoftInputMethodVisibilityChangedEventParameter(
                                 mSoftInputVisible, left, top, right, bottom));
 
-                if (!mSoftInputVisible && mHideSystemUIOnSoftKeyboardDismiss) {
+                boolean softInputVisibilityChanged = oldSoftInputVisible != mSoftInputVisible;
+                if (!mSoftInputVisible && softInputVisibilityChanged && !isActionBarVisible()) {
                     // Queue a task which will run after the current action (OSK dismiss) has
                     // completed, otherwise the hide request will not take effect.
                     new Handler().post(new Runnable() {
                         @Override
                         public void run() {
-                            if (mHideSystemUIOnSoftKeyboardDismiss) {
-                                mHideSystemUIOnSoftKeyboardDismiss = false;
-                                hideActionBar();
+                            if (!mSoftInputVisible && !isActionBarVisible()) {
+                                hideSystemUi();
                             }
                         }
                     });
                 }
             }
         });
     }
 
     private void onCardboardItemSelected() {
         if (getPreferences(MODE_PRIVATE).getBoolean(PREFERENCE_CARDBOARD_DIALOG_SEEN, false)) {
@@ skipping 111 matching lines @@
                 mClient.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
                 mClient.sendKeyEvent(0, KeyEvent.KEYCODE_EQUALS, pressed);
                 return true;
 
             default:
                 // We try to send all other key codes to the host directly.
                 return mClient.sendKeyEvent(0, keyCode, pressed);
         }
     }
 }