Merge "Pass more data through the recommendation request."

api/system-current.txt

@@ -25759,9 +25759,12 @@ package android.net {
   public final class RecommendationRequest implements android.os.Parcelable {
     ctor protected RecommendationRequest(android.os.Parcel);
     method public int describeContents();
-    method public android.net.wifi.WifiConfiguration getCurrentSelectedConfig();
+    method public android.net.wifi.WifiConfiguration[] getConnectableConfigs();
-    method public android.net.NetworkCapabilities getRequiredCapabilities();
+    method public android.net.wifi.WifiConfiguration getConnectedConfig();
+    method public android.net.wifi.WifiConfiguration getDefaultWifiConfig();
     method public android.net.wifi.ScanResult[] getScanResults();
+    method public void setConnectableConfigs(android.net.wifi.WifiConfiguration[]);
+    method public void setConnectedConfig(android.net.wifi.WifiConfiguration);
     method public void writeToParcel(android.os.Parcel, int);
     field public static final android.os.Parcelable.Creator<android.net.RecommendationRequest> CREATOR;
   }
@@ -25769,8 +25772,9 @@ package android.net {
   public static final class RecommendationRequest.Builder {
     ctor public RecommendationRequest.Builder();
     method public android.net.RecommendationRequest build();
-    method public android.net.RecommendationRequest.Builder setCurrentRecommendedWifiConfig(android.net.wifi.WifiConfiguration);
+    method public android.net.RecommendationRequest.Builder setConnectableConfigs(android.net.wifi.WifiConfiguration[]);
-    method public android.net.RecommendationRequest.Builder setNetworkCapabilities(android.net.NetworkCapabilities);
+    method public android.net.RecommendationRequest.Builder setConnectedWifiConfig(android.net.wifi.WifiConfiguration);
+    method public android.net.RecommendationRequest.Builder setDefaultWifiConfig(android.net.wifi.WifiConfiguration);
     method public android.net.RecommendationRequest.Builder setScanResults(android.net.wifi.ScanResult[]);
   }
 

core/java/android/net/RecommendationRequest.java

@@ -34,8 +34,9 @@ import com.android.internal.annotations.VisibleForTesting;
 @SystemApi
 public final class RecommendationRequest implements Parcelable {
     private final ScanResult[] mScanResults;
-    private final WifiConfiguration mCurrentSelectedConfig;
+    private final WifiConfiguration mDefaultConfig;
-    private final NetworkCapabilities mRequiredCapabilities;
+    private WifiConfiguration mConnectedConfig;
+    private WifiConfiguration[] mConnectableConfigs;
 
     /**
      * Builder class for constructing {@link RecommendationRequest} instances.
@@ -44,26 +45,62 @@ public final class RecommendationRequest implements Parcelable {
     @SystemApi
     public static final class Builder {
         private ScanResult[] mScanResults;
-        private WifiConfiguration mCurrentConfig;
+        private WifiConfiguration mDefaultConfig;
-        private NetworkCapabilities mNetworkCapabilities;
+        private WifiConfiguration mConnectedConfig;
+        private WifiConfiguration[] mConnectableConfigs;
 
+        /**
+         * @param scanResults the array of {@link ScanResult}s the recommendation must be
+         *                    constrained to i.e. if a non-null wifi config recommendation is
+         *                    returned then it must be able to connect to one of the networks in
+         *                    the results list.
+         *
+         *                    If the array is {@code null} or empty then there is no constraint.
+         *
+         * @return this
+         */
         public Builder setScanResults(ScanResult[] scanResults) {
             mScanResults = scanResults;
             return this;
         }
 
-        public Builder setCurrentRecommendedWifiConfig(WifiConfiguration config) {
+        /**
-            this.mCurrentConfig = config;
+         * @param config the {@link WifiConfiguration} to return if no recommendation is available.
+         * @return this
+         */
+        public Builder setDefaultWifiConfig(WifiConfiguration config) {
+            this.mDefaultConfig = config;
             return this;
         }
 
-        public Builder setNetworkCapabilities(NetworkCapabilities capabilities) {
+        /**
-            mNetworkCapabilities = capabilities;
+         * @param config the {@link WifiConfiguration} of the connected network at the time the
+         *               this request was made.
+         * @return this
+         */
+        public Builder setConnectedWifiConfig(WifiConfiguration config) {
+            this.mConnectedConfig = config;
             return this;
         }
 
+        /**
+         * @param connectableConfigs the set of saved {@link WifiConfiguration}s that can be
+         *                           connected to based on the current set of {@link ScanResult}s.
+         * @return this
+         */
+        public Builder setConnectableConfigs(WifiConfiguration[] connectableConfigs) {
+            mConnectableConfigs = connectableConfigs;
+            return this;
+        }
+
+        /**
+         * @return a new {@link RecommendationRequest} instance
+         */
         public RecommendationRequest build() {
-            return new RecommendationRequest(mScanResults, mCurrentConfig, mNetworkCapabilities);
+            return new RecommendationRequest(mScanResults,
+                    mDefaultConfig,
+                    mConnectedConfig,
+                    mConnectableConfigs);
         }
     }
 
@@ -79,45 +116,80 @@ public final class RecommendationRequest implements Parcelable {
     }
 
     /**
-     * @return The best recommendation at the time this {@code RecommendationRequest} instance
+     * @return the {@link WifiConfiguration} to return if no recommendation is available.
-     *         was created. This may be null which indicates that no recommendation is available.
      */
-    public WifiConfiguration getCurrentSelectedConfig() {
+    public WifiConfiguration getDefaultWifiConfig() {
-        return mCurrentSelectedConfig;
+        return mDefaultConfig;
     }
 
     /**
-     *
+     * @return the {@link WifiConfiguration} of the connected network at the time the this request
-     * @return The set of {@link NetworkCapabilities} the recommendation must be constrained to.
+     *         was made.
-     *         This may be {@code null} which indicates that there are no constraints on the
-     *         capabilities of the recommended network.
      */
-    public NetworkCapabilities getRequiredCapabilities() {
+    public WifiConfiguration getConnectedConfig() {
-        return mRequiredCapabilities;
+        return mConnectedConfig;
+    }
+
+    /**
+     * @return the set of saved {@link WifiConfiguration}s that can be connected to based on the
+     *         current set of {@link ScanResult}s.
+     */
+    public WifiConfiguration[] getConnectableConfigs() {
+        return mConnectableConfigs;
+    }
+
+    /**
+     * @param connectedConfig the {@link WifiConfiguration} of the connected network at the time
+     *                        the this request was made.
+     */
+    public void setConnectedConfig(WifiConfiguration connectedConfig) {
+        mConnectedConfig = connectedConfig;
+    }
+
+    /**
+     * @param connectableConfigs the set of saved {@link WifiConfiguration}s that can be connected
+     *                           to based on the current set of {@link ScanResult}s.
+     */
+    public void setConnectableConfigs(WifiConfiguration[] connectableConfigs) {
+        mConnectableConfigs = connectableConfigs;
     }
 
     @VisibleForTesting
     RecommendationRequest(ScanResult[] scanResults,
-            WifiConfiguration currentSelectedConfig,
+            WifiConfiguration defaultWifiConfig,
-            NetworkCapabilities requiredCapabilities) {
+            WifiConfiguration connectedWifiConfig,
+            WifiConfiguration[] connectableConfigs) {
         mScanResults = scanResults;
-        mCurrentSelectedConfig = currentSelectedConfig;
+        mDefaultConfig = defaultWifiConfig;
-        mRequiredCapabilities = requiredCapabilities;
+        mConnectedConfig = connectedWifiConfig;
+        mConnectableConfigs = connectableConfigs;
     }
 
     protected RecommendationRequest(Parcel in) {
         final int resultCount = in.readInt();
         if (resultCount > 0) {
             mScanResults = new ScanResult[resultCount];
+            final ClassLoader classLoader = ScanResult.class.getClassLoader();
             for (int i = 0; i < resultCount; i++) {
-                mScanResults[i] = in.readParcelable(ScanResult.class.getClassLoader());
+                mScanResults[i] = in.readParcelable(classLoader);
             }
         } else {
             mScanResults = null;
         }
 
-        mCurrentSelectedConfig = in.readParcelable(WifiConfiguration.class.getClassLoader());
+        mDefaultConfig = in.readParcelable(WifiConfiguration.class.getClassLoader());
-        mRequiredCapabilities = in.readParcelable(NetworkCapabilities.class.getClassLoader());
+        mConnectedConfig = in.readParcelable(WifiConfiguration.class.getClassLoader());
+
+        final int configCount = in.readInt();
+        if (configCount > 0) {
+            mConnectableConfigs = new WifiConfiguration[configCount];
+            final ClassLoader classLoader = WifiConfiguration.class.getClassLoader();
+            for (int i = 0; i < configCount; i++) {
+                mConnectableConfigs[i] = in.readParcelable(classLoader);
+            }
+        } else {
+            mConnectableConfigs = null;
+        }
     }
 
     @Override
@@ -135,8 +207,20 @@ public final class RecommendationRequest implements Parcelable {
         } else {
             dest.writeInt(0);
         }
-        dest.writeParcelable(mCurrentSelectedConfig, flags);
+
-        dest.writeParcelable(mRequiredCapabilities, flags);
+        dest.writeParcelable(mDefaultConfig, flags);
+        dest.writeParcelable(mConnectedConfig, flags);
+
+        if (mConnectableConfigs != null) {
+            dest.writeInt(mConnectableConfigs.length);
+            for (int i = 0; i < mConnectableConfigs.length; i++) {
+                dest.writeParcelable(mConnectableConfigs[i], flags);
+            }
+        } else {
+            dest.writeInt(0);
+        }
+
+
     }
 
     public static final Creator<RecommendationRequest> CREATOR =

core/tests/coretests/src/android/net/RecommendationRequestTest.java

@@ -7,8 +7,9 @@ import android.test.AndroidTestCase;
 
 public class RecommendationRequestTest extends AndroidTestCase {
     private ScanResult[] mScanResults;
-    private WifiConfiguration mConfiguration;
+    private WifiConfiguration mDefaultConfig;
-    private NetworkCapabilities mCapabilities;
+    private WifiConfiguration mConnectedConfig;
+    private WifiConfiguration[] mConnectableConfigs;
 
     @Override
     public void setUp() throws Exception {
@@ -29,45 +30,58 @@ public class RecommendationRequestTest extends AndroidTestCase {
                 8 /*centerFreq0*/,
                 9 /*centerFreq1*/,
                 false /*is80211McRTTResponder*/);
-        mConfiguration = new WifiConfiguration();
+        mDefaultConfig = new WifiConfiguration();
-        mConfiguration.SSID = "RecommendationRequestTest";
+        mDefaultConfig.SSID = "default_config";
-        mCapabilities = new NetworkCapabilities()
+        mConnectedConfig = new WifiConfiguration();
-                .removeCapability(NetworkCapabilities.NET_CAPABILITY_TRUSTED);
+        mConnectedConfig.SSID = "connected_config";
+        mConnectableConfigs = new WifiConfiguration[] {mDefaultConfig, mConnectedConfig};
     }
 
     public void testParceling() throws Exception {
         RecommendationRequest request = new RecommendationRequest.Builder()
-                .setCurrentRecommendedWifiConfig(mConfiguration)
+                .setDefaultWifiConfig(mDefaultConfig)
                 .setScanResults(mScanResults)
-                .setNetworkCapabilities(mCapabilities)
+                .setConnectedWifiConfig(mConnectedConfig)
+                .setConnectableConfigs(mConnectableConfigs)
                 .build();
 
         RecommendationRequest parceled = passThroughParcel(request);
-        assertEquals(request.getCurrentSelectedConfig().SSID,
+        assertEquals(request.getDefaultWifiConfig().SSID,
-                parceled.getCurrentSelectedConfig().SSID);
+                parceled.getDefaultWifiConfig().SSID);
-        assertEquals(request.getRequiredCapabilities(), parceled.getRequiredCapabilities());
+        assertEquals(request.getConnectedConfig().SSID,
+                parceled.getConnectedConfig().SSID);
         ScanResult[] parceledScanResults = parceled.getScanResults();
         assertNotNull(parceledScanResults);
         assertEquals(mScanResults.length, parceledScanResults.length);
         for (int i = 0; i < mScanResults.length; i++) {
             assertEquals(mScanResults[i].SSID, parceledScanResults[i].SSID);
         }
+        WifiConfiguration[] parceledConfigs = parceled.getConnectableConfigs();
+        for (int i = 0; i < parceledConfigs.length; i++) {
+            assertEquals(mConnectableConfigs[i].SSID, parceledConfigs[i].SSID);
+        }
     }
 
     public void testParceling_nullScanResults() throws Exception {
         RecommendationRequest request = new RecommendationRequest.Builder()
-                .setCurrentRecommendedWifiConfig(mConfiguration)
+                .setDefaultWifiConfig(mDefaultConfig)
-                .setNetworkCapabilities(mCapabilities)
                 .build();
 
         RecommendationRequest parceled = passThroughParcel(request);
-        assertEquals(request.getCurrentSelectedConfig().SSID,
-                parceled.getCurrentSelectedConfig().SSID);
-        assertEquals(request.getRequiredCapabilities(), parceled.getRequiredCapabilities());
         ScanResult[] parceledScanResults = parceled.getScanResults();
         assertNull(parceledScanResults);
     }
 
+    public void testParceling_nullWifiConfigArray() throws Exception {
+        RecommendationRequest request = new RecommendationRequest.Builder()
+                .setDefaultWifiConfig(mDefaultConfig)
+                .build();
+
+        RecommendationRequest parceled = passThroughParcel(request);
+        WifiConfiguration[] parceledConfigs = parceled.getConnectableConfigs();
+        assertNull(parceledConfigs);
+    }
+
     private RecommendationRequest passThroughParcel(RecommendationRequest request) {
         Parcel p = Parcel.obtain();
         RecommendationRequest output = null;

services/core/java/com/android/server/NetworkScoreService.java

@@ -582,9 +582,9 @@ public class NetworkScoreService extends INetworkScoreService.Stub {
                 Log.d(TAG, "Returning the default network recommendation.");
             }
 
-            if (request != null && request.getCurrentSelectedConfig() != null) {
+            if (request != null && request.getDefaultWifiConfig() != null) {
                 return RecommendationResult.createConnectRecommendation(
-                        request.getCurrentSelectedConfig());
+                        request.getDefaultWifiConfig());
             }
             return RecommendationResult.createDoNotConnectRecommendation();
         } finally {
@@ -887,9 +887,9 @@ public class NetworkScoreService extends INetworkScoreService.Stub {
         }
 
         final RecommendationResult result;
-        if (request != null && request.getCurrentSelectedConfig() != null) {
+        if (request != null && request.getDefaultWifiConfig() != null) {
             result = RecommendationResult.createConnectRecommendation(
-                    request.getCurrentSelectedConfig());
+                    request.getDefaultWifiConfig());
         } else {
             result = RecommendationResult.createDoNotConnectRecommendation();
         }

services/tests/servicestests/src/com/android/server/NetworkScoreServiceTest.java

@@ -144,7 +144,7 @@ public class NetworkScoreServiceTest {
         configuration.SSID = "NetworkScoreServiceTest_SSID";
         configuration.BSSID = "NetworkScoreServiceTest_BSSID";
         mRecommendationRequest = new RecommendationRequest.Builder()
-            .setCurrentRecommendedWifiConfig(configuration).build();
+            .setDefaultWifiConfig(configuration).build();
         mOnResultListener = new OnResultListener();
         mRemoteCallback = new RemoteCallback(mOnResultListener);
         Settings.Global.putLong(mContentResolver,
@@ -240,7 +240,7 @@ public class NetworkScoreServiceTest {
         final RecommendationResult result =
                 mNetworkScoreService.requestRecommendation(mRecommendationRequest);
         assertNotNull(result);
-        assertEquals(mRecommendationRequest.getCurrentSelectedConfig(),
+        assertEquals(mRecommendationRequest.getDefaultWifiConfig(),
                 result.getWifiConfiguration());
     }
 
@@ -255,7 +255,7 @@ public class NetworkScoreServiceTest {
         final RecommendationResult result =
                 mNetworkScoreService.requestRecommendation(mRecommendationRequest);
         assertNotNull(result);
-        assertEquals(mRecommendationRequest.getCurrentSelectedConfig(),
+        assertEquals(mRecommendationRequest.getDefaultWifiConfig(),
                 result.getWifiConfiguration());
     }
 
@@ -327,7 +327,7 @@ public class NetworkScoreServiceTest {
         RecommendationResult result =
                 mOnResultListener.receivedBundle.getParcelable(EXTRA_RECOMMENDATION_RESULT);
         assertTrue(result.hasRecommendation());
-        assertEquals(mRecommendationRequest.getCurrentSelectedConfig().SSID,
+        assertEquals(mRecommendationRequest.getDefaultWifiConfig().SSID,
                 result.getWifiConfiguration().SSID);
     }