[Android] Introduce RegistrationPolicy for NetworkChangeNotifier.

net/android/java/src/org/chromium/net/NetworkChangeNotifierAutoDetect.java

 // Copyright 2012 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.net;
 
 import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
 
 import android.Manifest.permission;
 import android.annotation.SuppressLint;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.net.ConnectivityManager;
 import android.net.ConnectivityManager.NetworkCallback;
 import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.net.NetworkInfo;
 import android.net.NetworkRequest;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.Build;
 import android.telephony.TelephonyManager;
 import android.util.Log;
 
-import org.chromium.base.ApplicationState;
-import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 
 /**
  * Used by the NetworkChangeNotifier to listens to platform changes in connectivity.
  * Note that use of this class requires that the app have the platform
  * ACCESS_NETWORK_STATE permission.
  */
-public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver
-        implements ApplicationStatus.ApplicationStateListener {
-
+public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
     static class NetworkState {
         private final boolean mConnected;
         private final int mType;
         private final int mSubtype;
 
         public NetworkState(boolean connected, int type, int subtype) {
             mConnected = connected;
             mType = type;
             mSubtype = subtype;
         }
@@ skipping 242 matching lines @@
             final int netId = networkToNetId(network);
             ThreadUtils.postOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     mObserver.onNetworkDisconnect(netId);
                 }
             });
         }
     }
 
+    /**
+     * Abstract class for providing a policy regarding when the NetworkChangeNotifier
+     * should listen for network changes.
+     */
+    public abstract static class RegistrationPolicy {
+        private NetworkChangeNotifierAutoDetect mNotifier;
+
+        /**
+         * Start listening for network changes.
+         */
+        protected final void register() {
+            assert mNotifier != null;
+            mNotifier.register();
+        }
+
+        /**
+         * Stop listening for network changes.
+         */
+        protected final void unregister() {
+            assert mNotifier != null;
+            mNotifier.unregister();
+        }
+
+        /**
+         * Initializes the policy with the notifier, overriding subclasses should always
+         * call this method.
+         */
+        protected void init(NetworkChangeNotifierAutoDetect notifier) {
+            mNotifier = notifier;
+        }
+
+        protected abstract void destroy();
+    }
+
     private static final String TAG = "NetworkChangeNotifierAutoDetect";
     private static final int UNKNOWN_LINK_SPEED = -1;
+
     private final NetworkConnectivityIntentFilter mIntentFilter;
+    private final Observer mObserver;
+    private final Context mContext;
+    private final RegistrationPolicy mRegistrationPolicy;
 
-    private final Observer mObserver;
-
-    private final Context mContext;
     // mConnectivityManagerDelegates and mWifiManagerDelegate are only non-final for testing.
     private ConnectivityManagerDelegate mConnectivityManagerDelegate;
     private WifiManagerDelegate mWifiManagerDelegate;
     // mNetworkCallback and mNetworkRequest are only non-null in Android L and above.
     private final NetworkCallback mNetworkCallback;
     private final NetworkRequest mNetworkRequest;
     private boolean mRegistered;
