[Android] Enable ApplicationStatus for WebView.

base/android/java/src/org/chromium/base/ApplicationStatus.java

 // Copyright 2014 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.base;
 
 import android.app.Activity;
 import android.app.Application;
 import android.app.Application.ActivityLifecycleCallbacks;
 import android.content.Context;
@@ skipping 46 matching lines @@
     private static Object sCachedApplicationStateLock = new Object();
     private static Integer sCachedApplicationState;
 
     /** Last activity that was shown (or null if none or it was destroyed). */
     private static Activity sActivity;
 
     /** A lazily initialized listener that forwards application state changes to native. */
     private static ApplicationStateListener sNativeApplicationStateListener;
 
     /**
+     * If true means we are running in an activity lifecycle independent mode,
+     * see {@link #initializeActivityIndependent(Application, Context)} for more details.
+     */
+    private static boolean sActivityLifecycleIndependentMode = false;
+
+    /**
+     * Context corresponding to sApplication. Note this context can be different from sApplication
+     * iself so use sApplicationContext instead of casting sApplication.
+     */
+    private static Context sApplicationContext;
+
+    /**
      * A map of which observers listen to state changes from which {@link Activity}.
      */
     private static final Map<Activity, ActivityInfo> sActivityInfo =
             new ConcurrentHashMap<Activity, ActivityInfo>();
 
     /**
      * A list of observers to be notified when any {@link Activity} has a state change.
      */
     private static final ObserverList<ActivityStateListener> sGeneralActivityStateListeners =
             new ObserverList<ActivityStateListener>();
@@ skipping 25 matching lines @@
          * @param activity The activity that had a state change.
          * @param newState New activity state.
          */
         public void onActivityStateChange(Activity activity, int newState);
     }
 
     private ApplicationStatus() {}
 
     /**
      * Initializes the activity status for a specified application.
+     * This method only registers for ActivityLifecycle changes.
      *
      * @param application The application whose status you wish to monitor.
      */
