public static HttpClient createHttpClient(@NonNull Context context) { HttpClient httpClient = new DefaultHttpClient(); NetworkStateHelper networkStateHelper = NetworkStateHelper.getSharedInstance(context); httpClient = new HttpClientNetworkStateHandler(httpClient, networkStateHelper); /* Retryer should be applied last to avoid retries in offline. */ return new HttpClientRetryer(httpClient); } }
@Test public void permissionDenied() { when(mConnectivityManager.getActiveNetworkInfo()).thenThrow(new SecurityException()); NetworkStateHelper helper = new NetworkStateHelper(mContext); assertFalse(helper.isNetworkConnected()); }
/** * Init. * * @param decoratedApi decorated API. * @param networkStateHelper network state helper. */ public HttpClientNetworkStateHandler(HttpClient decoratedApi, NetworkStateHelper networkStateHelper) { super(decoratedApi); mNetworkStateHelper = networkStateHelper; mNetworkStateHelper.addListener(this); }
/** * Handle network state update on API level < 21. */ private synchronized void handleNetworkStateUpdate() { /* * This code is used to notify listeners only when the network state goes from * connected to disconnected and vice versa * (without duplicate calls, the sequence will be consistent). */ String previousNetworkType = mNetworkType; updateNetworkType(); boolean networkTypeChanged = previousNetworkType == null ? mNetworkType != null : !previousNetworkType.equals(mNetworkType); if (networkTypeChanged) { boolean connected = isNetworkConnected(); if (connected && previousNetworkType != null) { notifyNetworkStateUpdated(false); } notifyNetworkStateUpdated(connected); } }
@Test @SuppressWarnings("deprecation") public void listenNetwork() { NetworkStateHelper helper = new NetworkStateHelper(mContext); ArgumentCaptor<ConnectivityManager.NetworkCallback> callback = ArgumentCaptor.forClass(ConnectivityManager.NetworkCallback.class); verify(mConnectivityManager).registerNetworkCallback(any(NetworkRequest.class), callback.capture()); NetworkStateHelper.Listener listener = mock(NetworkStateHelper.Listener.class); helper.addListener(listener); verify(listener).onNetworkStateUpdated(true); verify(listener, never()).onNetworkStateUpdated(false); assertTrue(helper.isNetworkConnected()); helper.removeListener(listener); NetworkStateHelper.Listener listener2 = mock(NetworkStateHelper.Listener.class); helper.addListener(listener2); callback.getValue().onLost(network); network = mock(Network.class); verify(listener2).onNetworkStateUpdated(false); verify(listener2).onNetworkStateUpdated(true); assertTrue(helper.isNetworkConnected()); helper.removeListener(listener2); NetworkStateHelper.Listener listener3 = mock(NetworkStateHelper.Listener.class); helper.addListener(listener3); Network network2 = mock(Network.class); callback.getValue().onAvailable(network2); assertTrue(helper.isNetworkConnected());
if (!NetworkStateHelper.getSharedInstance(activity).isNetworkConnected()) { AppCenterLog.info(LOG_TAG, "Postpone enabling in app updates via browser as network is disconnected."); Distribute.getInstance().completeWorkflow();
@Override public synchronized ServiceCall callAsync(String url, String method, Map<String, String> headers, CallTemplate callTemplate, ServiceCallback serviceCallback) { Call call = new Call(mDecoratedApi, url, method, headers, callTemplate, serviceCallback); if (mNetworkStateHelper.isNetworkConnected()) { call.run(); } else { mCalls.add(call); AppCenterLog.debug(LOG_TAG, "Call triggered with no network connectivity, waiting network to become available..."); } return call; }
NetworkStateHelper.getSharedInstance(mApplication).reopen(); } else if (switchToDisabled) { mUncaughtExceptionHandler.unregister(); NetworkStateHelper.getSharedInstance(mApplication).close();
when(networkStateHelper.isNetworkConnected()).thenReturn(true); verify(networkStateHelper).addListener(any(NetworkStateHelper.Listener.class)); decorator.callAsync(url, METHOD_GET, headers, callTemplate, callback); verify(httpClient).callAsync(eq(url), eq(METHOD_GET), eq(headers), eq(callTemplate), any(ServiceCallback.class)); verify(networkStateHelper).removeListener(any(NetworkStateHelper.Listener.class)); verify(networkStateHelper, times(2)).addListener(any(NetworkStateHelper.Listener.class));
NetworkStateHelper.getSharedInstance(mApplication).close();
@Test public void disablePersisted() { when(SharedPreferencesManager.getBoolean(KEY_ENABLED, true)).thenReturn(false); when(SharedPreferencesManager.getBoolean(AnotherDummyService.getInstance().getEnabledPreferenceKey(), true)).thenReturn(false); AppCenter.start(mApplication, DUMMY_APP_SECRET, DummyService.class, AnotherDummyService.class); AppCenter appCenter = AppCenter.getInstance(); /* Verify services are disabled by default if App Center is disabled. */ assertFalse(AppCenter.isEnabled().get()); for (AppCenterService service : appCenter.getServices()) { assertFalse(service.isInstanceEnabled()); verify((AbstractAppCenterService) service).applyEnabledState(eq(false)); verify((AbstractAppCenterService) service, never()).applyEnabledState(eq(true)); verify(mApplication).registerActivityLifecycleCallbacks(service); } verify(mNetworkStateHelper).close(); /* Verify we can enable back. */ AppCenter.setEnabled(true); assertTrue(AppCenter.isEnabled().get()); for (AppCenterService service : appCenter.getServices()) { assertTrue(service.isInstanceEnabled()); verify((AbstractAppCenterService) service).applyEnabledState(eq(true)); } verify(mNetworkStateHelper).reopen(); }
/** * Get shared instance. * * @param context any context. * @return shared instance. */ public static synchronized NetworkStateHelper getSharedInstance(Context context) { if (sSharedInstance == null) { sSharedInstance = new NetworkStateHelper(context); } return sSharedInstance; }
@Override public synchronized void close() throws IOException { mNetworkStateHelper.removeListener(this); mCalls.clear(); super.close(); }
/** * Init. * * @param context any Android context. */ @VisibleForTesting NetworkStateHelper(Context context) { mContext = context.getApplicationContext(); mConnectivityManager = (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE); reopen(); }
NetworkStateHelper helper = new NetworkStateHelper(mContext); verify(mContext).registerReceiver(any(BroadcastReceiver.class), any(IntentFilter.class)); NetworkStateHelper.Listener listener = mock(NetworkStateHelper.Listener.class); helper.addListener(listener); verify(listener).onNetworkStateUpdated(true); verify(listener, never()).onNetworkStateUpdated(false); assertTrue(helper.isNetworkConnected()); helper.removeListener(listener); NetworkStateHelper.Listener listener2 = mock(NetworkStateHelper.Listener.class); helper.addListener(listener2); when(networkInfo.getTypeName()).thenReturn("WIFI"); when(networkInfo.getSubtypeName()).thenReturn(null); verify(listener2).onNetworkStateUpdated(false); verify(listener2).onNetworkStateUpdated(true); assertTrue(helper.isNetworkConnected()); helper.removeListener(listener2); NetworkStateHelper.Listener listener3 = mock(NetworkStateHelper.Listener.class); helper.addListener(listener3); when(networkInfo.isConnected()).thenReturn(false); receiver.onReceive(mContext, intent); verify(listener3).onNetworkStateUpdated(false); assertFalse(helper.isNetworkConnected()); helper.removeListener(listener3); when(networkInfo.isConnected()).thenReturn(true);
NetworkStateHelper.getSharedInstance(mContext).isNetworkConnected() && downloadState == DOWNLOAD_STATE_AVAILABLE) { cancelPreviousTasks();
when(networkStateHelper.isNetworkConnected()).thenReturn(true);
verify(anotherDummyService, never()).setInstanceEnabled(anyBoolean()); verify(mChannel, times(2)).setEnabled(true); verify(mNetworkStateHelper, never()).close(); verify(mNetworkStateHelper, never()).reopen(); verify(anotherDummyService).setInstanceEnabled(false); verify(mChannel).setEnabled(false); verify(mNetworkStateHelper).close(); verify(mNetworkStateHelper, never()).reopen(); verify(mApplication, times(1)).registerActivityLifecycleCallbacks(anotherDummyService); verify(mChannel, times(3)).setEnabled(true); verify(mNetworkStateHelper).reopen(); verify(anotherDummyService).setInstanceEnabled(true); verify(mChannel, times(4)).setEnabled(true); verify(mNetworkStateHelper, times(1)).reopen(); assertFalse(AppCenter.isEnabled().get()); verify(mChannel, times(2)).setEnabled(false); verify(mNetworkStateHelper, times(2)).close(); verify(mNetworkStateHelper, times(2)).close();
@Test public void verifyRequestedCapabilitiesBeforeAndroidM() throws Exception { NetworkRequest.Builder builder = mock(NetworkRequest.Builder.class); whenNew(NetworkRequest.Builder.class).withAnyArguments().thenReturn(builder); new NetworkStateHelper(mContext); verify(builder).addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); verify(builder, never()).addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED); }
@Test public void nullNetworkInfo() { NetworkStateHelper helper = new NetworkStateHelper(mContext); assertFalse(helper.isNetworkConnected()); }