[NetInfo] Add MaxBandwidthChanged notification and implement on Android

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;
@@ skipping 127 matching lines @@
             new NetworkConnectivityIntentFilter();
 
     private final Observer mObserver;
 
     private final Context mContext;
     private ConnectivityManagerDelegate mConnectivityManagerDelegate;
     private WifiManagerDelegate mWifiManagerDelegate;
     private boolean mRegistered;
     private int mConnectionType;
     private String mWifiSSID;
+    private double mMaxBandwidthMbps;
 
     /**
-     * Observer notified on the UI thread whenever a new connection type was detected.
+     * 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) {
         mObserver = observer;
         mContext = context.getApplicationContext();
         mConnectivityManagerDelegate = new ConnectivityManagerDelegate(context);
         mWifiManagerDelegate = new WifiManagerDelegate(context);
         mConnectionType = getCurrentConnectionType();
         mWifiSSID = getCurrentWifiSSID();
+        mMaxBandwidthMbps = getCurrentMaxBandwidthInMbps();
         if (alwaysWatchForChanges) {
             registerReceiver();
         } else {
             ApplicationStatus.registerApplicationStateListener(this);
         }
     }
 
     /**
      * Allows overriding the ConnectivityManagerDelegate for tests.
      */
@@ skipping 75 matching lines @@
             default:
                 return ConnectionType.CONNECTION_UNKNOWN;
         }
     }
 
     /*
      * Returns the bandwidth of the current connection in Mbps.  The result is
      * derived from the NetInfo v3 specification's mapping from network type to
      * max link speed. In cases where more information is available, such as wifi,
      * that is used instead. For more on NetInfo, see http://w3c.github.io/netinfo/.
-     *
-     * TODO(jkarlin): Add a notification of bandwidth change to the NetworkChangeNotifier.
-     * Without that the MaxBandwidth value will be stale until the network type or address
-     * changes again.
      */
     public double getCurrentMaxBandwidthInMbps() {
         if (getCurrentConnectionType() == ConnectionType.CONNECTION_WIFI) {
             final int link_speed = mWifiManagerDelegate.getLinkSpeedInMbps();
             if (link_speed != UNKNOWN_LINK_SPEED) {
                 return link_speed;
             }
         }
 
         return NetworkChangeNotifier.getMaxBandwidthForConnectionSubtype(
@@ skipping 55 matching lines @@
 
     private String getCurrentWifiSSID() {
         if (getCurrentConnectionType() != ConnectionType.CONNECTION_WIFI)
             return "";
         return mWifiManagerDelegate.getWifiSSID();
     }
 
     // BroadcastReceiver
     @Override
     public void onReceive(Context context, Intent intent) {
-        connectionTypeChanged();
+        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
+            connectionTypeChanged();
+            maxBandwidthChanged();
+        } else if (WifiManager.RSSI_CHANGED_ACTION.equals(intent.getAction())) {
+            maxBandwidthChanged();
+        }
     }
 
     // ApplicationStatus.ApplicationStateListener
     @Override
     public void onApplicationStateChange(int newState) {
         if (newState == ApplicationState.HAS_RUNNING_ACTIVITIES) {
             connectionTypeChanged();
             registerReceiver();
         } else if (newState == ApplicationState.HAS_PAUSED_ACTIVITIES) {
             unregisterReceiver();
         }
     }
 
     private void connectionTypeChanged() {
         int newConnectionType = getCurrentConnectionType();
         String newWifiSSID = getCurrentWifiSSID();
         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() {
+        double newMaxBandwidthMbps = getCurrentMaxBandwidthInMbps();
+        if (newMaxBandwidthMbps == mMaxBandwidthMbps) return;
+        mMaxBandwidthMbps = newMaxBandwidthMbps;
+        mObserver.onMaxBandwidthChanged(newMaxBandwidthMbps);
+    }
+
     private static class NetworkConnectivityIntentFilter extends IntentFilter {
         NetworkConnectivityIntentFilter() {
             addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+            addAction(WifiManager.RSSI_CHANGED_ACTION);

[pauljensen, 2014/12/05 19:27:34]

We should not be registering for another broadcast when we don't have
ACCESS_WIFI_STATE permissions, otherwise we'll be needlessly waking up our app
every few seconds for no purpose.

[jkarlin, 2014/12/08 16:58:43]

Done.

         }
     }
 }