-    public static void initialize(BaseChromiumApplication application) {
+    private static void initializeLifecycleCallbacks(Application application) {
         sApplication = application;
 
-        application.registerWindowFocusChangedListener(
-                new BaseChromiumApplication.WindowFocusChangedListener() {
-                    @Override
-                    public void onWindowFocusChanged(Activity activity, boolean hasFocus) {
-                        if (!hasFocus || activity == sActivity) return;
-
-                        int state = getStateForActivity(activity);
-
-                        if (state != ActivityState.DESTROYED && state != ActivityState.STOPPED) {
-                            sActivity = activity;
-                        }
-
-                        // TODO(dtrainor): Notify of active activity change?
-                    }
-                });
-
         application.registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
             @Override
             public void onActivityCreated(final Activity activity, Bundle savedInstanceState) {
                 onStateChange(activity, ActivityState.CREATED);
             }
 
             @Override
             public void onActivityDestroyed(Activity activity) {
                 onStateChange(activity, ActivityState.DESTROYED);
             }
@@ skipping 17 matching lines @@
             }
 
             @Override
             public void onActivityStopped(Activity activity) {
                 onStateChange(activity, ActivityState.STOPPED);
             }
         });
     }
 
     /**
+     * Initializes the activity status for a specified application.
+     * The initialization should happen before any activity is created.
+     *
+     * @param application The application whose status you wish to monitor.
+     */
+    public static void initialize(BaseChromiumApplication application) {
+        sApplicationContext = application.getApplicationContext();
+        initializeLifecycleCallbacks(application);
+
+        application.registerWindowFocusChangedListener(
+                new BaseChromiumApplication.WindowFocusChangedListener() {
+                    @Override
+                    public void onWindowFocusChanged(Activity activity, boolean hasFocus) {
+                        if (!hasFocus || activity == sActivity) return;
+
+                        int state = getStateForActivity(activity);
+
+                        if (state != ActivityState.DESTROYED && state != ActivityState.STOPPED) {
+                            sActivity = activity;
+                        }
+
+                        // TODO(dtrainor): Notify of active activity change?
+                    }
+                });
+    }
+
+
+    /**
+     * Initializes ApplicationStatus in "ActivityLifecycleIndependentMode". This mode is
+     * different from the regular initialization (@see initialize) in the following ways:
+     *   1. Currently doesn't listen to focus changes (hence sActivity is always null).
+     *   2. Allows to specify a custom applicationContext and an android application object.
+     *   3. Allows to call this method at any time during lifetime of the application.
+     */
+    public static void initializeActivityIndependent(Application application,
+            Context applicationContext) {
+        sActivityLifecycleIndependentMode = true;
+        sApplicationContext = applicationContext;
+
+        // Assume we have running activity (or activity that will be running very soon).
+        // This is to handle the case when "initializeActivityIndependent" is executed
+        // after the ActivityState.CREATED, ActivityState.STARTED and ActivityState.RESUMED
+        // have been dispatched.
+        synchronized (sCachedApplicationStateLock) {
+            sCachedApplicationState = ApplicationState.HAS_RUNNING_ACTIVITIES;
+        }
+
+        initializeLifecycleCallbacks(application);
+    }
+
+    /**
      * Must be called by the main activity when it changes state.
      *
      * @param activity Current activity.
      * @param newState New state value.
      */
     private static void onStateChange(Activity activity, int newState) {
         if (activity == null) throw new IllegalArgumentException("null activity is not supported");
 
-        if (sActivity == null
-                || newState == ActivityState.CREATED
-                || newState == ActivityState.RESUMED
-                || newState == ActivityState.STARTED) {
-            sActivity = activity;
-        }
-
         int oldApplicationState = getStateForApplication();
 
-        if (newState == ActivityState.CREATED) {
-            assert !sActivityInfo.containsKey(activity);
-            sActivityInfo.put(activity, new ActivityInfo());
+        if (sActivityLifecycleIndependentMode) {
+            assert sActivity == null;
+            if (!sActivityInfo.containsKey(activity)) {
+                sActivityInfo.put(activity, new ActivityInfo());
+            }
+        } else {
+            if (sActivity == null
+                    || newState == ActivityState.CREATED
+                    || newState == ActivityState.RESUMED
+                    || newState == ActivityState.STARTED) {
+                sActivity = activity;
+            }
+
+            if (newState == ActivityState.CREATED) {
+                assert !sActivityInfo.containsKey(activity);
+                sActivityInfo.put(activity, new ActivityInfo());
+            }
         }
 
         // Invalidate the cached application state.
         synchronized (sCachedApplicationStateLock) {
             sCachedApplicationState = null;
         }
 
         ActivityInfo info = sActivityInfo.get(activity);
         info.setStatus(newState);
 
@@ skipping 25 matching lines @@
      * Testing method to update the state of the specified activity.
      */
     @VisibleForTesting
     public static void onStateChangeForTesting(Activity activity, int newState) {
         onStateChange(activity, newState);
     }
 
     /**
      * @return The most recent focused {@link Activity} tracked by this class.  Being focused means
      *         out of all the activities tracked here, it has most recently gained window focus.
+     *         Note that in 'sActivityLifecycleIndependentMode' the returned Activity is currently
+     *         always null (see crbug.com/538175).
      */
     public static Activity getLastTrackedFocusedActivity() {
+        // sActivityLifecycleIndependentMode implies sActivity == null
+        assert !sActivityLifecycleIndependentMode || sActivity == null;
         return sActivity;
     }
 
     /**
      * @return A {@link List} of all non-destroyed {@link Activity}s.
      */
     public static List<WeakReference<Activity>> getRunningActivities() {
         List<WeakReference<Activity>> activities = new ArrayList<WeakReference<Activity>>();
         for (Activity activity : sActivityInfo.keySet()) {
             activities.add(new WeakReference<Activity>(activity));
         }
         return activities;
     }
 
     /**
      * @return The {@link Context} for the {@link Application}.
      */
     public static Context getApplicationContext() {
-        return sApplication != null ? sApplication.getApplicationContext() : null;
+        return sApplicationContext;
     }
 
     /**
      * Query the state for a given activity.  If the activity is not being tracked, this will
      * return {@link ActivityState#DESTROYED}.
      *
      * <p>
      * Please note that Chrome can have multiple activities running simultaneously.  Please also
      * look at {@link #getStateForApplication()} for more details.
      *
@@ skipping 175 matching lines @@
 
         if (hasPausedActivity) return ApplicationState.HAS_PAUSED_ACTIVITIES;
         if (hasStoppedActivity) return ApplicationState.HAS_STOPPED_ACTIVITIES;
         return ApplicationState.HAS_DESTROYED_ACTIVITIES;
     }
 
     // Called to notify the native side of state changes.
     // IMPORTANT: This is always called on the main thread!
     private static native void nativeOnApplicationStateChange(int newState);
 }