diff --git a/core/api/system-current.txt b/core/api/system-current.txt index c14de7029a16f..d96af74ee5803 100644 --- a/core/api/system-current.txt +++ b/core/api/system-current.txt @@ -10071,6 +10071,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 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 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); } diff --git a/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java b/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java index 9593c8ae77a84..e765e963f838a 100644 --- a/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java +++ b/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java @@ -180,9 +180,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(); } } @@ -406,4 +406,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 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 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; + } } diff --git a/wifi/java/src/android/net/wifi/sharedconnectivity/service/ISharedConnectivityService.aidl b/wifi/java/src/android/net/wifi/sharedconnectivity/service/ISharedConnectivityService.aidl index 52da596081a4a..9f33e99ad3d15 100644 --- 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 getTetherNetworks(); + List getKnownNetworks(); + SharedConnectivitySettingsState getSettingsState(); + TetherNetworkConnectionStatus getTetherNetworkConnectionStatus(); + KnownNetworkConnectionStatus getKnownNetworkConnectionStatus(); } diff --git a/wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java b/wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java index f3af06247576e..07d9da29316fe 100644 --- a/wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java +++ b/wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java @@ -32,6 +32,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; @@ -67,9 +68,17 @@ public abstract class SharedConnectivityService extends Service { private List mTetherNetworks = Collections.emptyList(); private List 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; @@ -127,6 +136,36 @@ public abstract class SharedConnectivityService extends Service { mHandler.post(() -> onForgetKnownNetwork(network)); } + @Override + public List getTetherNetworks() { + checkPermissions(); + return mTetherNetworks; + } + + @Override + public List 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}) private void checkPermissions() { @@ -141,15 +180,6 @@ public abstract class SharedConnectivityService extends Service { } 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); diff --git a/wifi/tests/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManagerTest.java b/wifi/tests/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManagerTest.java index 439d456d76576..cdb438f8b96b5 100644 --- 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 networks = List.of(buildTetherNetwork()); + List 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 networks = List.of(buildKnownNetwork()); + List 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())) diff --git a/wifi/tests/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityServiceTest.java b/wifi/tests/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityServiceTest.java index d7f7fea4df3eb..a04526a61bcb6 100644 --- 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 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 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() {