Merge "Add getters to SharedConnectivityService" into udc-dev

core/api/system-current.txt

@@ -10075,6 +10075,11 @@ package android.net.wifi.sharedconnectivity.app {
     method public boolean connectTetherNetwork(@NonNull android.net.wifi.sharedconnectivity.app.TetherNetwork);
     method public boolean disconnectTetherNetwork(@NonNull android.net.wifi.sharedconnectivity.app.TetherNetwork);
     method public boolean forgetKnownNetwork(@NonNull android.net.wifi.sharedconnectivity.app.KnownNetwork);
+    method @Nullable public android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus getKnownNetworkConnectionStatus();
+    method @NonNull public java.util.List<android.net.wifi.sharedconnectivity.app.KnownNetwork> getKnownNetworks();
+    method @Nullable public android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState getSettingsState();
+    method @Nullable public android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus getTetherNetworkConnectionStatus();
+    method @NonNull public java.util.List<android.net.wifi.sharedconnectivity.app.TetherNetwork> getTetherNetworks();
     method public void registerCallback(@NonNull java.util.concurrent.Executor, @NonNull android.net.wifi.sharedconnectivity.app.SharedConnectivityClientCallback);
     method public boolean unregisterCallback(@NonNull android.net.wifi.sharedconnectivity.app.SharedConnectivityClientCallback);
   }

wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java

@@ -192,9 +192,9 @@ public class SharedConnectivityManager {
                 mService = ISharedConnectivityService.Stub.asInterface(service);
                 if (!mCallbackProxyCache.isEmpty()) {
                     synchronized (mCallbackProxyCache) {
-                        mCallbackProxyCache.keySet().forEach(callback -> {
+                        mCallbackProxyCache.keySet().forEach(callback ->
-                            registerCallbackInternal(callback, mCallbackProxyCache.get(callback));
+                                registerCallbackInternal(
-                        });
+                                        callback, mCallbackProxyCache.get(callback)));
                         mCallbackProxyCache.clear();
                     }
                 }
@@ -418,4 +418,104 @@ public class SharedConnectivityManager {
         }
         return true;
     }
+
+    /**
+     * Gets the list of tether networks the user can select to connect to.
+     *
+     * @return Returns a {@link List} of {@link TetherNetwork} objects, empty list on failure.
+     */
+    @NonNull
+    public List<TetherNetwork> getTetherNetworks() {
+        if (mService == null) {
+            return List.of();
+        }
+
+        try {
+            return mService.getTetherNetworks();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Exception in getTetherNetworks", e);
+        }
+        return List.of();
+    }
+
+    /**
+     * Gets the list of known networks the user can select to connect to.
+     *
+     * @return Returns a {@link List} of {@link KnownNetwork} objects, empty list on failure.
+     */
+    @NonNull
+    public List<KnownNetwork> getKnownNetworks() {
+        if (mService == null) {
+            return List.of();
+        }
+
+        try {
+            return mService.getKnownNetworks();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Exception in getKnownNetworks", e);
+        }
+        return List.of();
+    }
+
+    /**
+     * Gets the shared connectivity settings state.
+     *
+     * @return Returns a {@link SharedConnectivitySettingsState} object with the state, null on
+     * failure.
+     */
+    @Nullable
+    public SharedConnectivitySettingsState getSettingsState() {
+        if (mService == null) {
+            return null;
+        }
+
+        try {
+            return mService.getSettingsState();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Exception in getSettingsState", e);
+        }
+        return null;
+    }
+
+    /**
+     * Gets the connection status of the tether network the user selected to connect to.
+     *
+     * @return Returns a {@link TetherNetworkConnectionStatus} object with the connection status,
+     * null on failure. If no connection is active the status will be
+     * {@link TetherNetworkConnectionStatus#CONNECTION_STATUS_UNKNOWN}.
+     */
+    @Nullable
+    public TetherNetworkConnectionStatus getTetherNetworkConnectionStatus() {
+        if (mService == null) {
+            return null;
+        }
+
+        try {
+            return mService.getTetherNetworkConnectionStatus();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Exception in getTetherNetworkConnectionStatus", e);
+        }
+        return null;
+    }
+
+    /**
+     * Gets the connection status of the known network the user selected to connect to.
+     *
+     * @return Returns a {@link KnownNetworkConnectionStatus} object with the connection status,
+     * null on failure. If no connection is active the status will be
+     * {@link KnownNetworkConnectionStatus#CONNECTION_STATUS_UNKNOWN}.
+     */
+    @Nullable
+    public KnownNetworkConnectionStatus getKnownNetworkConnectionStatus() {
+        if (mService == null) {
+            return null;
+        }
+
+        try {
+            return mService.getKnownNetworkConnectionStatus();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Exception in getKnownNetworkConnectionStatus", e);
+        }
+        return null;
+    }
 }