-    private final boolean mApplicationStateRegistered;
     private int mConnectionType;
     private String mWifiSSID;
     private double mMaxBandwidthMbps;
 
     /**
      * Observer interface by which observer is notified of network changes.
      */
     public static interface Observer {
         /**
          * Called when default network changes.
@@ skipping 34 matching lines @@
         public void updateActiveNetworkList(int[] activeNetIds);
     }
 
     /**
      * Constructs a NetworkChangeNotifierAutoDetect. Should only be called on UI thread.
      * @param alwaysWatchForChanges If true, always watch for network changes.
      *    Otherwise, only watch if app is in foreground.
      */
     @SuppressLint("NewApi")
     public NetworkChangeNotifierAutoDetect(
-            Observer observer, Context context, boolean alwaysWatchForChanges) {
+            Observer observer, Context context, RegistrationPolicy policy) {
         // Since BroadcastReceiver is always called back on UI thread, ensure
         // running on UI thread so notification logic can be single-threaded.
         ThreadUtils.assertOnUiThread();
         mObserver = observer;
         mContext = context.getApplicationContext();
         mConnectivityManagerDelegate = new ConnectivityManagerDelegate(context);
         mWifiManagerDelegate = new WifiManagerDelegate(context);
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             mNetworkCallback = new MyNetworkCallback();
             mNetworkRequest =
                     new NetworkRequest.Builder().addCapability(NET_CAPABILITY_INTERNET).build();
         } else {
             mNetworkCallback = null;
             mNetworkRequest = null;
         }
         final NetworkState networkState = mConnectivityManagerDelegate.getNetworkState();
         mConnectionType = getCurrentConnectionType(networkState);
         mWifiSSID = getCurrentWifiSSID(networkState);
         mMaxBandwidthMbps = getCurrentMaxBandwidthInMbps(networkState);
         mIntentFilter =
                 new NetworkConnectivityIntentFilter(mWifiManagerDelegate.getHasWifiPermission());
-
-        if (alwaysWatchForChanges) {
-            registerReceiver();
-            mApplicationStateRegistered = false;
-        } else {
-            ApplicationStatus.registerApplicationStateListener(this);
-            onApplicationStateChange(getApplicationState());
-            mApplicationStateRegistered = true;
-        }
+        mRegistrationPolicy = policy;
+        mRegistrationPolicy.init(this);
     }
 
     /**
      * Allows overriding the ConnectivityManagerDelegate for tests.
      */
     void setConnectivityManagerDelegateForTests(ConnectivityManagerDelegate delegate) {
         mConnectivityManagerDelegate = delegate;
     }
 
     /**
      * Allows overriding the WifiManagerDelegate for tests.
      */
     void setWifiManagerDelegateForTests(WifiManagerDelegate delegate) {
         mWifiManagerDelegate = delegate;
     }
 
-    /**
-     * Returns the activity's status.
-     * @return an {@code int} that is one of {@code ApplicationState.HAS_*_ACTIVITIES}.
-     */
     @VisibleForTesting
