Merge "Add getters to SharedConnectivityService" into udc-dev

2023-02-24 21:18:55 +00:00
parent a4551d5615 bb165f6576
commit 3252063093
6 changed files with 447 additions and 20 deletions
--- a/core/api/system-current.txt
+++ b/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);
  }
--- a/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java
+++ b/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 -> {
-                            registerCallbackInternal(callback, mCallbackProxyCache.get(callback));
-                        });
+                        mCallbackProxyCache.keySet().forEach(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;
+    }
 }
--- a/wifi/java/src/android/net/wifi/sharedconnectivity/service/ISharedConnectivityService.aidl
+++ b/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();
 }
--- a/wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java
+++ b/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 TetherNetworkConnectionStatus mTetherNetworkConnectionStatus;
-    private KnownNetworkConnectionStatus mKnownNetworkConnectionStatus;
+    private SharedConnectivitySettingsState mSettingsState =
+            new SharedConnectivitySettingsState.Builder().setInstantTetherEnabled(false)
+                    .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);
--- a/wifi/tests/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManagerTest.java
+++ b/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()))
--- a/wifi/tests/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityServiceTest.java
+++ b/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() {