Fix status bar visibility issue on pre-Marshmallow devices

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.app.AlertDialog;
 import android.content.DialogInterface;
 import android.content.Intent;
@@ skipping 59 matching lines @@
     private DesktopView mRemoteHostDesktop;
 
     /** 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. */

[Lambros, 2016/01/29 19:09:57]

Avoid OSK abbreviation, maybe just "keyboard" or "Soft Input UI" instead?

[joedow, 2016/01/29 19:31:17]

Done.

+    private boolean mHideSystemUIOnOskDismiss = 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 290 matching lines @@
         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() {
+        mHideSystemUIOnOskDismiss = false;
+
         // 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();
         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.
         if (mSoftInputVisible) {
@@ skipping 32 matching lines @@
         }
 
         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.

[Lambros, 2016/01/29 19:09:57]

This comment seems to contradict the first sentence in the comment above? Are
you saying that the OS will not call onSystemUiVisibilityChange() until the
keyboard has been dismissed; and on pre-M versions, it doesn't even get called
at all?

I think the problem is slightly different than what the comment indicates. You
say that we don't get the full-screen notification, but I think perhaps the
system doesn't even go into fullscreen. That's the real problem isn't it - the
system is out of full-screen, but our toolbar gets hidden, so the user has no
way of revealing the toolbar?

[joedow, 2016/01/29 19:31:17]

It doesn't contradict the sentence, it is documenting a complication due to the
older OS behavior.  onSystemUiVisibilityChange() is called for all OSes except
when the user interacts with the stats bar on pre-Marshmallow OSes.

For the second comment, I don't think it is a fullscreen issue.  It seems to me
that the OS acts like it is in immersive sticky mode even though that flag is
not specified.

+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                mHideSystemUIOnOskDismiss = true;
+            }
         }
     }
 
     /** Hides the action bar without changing SystemUiVisibility. */
     private void hideActionBarWithoutSystemUi() {
         getSupportActionBar().hide();
         stopActionBarAutoHideTimer();
     }
 
     /** Called whenever an action bar button is pressed. */
@@ skipping 75 matching lines @@
                 }
 
                 // If the delta between lowest bound we have seen (should be a systemUI 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.
                 mSoftInputVisible = (bottom < mMaxBottomValue);
                 mRemoteHostDesktop.onSoftInputMethodVisibilityChanged(
                         mSoftInputVisible, new Rect(left, top, right, bottom));
+
+                if (!mSoftInputVisible && mHideSystemUIOnOskDismiss) {
+                    // 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 (mHideSystemUIOnOskDismiss) {

[Lambros, 2016/01/29 19:09:57]

Why do you need to check this flag again? You already check it in the previous
if statement.

[joedow, 2016/01/29 19:31:17]

I am checking it here because this task is appended to the work queue.  *If* a
pending call to 'showActionBar()' were ahead of this task then the show would be
negated by this call.  Instead I check the value of the flag inside the queued
task to ensure it is still the intended behavior when the task is executed.

If the task were queued multiple times (due to a bug) we would still only
execute the hide once.

+                                mHideSystemUIOnOskDismiss = false;
+                                hideActionBar();
+                            }
+                        }
+                    });
+                }
             }
         });
     }
 
     private void onCardboardItemSelected() {
         if (getPreferences(MODE_PRIVATE).getBoolean(PREFERENCE_CARDBOARD_DIALOG_SEEN, false)) {
             switchToCardboardMode();
             return;
         }
 
@@ skipping 107 matching lines @@
                 JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_SHIFT_LEFT, pressed);
                 JniInterface.sendKeyEvent(0, KeyEvent.KEYCODE_EQUALS, pressed);
                 return true;
 
             default:
                 // We try to send all other key codes to the host directly.
                 return JniInterface.sendKeyEvent(0, keyCode, pressed);
         }
     }
 }