wifi/java/src/android/net/wifi/sharedconnectivity/service/ISharedConnectivityService.aidl

@@ -18,6 +18,9 @@ package android.net.wifi.sharedconnectivity.service;
 
 import android.net.wifi.sharedconnectivity.app.KnownNetwork;
 import android.net.wifi.sharedconnectivity.app.TetherNetwork;
+import android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
+import android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus;
 import android.net.wifi.sharedconnectivity.service.ISharedConnectivityCallback;
 
 /*
@@ -30,4 +33,9 @@ interface ISharedConnectivityService {
     void disconnectTetherNetwork(in TetherNetwork network);
     void connectKnownNetwork(in KnownNetwork network);
     void forgetKnownNetwork(in KnownNetwork network);
+    List<TetherNetwork> getTetherNetworks();
+    List<KnownNetwork> getKnownNetworks();
+    SharedConnectivitySettingsState getSettingsState();
+    TetherNetworkConnectionStatus getTetherNetworkConnectionStatus();
+    KnownNetworkConnectionStatus getKnownNetworkConnectionStatus();
 }

wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java

@@ -33,6 +33,7 @@ import android.net.wifi.sharedconnectivity.app.SharedConnectivityManager;
 import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
 import android.net.wifi.sharedconnectivity.app.TetherNetwork;
 import android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus;
+import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.RemoteException;
@@ -68,9 +69,17 @@ public abstract class SharedConnectivityService extends Service {
 
     private List<TetherNetwork> mTetherNetworks = Collections.emptyList();
     private List<KnownNetwork> mKnownNetworks = Collections.emptyList();
-    private SharedConnectivitySettingsState mSettingsState;
+    private SharedConnectivitySettingsState mSettingsState =
-    private TetherNetworkConnectionStatus mTetherNetworkConnectionStatus;
+            new SharedConnectivitySettingsState.Builder().setInstantTetherEnabled(false)
-    private KnownNetworkConnectionStatus mKnownNetworkConnectionStatus;
+                    .setExtras(Bundle.EMPTY).build();
+    private TetherNetworkConnectionStatus mTetherNetworkConnectionStatus =
+            new TetherNetworkConnectionStatus.Builder()
+                    .setStatus(TetherNetworkConnectionStatus.CONNECTION_STATUS_UNKNOWN)
+                    .setExtras(Bundle.EMPTY).build();
+    private KnownNetworkConnectionStatus mKnownNetworkConnectionStatus =
+            new KnownNetworkConnectionStatus.Builder()
+                    .setStatus(KnownNetworkConnectionStatus.CONNECTION_STATUS_UNKNOWN)
+                    .setExtras(Bundle.EMPTY).build();
 
     private final class DeathRecipient implements IBinder.DeathRecipient {
         ISharedConnectivityCallback mCallback;
@@ -128,6 +137,36 @@ public abstract class SharedConnectivityService extends Service {
                 mHandler.post(() -> onForgetKnownNetwork(network));
             }
 
+            @Override
+            public List<TetherNetwork> getTetherNetworks() {
+                checkPermissions();
+                return mTetherNetworks;
+            }
+
+            @Override
+            public List<KnownNetwork> getKnownNetworks() {
+                checkPermissions();
+                return mKnownNetworks;
+            }
+
+            @Override
+            public SharedConnectivitySettingsState getSettingsState() {
+                checkPermissions();
+                return mSettingsState;
+            }
+
+            @Override
+            public TetherNetworkConnectionStatus getTetherNetworkConnectionStatus() {
+                checkPermissions();
+                return mTetherNetworkConnectionStatus;
+            }
+
+            @Override
+            public KnownNetworkConnectionStatus getKnownNetworkConnectionStatus() {
+                checkPermissions();
+                return mKnownNetworkConnectionStatus;
+            }
+
             @RequiresPermission(anyOf = {android.Manifest.permission.NETWORK_SETTINGS,
                     android.Manifest.permission.NETWORK_SETUP_WIZARD})
             /**
@@ -155,15 +194,6 @@ public abstract class SharedConnectivityService extends Service {
     public void onBind() {}
 
     private void onRegisterCallback(ISharedConnectivityCallback callback) {
-        // Listener gets triggered on first register using cashed data
-        if (!notifyTetherNetworkUpdate(callback) || !notifyKnownNetworkUpdate(callback)
-                || !notifySettingsStateUpdate(callback)
-                || !notifyTetherNetworkConnectionStatusChanged(callback)
-                || !notifyKnownNetworkConnectionStatusChanged(callback)) {
-            if (DEBUG) Log.w(TAG, "Failed to notify client");
-            return;
-        }
-
         DeathRecipient deathRecipient = new DeathRecipient(callback);
         try {
             callback.asBinder().linkToDeath(deathRecipient, 0);

wifi/tests/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManagerTest.java

@@ -22,6 +22,8 @@ import static android.net.wifi.sharedconnectivity.app.DeviceInfo.DEVICE_TYPE_TAB
 import static android.net.wifi.sharedconnectivity.app.KnownNetwork.NETWORK_SOURCE_NEARBY_SELF;
 import static android.net.wifi.sharedconnectivity.app.TetherNetwork.NETWORK_TYPE_CELLULAR;
 
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
@@ -36,6 +38,7 @@ import android.content.ComponentName;
 import android.content.Context;
 import android.content.res.Resources;
 import android.net.wifi.sharedconnectivity.service.ISharedConnectivityService;
+import android.os.Bundle;
 import android.os.Parcel;
 import android.os.RemoteException;
 
@@ -46,6 +49,7 @@ import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.util.List;
 import java.util.concurrent.Executor;
 
 /**
@@ -95,6 +99,7 @@ public class SharedConnectivityManagerTest {
     @Test
     public void bindingToService() {
         SharedConnectivityManager.create(mContext);
+
         verify(mContext).bindService(any(), any(), anyInt());
     }
 
@@ -104,6 +109,7 @@ public class SharedConnectivityManagerTest {
     @Test
     public void resourcesNotDefined() {
         when(mResources.getString(anyInt())).thenThrow(new Resources.NotFoundException());
+
         assertNull(SharedConnectivityManager.create(mContext));
     }
 
@@ -115,8 +121,10 @@ public class SharedConnectivityManagerTest {
             throws Exception {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.getServiceConnection().onServiceConnected(COMPONENT_NAME, mIBinder);
+
         // Since the binder is embedded in a proxy class, the call to registerCallback is done on
         // the proxy. So instead verifying that the proxy is calling the binder.
         verify(mIBinder).transact(anyInt(), any(Parcel.class), any(Parcel.class), anyInt());
@@ -126,9 +134,11 @@ public class SharedConnectivityManagerTest {
     public void registerCallback_serviceNotConnected_canUnregisterAndReregister() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.unregisterCallback(mClientCallback);
         manager.registerCallback(mExecutor, mClientCallback);
+
         verify(mClientCallback, never()).onRegisterCallbackFailed(any(Exception.class));
     }
 
@@ -136,7 +146,9 @@ public class SharedConnectivityManagerTest {
     public void registerCallback_serviceConnected() throws Exception {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.registerCallback(mExecutor, mClientCallback);
+
         verify(mService).registerCallback(any());
         verify(mClientCallback, never()).onRegisterCallbackFailed(any(Exception.class));
     }
@@ -145,8 +157,10 @@ public class SharedConnectivityManagerTest {
     public void registerCallback_doubleRegistration_shouldFail() throws Exception {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.registerCallback(mExecutor, mClientCallback);
+
         verify(mClientCallback).onRegisterCallbackFailed(any(IllegalStateException.class));
     }
 
@@ -155,7 +169,9 @@ public class SharedConnectivityManagerTest {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
         doThrow(new RemoteException()).when(mService).registerCallback(any());
+
         manager.registerCallback(mExecutor, mClientCallback);
+
         verify(mClientCallback).onRegisterCallbackFailed(any(RemoteException.class));
     }
 
@@ -166,6 +182,7 @@ public class SharedConnectivityManagerTest {
     public void unregisterCallback_withoutRegisteringFirst_serviceNotConnected_shouldFail() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         assertFalse(manager.unregisterCallback(mClientCallback));
     }
 
@@ -173,6 +190,7 @@ public class SharedConnectivityManagerTest {
     public void unregisterCallback_withoutRegisteringFirst_serviceConnected_shouldFail() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         assertFalse(manager.unregisterCallback(mClientCallback));
     }
 
@@ -180,7 +198,9 @@ public class SharedConnectivityManagerTest {
     public void unregisterCallback() throws Exception {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.registerCallback(mExecutor, mClientCallback);
+
         assertTrue(manager.unregisterCallback(mClientCallback));
         verify(mService).unregisterCallback(any());
     }
@@ -189,8 +209,10 @@ public class SharedConnectivityManagerTest {
     public void unregisterCallback_doubleUnregistration_serviceConnected_shouldFail() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.unregisterCallback(mClientCallback);
+
         assertFalse(manager.unregisterCallback(mClientCallback));
     }
 
@@ -198,8 +220,10 @@ public class SharedConnectivityManagerTest {
     public void unregisterCallback_doubleUnregistration_serviceNotConnected_shouldFail() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.unregisterCallback(mClientCallback);
+
         assertFalse(manager.unregisterCallback(mClientCallback));
     }
 
@@ -207,7 +231,9 @@ public class SharedConnectivityManagerTest {
     public void unregisterCallback_remoteException_shouldFail() throws Exception {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         doThrow(new RemoteException()).when(mService).unregisterCallback(any());
+
         assertFalse(manager.unregisterCallback(mClientCallback));
     }
 
@@ -217,16 +243,20 @@ public class SharedConnectivityManagerTest {
     @Test
     public void onServiceConnected_registerCallbackBeforeConnection() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.getServiceConnection().onServiceConnected(COMPONENT_NAME, mIBinder);
+
         verify(mClientCallback).onServiceConnected();
     }
 
     @Test
     public void onServiceConnected_registerCallbackAfterConnection() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+
         manager.getServiceConnection().onServiceConnected(COMPONENT_NAME, mIBinder);
         manager.registerCallback(mExecutor, mClientCallback);
+
         verify(mClientCallback).onServiceConnected();
     }
 
@@ -236,18 +266,22 @@ public class SharedConnectivityManagerTest {
     @Test
     public void onServiceDisconnected_registerCallbackBeforeConnection() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+
         manager.registerCallback(mExecutor, mClientCallback);
         manager.getServiceConnection().onServiceConnected(COMPONENT_NAME, mIBinder);
         manager.getServiceConnection().onServiceDisconnected(COMPONENT_NAME);
+
         verify(mClientCallback).onServiceDisconnected();
     }
 
     @Test
     public void onServiceDisconnected_registerCallbackAfterConnection() {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+
         manager.getServiceConnection().onServiceConnected(COMPONENT_NAME, mIBinder);
         manager.registerCallback(mExecutor, mClientCallback);
         manager.getServiceConnection().onServiceDisconnected(COMPONENT_NAME);
+
         verify(mClientCallback).onServiceDisconnected();
     }
 
@@ -259,6 +293,7 @@ public class SharedConnectivityManagerTest {
         TetherNetwork network = buildTetherNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         assertFalse(manager.connectTetherNetwork(network));
     }
 
@@ -267,7 +302,9 @@ public class SharedConnectivityManagerTest {
         TetherNetwork network = buildTetherNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.connectTetherNetwork(network);
+
         verify(mService).connectTetherNetwork(network);
     }
 
@@ -277,6 +314,7 @@ public class SharedConnectivityManagerTest {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
         doThrow(new RemoteException()).when(mService).connectTetherNetwork(network);
+
         assertFalse(manager.connectTetherNetwork(network));
     }
 
@@ -288,6 +326,7 @@ public class SharedConnectivityManagerTest {
         TetherNetwork network = buildTetherNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         assertFalse(manager.disconnectTetherNetwork(network));
     }
 
@@ -296,7 +335,9 @@ public class SharedConnectivityManagerTest {
         TetherNetwork network = buildTetherNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.disconnectTetherNetwork(network);
+
         verify(mService).disconnectTetherNetwork(network);
     }
 
@@ -306,6 +347,7 @@ public class SharedConnectivityManagerTest {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
         doThrow(new RemoteException()).when(mService).disconnectTetherNetwork(any());
+
         assertFalse(manager.disconnectTetherNetwork(network));
     }
 
@@ -317,6 +359,7 @@ public class SharedConnectivityManagerTest {
         KnownNetwork network = buildKnownNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         assertFalse(manager.connectKnownNetwork(network));
     }
 
@@ -325,7 +368,9 @@ public class SharedConnectivityManagerTest {
         KnownNetwork network = buildKnownNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.connectKnownNetwork(network);
+
         verify(mService).connectKnownNetwork(network);
     }
 
@@ -335,6 +380,7 @@ public class SharedConnectivityManagerTest {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
         doThrow(new RemoteException()).when(mService).connectKnownNetwork(network);
+
         assertFalse(manager.connectKnownNetwork(network));
     }
 
@@ -346,6 +392,7 @@ public class SharedConnectivityManagerTest {
         KnownNetwork network = buildKnownNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(null);
+
         assertFalse(manager.forgetKnownNetwork(network));
     }
 
@@ -354,7 +401,9 @@ public class SharedConnectivityManagerTest {
         KnownNetwork network = buildKnownNetwork();
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
+
         manager.forgetKnownNetwork(network);
+
         verify(mService).forgetKnownNetwork(network);
     }
 
@@ -364,9 +413,162 @@ public class SharedConnectivityManagerTest {
         SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
         manager.setService(mService);
         doThrow(new RemoteException()).when(mService).forgetKnownNetwork(network);
+
         assertFalse(manager.forgetKnownNetwork(network));
     }
 
+    /**
+     * Verify getters.
+     */
+    @Test
+    public void getTetherNetworks_serviceNotConnected_shouldReturnEmptyList() {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(null);
+
+        assertArrayEquals(List.of().toArray(), manager.getTetherNetworks().toArray());
+    }
+
+    @Test
+    public void getTetherNetworks_remoteException_shouldReturnEmptyList() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(mService);
+        doThrow(new RemoteException()).when(mService).getTetherNetworks();
+
+        assertArrayEquals(List.of().toArray(), manager.getTetherNetworks().toArray());
+    }
+
+    @Test
+    public void getTetherNetworks_shouldReturnNetworksList() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        List<TetherNetwork> networks = List.of(buildTetherNetwork());
+        List<TetherNetwork> expected = List.of(buildTetherNetwork());
+        manager.setService(mService);
+        when(mService.getTetherNetworks()).thenReturn(networks);
+
+        assertArrayEquals(expected.toArray(), manager.getTetherNetworks().toArray());
+    }
+
+    @Test
+    public void getKnownNetworks_serviceNotConnected_shouldReturnEmptyList()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(null);
+
+        assertArrayEquals(List.of().toArray(), manager.getKnownNetworks().toArray());
+    }
+
+    @Test
+    public void getKnownNetworks_remoteException_shouldReturnEmptyList() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(mService);
+        doThrow(new RemoteException()).when(mService).getKnownNetworks();
+
+        assertArrayEquals(List.of().toArray(), manager.getKnownNetworks().toArray());
+    }
+
+    @Test
+    public void getKnownNetworks_shouldReturnNetworksList() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        List<KnownNetwork> networks = List.of(buildKnownNetwork());
+        List<KnownNetwork> expected = List.of(buildKnownNetwork());
+        manager.setService(mService);
+        when(mService.getKnownNetworks()).thenReturn(networks);
+
+        assertArrayEquals(expected.toArray(), manager.getKnownNetworks().toArray());
+    }
+
+    @Test
+    public void getSettingsState_serviceNotConnected_shouldReturnNull() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(null);
+
+        assertNull(manager.getSettingsState());
+    }
+
+    @Test
+    public void getSettingsState_remoteException_shouldReturnNull() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(mService);
+        doThrow(new RemoteException()).when(mService).getSettingsState();
+
+        assertNull(manager.getSettingsState());
+    }
+
+    @Test
+    public void getSettingsState_serviceConnected_shouldReturnState() throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        SharedConnectivitySettingsState state = new SharedConnectivitySettingsState.Builder()
+                .setInstantTetherEnabled(true).setExtras(new Bundle()).build();
+        manager.setService(mService);
+        when(mService.getSettingsState()).thenReturn(state);
+
+        assertEquals(state, manager.getSettingsState());
+    }
+
+    @Test
+    public void getTetherNetworkConnectionStatus_serviceNotConnected_shouldReturnNull()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(null);
+
+        assertNull(manager.getTetherNetworkConnectionStatus());
+    }
+
+    @Test
+    public void getTetherNetworkConnectionStatus_remoteException_shouldReturnNull()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(mService);
+        doThrow(new RemoteException()).when(mService).getTetherNetworkConnectionStatus();
+
+        assertNull(manager.getTetherNetworkConnectionStatus());
+    }
+
+    @Test
+    public void getTetherNetworkConnectionStatus_serviceConnected_shouldReturnStatus()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        TetherNetworkConnectionStatus status = new TetherNetworkConnectionStatus.Builder()
+                .setStatus(TetherNetworkConnectionStatus.CONNECTION_STATUS_ENABLING_HOTSPOT)
+                .setExtras(new Bundle()).build();
+        manager.setService(mService);
+        when(mService.getTetherNetworkConnectionStatus()).thenReturn(status);
+
+        assertEquals(status, manager.getTetherNetworkConnectionStatus());
+    }
+
+    @Test
+    public void getKnownNetworkConnectionStatus_serviceNotConnected_shouldReturnNull()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(null);
+
+        assertNull(manager.getKnownNetworkConnectionStatus());
+    }
+
+    @Test
+    public void getKnownNetworkConnectionStatus_remoteException_shouldReturnNull()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        manager.setService(mService);
+        doThrow(new RemoteException()).when(mService).getKnownNetworkConnectionStatus();
+
+        assertNull(manager.getKnownNetworkConnectionStatus());
+    }
+
+    @Test
+    public void getKnownNetworkConnectionStatus_serviceConnected_shouldReturnStatus()
+            throws RemoteException {
+        SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+        KnownNetworkConnectionStatus status = new KnownNetworkConnectionStatus.Builder()
+                .setStatus(KnownNetworkConnectionStatus.CONNECTION_STATUS_SAVED)
+                .setExtras(new Bundle()).build();
+        manager.setService(mService);
+        when(mService.getKnownNetworkConnectionStatus()).thenReturn(status);
+
+        assertEquals(status, manager.getKnownNetworkConnectionStatus());
+    }
+
     private void setResources(@Mock Context context) {
         when(context.getResources()).thenReturn(mResources);
         when(mResources.getString(anyInt()))

wifi/tests/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityServiceTest.java

@@ -16,14 +16,30 @@
 
 package android.net.wifi.sharedconnectivity.service;
 
+import static android.net.wifi.WifiInfo.SECURITY_TYPE_EAP;
+import static android.net.wifi.WifiInfo.SECURITY_TYPE_WEP;
+import static android.net.wifi.sharedconnectivity.app.DeviceInfo.DEVICE_TYPE_TABLET;
+import static android.net.wifi.sharedconnectivity.app.KnownNetwork.NETWORK_SOURCE_NEARBY_SELF;
+import static android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus.CONNECTION_STATUS_SAVED;
+import static android.net.wifi.sharedconnectivity.app.TetherNetwork.NETWORK_TYPE_CELLULAR;
+import static android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus.CONNECTION_STATUS_UNKNOWN;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.content.Intent;
+import android.net.wifi.sharedconnectivity.app.DeviceInfo;
 import android.net.wifi.sharedconnectivity.app.KnownNetwork;
+import android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
 import android.net.wifi.sharedconnectivity.app.TetherNetwork;
+import android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus;
+import android.os.Bundle;
 import android.os.Looper;
+import android.os.RemoteException;
 
 import androidx.annotation.NonNull;
 import androidx.test.filters.SmallTest;
@@ -33,11 +49,37 @@ import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.util.List;
+
 /**
  * Unit tests for {@link android.net.wifi.sharedconnectivity.service.SharedConnectivityService}.
  */
 @SmallTest
 public class SharedConnectivityServiceTest {
+    private static final int[] SECURITY_TYPES = {SECURITY_TYPE_WEP, SECURITY_TYPE_EAP};
+    private static final DeviceInfo DEVICE_INFO = new DeviceInfo.Builder()
+            .setDeviceType(DEVICE_TYPE_TABLET).setDeviceName("TEST_NAME").setModelName("TEST_MODEL")
+            .setConnectionStrength(2).setBatteryPercentage(50).build();
+    private static final TetherNetwork TETHER_NETWORK =
+            new TetherNetwork.Builder().setDeviceId(1).setDeviceInfo(DEVICE_INFO)
+                    .setNetworkType(NETWORK_TYPE_CELLULAR).setNetworkName("TEST_NETWORK")
+                    .setHotspotSsid("TEST_SSID").setHotspotBssid("TEST_BSSID")
+                    .setHotspotSecurityTypes(SECURITY_TYPES).build();
+    private static final List<TetherNetwork> TETHER_NETWORKS = List.of(TETHER_NETWORK);
+    private static final KnownNetwork KNOWN_NETWORK =
+            new KnownNetwork.Builder().setNetworkSource(NETWORK_SOURCE_NEARBY_SELF)
+                    .setSsid("TEST_SSID").setSecurityTypes(SECURITY_TYPES)
+                    .setDeviceInfo(DEVICE_INFO).build();
+    private static final List<KnownNetwork> KNOWN_NETWORKS = List.of(KNOWN_NETWORK);
+    private static final SharedConnectivitySettingsState SETTINGS_STATE =
+            new SharedConnectivitySettingsState.Builder().setInstantTetherEnabled(true)
+                    .setExtras(Bundle.EMPTY).build();
+    private static final TetherNetworkConnectionStatus TETHER_NETWORK_CONNECTION_STATUS =
+            new TetherNetworkConnectionStatus.Builder().setStatus(CONNECTION_STATUS_UNKNOWN)
+                    .setTetherNetwork(TETHER_NETWORK).setExtras(Bundle.EMPTY).build();
+    private static final KnownNetworkConnectionStatus KNOWN_NETWORK_CONNECTION_STATUS =
+            new KnownNetworkConnectionStatus.Builder().setStatus(CONNECTION_STATUS_SAVED)
+                    .setKnownNetwork(KNOWN_NETWORK).setExtras(Bundle.EMPTY).build();
 
     @Mock
     Context mContext;
@@ -66,20 +108,60 @@ public class SharedConnectivityServiceTest {
         when(mContext.getMainLooper()).thenReturn(Looper.getMainLooper());
     }
 
-    /**
-     * Verifies service returns
-     */
     @Test
-    public void testOnBind() {
+    public void onBind_isNotNull() {
         SharedConnectivityService service = createService();
         assertNotNull(service.onBind(new Intent()));
     }
 
     @Test
-    public void testCallbacks() {
+    public void getTetherNetworks() throws RemoteException {
         SharedConnectivityService service = createService();
         ISharedConnectivityService.Stub binder =
                 (ISharedConnectivityService.Stub) service.onBind(new Intent());
+
+        service.setTetherNetworks(TETHER_NETWORKS);
+        assertArrayEquals(TETHER_NETWORKS.toArray(), binder.getTetherNetworks().toArray());
+    }
+
+    @Test
+    public void getKnownNetworks() throws RemoteException {
+        SharedConnectivityService service = createService();
+        ISharedConnectivityService.Stub binder =
+                (ISharedConnectivityService.Stub) service.onBind(new Intent());
+
+        service.setKnownNetworks(KNOWN_NETWORKS);
+        assertArrayEquals(KNOWN_NETWORKS.toArray(), binder.getKnownNetworks().toArray());
+    }
+
+    @Test
+    public void getSharedConnectivitySettingsState() throws RemoteException {
+        SharedConnectivityService service = createService();
+        ISharedConnectivityService.Stub binder =
+                (ISharedConnectivityService.Stub) service.onBind(new Intent());
+
+        service.setSettingsState(SETTINGS_STATE);
+        assertEquals(SETTINGS_STATE, binder.getSettingsState());
+    }
+
+    @Test
+    public void updateTetherNetworkConnectionStatus() throws RemoteException {
+        SharedConnectivityService service = createService();
+        ISharedConnectivityService.Stub binder =
+                (ISharedConnectivityService.Stub) service.onBind(new Intent());
+
+        service.updateTetherNetworkConnectionStatus(TETHER_NETWORK_CONNECTION_STATUS);
+        assertEquals(TETHER_NETWORK_CONNECTION_STATUS, binder.getTetherNetworkConnectionStatus());
+    }
+
+    @Test
+    public void updateKnownNetworkConnectionStatus() throws RemoteException {
+        SharedConnectivityService service = createService();
+        ISharedConnectivityService.Stub binder =
+                (ISharedConnectivityService.Stub) service.onBind(new Intent());
+
+        service.updateKnownNetworkConnectionStatus(KNOWN_NETWORK_CONNECTION_STATUS);
+        assertEquals(KNOWN_NETWORK_CONNECTION_STATUS, binder.getKnownNetworkConnectionStatus());
     }
 
     private SharedConnectivityService createService() {