Merge "Notify client via callback when service is connected."
diff --git a/core/api/system-current.txt b/core/api/system-current.txt
index ca726d6..fdef066 100644
--- a/core/api/system-current.txt
+++ b/core/api/system-current.txt
@@ -10045,6 +10045,9 @@
public interface SharedConnectivityClientCallback {
method public void onKnownNetworkConnectionStatusChanged(@NonNull android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus);
method public void onKnownNetworksUpdated(@NonNull java.util.List<android.net.wifi.sharedconnectivity.app.KnownNetwork>);
+ method public void onRegisterCallbackFailed(@NonNull Exception);
+ method public void onServiceConnected();
+ method public void onServiceDisconnected();
method public void onSharedConnectivitySettingsChanged(@NonNull android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState);
method public void onTetherNetworkConnectionStatusChanged(@NonNull android.net.wifi.sharedconnectivity.app.TetherNetworkConnectionStatus);
method public void onTetherNetworksUpdated(@NonNull java.util.List<android.net.wifi.sharedconnectivity.app.TetherNetwork>);
@@ -10055,7 +10058,7 @@
method public boolean connectTetherNetwork(@NonNull android.net.wifi.sharedconnectivity.app.TetherNetwork);
method public boolean disconnectTetherNetwork();
method public boolean forgetKnownNetwork(@NonNull android.net.wifi.sharedconnectivity.app.KnownNetwork);
- method public boolean registerCallback(@NonNull java.util.concurrent.Executor, @NonNull android.net.wifi.sharedconnectivity.app.SharedConnectivityClientCallback);
+ 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/core/api/test-current.txt b/core/api/test-current.txt
index 28febbd..164c640 100644
--- a/core/api/test-current.txt
+++ b/core/api/test-current.txt
@@ -1949,6 +1949,7 @@
package android.net.wifi.sharedconnectivity.app {
public class SharedConnectivityManager {
+ method @Nullable public android.content.ServiceConnection getServiceConnection();
method public void setService(@Nullable android.os.IInterface);
}
diff --git a/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityClientCallback.java b/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityClientCallback.java
index f62bfd4..d2b9be7 100644
--- a/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityClientCallback.java
+++ b/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityClientCallback.java
@@ -64,5 +64,24 @@
* @param status The new status.
*/
void onKnownNetworkConnectionStatusChanged(@NonNull KnownNetworkConnectionStatus status);
+
+ /**
+ * This method is being called when the service is ready to be used.
+ */
+ void onServiceConnected();
+
+ /**
+ * This method is being called when the service is no longer available.
+ */
+ void onServiceDisconnected();
+
+ /**
+ * This method is called when the registration of the callback with the shared connectivity
+ * service failed.
+ *
+ * @param exception The exception received from the system when trying to connect to the
+ * service.
+ */
+ void onRegisterCallbackFailed(@NonNull Exception exception);
}
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 8aa369e..74b42d4 100644
--- a/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java
+++ b/wifi/java/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManager.java
@@ -47,6 +47,12 @@
* This class is the library used by consumers of Shared Connectivity data to bind to the service,
* receive callbacks from, and send user actions to the service.
*
+ * The methods {@link #connectTetherNetwork}, {@link #disconnectTetherNetwork},
+ * {@link #connectKnownNetwork} and {@link #forgetKnownNetwork} are not valid and will return false
+ * if not called between {@link SharedConnectivityClientCallback#onServiceConnected()}
+ * and {@link SharedConnectivityClientCallback#onServiceDisconnected()} or if
+ * {@link SharedConnectivityClientCallback#onRegisterCallbackFailed} was called.
+ *
* @hide
*/
@SystemApi
@@ -135,6 +141,10 @@
private ISharedConnectivityService mService;
private final Map<SharedConnectivityClientCallback, SharedConnectivityCallbackProxy>
mProxyMap = new HashMap<>();
+ private final Map<SharedConnectivityClientCallback, SharedConnectivityCallbackProxy>
+ mCallbackProxyCache = new HashMap<>();
+ // Used for testing
+ private final ServiceConnection mServiceConnection;
/**
* Creates a new instance of {@link SharedConnectivityManager}.
@@ -164,23 +174,58 @@
private SharedConnectivityManager(@NonNull Context context, String servicePackageName,
String serviceIntentAction) {
- ServiceConnection serviceConnection = new ServiceConnection() {
+ mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = ISharedConnectivityService.Stub.asInterface(service);
+ if (!mCallbackProxyCache.isEmpty()) {
+ synchronized (mCallbackProxyCache) {
+ mCallbackProxyCache.keySet().forEach(callback -> {
+ registerCallbackInternal(callback, mCallbackProxyCache.get(callback));
+ });
+ mCallbackProxyCache.clear();
+ }
+ }
}
@Override
public void onServiceDisconnected(ComponentName name) {
if (DEBUG) Log.i(TAG, "onServiceDisconnected");
mService = null;
- mProxyMap.clear();
+ if (!mCallbackProxyCache.isEmpty()) {
+ synchronized (mCallbackProxyCache) {
+ mCallbackProxyCache.keySet().forEach(
+ SharedConnectivityClientCallback::onServiceDisconnected);
+ mCallbackProxyCache.clear();
+ }
+ }
+ if (!mProxyMap.isEmpty()) {
+ synchronized (mProxyMap) {
+ mProxyMap.keySet().forEach(
+ SharedConnectivityClientCallback::onServiceDisconnected);
+ mProxyMap.clear();
+ }
+ }
}
};
context.bindService(
new Intent().setPackage(servicePackageName).setAction(serviceIntentAction),
- serviceConnection, Context.BIND_AUTO_CREATE);
+ mServiceConnection, Context.BIND_AUTO_CREATE);
+ }
+
+ private void registerCallbackInternal(SharedConnectivityClientCallback callback,
+ SharedConnectivityCallbackProxy proxy) {
+ try {
+ mService.registerCallback(proxy);
+ synchronized (mProxyMap) {
+ mProxyMap.put(callback, proxy);
+ }
+ callback.onServiceConnected();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Exception in registerCallback", e);
+ callback.onRegisterCallbackFailed(e);
+ }
}
/**
@@ -192,29 +237,45 @@
}
/**
+ * @hide
+ */
+ @TestApi
+ @Nullable
+ public ServiceConnection getServiceConnection() {
+ return mServiceConnection;
+ }
+
+ /**
* Registers a callback for receiving updates to the list of Tether Networks and Known Networks.
+ * The {@link SharedConnectivityClientCallback#onRegisterCallbackFailed} will be called if the
+ * registration failed.
*
* @param executor The Executor used to invoke the callback.
* @param callback The callback of type {@link SharedConnectivityClientCallback} that is invoked
* when the service updates either the list of Tether Networks or Known
* Networks.
- * @return Returns true if the registration was successful, false otherwise.
*/
- public boolean registerCallback(@NonNull @CallbackExecutor Executor executor,
+ public void registerCallback(@NonNull @CallbackExecutor Executor executor,
@NonNull SharedConnectivityClientCallback callback) {
Objects.requireNonNull(executor, "executor cannot be null");
Objects.requireNonNull(callback, "callback cannot be null");
- if (mService == null || mProxyMap.containsKey(callback)) return false;
- try {
- SharedConnectivityCallbackProxy proxy =
- new SharedConnectivityCallbackProxy(executor, callback);
- mService.registerCallback(proxy);
- mProxyMap.put(callback, proxy);
- } catch (RemoteException e) {
- Log.e(TAG, "Exception in registerCallback", e);
- return false;
+
+ if (mProxyMap.containsKey(callback) || mCallbackProxyCache.containsKey(callback)) {
+ Log.e(TAG, "Callback already registered");
+ callback.onRegisterCallbackFailed(new IllegalStateException(
+ "Callback already registered"));
+ return;
}
- return true;
+
+ SharedConnectivityCallbackProxy proxy =
+ new SharedConnectivityCallbackProxy(executor, callback);
+ if (mService == null) {
+ synchronized (mCallbackProxyCache) {
+ mCallbackProxyCache.put(callback, proxy);
+ }
+ return;
+ }
+ registerCallbackInternal(callback, proxy);
}
/**
@@ -225,10 +286,24 @@
public boolean unregisterCallback(
@NonNull SharedConnectivityClientCallback callback) {
Objects.requireNonNull(callback, "callback cannot be null");
- if (mService == null || !mProxyMap.containsKey(callback)) return false;
+
+ if (!mProxyMap.containsKey(callback) && !mCallbackProxyCache.containsKey(callback)) {
+ Log.e(TAG, "Callback not found, cannot unregister");
+ return false;
+ }
+
+ if (mService == null) {
+ synchronized (mCallbackProxyCache) {
+ mCallbackProxyCache.remove(callback);
+ }
+ return true;
+ }
+
try {
mService.unregisterCallback(mProxyMap.get(callback));
- mProxyMap.remove(callback);
+ synchronized (mProxyMap) {
+ mProxyMap.remove(callback);
+ }
} catch (RemoteException e) {
Log.e(TAG, "Exception in unregisterCallback", e);
return false;
@@ -246,7 +321,12 @@
* connection was successful.
*/
public boolean connectTetherNetwork(@NonNull TetherNetwork network) {
- if (mService == null) return false;
+ Objects.requireNonNull(network, "Tether network cannot be null");
+
+ if (mService == null) {
+ return false;
+ }
+
try {
mService.connectTetherNetwork(network);
} catch (RemoteException e) {
@@ -264,7 +344,10 @@
* disconnection was successful.
*/
public boolean disconnectTetherNetwork() {
- if (mService == null) return false;
+ if (mService == null) {
+ return false;
+ }
+
try {
mService.disconnectTetherNetwork();
} catch (RemoteException e) {
@@ -284,7 +367,12 @@
* connection was successful.
*/
public boolean connectKnownNetwork(@NonNull KnownNetwork network) {
- if (mService == null) return false;
+ Objects.requireNonNull(network, "Known network cannot be null");
+
+ if (mService == null) {
+ return false;
+ }
+
try {
mService.connectKnownNetwork(network);
} catch (RemoteException e) {
@@ -302,7 +390,12 @@
* forget action was successful.
*/
public boolean forgetKnownNetwork(@NonNull KnownNetwork network) {
- if (mService == null) return false;
+ Objects.requireNonNull(network, "Known network cannot be null");
+
+ if (mService == null) {
+ return false;
+ }
+
try {
mService.forgetKnownNetwork(network);
} catch (RemoteException e) {
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 784e9c4..815a012 100644
--- a/wifi/tests/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManagerTest.java
+++ b/wifi/tests/src/android/net/wifi/sharedconnectivity/app/SharedConnectivityManagerTest.java
@@ -23,17 +23,20 @@
import static android.net.wifi.sharedconnectivity.app.TetherNetwork.NETWORK_TYPE_CELLULAR;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.content.ComponentName;
import android.content.Context;
import android.content.res.Resources;
import android.net.wifi.sharedconnectivity.service.ISharedConnectivityService;
+import android.os.Parcel;
import android.os.RemoteException;
import androidx.test.filters.SmallTest;
@@ -63,12 +66,9 @@
private static final String SSID = "TEST_SSID";
private static final int[] SECURITY_TYPES = {SECURITY_TYPE_WEP};
- private static final int SERVICE_PACKAGE_ID = 1;
- private static final int SERVICE_CLASS_ID = 2;
-
private static final String SERVICE_PACKAGE_NAME = "TEST_PACKAGE";
- private static final String SERVICE_CLASS_NAME = "TEST_CLASS";
- private static final String PACKAGE_NAME = "TEST_PACKAGE";
+ private static final String SERVICE_INTENT_ACTION = "TEST_INTENT_ACTION";
+
@Mock Context mContext;
@Mock
@@ -77,6 +77,11 @@
@Mock
SharedConnectivityClientCallback mClientCallback;
@Mock Resources mResources;
+ @Mock
+ ISharedConnectivityService.Stub mIBinder;
+
+ private static final ComponentName COMPONENT_NAME =
+ new ComponentName("dummypkg", "dummycls");
@Before
public void setUp() {
@@ -88,155 +93,281 @@
* Verifies constructor is binding to service.
*/
@Test
- public void testBindingToService() {
+ public void bindingToService() {
SharedConnectivityManager.create(mContext);
verify(mContext).bindService(any(), any(), anyInt());
}
/**
- * Verifies callback is registered in the service only once and only when service is not null.
+ * Verifies create method returns null when resources are not specified
*/
@Test
- public void testRegisterCallback() throws Exception {
- SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
- manager.setService(null);
- assertFalse(manager.registerCallback(mExecutor, mClientCallback));
-
- manager = SharedConnectivityManager.create(mContext);
- manager.setService(mService);
- assertTrue(manager.registerCallback(mExecutor, mClientCallback));
- verify(mService).registerCallback(any());
-
- // Registering the same callback twice should fail.
- manager = SharedConnectivityManager.create(mContext);
- manager.setService(mService);
- manager.registerCallback(mExecutor, mClientCallback);
- assertFalse(manager.registerCallback(mExecutor, mClientCallback));
-
- manager = SharedConnectivityManager.create(mContext);
- manager.setService(mService);
- doThrow(new RemoteException()).when(mService).registerCallback(any());
- assertFalse(manager.registerCallback(mExecutor, mClientCallback));
+ public void resourcesNotDefined() {
+ when(mResources.getString(anyInt())).thenThrow(new Resources.NotFoundException());
+ assertNull(SharedConnectivityManager.create(mContext));
}
/**
- * Verifies callback is unregistered from the service if it was registered before and only when
- * service is not null.
+ * Verifies registerCallback behavior.
*/
@Test
- public void testUnregisterCallback() throws Exception {
+ public void registerCallback_serviceNotConnected_registrationCachedThenConnected()
+ 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());
+ }
+
+ @Test
+ 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));
+ }
+
+ @Test
+ 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));
+ }
+
+ @Test
+ 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));
+ }
+
+ @Test
+ public void registerCallback_remoteException_shouldFail() throws Exception {
+ 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));
+ }
+
+ /**
+ * Verifies unregisterCallback behavior.
+ */
+ @Test
+ public void unregisterCallback_withoutRegisteringFirst_serviceNotConnected_shouldFail() {
SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(null);
assertFalse(manager.unregisterCallback(mClientCallback));
+ }
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ public void unregisterCallback_withoutRegisteringFirst_serviceConnected_shouldFail() {
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+ manager.setService(mService);
+ assertFalse(manager.unregisterCallback(mClientCallback));
+ }
+
+ @Test
+ 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());
+ }
-
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ 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));
+ }
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ 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));
+ }
+
+ @Test
+ 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));
}
/**
- * Verifies service is called when not null and exceptions are handles when calling
- * connectTetherNetwork.
+ * Verifies callback is called when service is connected
*/
@Test
- public void testConnectTetherNetwork() throws RemoteException {
- TetherNetwork network = buildTetherNetwork();
+ 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();
+ }
+
+ /**
+ * Verifies callback is called when service is disconnected
+ */
+ @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();
+ }
+
+ /**
+ * Verifies connectTetherNetwork behavior.
+ */
+ @Test
+ public void connectTetherNetwork_serviceNotConnected_shouldFail() {
+ TetherNetwork network = buildTetherNetwork();
SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(null);
assertFalse(manager.connectTetherNetwork(network));
+ }
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ public void connectTetherNetwork() throws RemoteException {
+ TetherNetwork network = buildTetherNetwork();
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(mService);
manager.connectTetherNetwork(network);
verify(mService).connectTetherNetwork(network);
+ }
+ @Test
+ public void connectTetherNetwork_remoteException_shouldFail() throws RemoteException {
+ TetherNetwork network = buildTetherNetwork();
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+ manager.setService(mService);
doThrow(new RemoteException()).when(mService).connectTetherNetwork(network);
assertFalse(manager.connectTetherNetwork(network));
}
/**
- * Verifies service is called when not null and exceptions are handles when calling
- * disconnectTetherNetwork.
+ * Verifies disconnectTetherNetwork behavior.
*/
@Test
- public void testDisconnectTetherNetwork() throws RemoteException {
+ public void disconnectTetherNetwork_serviceNotConnected_shouldFail() {
SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(null);
assertFalse(manager.disconnectTetherNetwork());
+ }
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ public void disconnectTetherNetwork() throws RemoteException {
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(mService);
manager.disconnectTetherNetwork();
verify(mService).disconnectTetherNetwork();
+ }
+ @Test
+ public void disconnectTetherNetwork_remoteException_shouldFail() throws RemoteException {
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+ manager.setService(mService);
doThrow(new RemoteException()).when(mService).disconnectTetherNetwork();
assertFalse(manager.disconnectTetherNetwork());
}
/**
- * Verifies service is called when not null and exceptions are handles when calling
- * connectKnownNetwork.
+ * Verifies connectKnownNetwork behavior.
*/
@Test
- public void testConnectKnownNetwork() throws RemoteException {
+ public void connectKnownNetwork_serviceNotConnected_shouldFail() throws RemoteException {
KnownNetwork network = buildKnownNetwork();
-
SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(null);
assertFalse(manager.connectKnownNetwork(network));
+ }
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ public void connectKnownNetwork() throws RemoteException {
+ KnownNetwork network = buildKnownNetwork();
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(mService);
manager.connectKnownNetwork(network);
verify(mService).connectKnownNetwork(network);
+ }
+ @Test
+ public void connectKnownNetwork_remoteException_shouldFail() throws RemoteException {
+ KnownNetwork network = buildKnownNetwork();
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+ manager.setService(mService);
doThrow(new RemoteException()).when(mService).connectKnownNetwork(network);
assertFalse(manager.connectKnownNetwork(network));
}
/**
- * Verifies service is called when not null and exceptions are handles when calling
- * forgetKnownNetwork.
+ * Verifies forgetKnownNetwork behavior.
*/
@Test
- public void testForgetKnownNetwork() throws RemoteException {
+ public void forgetKnownNetwork_serviceNotConnected_shouldFail() {
KnownNetwork network = buildKnownNetwork();
-
SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(null);
assertFalse(manager.forgetKnownNetwork(network));
+ }
- manager = SharedConnectivityManager.create(mContext);
+ @Test
+ public void forgetKnownNetwork_serviceConnected() throws RemoteException {
+ KnownNetwork network = buildKnownNetwork();
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
manager.setService(mService);
manager.forgetKnownNetwork(network);
verify(mService).forgetKnownNetwork(network);
+ }
+ @Test
+ public void forgetKnownNetwork_remoteException_shouldFail() throws RemoteException {
+ KnownNetwork network = buildKnownNetwork();
+ SharedConnectivityManager manager = SharedConnectivityManager.create(mContext);
+ manager.setService(mService);
doThrow(new RemoteException()).when(mService).forgetKnownNetwork(network);
assertFalse(manager.forgetKnownNetwork(network));
}
private void setResources(@Mock Context context) {
when(context.getResources()).thenReturn(mResources);
- when(context.getPackageName()).thenReturn(PACKAGE_NAME);
- when(mResources.getIdentifier(anyString(), anyString(), anyString()))
- .thenReturn(SERVICE_PACKAGE_ID, SERVICE_CLASS_ID);
- when(mResources.getString(SERVICE_PACKAGE_ID)).thenReturn(SERVICE_PACKAGE_NAME);
- when(mResources.getString(SERVICE_CLASS_ID)).thenReturn(SERVICE_CLASS_NAME);
+ when(mResources.getString(anyInt()))
+ .thenReturn(SERVICE_PACKAGE_NAME, SERVICE_INTENT_ACTION);
}
private TetherNetwork buildTetherNetwork() {