From a88242633e76bf3a070cfcc0a018ff7f9806f1f4 Mon Sep 17 00:00:00 2001 From: Stephen Chen Date: Mon, 18 Sep 2017 16:38:23 -0700 Subject: WifiMetrics: add methods to increment ONA metrics. Tracks the number of notifications posted for each state of ONA, and the number of user actions made for each notification type. Also tracks the state of the feature setting, the size of the recommender blacklist, recommendation update counts, and connection initiation failure counts. Also adds additional debug logging. Bug: 37501326 Bug: 66996715 Test: frameworks/opt/net/wifi/tests/wifitests/runtests.sh and verify in dumpsys Change-Id: Ia00ae95fbcf923ebae051ba82cd3174cfe11be31 --- .../android/server/wifi/OpenNetworkNotifier.java | 55 ++++++++- .../java/com/android/server/wifi/WifiInjector.java | 2 +- .../java/com/android/server/wifi/WifiMetrics.java | 127 ++++++++++++++++++++- 3 files changed, 180 insertions(+), 4 deletions(-) (limited to 'service') diff --git a/service/java/com/android/server/wifi/OpenNetworkNotifier.java b/service/java/com/android/server/wifi/OpenNetworkNotifier.java index 31ff44b72..eee4ac53c 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.Messenger; 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 @@ public class OpenNetworkNotifier { 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 @@ public class OpenNetworkNotifier { Looper looper, FrameworkFacade framework, Clock clock, + WifiMetrics wifiMetrics, WifiConfigManager wifiConfigManager, WifiConfigStore wifiConfigStore, WifiStateMachine wifiStateMachine, @@ -146,6 +150,7 @@ public class OpenNetworkNotifier { mContext = context; mHandler = new Handler(looper); mFrameworkFacade = framework; + mWifiMetrics = wifiMetrics; mClock = clock; mConfigManager = wifiConfigManager; mWifiStateMachine = wifiStateMachine; @@ -206,7 +211,7 @@ public class OpenNetworkNotifier { 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 @@ public class OpenNetworkNotifier { 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 @@ public class OpenNetworkNotifier { 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 @@ public class OpenNetworkNotifier { 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 @@ public class OpenNetworkNotifier { } 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 @@ public class OpenNetworkNotifier { } 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 @@ public class OpenNetworkNotifier { } private void handleSeeAllNetworksAction() { + mWifiMetrics.incrementConnectToNetworkNotificationAction(mState, + ConnectToNetworkNotificationAndActionCount.ACTION_PICK_WIFI_NETWORK); startWifiSettings(); } @@ -378,14 +414,26 @@ public class OpenNetworkNotifier { 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 @@ public class OpenNetworkNotifier { @Override public void setSsids(Set ssidList) { mBlacklistedSsids.addAll(ssidList); + mWifiMetrics.setOpenNetworkRecommenderBlacklistSize(mBlacklistedSsids.size()); } } @@ -440,8 +489,10 @@ public class OpenNetworkNotifier { } 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 fc3af83e5..4a42c339d 100644 --- a/service/java/com/android/server/wifi/WifiInjector.java +++ b/service/java/com/android/server/wifi/WifiInjector.java @@ -225,7 +225,7 @@ public class WifiInjector { 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 5db5ee67b..071b4f883 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.PasspointManager; 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 class WifiMetrics { 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 @@ public class WifiMetrics { 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 @@ public class WifiMetrics { } } + /** 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 @@ public class WifiMetrics { + 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 @@ public class WifiMetrics { 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 @@ public class WifiMetrics { } /** - * 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 @@ public class WifiMetrics { mAvailableSavedPasspointProviderProfilesInScanHistogram.clear(); mAvailableSavedPasspointProviderBssidsInScanHistogram.clear(); mPnoScanMetrics.clear(); + mConnectToNetworkNotificationCount.clear(); + mConnectToNetworkNotificationActionCount.clear(); + mNumOpenNetworkRecommendationUpdates = 0; + mNumOpenNetworkConnectMessageFailedToSend = 0; } } -- cgit v1.2.3