Extension API: Create System APIs to allow OEM module to override WiFi

scorer in AOSP

Pass WiFi connected network scorer provided by OEM extension module into
WiFiScoreReport; Create the ScoreChangeCallback object and register it
to OEM extension module; Implement other methods defined in the WiFi
scorer interface.

Test: atest com.android.server.wifi
Bug: 135573686, 122133502, 136312816, 135572156

Change-Id: Ic4808e7c1e92cab3739235c7440de52df3747e18
Signed-off-by: Mingguang Xu <mingguangxu@google.com>

2 files changed, 210 insertions, 3 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/WifiScoreReportTest.java b/tests/wifitests/src/com/android/server/wifi/WifiScoreReportTest.java
index 19497bb21..c28763288 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiScoreReportTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiScoreReportTest.java
@@ -22,10 +22,12 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.answerVoid;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.atMost;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
@@ -41,8 +43,13 @@ import android.net.Network;
 import android.net.NetworkAgent;
 import android.net.NetworkCapabilities;
 import android.net.NetworkInfo;
+import android.net.wifi.IScoreChangeCallback;
+import android.net.wifi.IWifiConnectedNetworkScorer;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiInfo;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.RemoteException;
 import android.os.test.TestLooper;
 
 import androidx.test.filters.SmallTest;