-    int getApplicationState() {
-        return ApplicationStatus.getStateForApplication();
+    RegistrationPolicy getRegistrationPolicy() {
+        return mRegistrationPolicy;
     }
 
     /**
      * Returns whether the object has registered to receive network connectivity intents.
      */
     @VisibleForTesting
     boolean isReceiverRegisteredForTesting() {
         return mRegistered;
     }
 
     public void destroy() {
-        if (mApplicationStateRegistered) ApplicationStatus.unregisterApplicationStateListener(this);
-        unregisterReceiver();
+        mRegistrationPolicy.destroy();
+        unregister();
     }
 
     /**
      * Registers a BroadcastReceiver in the given context.
      */
-    private void registerReceiver() {
-        if (!mRegistered) {
-            mRegistered = true;
-            mContext.registerReceiver(this, mIntentFilter);
-            if (mNetworkCallback != null) {
-                mConnectivityManagerDelegate.registerNetworkCallback(
-                        mNetworkRequest, mNetworkCallback);
-                // registerNetworkCallback() will rematch our NetworkRequest
-                // against active networks, so a cached list of active networks
-                // will be repopulated immediatly after this. However we need to
-                // purge any cached networks as they may have been disconnected
-                // while mNetworkCallback was unregistered.
-                final Network[] networks = mConnectivityManagerDelegate.getAllNetworks();
-                // Convert Networks to NetIDs.
-                final int[] netIds = new int[networks.length];
-                for (int i = 0; i < networks.length; i++) {
-                    netIds[i] = networkToNetId(networks[i]);
-                }
-                mObserver.updateActiveNetworkList(netIds);
+    public void register() {
+        if (mRegistered) return;
+
+        final NetworkState networkState = getCurrentNetworkState();
+        connectionTypeChanged(networkState);
+        maxBandwidthChanged(networkState);
+        mContext.registerReceiver(this, mIntentFilter);
+        mRegistered = true;
+
+        if (mNetworkCallback != null) {
+            mConnectivityManagerDelegate.registerNetworkCallback(mNetworkRequest, mNetworkCallback);
+            // registerNetworkCallback() will rematch our NetworkRequest
+            // against active networks, so a cached list of active networks
+            // will be repopulated immediatly after this. However we need to
+            // purge any cached networks as they may have been disconnected
+            // while mNetworkCallback was unregistered.
+            final Network[] networks = mConnectivityManagerDelegate.getAllNetworks();
+            // Convert Networks to NetIDs.
+            final int[] netIds = new int[networks.length];
+            for (int i = 0; i < networks.length; i++) {
+                netIds[i] = networkToNetId(networks[i]);
             }
+            mObserver.updateActiveNetworkList(netIds);
         }
     }
 
     /**
-     * Unregisters the BroadcastReceiver in the given context.
+     * Unregisters a BroadcastReceiver in the given context.
      */
-    private void unregisterReceiver() {
-        if (mRegistered) {
-            mRegistered = false;
-            mContext.unregisterReceiver(this);
-            if (mNetworkCallback != null) {
-                mConnectivityManagerDelegate.unregisterNetworkCallback(mNetworkCallback);
-            }
+    public void unregister() {
+        if (!mRegistered) return;
+        mContext.unregisterReceiver(this);
+        mRegistered = false;
+        if (mNetworkCallback != null) {
+            mConnectivityManagerDelegate.unregisterNetworkCallback(mNetworkCallback);
         }
     }
 
     public NetworkState getCurrentNetworkState() {
         return mConnectivityManagerDelegate.getNetworkState();
     }
 
     /**
      * Returns an array of all of the device's currently connected
      * networks and ConnectionTypes. Array elements are a repeated sequence of:
@@ skipping 158 matching lines @@
     public void onReceive(Context context, Intent intent) {
         final NetworkState networkState = getCurrentNetworkState();
         if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
             connectionTypeChanged(networkState);
             maxBandwidthChanged(networkState);
         } else if (WifiManager.RSSI_CHANGED_ACTION.equals(intent.getAction())) {
             maxBandwidthChanged(networkState);
         }
     }
 
-    // ApplicationStatus.ApplicationStateListener
-    @Override
-    public void onApplicationStateChange(int newState) {
-        final NetworkState networkState = getCurrentNetworkState();
-        if (newState == ApplicationState.HAS_RUNNING_ACTIVITIES) {
-            connectionTypeChanged(networkState);
-            maxBandwidthChanged(networkState);
-            registerReceiver();
-        } else if (newState == ApplicationState.HAS_PAUSED_ACTIVITIES) {
-            unregisterReceiver();
-        }
-    }
-
     private void connectionTypeChanged(NetworkState networkState) {
         int newConnectionType = getCurrentConnectionType(networkState);
         String newWifiSSID = getCurrentWifiSSID(networkState);
         if (newConnectionType == mConnectionType && newWifiSSID.equals(mWifiSSID)) return;
 
         mConnectionType = newConnectionType;
         mWifiSSID = newWifiSSID;
         Log.d(TAG, "Network connectivity changed, type is: " + mConnectionType);
         mObserver.onConnectionTypeChanged(newConnectionType);
     }
@@ skipping 16 matching lines @@
      * Extracts NetID of network. Only available on Lollipop and newer releases.
      */
     @SuppressLint("NewApi")
     private static int networkToNetId(Network network) {
         // NOTE(pauljensen): This depends on Android framework implementation details.
         // Fortunately this functionality is unlikely to ever change.
         // TODO(pauljensen): When we update to Android M SDK, use Network.getNetworkHandle().
         return Integer.parseInt(network.toString());
     }
 }