Updating Toolbar Autohide behavior to account for multi-window mode.

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.res.Configuration;
 import android.os.Build;
 import android.os.Bundle;
@@ skipping 75 matching lines @@
     private DesktopView mRemoteHostDesktop;
 
     /**
      * Indicates whether the device is connected to a non-hidden physical qwerty keyboard. This is
      * set by {@link Desktop#setKeyboardState(Configuration)}. DO NOT request a soft keyboard when a
      * physical keyboard exists, otherwise the activity will enter an undefined state where the soft
      * keyboard never shows up meanwhile request to hide status bar always fails.
      */
     private boolean mHasPhysicalKeyboard;
 
+    /** Tracks whether the activity is in the resumed (running) state. */
+    private boolean mIsActivityRunning = false;
+
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.desktop);
 
         mClient = Client.getInstance();
         mInjector = new InputEventSender(mClient);
 
         Preconditions.notNull(mClient);
@@ skipping 19 matching lines @@
         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()) {
-                        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 {
-                        startActionBarAutoHideTimer();
-                    }
-                }
-            });
+            attachSystemUiResizeListener();
         } else {
             mRemoteHostDesktop.setFitsSystemWindows(true);
         }
     }
 
     @Override
     protected void onStart() {
         super.onStart();
         mActivityLifecycleListener.onActivityStarted(this);
         mClient.enableVideoChannel(true);
         mClient.getCapabilityManager().addListener(this);
     }
 
     @Override
+    public void onResume() {
+        mIsActivityRunning = true;
+        super.onResume();
+        mActivityLifecycleListener.onActivityResumed(this);
+        mClient.enableVideoChannel(true);
+        if (!inWindowedMode()) {
+            setUpAutoHideToolbar();
+            syncActionBarToSystemUiState();
+        }
+    }
+
+    @Override
     protected void onPause() {
         if (isFinishing()) mActivityLifecycleListener.onActivityPaused(this);
         super.onPause();
-        mClient.enableVideoChannel(false);
+        // The activity is paused in windowed mode when the user switches to another window.  In
+        // that case we should leave the video channel running so they continue to see updates from
+        // their remote machine.  The video channel will be stopped when onStop() is called.
+        if (!inWindowedMode()) {
+            mClient.enableVideoChannel(false);
+        }
         stopActionBarAutoHideTimer();
+        mIsActivityRunning = false;
     }
 
     @Override
-    public void onResume() {
-        super.onResume();
-        mActivityLifecycleListener.onActivityResumed(this);
-        mClient.enableVideoChannel(true);
-        syncActionBarToSystemUiState();
-    }
-
-    @Override
     protected void onStop() {
         mClient.getCapabilityManager().removeListener(this);
         mActivityLifecycleListener.onActivityStopped(this);
         super.onStop();
         mClient.enableVideoChannel(false);
     }
 
     @Override
     protected void onDestroy() {
         mRemoteHostDesktop.destroy();
@@ skipping 140 matching lines @@
                     default:
                         // Ignore.
                         break;
                 }
 
                 return false;
             }
         });
     }
 
+    private Boolean inWindowedMode() {
+        // NOTE: This method should only be called after OnResume() is called, otherwise
+        // isInMultiWindowMode() may not be accurate.  The value returned by this method is updated
+        // on a background thread and there is a race-condition between when the UX changes and this
+        // value is updated.  Hence, calling this method from onCreate() is not safe and we need to
+        // be careful when we query this value.
+        Preconditions.isTrue(mIsActivityRunning);
+
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isInMultiWindowMode();
+    }
+
+    private void setUpAutoHideToolbar() {
+        // Configure the auto-hiding taskbar if the activity is not in multi-window mode and the
+        // application is run on an OS which supports fullscreen mode (KitKat or higher).
+        Preconditions.isTrue(!inWindowedMode());
+        if (mActionBarAutoHideTask != null || Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
+            return;
+        }
+
+        mActionBarAutoHideTask = new Runnable() {
+            public void run() {
+                if (!mToolbar.isOverflowMenuShowing()) {
+                    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 {
+                    startActionBarAutoHideTimer();
+                }
+            }
+        });
+    }
+
     // Posts a deplayed task to hide the ActionBar.  If an existing task has already been scheduled,
     // then the previous task is removed and the new one scheduled, effectively resetting the timer.
     private void startActionBarAutoHideTimer() {
         if (mActionBarAutoHideTask != null) {
             stopActionBarAutoHideTimer();
             getWindow().getDecorView().postDelayed(
                     mActionBarAutoHideTask, ACTIONBAR_AUTO_HIDE_DELAY_MS);
         }
     }
 
@@ skipping 163 matching lines @@
             mInjector.sendCtrlAltDel();
             return true;
         }
         if (id == R.id.actionbar_help) {
             HelpSingleton.getInstance().launchHelp(this, HelpContext.DESKTOP);
             return true;
         }
         return super.onOptionsItemSelected(item);
     }
 
-    private void attachKeyboardVisibilityListener() {
-        View keyboardVisibilityDetector = findViewById(R.id.resize_detector);
-        keyboardVisibilityDetector.addOnLayoutChangeListener(new OnLayoutChangeListener() {
+    private void attachSystemUiResizeListener() {
+        View systemUiResizeDetector = findViewById(R.id.resize_detector);
+        systemUiResizeDetector.addOnLayoutChangeListener(new OnLayoutChangeListener() {
             // Tracks the maximum 'bottom' value seen during layout changes.  This value represents
             // the top of the SystemUI displayed at the bottom of the screen.
             // Note: This value is a screen coordinate so a larger value means lower on the screen.
             private int mMaxBottomValue;
 
             @Override
             public void onLayoutChange(View v, int left, int top, int right, int bottom,
                     int oldLeft, int oldTop, int oldRight, int oldBottom) {
                 // As the activity is started, a number of layout changes will flow through.  If
                 // this is a fresh start, then we will see one layout change which will represent
@@ skipping 43 matching lines @@
     @Override
     public boolean dispatchKeyEvent(KeyEvent event) {
         if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
             mClient.destroy();
             return super.dispatchKeyEvent(event);
         }
 
         return mInjector.sendKeyEvent(event);
     }
 }