Support "display": "fullscreen" for sites added to the home screen.

chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappActivity.java

 // Copyright 2015 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.chrome.browser.webapps;
 
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.StrictMode;
 import android.os.SystemClock;
 import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.View;
+import android.view.View.OnSystemUiVisibilityChangeListener;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.chromium.base.ActivityState;
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.blink_public.platform.WebDisplayMode;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.TabState;
 import org.chromium.chrome.browser.document.DocumentUtils;
+import org.chromium.chrome.browser.fullscreen.ChromeFullscreenManager;
 import org.chromium.chrome.browser.metrics.WebappUma;
 import org.chromium.chrome.browser.tab.EmptyTabObserver;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tab.TabDelegateFactory;
 import org.chromium.chrome.browser.tab.TabObserver;
 import org.chromium.chrome.browser.util.ColorUtils;
 import org.chromium.chrome.browser.util.UrlUtilities;
 import org.chromium.content.browser.ScreenOrientationProvider;
 import org.chromium.content_public.browser.LoadUrlParams;
 import org.chromium.net.NetworkChangeNotifier;
 import org.chromium.ui.base.PageTransition;
 
 import java.io.File;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Displays a webapp in a nearly UI-less Chrome (InfoBars still appear).
  */
 public class WebappActivity extends FullScreenActivity {
     public static final String WEBAPP_SCHEME = "webapp";
 
     private static final String TAG = "WebappActivity";
     private static final long MS_BEFORE_NAVIGATING_BACK_FROM_INTERSTITIAL = 1000;
 
+    private static final int ENTER_IMMERSIVE_MODE_DELAY_MILLIS = 300;
+    private static final int RESTORE_IMMERSIVE_MODE_DELAY_MILLIS = 3000;
+    private static final int IMMERSIVE_MODE_UI_FLAGS = View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION // hide nav bar
+            | View.SYSTEM_UI_FLAG_FULLSCREEN // hide status bar
+            | View.SYSTEM_UI_FLAG_LOW_PROFILE
+            | View.SYSTEM_UI_FLAG_IMMERSIVE;
+
     private final WebappDirectoryManager mDirectoryManager;
 
     protected WebappInfo mWebappInfo;
 
     private ViewGroup mSplashScreen;
     private WebappUrlBar mUrlBar;
 
     private boolean mIsInitialized;
     private Integer mBrandColor;
 
     private WebappUma mWebappUma;
 
     private Bitmap mLargestFavicon;
 
+    private Runnable mSetImmersiveRunnable;
+
     /**
      * Construct all the variables that shouldn't change.  We do it here both to clarify when the
      * objects are created and to ensure that they exist throughout the parallelized initialization
      * of the WebappActivity.
      */
     public WebappActivity() {
         mWebappInfo = createWebappInfo(null);
         mDirectoryManager = new WebappDirectoryManager();
         mWebappUma = new WebappUma();
     }
 
     @Override
     protected void onNewIntent(Intent intent) {
         if (intent == null) return;
         super.onNewIntent(intent);
 
         WebappInfo newWebappInfo = createWebappInfo(intent);
         if (newWebappInfo == null) {
             Log.e(TAG, "Failed to parse new Intent: " + intent);
             finish();
         } else if (!TextUtils.equals(mWebappInfo.id(), newWebappInfo.id())) {
             mWebappInfo = newWebappInfo;
             resetSavedInstanceState();
             if (mIsInitialized) initializeUI(null);
-            // TODO(dominickn): send the web app into fullscreen if mDisplayMode is
-            // WebDisplayMode.Fullscreen. See crbug.com/581522
         }
     }
 
     protected boolean isInitialized() {
         return mIsInitialized;
     }
 
     protected WebappInfo createWebappInfo(Intent intent) {
         return (intent == null) ? WebappInfo.createEmpty() : WebappInfo.create(intent);
     }
 
     private void initializeUI(Bundle savedInstanceState) {
         // We do not load URL when restoring from saved instance states.
         if (savedInstanceState == null && mWebappInfo.isInitialized()) {
             if (TextUtils.isEmpty(getActivityTab().getUrl())) {
                 getActivityTab().loadUrl(new LoadUrlParams(
                         mWebappInfo.uri().toString(), PageTransition.AUTO_TOPLEVEL));
             }
         } else {
             if (NetworkChangeNotifier.isOnline()) getActivityTab().reloadIgnoringCache();
         }
 
         getActivityTab().addObserver(createTabObserver());
         getActivityTab().getTabWebContentsDelegateAndroid().setDisplayMode(
-                WebDisplayMode.Standalone);
-        // TODO(dominickn): send the web app into fullscreen if mDisplayMode is
-        // WebDisplayMode.Fullscreen. See crbug.com/581522
+                mWebappInfo.displayMode());
+        if (mWebappInfo.displayMode() == WebDisplayMode.Fullscreen) {
+            enterImmersiveMode();
+        }
     }
 
     @Override
     public void preInflationStartup() {
         WebappInfo info = createWebappInfo(getIntent());
 
         String id = "";
         if (info != null) {
             mWebappInfo = info;
             id = info.id();
@@ skipping 62 matching lines @@
             long time = SystemClock.elapsedRealtime();
             TabState.saveState(tabFile, getActivityTab().getState(), false);
             RecordHistogram.recordTimesHistogram("Android.StrictMode.WebappSaveState",
                     SystemClock.elapsedRealtime() - time, TimeUnit.MILLISECONDS);
         } finally {
             StrictMode.setThreadPolicy(oldPolicy);
         }
     }
 
     @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+