@@ -52,6 +59,7 @@ import com.android.wifi.resources.R;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -62,8 +70,6 @@ import java.io.PrintWriter;
  */
 @SmallTest
 public class WifiScoreReportTest extends WifiBaseTest {
-
-
     class FakeClock extends Clock {
         long mWallClockMillis = 1500000000000L;
         int mStepMillis = 1001;
@@ -86,6 +92,26 @@ public class WifiScoreReportTest extends WifiBaseTest {
     @Mock Resources mResources;
     @Mock WifiMetrics mWifiMetrics;
     @Mock PrintWriter mPrintWriter;
+    @Mock IBinder mAppBinder;
+    @Mock IWifiConnectedNetworkScorer mWifiConnectedNetworkScorer;
+    private TestLooper mLooper;
+
+    public class WifiConnectedNetworkScorerImpl extends IWifiConnectedNetworkScorer.Stub {
+        public IScoreChangeCallback mScoreChangeCallback;
+        public int mSessionId = -1;
+
+        @Override
+        public void start(int sessionId) {
+            mSessionId = sessionId;
+        }
+        @Override
+        public void stop(int sessionId) {
+        }
+        @Override
+        public void setScoreChangeCallback(IScoreChangeCallback cbImpl) {
+            mScoreChangeCallback = cbImpl;
+        }
+    }
 
     // NetworkAgent is abstract, so a subclass is necessary
     private static class TestNetworkAgent extends NetworkAgent {
@@ -152,6 +178,7 @@ public class WifiScoreReportTest extends WifiBaseTest {
         setUpResources(mResources);
         mWifiInfo = new WifiInfo();
         mWifiInfo.setFrequency(2412);
+        mLooper = new TestLooper();
         when(mContext.getResources()).thenReturn(mResources);
         final ConnectivityManager cm = mock(ConnectivityManager.class);
         when(mContext.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(cm);
@@ -160,7 +187,8 @@ public class WifiScoreReportTest extends WifiBaseTest {
         mNetworkAgent = spy(new TestNetworkAgent(mContext));
         mClock = new FakeClock();
         mScoringParams = new ScoringParams(mContext);
-        mWifiScoreReport = new WifiScoreReport(mScoringParams, mClock);
+        mWifiScoreReport = new WifiScoreReport(mScoringParams, mClock,
+                new Handler(mLooper.getLooper()));
     }
 
     /**
@@ -519,4 +547,112 @@ public class WifiScoreReportTest extends WifiBaseTest {
         mWifiScoreReport.calculateAndReportScore(mWifiInfo, mNetworkAgent, mWifiMetrics);
         assertTrue(mWifiInfo.getScore() > ConnectedScore.WIFI_TRANSITION_SCORE);
     }
+
+    /**
+     * Verify that client gets ScoreChangeCallback object when client sets its scorer.
+     */
+    @Test
+    public void testClientNotification() throws RemoteException {
+        // Register Client for verification.
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        // Client should get ScoreChangeCallback.
+        verify(mWifiConnectedNetworkScorer).setScoreChangeCallback(any());
+    }
+
+    /**
+     * Verify that clear client should be handled.
+     */
+    @Test
+    public void testClearClient() throws RemoteException {
+        // Register Client for verification.
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        mWifiScoreReport.clearWifiConnectedNetworkScorer();
+        verify(mAppBinder).unlinkToDeath(any(), anyInt());
+
+        mWifiScoreReport.startConnectedNetworkScorer();
+        verify(mWifiConnectedNetworkScorer, never()).start(anyInt());
+    }
+
+    /**
+     * Verify that WifiScoreReport adds for death notification on setting client.
+     */
+    @Test
+    public void testAddsForBinderDeathOnSetClient() throws Exception {
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        verify(mAppBinder).linkToDeath(any(IBinder.DeathRecipient.class), anyInt());
+    }
+
+    /**
+     * Verify that client fails to get message when scorer add failed.
+     */
+    @Test
+    public void testAddsScorerFailureOnLinkToDeath() throws Exception {
+        doThrow(new RemoteException())
+                .when(mAppBinder).linkToDeath(any(IBinder.DeathRecipient.class), anyInt());
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        verify(mAppBinder).linkToDeath(any(IBinder.DeathRecipient.class), anyInt());
+
+        // Client should not get any message when scorer add failed.
+        verify(mWifiConnectedNetworkScorer, never()).setScoreChangeCallback(any());
+    }
+
+    /**
+     * Verify that client gets session ID when start method is called.
+     */
+    @Test
+    public void testClientGetSessionIdOnStart() throws Exception {
+        ArgumentCaptor<Integer> startId = ArgumentCaptor.forClass(Integer.class);
+        // Register Client for verification.
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        mWifiScoreReport.setSessionId(anyInt());
+        mWifiScoreReport.startConnectedNetworkScorer();
+        verify(mWifiConnectedNetworkScorer).start(startId.capture());
+        assertEquals((int) startId.getValue(), anyInt());
+    }
+
+    /**
+     * Verify that client gets session ID when stop method is called.
+     */
+    @Test
+    public void testClientGetSessionIdOnStop() throws Exception {
+        ArgumentCaptor<Integer> stopId = ArgumentCaptor.forClass(Integer.class);
+        // Register Client for verification.
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        mWifiScoreReport.setSessionId(anyInt());
+        mWifiScoreReport.stopConnectedNetworkScorer();
+        verify(mWifiConnectedNetworkScorer).stop(stopId.capture());
+        assertEquals((int) stopId.getValue(), anyInt());
+    }
+
+    /**
+     * Verify that WifiScoreReport gets updated score when onScoreChange() is called by apps.
+     */
+    @Test
+    public void testFrameworkGetsUpdatesScore() throws Exception {
+        WifiConnectedNetworkScorerImpl scorerImpl = new WifiConnectedNetworkScorerImpl();
+        // Register Client for verification.
+        mWifiScoreReport.setWifiConnectedNetworkScorer(mAppBinder, scorerImpl);
+
+        mWifiScoreReport.setSessionId(anyInt());
+        mWifiScoreReport.startConnectedNetworkScorer();
+        scorerImpl.mScoreChangeCallback.onStatusChange(scorerImpl.mSessionId, true);
+        assertEquals(mWifiScoreReport.getExternalConnectedScore(), 51);
+        scorerImpl.mScoreChangeCallback.onStatusChange(scorerImpl.mSessionId, false);
+        assertEquals(mWifiScoreReport.getExternalConnectedScore(), 49);
+
+        // TODO: Test WifiScoreReport gets notification for triggering update of
+        //  WifiUsabilityStatsEntrypl when scorerImpl calls onTriggerUpdateOfWifiUsabilityStats.
+    }
+
+    /**
+     * Verify that only a single Wi-Fi connected network scorer can be registered successfully.
+     */
+    @Test
+    public void verifyOnlyASingleScorerCanBeRegisteredSuccessively() throws Exception {
+        WifiConnectedNetworkScorerImpl scorerImpl = new WifiConnectedNetworkScorerImpl();
+        assertEquals(true, mWifiScoreReport.setWifiConnectedNetworkScorer(
+                mAppBinder, scorerImpl));
+        assertEquals(false, mWifiScoreReport.setWifiConnectedNetworkScorer(
+                mAppBinder, scorerImpl));
+    }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
index 3ba5682a6..eb8fe7781 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
@@ -103,6 +103,7 @@ import android.net.wifi.ISoftApCallback;
 import android.net.wifi.ISuggestionConnectionStatusListener;
 import android.net.wifi.ITrafficStateCallback;
 import android.net.wifi.ITxPacketCountListener;
+import android.net.wifi.IWifiConnectedNetworkScorer;
 import android.net.wifi.ScanResult;
 import android.net.wifi.SoftApConfiguration;
 import android.net.wifi.SoftApInfo;
@@ -194,6 +195,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
     private static final int TEST_TRAFFIC_STATE_CALLBACK_IDENTIFIER = 17;
     private static final int TEST_NETWORK_REQUEST_MATCH_CALLBACK_IDENTIFIER = 234;
     private static final int TEST_WIFI_USABILITY_STATS_LISTENER_IDENTIFIER = 2;
+    private static final int TEST_WIFI_CONNECTED_NETWORK_SCORER_IDENTIFIER = 1;
     private static final String WIFI_IFACE_NAME = "wlan0";
     private static final String WIFI_IFACE_NAME2 = "wlan1";
     private static final String TEST_COUNTRY_CODE = "US";
@@ -295,6 +297,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
     @Mock IScanResultsCallback mScanResultsCallback;
     @Mock ISuggestionConnectionStatusListener mSuggestionConnectionStatusListener;
     @Mock IOnWifiActivityEnergyInfoListener mOnWifiActivityEnergyInfoListener;
+    @Mock IWifiConnectedNetworkScorer mWifiConnectedNetworkScorer;
 
     WifiLog mLog = new LogcatLog(TAG);
 
@@ -5002,4 +5005,72 @@ public class WifiServiceImplTest extends WifiBaseTest {
         verify(mWifiNetworkSuggestionsManager)
                 .getWifiConfigForMatchedNetworkSuggestionsSharedWithUser(any());
     }
+
+    /**
+     * Verify that a call to setWifiConnectedNetworkScorer throws a SecurityException if
+     * the caller does not have WIFI_UPDATE_USABILITY_STATS_SCORE permission.
+     */
+    @Test
+    public void testSetNetworkScorerThrowsSecurityExceptionOnMissingPermissions() {
+        doThrow(new SecurityException()).when(mContext)
+                .enforceCallingPermission(
+                        eq(android.Manifest.permission.WIFI_UPDATE_USABILITY_STATS_SCORE),
+                        eq("WifiService"));
+        try {
+            mWifiServiceImpl.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+            fail("expected SecurityException");
+        } catch (SecurityException expected) {
+        }
+    }
+
+    /**
+     * Verify that a call to setWifiConnectedNetworkScorer throws an IllegalArgumentException
+     * if the parameters are not provided.
+     */
+    @Test
+    public void testSetScorerThrowsIllegalArgumentExceptionOnInvalidArguments() {
+        try {
+            mWifiServiceImpl.setWifiConnectedNetworkScorer(mAppBinder, null);
+            fail("expected IllegalArgumentException");
+        } catch (IllegalArgumentException expected) {
+        }
+    }
+
+    /**
+     * Verify that a call to clearWifiConnectedNetworkScorer throws a SecurityException if
+     * the caller does not have WIFI_UPDATE_USABILITY_STATS_SCORE permission.
+     */
+    @Test
+    public void testClearNetworkScorerThrowsSecurityExceptionOnMissingPermissions() {
+        doThrow(new SecurityException()).when(mContext)
+                .enforceCallingPermission(
+                        eq(android.Manifest.permission.WIFI_UPDATE_USABILITY_STATS_SCORE),
+                                eq("WifiService"));
+        try {
+            mWifiServiceImpl.clearWifiConnectedNetworkScorer();
+            fail("expected SecurityException");
+        } catch (SecurityException expected) {
+        }
+    }
+
+    /**
+     * Verify that setWifiConnectedNetworkScorer sets scorer to {@link WifiScoreReport}.
+     */
+    @Test
+    public void testSetWifiConnectedNetworkScorerAndVerify() throws Exception {
+        mWifiServiceImpl.setWifiConnectedNetworkScorer(mAppBinder, mWifiConnectedNetworkScorer);
+        mLooper.dispatchAll();
+        verify(mWifiScoreReport).setWifiConnectedNetworkScorer(mAppBinder,
+                mWifiConnectedNetworkScorer);
+    }
+
+    /**
+     * Verify that clearWifiConnectedNetworkScorer clears scorer from {@link WifiScoreReport}.
+     */
+    @Test
+    public void testClearWifiConnectedNetworkScorerAndVerify() throws Exception {
+        mWifiServiceImpl.clearWifiConnectedNetworkScorer();
+        mLooper.dispatchAll();
+        verify(mWifiScoreReport).clearWifiConnectedNetworkScorer();
+    }
 }