[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 android.Manifest.permission;
 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.NetworkInfo;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.telephony.TelephonyManager;
 import android.util.Log;
 
-import org.chromium.base.ApplicationState;
-import org.chromium.base.ApplicationStatus;
 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 implements RegistrationPolicy.Listener {
     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 90 matching lines @@
             return wifiInfo.getLinkSpeed();
         }
 
         boolean getHasWifiPermission() {
             return mHasWifiPermission;
         }
     }
 
     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;
     private ConnectivityManagerDelegate mConnectivityManagerDelegate;
     private WifiManagerDelegate mWifiManagerDelegate;
     private boolean mRegistered;
-    private final boolean mApplicationStateRegistered;
     private int mConnectionType;
     private String mWifiSSID;
     private double mMaxBandwidthMbps;
 
     /**
      * Observer notified on the UI thread whenever a new connection type was detected or max
      * bandwidth is changed.
      */
     public static interface Observer {
         public void onConnectionTypeChanged(int newConnectionType);
         public void onMaxBandwidthChanged(double maxBandwidthMbps);
     }
 
     /**
      * Constructs a NetworkChangeNotifierAutoDetect.
      * @param alwaysWatchForChanges If true, always watch for network changes.
      *    Otherwise, only watch if app is in foreground.
      */
-    public NetworkChangeNotifierAutoDetect(Observer observer, Context context,
-            boolean alwaysWatchForChanges) {
+    public NetworkChangeNotifierAutoDetect(
+            Observer observer, Context context, RegistrationPolicy policy) {
         mObserver = observer;
         mContext = context.getApplicationContext();
         mConnectivityManagerDelegate = new ConnectivityManagerDelegate(context);
         mWifiManagerDelegate = new WifiManagerDelegate(context);
         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();
-    }
-
-    /**
-     * Register a BroadcastReceiver in the given context.
-     */
-    private void registerReceiver() {
-        if (!mRegistered) {
-            mRegistered = true;
-            mContext.registerReceiver(this, mIntentFilter);
-        }
-    }
-
-    /**
-     * Unregister the BroadcastReceiver in the given context.
-     */
-    private void unregisterReceiver() {
-        if (mRegistered) {
-            mRegistered = false;
-            mContext.unregisterReceiver(this);
-        }
+        mRegistrationPolicy.destroy();
+        unregister();
     }
 
     public NetworkState getCurrentNetworkState() {
         return mConnectivityManagerDelegate.getNetworkState();
     }
 
     public int getCurrentConnectionType(NetworkState networkState) {
         if (!networkState.isConnected()) {
             return ConnectionType.CONNECTION_NONE;
         }
@@ skipping 116 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
+    // RegistrationPolicy.Listener
     @Override
-    public void onApplicationStateChange(int newState) {
+    public void register() {
+        if (mRegistered) return;
+
         final NetworkState networkState = getCurrentNetworkState();
-        if (newState == ApplicationState.HAS_RUNNING_ACTIVITIES) {
-            connectionTypeChanged(networkState);
-            maxBandwidthChanged(networkState);
-            registerReceiver();
-        } else if (newState == ApplicationState.HAS_PAUSED_ACTIVITIES) {
-            unregisterReceiver();
-        }
+        connectionTypeChanged(networkState);
+        maxBandwidthChanged(networkState);
+        mContext.registerReceiver(this, mIntentFilter);
+        mRegistered = true;
+    }
+
+    @Override
+    public void unregister() {
+        if (!mRegistered) return;
+        mContext.unregisterReceiver(this);
+        mRegistered = false;
     }
 
     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);
     }
 
     private void maxBandwidthChanged(NetworkState networkState) {
         double newMaxBandwidthMbps = getCurrentMaxBandwidthInMbps(networkState);
         if (newMaxBandwidthMbps == mMaxBandwidthMbps) return;
         mMaxBandwidthMbps = newMaxBandwidthMbps;
         mObserver.onMaxBandwidthChanged(newMaxBandwidthMbps);
     }
 
     private static class NetworkConnectivityIntentFilter extends IntentFilter {
         NetworkConnectivityIntentFilter(boolean monitorRSSI) {
             addAction(ConnectivityManager.CONNECTIVITY_ACTION);
             if (monitorRSSI) addAction(WifiManager.RSSI_CHANGED_ACTION);
         }
     }
 }