Merge "WifiMetrics: add methods to increment ONA metrics." into oc-mr1-dev
am: dbaf29e09a
Change-Id: I4f4b49f963492a59085e8ba1f37b88713b6cf568
diff --git a/service/java/com/android/server/wifi/OpenNetworkNotifier.java b/service/java/com/android/server/wifi/OpenNetworkNotifier.java
index 31ff44b..eee4ac5 100644
--- a/service/java/com/android/server/wifi/OpenNetworkNotifier.java
+++ b/service/java/com/android/server/wifi/OpenNetworkNotifier.java
@@ -40,11 +40,13 @@
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
+import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
+import com.android.server.wifi.nano.WifiMetricsProto.ConnectToNetworkNotificationAndActionCount;
import com.android.server.wifi.util.ScanResultUtil;
import java.io.FileDescriptor;
@@ -124,6 +126,7 @@
private final Context mContext;
private final Handler mHandler;
private final FrameworkFacade mFrameworkFacade;
+ private final WifiMetrics mWifiMetrics;
private final Clock mClock;
private final WifiConfigManager mConfigManager;
private final WifiStateMachine mWifiStateMachine;
@@ -138,6 +141,7 @@
Looper looper,
FrameworkFacade framework,
Clock clock,
+ WifiMetrics wifiMetrics,
WifiConfigManager wifiConfigManager,
WifiConfigStore wifiConfigStore,
WifiStateMachine wifiStateMachine,
@@ -146,6 +150,7 @@
mContext = context;
mHandler = new Handler(looper);
mFrameworkFacade = framework;
+ mWifiMetrics = wifiMetrics;
mClock = clock;
mConfigManager = wifiConfigManager;
mWifiStateMachine = wifiStateMachine;
@@ -206,7 +211,7 @@
case WifiManager.CONNECT_NETWORK_SUCCEEDED:
break;
case WifiManager.CONNECT_NETWORK_FAILED:
- handleConnectionFailure();
+ handleConnectionAttemptFailedToSend();
break;
default:
Log.e(TAG, "Unknown message " + msg.what);
@@ -226,6 +231,13 @@
if (mState != STATE_NO_NOTIFICATION) {
getNotificationManager().cancel(SystemMessage.NOTE_NETWORK_AVAILABLE);
+
+ if (mRecommendedNetwork != null) {
+ Log.d(TAG, "Notification with state="
+ + mState
+ + " was cleared for recommended network: "
+ + mRecommendedNetwork.SSID);
+ }
mState = STATE_NO_NOTIFICATION;
mRecommendedNetwork = null;
}
@@ -295,6 +307,10 @@
postNotification(mNotificationBuilder.createNetworkConnectedNotification(
mRecommendedNetwork));
+
+ Log.d(TAG, "User connected to recommended network: " + mRecommendedNetwork.SSID);
+ mWifiMetrics.incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTED_TO_NETWORK);
mState = STATE_CONNECTED_NOTIFICATION;
mHandler.postDelayed(
() -> {
@@ -313,6 +329,10 @@
return;
}
postNotification(mNotificationBuilder.createNetworkFailedNotification());
+
+ Log.d(TAG, "User failed to connect to recommended network: " + mRecommendedNetwork.SSID);
+ mWifiMetrics.incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_FAILED_TO_CONNECT);
mState = STATE_CONNECT_FAILED_NOTIFICATION;
mHandler.postDelayed(
() -> {
@@ -328,8 +348,18 @@
}
private void postInitialNotification(ScanResult recommendedNetwork) {
+ if (mRecommendedNetwork != null
+ && TextUtils.equals(mRecommendedNetwork.SSID, recommendedNetwork.SSID)) {
+ return;
+ }
postNotification(mNotificationBuilder.createConnectToNetworkNotification(
recommendedNetwork));
+ if (mState == STATE_NO_NOTIFICATION) {
+ mWifiMetrics.incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
+ } else {
+ mWifiMetrics.incrementNumOpenNetworkRecommendationUpdates();
+ }
mState = STATE_SHOWING_RECOMMENDATION_NOTIFICATION;
mRecommendedNetwork = recommendedNetwork;
mNotificationRepeatTime = mClock.getWallClockMillis() + mNotificationRepeatDelay;
@@ -340,11 +370,15 @@
}
private void handleConnectToNetworkAction() {
+ mWifiMetrics.incrementConnectToNetworkNotificationAction(mState,
+ ConnectToNetworkNotificationAndActionCount.ACTION_CONNECT_TO_NETWORK);
if (mState != STATE_SHOWING_RECOMMENDATION_NOTIFICATION) {
return;
}
postNotification(mNotificationBuilder.createNetworkConnectingNotification(
mRecommendedNetwork));
+ mWifiMetrics.incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTING_TO_NETWORK);
Log.d(TAG, "User initiated connection to recommended network: " + mRecommendedNetwork.SSID);
WifiConfiguration network = ScanResultUtil.createNetworkFromScanResult(mRecommendedNetwork);
@@ -366,6 +400,8 @@
}
private void handleSeeAllNetworksAction() {
+ mWifiMetrics.incrementConnectToNetworkNotificationAction(mState,
+ ConnectToNetworkNotificationAndActionCount.ACTION_PICK_WIFI_NETWORK);
startWifiSettings();
}
@@ -378,14 +414,26 @@
clearPendingNotification(false /* resetRepeatTime */);
}
+ private void handleConnectionAttemptFailedToSend() {
+ handleConnectionFailure();
+ mWifiMetrics.incrementNumOpenNetworkConnectMessageFailedToSend();
+ }
+
private void handlePickWifiNetworkAfterConnectFailure() {
+ mWifiMetrics.incrementConnectToNetworkNotificationAction(mState,
+ ConnectToNetworkNotificationAndActionCount
+ .ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE);
startWifiSettings();
}
private void handleUserDismissedAction() {
+ Log.d(TAG, "User dismissed notification with state=" + mState);
+ mWifiMetrics.incrementConnectToNetworkNotificationAction(mState,
+ ConnectToNetworkNotificationAndActionCount.ACTION_USER_DISMISSED_NOTIFICATION);
if (mState == STATE_SHOWING_RECOMMENDATION_NOTIFICATION) {
// blacklist dismissed network
mBlacklistedSsids.add(mRecommendedNetwork.SSID);
+ mWifiMetrics.setOpenNetworkRecommenderBlacklistSize(mBlacklistedSsids.size());
mConfigManager.saveToStore(false /* forceWrite */);
Log.d(TAG, "Network is added to the open network notification blacklist: "
+ mRecommendedNetwork.SSID);
@@ -418,6 +466,7 @@
@Override
public void setSsids(Set<String> ssidList) {
mBlacklistedSsids.addAll(ssidList);
+ mWifiMetrics.setOpenNetworkRecommenderBlacklistSize(mBlacklistedSsids.size());
}
}
@@ -440,8 +489,10 @@
}
private boolean getValue() {
- return mFrameworkFacade.getIntegerSetting(mContext,
+ boolean enabled = mFrameworkFacade.getIntegerSetting(mContext,
Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1) == 1;
+ mWifiMetrics.setIsWifiNetworksAvailableNotificationEnabled(enabled);
+ return enabled;
}
}
}
diff --git a/service/java/com/android/server/wifi/WifiInjector.java b/service/java/com/android/server/wifi/WifiInjector.java
index fc3af83..4a42c33 100644
--- a/service/java/com/android/server/wifi/WifiInjector.java
+++ b/service/java/com/android/server/wifi/WifiInjector.java
@@ -225,7 +225,7 @@
new WrongPasswordNotifier(mContext, mFrameworkFacade));
mCertManager = new WifiCertManager(mContext);
mOpenNetworkNotifier = new OpenNetworkNotifier(mContext,
- mWifiStateMachineHandlerThread.getLooper(), mFrameworkFacade, mClock,
+ mWifiStateMachineHandlerThread.getLooper(), mFrameworkFacade, mClock, mWifiMetrics,
mWifiConfigManager, mWifiConfigStore, mWifiStateMachine,
new OpenNetworkRecommender(),
new ConnectToNetworkNotificationBuilder(mContext, mFrameworkFacade));
diff --git a/service/java/com/android/server/wifi/WifiMetrics.java b/service/java/com/android/server/wifi/WifiMetrics.java
index 5db5ee6..071b4f8 100644
--- a/service/java/com/android/server/wifi/WifiMetrics.java
+++ b/service/java/com/android/server/wifi/WifiMetrics.java
@@ -37,6 +37,7 @@
import com.android.server.wifi.hotspot2.PasspointMatch;
import com.android.server.wifi.hotspot2.PasspointProvider;
import com.android.server.wifi.nano.WifiMetricsProto;
+import com.android.server.wifi.nano.WifiMetricsProto.ConnectToNetworkNotificationAndActionCount;
import com.android.server.wifi.nano.WifiMetricsProto.PnoScanMetrics;
import com.android.server.wifi.nano.WifiMetricsProto.StaEvent;
import com.android.server.wifi.nano.WifiMetricsProto.StaEvent.ConfigInfo;
@@ -83,6 +84,7 @@
public static final int MAX_CONNECTABLE_BSSID_NETWORK_BUCKET = 50;
public static final int MAX_TOTAL_SCAN_RESULT_SSIDS_BUCKET = 100;
public static final int MAX_TOTAL_SCAN_RESULTS_BUCKET = 250;
+ private static final int CONNECT_TO_NETWORK_NOTIFICATION_ACTION_KEY_MULTIPLIER = 1000;
private Clock mClock;
private boolean mScreenOn;
private int mWifiState;
@@ -150,6 +152,15 @@
private final SparseIntArray mAvailableSavedPasspointProviderBssidsInScanHistogram =
new SparseIntArray();
+ /** Mapping of "Connect to Network" notifications to counts. */
+ private final SparseIntArray mConnectToNetworkNotificationCount = new SparseIntArray();
+ /** Mapping of "Connect to Network" notification user actions to counts. */
+ private final SparseIntArray mConnectToNetworkNotificationActionCount = new SparseIntArray();
+ private int mOpenNetworkRecommenderBlacklistSize = 0;
+ private boolean mIsWifiNetworksAvailableNotificationOn = false;
+ private int mNumOpenNetworkConnectMessageFailedToSend = 0;
+ private int mNumOpenNetworkRecommendationUpdates = 0;
+
class RouterFingerPrint {
private WifiMetricsProto.RouterFingerPrint mRouterFingerPrintProto;
RouterFingerPrint() {
@@ -1237,6 +1248,55 @@
}
}
+ /** Increments the occurence of a "Connect to Network" notification. */
+ public void incrementConnectToNetworkNotification(int notificationType) {
+ synchronized (mLock) {
+ int count = mConnectToNetworkNotificationCount.get(notificationType);
+ mConnectToNetworkNotificationCount.put(notificationType, count + 1);
+ }
+ }
+
+ /** Increments the occurence of an "Connect to Network" notification user action. */
+ public void incrementConnectToNetworkNotificationAction(int notificationType, int actionType) {
+ synchronized (mLock) {
+ int key = notificationType * CONNECT_TO_NETWORK_NOTIFICATION_ACTION_KEY_MULTIPLIER
+ + actionType;
+ int count = mConnectToNetworkNotificationActionCount.get(key);
+ mConnectToNetworkNotificationActionCount.put(key, count + 1);
+ }
+ }
+
+ /**
+ * Sets the number of SSIDs blacklisted from recommendation by the open network notification
+ * recommender.
+ */
+ public void setOpenNetworkRecommenderBlacklistSize(int size) {
+ synchronized (mLock) {
+ mOpenNetworkRecommenderBlacklistSize = size;
+ }
+ }
+
+ /** Sets if the available network notification feature is enabled. */
+ public void setIsWifiNetworksAvailableNotificationEnabled(boolean enabled) {
+ synchronized (mLock) {
+ mIsWifiNetworksAvailableNotificationOn = enabled;
+ }
+ }
+
+ /** Increments the occurence of connection attempts that were initiated unsuccessfully */
+ public void incrementNumOpenNetworkRecommendationUpdates() {
+ synchronized (mLock) {
+ mNumOpenNetworkRecommendationUpdates++;
+ }
+ }
+
+ /** Increments the occurence of connection attempts that were initiated unsuccessfully */
+ public void incrementNumOpenNetworkConnectMessageFailedToSend() {
+ synchronized (mLock) {
+ mNumOpenNetworkConnectMessageFailedToSend++;
+ }
+ }
+
public static final String PROTO_DUMP_ARG = "wifiMetricsProto";
public static final String CLEAN_DUMP_ARG = "clean";
@@ -1488,6 +1548,19 @@
+ mPnoScanMetrics.numPnoScanFailedOverOffload);
pw.println("mPnoScanMetrics.numPnoFoundNetworkEvents="
+ mPnoScanMetrics.numPnoFoundNetworkEvents);
+
+ pw.println("mWifiLogProto.connectToNetworkNotificationCount="
+ + mConnectToNetworkNotificationCount.toString());
+ pw.println("mWifiLogProto.connectToNetworkNotificationActionCount="
+ + mConnectToNetworkNotificationActionCount.toString());
+ pw.println("mWifiLogProto.openNetworkRecommenderBlacklistSize="
+ + mOpenNetworkRecommenderBlacklistSize);
+ pw.println("mWifiLogProto.isWifiNetworksAvailableNotificationOn="
+ + mIsWifiNetworksAvailableNotificationOn);
+ pw.println("mWifiLogProto.numOpenNetworkRecommendationUpdates="
+ + mNumOpenNetworkRecommendationUpdates);
+ pw.println("mWifiLogProto.numOpenNetworkConnectMessageFailedToSend="
+ + mNumOpenNetworkConnectMessageFailedToSend);
}
}
}
@@ -1698,6 +1771,53 @@
mWifiLogProto.wifiAwareLog = mWifiAwareMetrics.consolidateProto();
mWifiLogProto.pnoScanMetrics = mPnoScanMetrics;
+
+ /**
+ * Convert the SparseIntArray of "Connect to Network" notification types and counts to
+ * proto's repeated IntKeyVal array.
+ */
+ ConnectToNetworkNotificationAndActionCount[] notificationCountArray =
+ new ConnectToNetworkNotificationAndActionCount[
+ mConnectToNetworkNotificationCount.size()];
+ for (int i = 0; i < mConnectToNetworkNotificationCount.size(); i++) {
+ ConnectToNetworkNotificationAndActionCount keyVal =
+ new ConnectToNetworkNotificationAndActionCount();
+ keyVal.notification = mConnectToNetworkNotificationCount.keyAt(i);
+ keyVal.recommender =
+ ConnectToNetworkNotificationAndActionCount.RECOMMENDER_OPEN;
+ keyVal.count = mConnectToNetworkNotificationCount.valueAt(i);
+ notificationCountArray[i] = keyVal;
+ }
+ mWifiLogProto.connectToNetworkNotificationCount = notificationCountArray;
+
+ /**
+ * Convert the SparseIntArray of "Connect to Network" notification types and counts to
+ * proto's repeated IntKeyVal array.
+ */
+ ConnectToNetworkNotificationAndActionCount[] notificationActionCountArray =
+ new ConnectToNetworkNotificationAndActionCount[
+ mConnectToNetworkNotificationActionCount.size()];
+ for (int i = 0; i < mConnectToNetworkNotificationActionCount.size(); i++) {
+ ConnectToNetworkNotificationAndActionCount keyVal =
+ new ConnectToNetworkNotificationAndActionCount();
+ int key = mConnectToNetworkNotificationActionCount.keyAt(i);
+ keyVal.notification = key / CONNECT_TO_NETWORK_NOTIFICATION_ACTION_KEY_MULTIPLIER;
+ keyVal.action = key % CONNECT_TO_NETWORK_NOTIFICATION_ACTION_KEY_MULTIPLIER;
+ keyVal.recommender =
+ ConnectToNetworkNotificationAndActionCount.RECOMMENDER_OPEN;
+ keyVal.count = mConnectToNetworkNotificationActionCount.valueAt(i);
+ notificationActionCountArray[i] = keyVal;
+ }
+ mWifiLogProto.connectToNetworkNotificationActionCount = notificationActionCountArray;
+
+ mWifiLogProto.openNetworkRecommenderBlacklistSize =
+ mOpenNetworkRecommenderBlacklistSize;
+ mWifiLogProto.isWifiNetworksAvailableNotificationOn =
+ mIsWifiNetworksAvailableNotificationOn;
+ mWifiLogProto.numOpenNetworkRecommendationUpdates =
+ mNumOpenNetworkRecommendationUpdates;
+ mWifiLogProto.numOpenNetworkConnectMessageFailedToSend =
+ mNumOpenNetworkConnectMessageFailedToSend;
}
}
@@ -1716,7 +1836,8 @@
}
/**
- * Clear all WifiMetrics, except for currentConnectionEvent.
+ * Clear all WifiMetrics, except for currentConnectionEvent and Open Network Notification
+ * feature enabled state, blacklist size.
*/
private void clear() {
synchronized (mLock) {
@@ -1747,6 +1868,10 @@
mAvailableSavedPasspointProviderProfilesInScanHistogram.clear();
mAvailableSavedPasspointProviderBssidsInScanHistogram.clear();
mPnoScanMetrics.clear();
+ mConnectToNetworkNotificationCount.clear();
+ mConnectToNetworkNotificationActionCount.clear();
+ mNumOpenNetworkRecommendationUpdates = 0;
+ mNumOpenNetworkConnectMessageFailedToSend = 0;
}
}
diff --git a/tests/wifitests/src/com/android/server/wifi/OpenNetworkNotifierTest.java b/tests/wifitests/src/com/android/server/wifi/OpenNetworkNotifierTest.java
index 46ec159..5a0b011 100644
--- a/tests/wifitests/src/com/android/server/wifi/OpenNetworkNotifierTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/OpenNetworkNotifierTest.java
@@ -20,6 +20,7 @@
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@@ -31,6 +32,8 @@
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
+import android.database.ContentObserver;
+import android.net.Uri;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.os.Message;
@@ -41,6 +44,8 @@
import android.provider.Settings;
import android.util.ArraySet;
+import com.android.server.wifi.nano.WifiMetricsProto.ConnectToNetworkNotificationAndActionCount;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
@@ -57,11 +62,13 @@
public class OpenNetworkNotifierTest {
private static final String TEST_SSID_1 = "Test SSID 1";
+ private static final String TEST_SSID_2 = "Test SSID 2";
private static final int MIN_RSSI_LEVEL = -127;
@Mock private Context mContext;
@Mock private Resources mResources;
@Mock private FrameworkFacade mFrameworkFacade;
+ @Mock private WifiMetrics mWifiMetrics;
@Mock private Clock mClock;
@Mock private WifiConfigStore mWifiConfigStore;
@Mock private WifiConfigManager mWifiConfigManager;
@@ -73,6 +80,7 @@
private OpenNetworkNotifier mNotificationController;
private TestLooper mLooper;
private BroadcastReceiver mBroadcastReceiver;
+ private ContentObserver mContentObserver;
private ScanResult mDummyNetwork;
private List<ScanDetail> mOpenNetworks;
private Set<String> mBlacklistedSsids;
@@ -103,16 +111,42 @@
mLooper = new TestLooper();
mNotificationController = new OpenNetworkNotifier(
- mContext, mLooper.getLooper(), mFrameworkFacade, mClock, mWifiConfigManager,
- mWifiConfigStore, mWifiStateMachine, mOpenNetworkRecommender, mNotificationBuilder);
+ mContext, mLooper.getLooper(), mFrameworkFacade, mClock, mWifiMetrics,
+ mWifiConfigManager, mWifiConfigStore, mWifiStateMachine, mOpenNetworkRecommender,
+ mNotificationBuilder);
ArgumentCaptor<BroadcastReceiver> broadcastReceiverCaptor =
ArgumentCaptor.forClass(BroadcastReceiver.class);
verify(mContext).registerReceiver(broadcastReceiverCaptor.capture(), any(), any(), any());
mBroadcastReceiver = broadcastReceiverCaptor.getValue();
+ ArgumentCaptor<ContentObserver> observerCaptor =
+ ArgumentCaptor.forClass(ContentObserver.class);
+ verify(mFrameworkFacade).registerContentObserver(eq(mContext), any(Uri.class), eq(true),
+ observerCaptor.capture());
+ mContentObserver = observerCaptor.getValue();
mNotificationController.handleScreenStateChanged(true);
}
/**
+ * On {@link OpenNetworkNotifier} construction, WifiMetrics should track setting state.
+ */
+ @Test
+ public void onCreate_setWifiNetworksAvailableNotificationSettingState() {
+ verify(mWifiMetrics).setIsWifiNetworksAvailableNotificationEnabled(true);
+ }
+
+ /**
+ * When feature setting is toggled, WifiMetrics should track the disabled setting state.
+ */
+ @Test
+ public void onFeatureDisable_setWifiNetworksAvailableNotificationSettingDisabled() {
+ when(mFrameworkFacade.getIntegerSetting(mContext,
+ Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1)).thenReturn(0);
+ mContentObserver.onChange(false);
+
+ verify(mWifiMetrics).setIsWifiNetworksAvailableNotificationEnabled(false);
+ }
+
+ /**
* When scan results with open networks are handled, a notification is posted.
*/
@Test
@@ -121,6 +155,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
}
@@ -136,6 +172,20 @@
}
/**
+ * When the feature is disabled, no notifications are posted.
+ */
+ @Test
+ public void handleScanResults_featureDisabled_notificationNotDisplayed() {
+ when(mFrameworkFacade.getIntegerSetting(mContext,
+ Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1)).thenReturn(0);
+ mContentObserver.onChange(false);
+ mNotificationController.handleScanResults(new ArrayList<>());
+
+ verify(mOpenNetworkRecommender, never()).recommendNetwork(any(), any());
+ verify(mNotificationManager, never()).notify(anyInt(), any());
+ }
+
+ /**
* When a notification is showing and scan results with no open networks are handled, the
* notification is cleared.
*/
@@ -145,6 +195,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.handleScanResults(new ArrayList<>());
@@ -162,6 +214,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
when(mOpenNetworkRecommender.recommendNetwork(any(), any())).thenReturn(null);
@@ -180,6 +234,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.handleScreenStateChanged(false);
@@ -198,6 +254,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.clearPendingNotification(true);
@@ -239,15 +297,25 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
+ ScanResult newNetwork = new ScanResult();
+ newNetwork.SSID = TEST_SSID_2;
+ mDummyNetwork.capabilities = "[ESS]";
+ mDummyNetwork.level = MIN_RSSI_LEVEL;
+ mOpenNetworks.add(new ScanDetail(newNetwork, null /* networkDetail */));
+ when(mOpenNetworkRecommender.recommendNetwork(any(), any())).thenReturn(newNetwork);
+
mNotificationController.handleScreenStateChanged(false);
mNotificationController.handleScanResults(mOpenNetworks);
- // Recommendation made twice
+ // Recommendation changed
verify(mOpenNetworkRecommender, times(2)).recommendNetwork(
mOpenNetworks, mBlacklistedSsids);
- verify(mNotificationBuilder, times(2)).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mNotificationBuilder).createConnectToNetworkNotification(newNetwork);
+ verify(mWifiMetrics).incrementNumOpenNetworkRecommendationUpdates();
verify(mNotificationManager, times(2)).notify(anyInt(), any());
}
@@ -261,6 +329,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.clearPendingNotification(false);
@@ -283,6 +353,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.clearPendingNotification(true);
@@ -292,6 +364,8 @@
verify(mOpenNetworkRecommender, times(2)).recommendNetwork(
mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder, times(2)).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics, times(2)).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager, times(2)).notify(anyInt(), any());
}
@@ -305,6 +379,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mBroadcastReceiver.onReceive(
@@ -320,6 +396,7 @@
Set<String> expectedBlacklist = new ArraySet<>();
expectedBlacklist.add(mDummyNetwork.SSID);
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, expectedBlacklist);
+ verify(mWifiMetrics).setOpenNetworkRecommenderBlacklistSize(expectedBlacklist.size());
}
/**
@@ -332,6 +409,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.clearPendingNotification(false);
@@ -344,6 +423,8 @@
verify(mOpenNetworkRecommender, times(2)).recommendNetwork(
mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder, times(2)).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics, times(2)).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager, times(2)).notify(anyInt(), any());
}
@@ -366,6 +447,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
when(mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI, UserHandle.CURRENT))
@@ -399,6 +482,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
// Initial Notification
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mBroadcastReceiver.onReceive(mContext,
@@ -407,10 +492,41 @@
verify(mWifiStateMachine).sendMessage(any(Message.class));
// Connecting Notification
verify(mNotificationBuilder).createNetworkConnectingNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTING_TO_NETWORK);
+ verify(mWifiMetrics).incrementConnectToNetworkNotificationAction(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK,
+ ConnectToNetworkNotificationAndActionCount.ACTION_CONNECT_TO_NETWORK);
verify(mNotificationManager, times(2)).notify(anyInt(), any());
}
/**
+ * {@link ConnectToNetworkNotificationBuilder#ACTION_PICK_WIFI_NETWORK} opens Wi-Fi settings
+ * if the recommendation notification is showing.
+ */
+ @Test
+ public void actionPickWifiNetwork_currentRecommendationExists_opensWifiSettings() {
+ mNotificationController.handleScanResults(mOpenNetworks);
+
+ verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
+ // Initial Notification
+ verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
+ verify(mNotificationManager).notify(anyInt(), any());
+
+ mBroadcastReceiver.onReceive(mContext,
+ new Intent(ConnectToNetworkNotificationBuilder.ACTION_PICK_WIFI_NETWORK));
+
+ ArgumentCaptor<Intent> pickerIntentCaptor = ArgumentCaptor.forClass(Intent.class);
+ verify(mContext).startActivity(pickerIntentCaptor.capture());
+ assertEquals(pickerIntentCaptor.getValue().getAction(), Settings.ACTION_WIFI_SETTINGS);
+ verify(mWifiMetrics).incrementConnectToNetworkNotificationAction(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK,
+ ConnectToNetworkNotificationAndActionCount.ACTION_PICK_WIFI_NETWORK);
+ }
+
+ /**
* {@link OpenNetworkNotifier#handleWifiConnected()} does not post connected notification if
* the connecting notification is not showing
*/
@@ -419,6 +535,8 @@
mNotificationController.handleWifiConnected();
verify(mNotificationManager, never()).notify(anyInt(), any());
+ verify(mWifiMetrics, never()).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTED_TO_NETWORK);
}
/**
@@ -431,6 +549,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
// Initial Notification
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mNotificationController.handleWifiConnected();
@@ -449,6 +569,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
// Initial Notification
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mBroadcastReceiver.onReceive(mContext,
@@ -456,12 +578,19 @@
// Connecting Notification
verify(mNotificationBuilder).createNetworkConnectingNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTING_TO_NETWORK);
+ verify(mWifiMetrics).incrementConnectToNetworkNotificationAction(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK,
+ ConnectToNetworkNotificationAndActionCount.ACTION_CONNECT_TO_NETWORK);
verify(mNotificationManager, times(2)).notify(anyInt(), any());
mNotificationController.handleWifiConnected();
// Connected Notification
verify(mNotificationBuilder).createNetworkConnectedNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTED_TO_NETWORK);
verify(mNotificationManager, times(3)).notify(anyInt(), any());
}
@@ -474,6 +603,8 @@
mNotificationController.handleConnectionFailure();
verify(mNotificationManager, never()).notify(anyInt(), any());
+ verify(mWifiMetrics, never()).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_FAILED_TO_CONNECT);
}
/**
@@ -487,6 +618,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
// Initial Notification
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mBroadcastReceiver.onReceive(mContext,
@@ -494,12 +627,19 @@
// Connecting Notification
verify(mNotificationBuilder).createNetworkConnectingNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTING_TO_NETWORK);
+ verify(mWifiMetrics).incrementConnectToNetworkNotificationAction(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK,
+ ConnectToNetworkNotificationAndActionCount.ACTION_CONNECT_TO_NETWORK);
verify(mNotificationManager, times(2)).notify(anyInt(), any());
mNotificationController.handleConnectionFailure();
// Failed to Connect Notification
verify(mNotificationBuilder).createNetworkFailedNotification();
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_FAILED_TO_CONNECT);
verify(mNotificationManager, times(3)).notify(anyInt(), any());
}
@@ -515,6 +655,8 @@
verify(mOpenNetworkRecommender).recommendNetwork(mOpenNetworks, mBlacklistedSsids);
// Initial Notification
verify(mNotificationBuilder).createConnectToNetworkNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
verify(mNotificationManager).notify(anyInt(), any());
mBroadcastReceiver.onReceive(mContext,
@@ -526,6 +668,11 @@
// Connecting Notification
verify(mNotificationBuilder).createNetworkConnectingNotification(mDummyNetwork);
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTING_TO_NETWORK);
+ verify(mWifiMetrics).incrementConnectToNetworkNotificationAction(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK,
+ ConnectToNetworkNotificationAndActionCount.ACTION_CONNECT_TO_NETWORK);
verify(mNotificationManager, times(2)).notify(anyInt(), any());
Message connectFailedMsg = Message.obtain();
@@ -535,6 +682,9 @@
// Failed to Connect Notification
verify(mNotificationBuilder).createNetworkFailedNotification();
+ verify(mWifiMetrics).incrementConnectToNetworkNotification(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_FAILED_TO_CONNECT);
+ verify(mWifiMetrics).incrementNumOpenNetworkConnectMessageFailedToSend();
verify(mNotificationManager, times(3)).notify(anyInt(), any());
mBroadcastReceiver.onReceive(mContext,
@@ -544,5 +694,9 @@
ArgumentCaptor<Intent> pickerIntentCaptor = ArgumentCaptor.forClass(Intent.class);
verify(mContext).startActivity(pickerIntentCaptor.capture());
assertEquals(pickerIntentCaptor.getValue().getAction(), Settings.ACTION_WIFI_SETTINGS);
+ verify(mWifiMetrics).incrementConnectToNetworkNotificationAction(
+ ConnectToNetworkNotificationAndActionCount.NOTIFICATION_FAILED_TO_CONNECT,
+ ConnectToNetworkNotificationAndActionCount
+ .ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE);
}
}
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java b/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java
index 10ad3c6..65427be 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiMetricsTest.java
@@ -38,6 +38,7 @@
import com.android.server.wifi.hotspot2.PasspointMatch;
import com.android.server.wifi.hotspot2.PasspointProvider;
import com.android.server.wifi.nano.WifiMetricsProto;
+import com.android.server.wifi.nano.WifiMetricsProto.ConnectToNetworkNotificationAndActionCount;
import com.android.server.wifi.nano.WifiMetricsProto.PnoScanMetrics;
import com.android.server.wifi.nano.WifiMetricsProto.StaEvent;
@@ -259,6 +260,19 @@
private static final int NUM_PNO_SCAN_STARTED_OVER_OFFLOAD = 17;
private static final int NUM_PNO_SCAN_FAILED_OVER_OFFLOAD = 8;
private static final int NUM_PNO_FOUND_NETWORK_EVENTS = 10;
+ /** Number of notifications per "Connect to Network" notification type. */
+ private static final int[] NUM_CONNECT_TO_NETWORK_NOTIFICATIONS = {0, 10, 20, 30, 40};
+ /** Number of notifications per "Connect to Network notification type and action type. */
+ private static final int[][] NUM_CONNECT_TO_NETWORK_NOTIFICATION_ACTIONS = {
+ {0, 1, 2, 3, 4},
+ {10, 11, 12, 13, 14},
+ {20, 21, 22, 23, 24},
+ {30, 31, 32, 33, 34},
+ {40, 41, 42, 43, 44}};
+ private static final int SIZE_OPEN_NETWORK_RECOMMENDER_BLACKLIST = 10;
+ private static final boolean IS_WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = true;
+ private static final int NUM_OPEN_NETWORK_CONNECT_MESSAGE_FAILED_TO_SEND = 5;
+ private static final int NUM_OPEN_NETWORK_RECOMMENDATION_UPDATES = 8;
private ScanDetail buildMockScanDetail(boolean hidden, NetworkDetail.HSRelease hSRelease,
String capabilities) {
@@ -498,6 +512,33 @@
for (int i = 0; i < NUM_PNO_FOUND_NETWORK_EVENTS; i++) {
mWifiMetrics.incrementPnoFoundNetworkEventCount();
}
+
+ // set and increment "connect to network" notification metrics
+ for (int i = 0; i < NUM_CONNECT_TO_NETWORK_NOTIFICATIONS.length; i++) {
+ int count = NUM_CONNECT_TO_NETWORK_NOTIFICATIONS[i];
+ for (int j = 0; j < count; j++) {
+ mWifiMetrics.incrementConnectToNetworkNotification(i);
+ }
+ }
+ for (int i = 0; i < NUM_CONNECT_TO_NETWORK_NOTIFICATION_ACTIONS.length; i++) {
+ int[] actions = NUM_CONNECT_TO_NETWORK_NOTIFICATION_ACTIONS[i];
+ for (int j = 0; j < actions.length; j++) {
+ int count = actions[j];
+ for (int k = 0; k < count; k++) {
+ mWifiMetrics.incrementConnectToNetworkNotificationAction(i, j);
+ }
+ }
+ }
+ mWifiMetrics.setOpenNetworkRecommenderBlacklistSize(
+ SIZE_OPEN_NETWORK_RECOMMENDER_BLACKLIST);
+ mWifiMetrics.setIsWifiNetworksAvailableNotificationEnabled(
+ IS_WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON);
+ for (int i = 0; i < NUM_OPEN_NETWORK_RECOMMENDATION_UPDATES; i++) {
+ mWifiMetrics.incrementNumOpenNetworkRecommendationUpdates();
+ }
+ for (int i = 0; i < NUM_OPEN_NETWORK_CONNECT_MESSAGE_FAILED_TO_SEND; i++) {
+ mWifiMetrics.incrementNumOpenNetworkConnectMessageFailedToSend();
+ }
}
/**
@@ -650,6 +691,32 @@
assertEquals(NUM_PNO_SCAN_STARTED_OVER_OFFLOAD, pno_metrics.numPnoScanStartedOverOffload);
assertEquals(NUM_PNO_SCAN_FAILED_OVER_OFFLOAD, pno_metrics.numPnoScanFailedOverOffload);
assertEquals(NUM_PNO_FOUND_NETWORK_EVENTS, pno_metrics.numPnoFoundNetworkEvents);
+
+ for (ConnectToNetworkNotificationAndActionCount notificationCount
+ : mDecodedProto.connectToNetworkNotificationCount) {
+ assertEquals(NUM_CONNECT_TO_NETWORK_NOTIFICATIONS[notificationCount.notification],
+ notificationCount.count);
+ assertEquals(ConnectToNetworkNotificationAndActionCount.RECOMMENDER_OPEN,
+ notificationCount.recommender);
+ }
+ for (ConnectToNetworkNotificationAndActionCount notificationActionCount
+ : mDecodedProto.connectToNetworkNotificationActionCount) {
+ assertEquals(NUM_CONNECT_TO_NETWORK_NOTIFICATION_ACTIONS
+ [notificationActionCount.notification]
+ [notificationActionCount.action],
+ notificationActionCount.count);
+ assertEquals(ConnectToNetworkNotificationAndActionCount.RECOMMENDER_OPEN,
+ notificationActionCount.recommender);
+ }
+
+ assertEquals(SIZE_OPEN_NETWORK_RECOMMENDER_BLACKLIST,
+ mDecodedProto.openNetworkRecommenderBlacklistSize);
+ assertEquals(IS_WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
+ mDecodedProto.isWifiNetworksAvailableNotificationOn);
+ assertEquals(NUM_OPEN_NETWORK_RECOMMENDATION_UPDATES,
+ mDecodedProto.numOpenNetworkRecommendationUpdates);
+ assertEquals(NUM_OPEN_NETWORK_CONNECT_MESSAGE_FAILED_TO_SEND,
+ mDecodedProto.numOpenNetworkConnectMessageFailedToSend);
}
/**
@@ -1203,6 +1270,39 @@
a(WifiMetrics.MAX_CONNECTABLE_BSSID_NETWORK_BUCKET), a(1));
}
+ /**
+ * Test Open Network Notification blacklist size and feature state are not cleared when proto
+ * is dumped.
+ */
+ public void testOpenNetworkNotificationBlacklistSizeAndFeatureStateNotCleared()
+ throws Exception {
+ mWifiMetrics.setOpenNetworkRecommenderBlacklistSize(
+ SIZE_OPEN_NETWORK_RECOMMENDER_BLACKLIST);
+ mWifiMetrics.setIsWifiNetworksAvailableNotificationEnabled(
+ IS_WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON);
+ for (int i = 0; i < NUM_OPEN_NETWORK_RECOMMENDATION_UPDATES; i++) {
+ mWifiMetrics.incrementNumOpenNetworkRecommendationUpdates();
+ }
+
+ // This should clear most metrics in mWifiMetrics
+ dumpProtoAndDeserialize();
+ assertEquals(SIZE_OPEN_NETWORK_RECOMMENDER_BLACKLIST,
+ mDecodedProto.openNetworkRecommenderBlacklistSize);
+ assertEquals(IS_WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
+ mDecodedProto.isWifiNetworksAvailableNotificationOn);
+ assertEquals(NUM_OPEN_NETWORK_RECOMMENDATION_UPDATES,
+ mDecodedProto.numOpenNetworkRecommendationUpdates);
+
+ // Check that blacklist size and feature state persist on next dump but
+ // others do not.
+ dumpProtoAndDeserialize();
+ assertEquals(SIZE_OPEN_NETWORK_RECOMMENDER_BLACKLIST,
+ mDecodedProto.openNetworkRecommenderBlacklistSize);
+ assertEquals(IS_WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
+ mDecodedProto.isWifiNetworksAvailableNotificationOn);
+ assertEquals(0, mDecodedProto.numOpenNetworkRecommendationUpdates);
+ }
+
/** short hand for instantiating an anonymous int array, instead of 'new int[]{a1, a2, ...}' */
private int[] a(int... element) {
return element;