+        // Re-enter immersive mode after users switch back to this Activity.
+        if (hasFocus) {
+            asyncSetImmersive(ENTER_IMMERSIVE_MODE_DELAY_MILLIS);
+        }
+    }
+
+    /**
+     * Sets activity's decor view into an immersive mode.
+     * If immersive mode is not supported, this method no-ops.
+     */
+    private void enterImmersiveMode() {
+        // Immersive mode is only supported in API 19+.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return;
+
+        if (mSetImmersiveRunnable == null) {
+
+            final View decor = getWindow().getDecorView();
+
+            mSetImmersiveRunnable = new Runnable() {
+                @Override
+                public void run() {
+                    int currentFlags = decor.getSystemUiVisibility();
+                    int desiredFlags = currentFlags | IMMERSIVE_MODE_UI_FLAGS;
+                    if (currentFlags != desiredFlags) {
+                        decor.setSystemUiVisibility(desiredFlags);
+                    }
+                }
+            };
+
+            // When we enter immersive mode for the first time, register a
+            // SystemUiVisibilityChangeListener that restores immersive mode. This is necessary
+            // because user actions like focusing a keyboard will break out of immersive mode.
+            decor.setOnSystemUiVisibilityChangeListener(new OnSystemUiVisibilityChangeListener() {
+                @Override
+                public void onSystemUiVisibilityChange(int newFlags) {
+                    if ((newFlags & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0) {
+                        asyncSetImmersive(RESTORE_IMMERSIVE_MODE_DELAY_MILLIS);
+                    }
+                }
+            });
+        }
+
+        asyncSetImmersive(ENTER_IMMERSIVE_MODE_DELAY_MILLIS);
+    }
+
+    /**
+     * This method no-ops before {@link enterImmersiveMode()) is called explicitly.
+     */
+    private void asyncSetImmersive(int delayInMills) {
+        if (mSetImmersiveRunnable == null) return;
+
+        mHandler.removeCallbacks(mSetImmersiveRunnable);
+        mHandler.postDelayed(mSetImmersiveRunnable, delayInMills);
+    }
+
+    @Override
     public void onResume() {
         if (!isFinishing()) {
             if (getIntent() != null) {
                 // Avoid situations where Android starts two Activities with the same data.
                 DocumentUtils.finishOtherTasksWithData(getIntent().getData(), getTaskId());
             }
             updateTaskDescription();
         }
         super.onResume();
     }
@@ skipping 149 matching lines @@
         Tab tab = getActivityTab();
         if (tab == null || mUrlBar == null) return;
         mUrlBar.update(tab.getUrl(), tab.getSecurityLevel());
     }
 
     private boolean isWebappDomain() {
         return UrlUtilities.sameDomainOrHost(
                 getActivityTab().getUrl(), getWebappInfo().uri().toString(), true);
     }
 
+    @Override
+    protected ChromeFullscreenManager createFullscreenManager() {
+        // Disable HTML5 fullscreen in PWA fullscreen mode.
+        return new ChromeFullscreenManager(this, false) {

[Ted C, 2017/02/17 05:51:50]

I'm also not against returning null here assuming we know mWebappInfo is
initialized properly before we get here.

Although if you navigate to a different domain, do we bring down the tiny little
location bar from the top in this mode?  If we return null, does that break (I
believe it uses fullscreen manager to do the showing/hiding of that these days).

If it does break, this seems ok to me (but i would hope it would since I
suggested it :-P)

[Leo, 2017/02/17 07:03:08]

I prefer your suggestion. Even returning null is cleaner and worked fine in my
testing (all existing code checked fullscreenManager before using), it still
looks not very safe. 

For the different domain bar. In the testing, I switched my test webapp's url in
fullscreen mode to google.com.au and the location bar was shown correctly
https://drive.google.com/a/chromium.org/file/d/0B7BQekACXW_VanNIUVJfN2tLQlU/v...

Thanks

+            @Override
+            public void setPersistentFullscreenMode(boolean enabled) {
+                if (mWebappInfo.displayMode() == WebDisplayMode.Fullscreen) return;
+                super.setPersistentFullscreenMode(enabled);
+            }
+
+            @Override
+            public boolean getPersistentFullscreenMode() {
+                if (mWebappInfo.displayMode() == WebDisplayMode.Fullscreen) return false;
+                return super.getPersistentFullscreenMode();
+            }
+        };
+    }
+
     protected TabObserver createTabObserver() {
         return new EmptyTabObserver() {
 
             @Override
             public void onSSLStateUpdated(Tab tab) {
                 updateUrlBar();
             }
 
             @Override
             public void onDidStartProvisionalLoadForFrame(
@@ skipping 198 matching lines @@
         return new WebappDelegateFactory(this);
     }
 
     // We're temporarily disable CS on webapp since there are some issues. (http://crbug.com/471950)
     // TODO(changwan): re-enable it once the issues are resolved.
     @Override
     protected boolean isContextualSearchAllowed() {
         return false;
     }
 }