1 /*
2  * Copyright (C) 2015 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.systemui.statusbar.connectivity;
18 
19 import static android.telephony.AccessNetworkConstants.TRANSPORT_TYPE_WWAN;
20 import static android.telephony.NetworkRegistrationInfo.DOMAIN_PS;
21 
22 import static junit.framework.Assert.assertEquals;
23 import static junit.framework.Assert.assertNotNull;
24 import static junit.framework.Assert.assertTrue;
25 
26 import static org.mockito.ArgumentMatchers.any;
27 import static org.mockito.Matchers.anyInt;
28 import static org.mockito.Matchers.eq;
29 import static org.mockito.Matchers.isA;
30 import static org.mockito.Mockito.atLeastOnce;
31 import static org.mockito.Mockito.doAnswer;
32 import static org.mockito.Mockito.doReturn;
33 import static org.mockito.Mockito.mock;
34 import static org.mockito.Mockito.verify;
35 import static org.mockito.Mockito.when;
36 
37 import android.app.Instrumentation;
38 import android.net.ConnectivityManager;
39 import android.net.Network;
40 import android.net.NetworkCapabilities;
41 import android.net.NetworkRequest;
42 import android.net.NetworkScoreManager;
43 import android.net.vcn.VcnTransportInfo;
44 import android.net.wifi.WifiInfo;
45 import android.net.wifi.WifiManager;
46 import android.os.Handler;
47 import android.provider.Settings;
48 import android.provider.Settings.Global;
49 import android.telephony.CellSignalStrength;
50 import android.telephony.NetworkRegistrationInfo;
51 import android.telephony.ServiceState;
52 import android.telephony.SignalStrength;
53 import android.telephony.SubscriptionInfo;
54 import android.telephony.SubscriptionManager;
55 import android.telephony.TelephonyDisplayInfo;
56 import android.telephony.TelephonyManager;
57 import android.testing.TestableLooper;
58 import android.testing.TestableResources;
59 import android.util.Log;
60 
61 import androidx.test.InstrumentationRegistry;
62 
63 import com.android.dx.mockito.inline.extended.ExtendedMockito;
64 import com.android.settingslib.R;
65 import com.android.settingslib.graph.SignalDrawable;
66 import com.android.settingslib.mobile.MobileMappings.Config;
67 import com.android.settingslib.mobile.MobileStatusTracker.SubscriptionDefaults;
68 import com.android.settingslib.mobile.TelephonyIcons;
69 import com.android.settingslib.net.DataUsageController;
70 import com.android.systemui.SysuiTestCase;
71 import com.android.systemui.broadcast.BroadcastDispatcher;
72 import com.android.systemui.demomode.DemoModeController;
73 import com.android.systemui.dump.DumpManager;
74 import com.android.systemui.flags.FeatureFlags;
75 import com.android.systemui.statusbar.policy.DeviceProvisionedController;
76 import com.android.systemui.statusbar.policy.DeviceProvisionedController.DeviceProvisionedListener;
77 import com.android.systemui.telephony.TelephonyListenerManager;
78 import com.android.systemui.util.CarrierConfigTracker;
79 import com.android.systemui.util.concurrency.FakeExecutor;
80 import com.android.systemui.util.time.FakeSystemClock;
81 
82 import org.junit.After;
83 import org.junit.Before;
84 import org.junit.Rule;
85 import org.junit.rules.TestWatcher;
86 import org.junit.runner.Description;
87 import org.mockito.ArgumentCaptor;
88 import org.mockito.Mockito;
89 import org.mockito.MockitoSession;
90 import org.mockito.quality.Strictness;
91 
92 import java.io.PrintWriter;
93 import java.io.StringWriter;
94 import java.util.ArrayList;
95 import java.util.List;
96 
97 public class NetworkControllerBaseTest extends SysuiTestCase {
98     private static final String TAG = "NetworkControllerBaseTest";
99     protected static final int DEFAULT_LEVEL = 2;
100     protected static final int DEFAULT_SIGNAL_STRENGTH = DEFAULT_LEVEL;
101     protected static final int DEFAULT_QS_SIGNAL_STRENGTH = DEFAULT_LEVEL;
102     protected static final int DEFAULT_ICON = TelephonyIcons.ICON_3G;
103     protected static final int DEFAULT_QS_ICON = TelephonyIcons.ICON_3G;
104     protected static final String NO_DATA_STRING = "Data disabled";
105     protected static final String NOT_DEFAULT_DATA_STRING = "Not default data";
106 
107     protected NetworkControllerImpl mNetworkController;
108     protected MobileSignalController mMobileSignalController;
109     protected SignalStrength mSignalStrength;
110     protected ServiceState mServiceState;
111     protected TelephonyDisplayInfo mTelephonyDisplayInfo;
112     protected NetworkRegistrationInfo mFakeRegInfo;
113     protected ConnectivityManager mMockCm;
114     protected WifiManager mMockWm;
115     protected NetworkScoreManager mMockNsm;
116     protected SubscriptionManager mMockSm;
117     protected TelephonyManager mMockTm;
118     protected TelephonyListenerManager mTelephonyListenerManager;
119     protected BroadcastDispatcher mMockBd;
120     protected Config mConfig;
121     protected CallbackHandler mCallbackHandler;
122     protected SubscriptionDefaults mMockSubDefaults;
123     protected DeviceProvisionedController mMockProvisionController;
124     protected DeviceProvisionedListener mUserCallback;
125     protected Instrumentation mInstrumentation;
126     protected DemoModeController mDemoModeController;
127     protected CarrierConfigTracker mCarrierConfigTracker;
128     protected FakeExecutor mFakeExecutor = new FakeExecutor(new FakeSystemClock());
129     protected FeatureFlags mFeatureFlags;
130 
131     protected int mSubId;
132 
133     private NetworkCapabilities mNetCapabilities;
134     private ConnectivityManager.NetworkCallback mDefaultCallbackInWifiTracker;
135     private ConnectivityManager.NetworkCallback mDefaultCallbackInNetworkController;
136     private ConnectivityManager.NetworkCallback mNetworkCallback;
137 
138     MockitoSession mMockingSession = null;
139 
140     @Rule
141     public TestWatcher failWatcher = new TestWatcher() {
142         @Override
143         protected void failed(Throwable e, Description description) {
144             if (mNetworkController == null) {
145                 Log.d(TAG, "mNetworkController = null!");
146                 return;
147             }
148             // Print out mNetworkController state if the test fails.
149             StringWriter sw = new StringWriter();
150             PrintWriter pw = new PrintWriter(sw);
151             mNetworkController.dump(null, pw, null);
152             pw.flush();
153             Log.d(TAG, sw.toString());
154         }
155     };
156 
157     @Before
setUp()158     public void setUp() throws Exception {
159         mMockingSession = ExtendedMockito.mockitoSession().strictness(Strictness.LENIENT)
160                 .mockStatic(FeatureFlags.class).startMocking();
161         ExtendedMockito.doReturn(true).when(() ->
162                 FeatureFlags.isProviderModelSettingEnabled(mContext));
163         mFeatureFlags = mock(FeatureFlags.class);
164         when(mFeatureFlags.isCombinedStatusBarSignalIconsEnabled()).thenReturn(false);
165         when(mFeatureFlags.isProviderModelSettingEnabled()).thenReturn(true);
166 
167 
168         mInstrumentation = InstrumentationRegistry.getInstrumentation();
169         Settings.Global.putInt(mContext.getContentResolver(), Global.AIRPLANE_MODE_ON, 0);
170         TestableResources res = mContext.getOrCreateTestableResources();
171         res.addOverride(R.string.cell_data_off_content_description, NO_DATA_STRING);
172         res.addOverride(R.string.not_default_data_content_description, NOT_DEFAULT_DATA_STRING);
173 
174         mDemoModeController = mock(DemoModeController.class);
175         mMockWm = mock(WifiManager.class);
176         mMockTm = mock(TelephonyManager.class);
177         mTelephonyListenerManager = mock(TelephonyListenerManager.class);
178         mMockSm = mock(SubscriptionManager.class);
179         mMockCm = mock(ConnectivityManager.class);
180         mMockBd = mock(BroadcastDispatcher.class);
181         mMockNsm = mock(NetworkScoreManager.class);
182         mMockSubDefaults = mock(SubscriptionDefaults.class);
183         mCarrierConfigTracker = mock(CarrierConfigTracker.class);
184         mNetCapabilities = new NetworkCapabilities();
185         when(mMockTm.isDataCapable()).thenReturn(true);
186         when(mMockTm.createForSubscriptionId(anyInt())).thenReturn(mMockTm);
187         doAnswer(invocation -> {
188             int rssi = invocation.getArgument(0);
189             if (rssi < -88) return 0;
190             if (rssi < -77) return 1;
191             if (rssi < -66) return 2;
192             if (rssi < -55) return 3;
193             return 4;
194         }).when(mMockWm).calculateSignalLevel(anyInt());
195         when(mMockWm.getMaxSignalLevel()).thenReturn(4);
196 
197         mSignalStrength = mock(SignalStrength.class);
198         mServiceState = mock(ServiceState.class);
199         mTelephonyDisplayInfo = mock(TelephonyDisplayInfo.class);
200 
201         mFakeRegInfo = new NetworkRegistrationInfo.Builder()
202                 .setTransportType(TRANSPORT_TYPE_WWAN)
203                 .setDomain(DOMAIN_PS)
204                 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_LTE)
205                 .build();
206         doReturn(mFakeRegInfo).when(mServiceState)
207                 .getNetworkRegistrationInfo(DOMAIN_PS, TRANSPORT_TYPE_WWAN);
208         doReturn(TelephonyManager.NETWORK_TYPE_LTE).when(mTelephonyDisplayInfo).getNetworkType();
209         doReturn(TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE).when(mTelephonyDisplayInfo)
210                 .getOverrideNetworkType();
211         mConfig = new Config();
212         mConfig.hspaDataDistinguishable = true;
213         mCallbackHandler = mock(CallbackHandler.class);
214 
215         mMockProvisionController = mock(DeviceProvisionedController.class);
216         when(mMockProvisionController.isCurrentUserSetup()).thenReturn(true);
217         doAnswer(invocation -> {
218             mUserCallback = (DeviceProvisionedListener) invocation.getArguments()[0];
219             TestableLooper.get(this).processAllMessages();
220             return null;
221         }).when(mMockProvisionController).addCallback(any());
222 
223         mNetworkController = new NetworkControllerImpl(mContext,
224                 mMockCm,
225                 mMockTm,
226                 mTelephonyListenerManager,
227                 mMockWm,
228                 mMockNsm,
229                 mMockSm,
230                 mConfig,
231                 TestableLooper.get(this).getLooper(),
232                 mFakeExecutor,
233                 mCallbackHandler,
234                 mock(AccessPointControllerImpl.class),
235                 mock(DataUsageController.class),
236                 mMockSubDefaults,
237                 mMockProvisionController,
238                 mMockBd,
239                 mDemoModeController,
240                 mCarrierConfigTracker,
241                 mFeatureFlags,
242                 mock(DumpManager.class)
243         );
244         setupNetworkController();
245 
246         // Trigger blank callbacks to always get the current state (some tests don't trigger
247         // changes from default state).
248         mNetworkController.addCallback(mock(SignalCallback.class));
249         mNetworkController.addEmergencyListener(null);
250     }
251 
252     @After
tearDown()253     public void tearDown() throws Exception {
254         if (mMockingSession != null) {
255             mMockingSession.finishMocking();
256         }
257     }
258 
setupNetworkController()259     protected void setupNetworkController() {
260         // For now just pretend to be the data sim, so we can test that too.
261         mSubId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
262         when(mMockTm.isDataConnectionAllowed()).thenReturn(true);
263         setDefaultSubId(mSubId);
264         setSubscriptions(mSubId);
265         mMobileSignalController = mNetworkController.mMobileSignalControllers.get(mSubId);
266         ArgumentCaptor<ConnectivityManager.NetworkCallback> callbackArg =
267                 ArgumentCaptor.forClass(ConnectivityManager.NetworkCallback.class);
268         verify(mMockCm, atLeastOnce())
269             .registerDefaultNetworkCallback(callbackArg.capture(), isA(Handler.class));
270         int captureSize = callbackArg.getAllValues().size();
271         assertTrue(captureSize > 1);
272         assertEquals(captureSize % 2, 0);
273         mDefaultCallbackInWifiTracker = callbackArg.getAllValues().get(captureSize - 2);
274         mDefaultCallbackInNetworkController = callbackArg.getAllValues().get(captureSize - 1);
275         assertNotNull(mDefaultCallbackInWifiTracker);
276         assertNotNull(mDefaultCallbackInNetworkController);
277         verify(mMockCm, atLeastOnce()).registerNetworkCallback(
278                 isA(NetworkRequest.class), callbackArg.capture(), isA(Handler.class));
279         mNetworkCallback = callbackArg.getValue();
280         assertNotNull(mNetworkCallback);
281     }
282 
setDefaultSubId(int subId)283     protected void setDefaultSubId(int subId) {
284         when(mMockSubDefaults.getDefaultDataSubId()).thenReturn(subId);
285         when(mMockSubDefaults.getDefaultVoiceSubId()).thenReturn(subId);
286         when(mMockSubDefaults.getActiveDataSubId()).thenReturn(subId);
287     }
288 
setSubscriptions(int... subIds)289     protected void setSubscriptions(int... subIds) {
290         List<SubscriptionInfo> subs = new ArrayList<SubscriptionInfo>();
291         for (int subId : subIds) {
292             SubscriptionInfo subscription = mock(SubscriptionInfo.class);
293             when(subscription.getSubscriptionId()).thenReturn(subId);
294             subs.add(subscription);
295         }
296         when(mMockSm.getActiveSubscriptionInfoList()).thenReturn(subs);
297         when(mMockSm.getCompleteActiveSubscriptionInfoList()).thenReturn(subs);
298         mNetworkController.doUpdateMobileControllers();
299     }
300 
setUpNoMobileData()301     protected NetworkControllerImpl setUpNoMobileData() {
302         when(mMockTm.isDataCapable()).thenReturn(false);
303         NetworkControllerImpl networkControllerNoMobile =
304                 new NetworkControllerImpl(mContext, mMockCm, mMockTm, mTelephonyListenerManager,
305                         mMockWm, mMockNsm, mMockSm,
306                         mConfig, TestableLooper.get(this).getLooper(), mFakeExecutor,
307                         mCallbackHandler,
308                         mock(AccessPointControllerImpl.class),
309                         mock(DataUsageController.class), mMockSubDefaults,
310                         mock(DeviceProvisionedController.class), mMockBd, mDemoModeController,
311                         mCarrierConfigTracker, mFeatureFlags,
312                         mock(DumpManager.class));
313 
314         setupNetworkController();
315 
316         return networkControllerNoMobile;
317     }
318 
319     // 2 Bars 3G GSM.
setupDefaultSignal()320     public void setupDefaultSignal() {
321         setIsGsm(true);
322         setVoiceRegState(ServiceState.STATE_IN_SERVICE);
323         setGsmRoaming(false);
324         setLevel(DEFAULT_LEVEL);
325         updateDataConnectionState(TelephonyManager.DATA_CONNECTED,
326                 TelephonyManager.NETWORK_TYPE_UMTS);
327         setConnectivityViaCallbackInNetworkController(
328                 NetworkCapabilities.TRANSPORT_CELLULAR, true, true, null);
329     }
330 
setConnectivityViaCallbackInNetworkControllerForVcn( int networkType, boolean validated, boolean isConnected, VcnTransportInfo info)331     public void setConnectivityViaCallbackInNetworkControllerForVcn(
332             int networkType, boolean validated, boolean isConnected, VcnTransportInfo info) {
333         final NetworkCapabilities.Builder builder =
334                 new NetworkCapabilities.Builder(mNetCapabilities);
335         builder.setTransportInfo(info);
336         setConnectivityCommon(builder, networkType, validated, isConnected);
337         mDefaultCallbackInNetworkController.onCapabilitiesChanged(
338                 mock(Network.class), builder.build());
339     }
340 
setConnectivityViaCallbackInNetworkController( int networkType, boolean validated, boolean isConnected, WifiInfo wifiInfo)341     public void setConnectivityViaCallbackInNetworkController(
342             int networkType, boolean validated, boolean isConnected, WifiInfo wifiInfo) {
343         final NetworkCapabilities.Builder builder =
344                 new NetworkCapabilities.Builder(mNetCapabilities);
345         if (networkType == NetworkCapabilities.TRANSPORT_WIFI) {
346             builder.setTransportInfo(wifiInfo);
347         }
348         setConnectivityCommon(builder, networkType, validated, isConnected);
349         mDefaultCallbackInNetworkController.onCapabilitiesChanged(
350                 mock(Network.class), builder.build());
351     }
352 
setConnectivityViaCallbackInWifiTracker( int networkType, boolean validated, boolean isConnected, WifiInfo wifiInfo)353     public void setConnectivityViaCallbackInWifiTracker(
354             int networkType, boolean validated, boolean isConnected, WifiInfo wifiInfo) {
355         final NetworkCapabilities.Builder builder =
356                 new NetworkCapabilities.Builder(mNetCapabilities);
357         if (networkType == NetworkCapabilities.TRANSPORT_WIFI) {
358             builder.setTransportInfo(wifiInfo);
359         }
360         setConnectivityCommon(builder, networkType, validated, isConnected);
361         if (networkType == NetworkCapabilities.TRANSPORT_WIFI) {
362             if (isConnected) {
363                 final NetworkCapabilities newCap = builder.build();
364                 mNetworkCallback.onAvailable(mock(Network.class));
365                 mNetworkCallback.onCapabilitiesChanged(mock(Network.class), newCap);
366             } else {
367                 mNetworkCallback.onLost(mock(Network.class));
368             }
369         }
370     }
371 
setConnectivityViaCallbackInWifiTrackerForVcn( int networkType, boolean validated, boolean isConnected, VcnTransportInfo info)372     public void setConnectivityViaCallbackInWifiTrackerForVcn(
373             int networkType, boolean validated, boolean isConnected, VcnTransportInfo info) {
374         final NetworkCapabilities.Builder builder =
375                 new NetworkCapabilities.Builder(mNetCapabilities);
376         builder.setTransportInfo(info);
377         setConnectivityCommon(builder, networkType, validated, isConnected);
378         if (networkType == NetworkCapabilities.TRANSPORT_CELLULAR) {
379             if (isConnected) {
380                 final NetworkCapabilities newCap = builder.build();
381                 mNetworkCallback.onAvailable(mock(Network.class));
382                 mNetworkCallback.onCapabilitiesChanged(mock(Network.class), newCap);
383                 mDefaultCallbackInWifiTracker.onCapabilitiesChanged(mock(Network.class), newCap);
384             } else {
385                 mNetworkCallback.onLost(mock(Network.class));
386             }
387         }
388     }
389 
setConnectivityViaDefaultCallbackInWifiTracker( int networkType, boolean validated, boolean isConnected, WifiInfo wifiInfo)390     public void setConnectivityViaDefaultCallbackInWifiTracker(
391             int networkType, boolean validated, boolean isConnected, WifiInfo wifiInfo) {
392         final NetworkCapabilities.Builder builder =
393                 new NetworkCapabilities.Builder(mNetCapabilities);
394         if (networkType == NetworkCapabilities.TRANSPORT_WIFI) {
395             builder.setTransportInfo(wifiInfo);
396         }
397         setConnectivityCommon(builder, networkType, validated, isConnected);
398         mDefaultCallbackInWifiTracker.onCapabilitiesChanged(
399                 mock(Network.class), builder.build());
400     }
401 
setConnectivityCommon(NetworkCapabilities.Builder builder, int networkType, boolean validated, boolean isConnected)402     private static void setConnectivityCommon(NetworkCapabilities.Builder builder,
403             int networkType, boolean validated, boolean isConnected) {
404         // TODO: Separate out into several NetworkCapabilities.
405         if (isConnected) {
406             builder.addTransportType(networkType);
407         } else {
408             builder.removeTransportType(networkType);
409         }
410         if (validated) {
411             builder.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
412         } else {
413             builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
414         }
415     }
416 
setGsmRoaming(boolean isRoaming)417     public void setGsmRoaming(boolean isRoaming) {
418         when(mServiceState.getRoaming()).thenReturn(isRoaming);
419         updateServiceState();
420     }
421 
setCdmaRoaming(boolean isRoaming)422     public void setCdmaRoaming(boolean isRoaming) {
423         when(mMockTm.getCdmaEnhancedRoamingIndicatorDisplayNumber()).thenReturn(
424                 isRoaming ? TelephonyManager.ERI_ON : TelephonyManager.ERI_OFF);
425     }
426 
setVoiceRegState(int voiceRegState)427     public void setVoiceRegState(int voiceRegState) {
428         when(mServiceState.getState()).thenReturn(voiceRegState);
429         updateServiceState();
430     }
431 
setDataRegState(int dataRegState)432     public void setDataRegState(int dataRegState) {
433         when(mServiceState.getDataRegistrationState()).thenReturn(dataRegState);
434         updateServiceState();
435     }
436 
setIsEmergencyOnly(boolean isEmergency)437     public void setIsEmergencyOnly(boolean isEmergency) {
438         when(mServiceState.isEmergencyOnly()).thenReturn(isEmergency);
439         updateServiceState();
440     }
441 
setCdmaLevel(int level)442     public void setCdmaLevel(int level) {
443         when(mSignalStrength.getCdmaLevel()).thenReturn(level);
444         updateSignalStrength();
445     }
446 
setLevel(int level)447     public void setLevel(int level) {
448         when(mSignalStrength.getLevel()).thenReturn(level);
449         updateSignalStrength();
450     }
451 
setImsType(int imsType)452     public void setImsType(int imsType) {
453         mMobileSignalController.setImsType(imsType);
454     }
455 
setIsGsm(boolean gsm)456     public void setIsGsm(boolean gsm) {
457         when(mSignalStrength.isGsm()).thenReturn(gsm);
458         updateSignalStrength();
459     }
460 
setCdmaEri(int index, int mode)461     public void setCdmaEri(int index, int mode) {
462         // TODO: Figure this out.
463     }
464 
updateSignalStrength()465     private void updateSignalStrength() {
466         Log.d(TAG, "Sending Signal Strength: " + mSignalStrength);
467         mMobileSignalController.mMobileStatusTracker.getTelephonyCallback()
468                 .onSignalStrengthsChanged(mSignalStrength);
469     }
470 
updateServiceState()471     protected void updateServiceState() {
472         Log.d(TAG, "Sending Service State: " + mServiceState);
473         mMobileSignalController.mMobileStatusTracker.getTelephonyCallback()
474                 .onServiceStateChanged(mServiceState);
475         mMobileSignalController.mMobileStatusTracker.getTelephonyCallback()
476                 .onDisplayInfoChanged(mTelephonyDisplayInfo);
477     }
478 
updateDataConnectionState(int dataState, int dataNetType)479     public void updateDataConnectionState(int dataState, int dataNetType) {
480         NetworkRegistrationInfo fakeRegInfo = new NetworkRegistrationInfo.Builder()
481                 .setTransportType(TRANSPORT_TYPE_WWAN)
482                 .setDomain(DOMAIN_PS)
483                 .setAccessNetworkTechnology(dataNetType)
484                 .build();
485         when(mServiceState.getNetworkRegistrationInfo(DOMAIN_PS, TRANSPORT_TYPE_WWAN))
486                 .thenReturn(fakeRegInfo);
487         when(mTelephonyDisplayInfo.getNetworkType()).thenReturn(dataNetType);
488         mMobileSignalController.mMobileStatusTracker.getTelephonyCallback()
489                 .onDataConnectionStateChanged(dataState, dataNetType);
490     }
491 
updateDataActivity(int dataActivity)492     public void updateDataActivity(int dataActivity) {
493         mMobileSignalController.mMobileStatusTracker.getTelephonyCallback()
494                 .onDataActivity(dataActivity);
495     }
496 
setCarrierNetworkChange(boolean enable)497     public void setCarrierNetworkChange(boolean enable) {
498         Log.d(TAG, "setCarrierNetworkChange(" + enable + ")");
499         mMobileSignalController.mMobileStatusTracker.getTelephonyCallback()
500                 .onCarrierNetworkChange(enable);
501     }
502 
verifyHasNoSims(boolean hasNoSimsVisible)503     protected void verifyHasNoSims(boolean hasNoSimsVisible) {
504         verify(mCallbackHandler, Mockito.atLeastOnce()).setNoSims(
505                 eq(hasNoSimsVisible), eq(false));
506     }
507 
verifyLastQsMobileDataIndicators(boolean visible, int icon, int typeIcon, boolean dataIn, boolean dataOut)508     protected void verifyLastQsMobileDataIndicators(boolean visible, int icon, int typeIcon,
509             boolean dataIn, boolean dataOut) {
510         ArgumentCaptor<MobileDataIndicators> indicatorsArg =
511                 ArgumentCaptor.forClass(MobileDataIndicators.class);
512 
513         verify(mCallbackHandler, Mockito.atLeastOnce()).setMobileDataIndicators(
514                     indicatorsArg.capture());
515         MobileDataIndicators expected = indicatorsArg.getValue();
516         int state = SignalDrawable.getState(icon, CellSignalStrength.getNumSignalStrengthLevels(),
517                 false);
518         assertEquals("Visibility in, quick settings", visible, expected.qsIcon.visible);
519         assertEquals("Signal icon in, quick settings", state, expected.qsIcon.icon);
520         assertEquals("Data icon in, quick settings", typeIcon, expected.qsType);
521         assertEquals("Data direction in, in quick settings", dataIn,
522                 expected.activityIn);
523         assertEquals("Data direction out, in quick settings", dataOut,
524                 expected.activityOut);
525     }
526 
verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon)527     protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon) {
528         verifyLastMobileDataIndicators(visible, icon, typeIcon, false);
529     }
530 
verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon, boolean roaming)531     protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon,
532             boolean roaming) {
533         verifyLastMobileDataIndicators(visible, icon, typeIcon, roaming, true);
534     }
535 
verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon, boolean roaming, boolean inet)536     protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon,
537             boolean roaming, boolean inet) {
538         ArgumentCaptor<MobileDataIndicators> indicatorsArg =
539                 ArgumentCaptor.forClass(MobileDataIndicators.class);
540 
541         // TODO: Verify all fields.
542         verify(mCallbackHandler, Mockito.atLeastOnce()).setMobileDataIndicators(
543                 indicatorsArg.capture());
544         MobileDataIndicators expected = indicatorsArg.getValue();
545         int state = icon == -1 ? 0
546                 : SignalDrawable.getState(icon, CellSignalStrength.getNumSignalStrengthLevels(),
547                         !inet);
548         assertEquals("Signal icon in status bar", state, expected.statusIcon.icon);
549         assertEquals("Data icon in status bar", typeIcon, expected.statusType);
550         assertEquals("Visibility in status bar", visible, expected.statusIcon.visible);
551     }
552 
verifyLastMobileDataIndicatorsForVcn(boolean visible, int level, int typeIcon, boolean inet)553     protected void verifyLastMobileDataIndicatorsForVcn(boolean visible, int level, int typeIcon,
554             boolean inet) {
555         ArgumentCaptor<MobileDataIndicators> indicatorsArg =
556                 ArgumentCaptor.forClass(MobileDataIndicators.class);
557 
558         verify(mCallbackHandler, Mockito.atLeastOnce()).setMobileDataIndicators(
559                 indicatorsArg.capture());
560 
561         MobileDataIndicators expected = indicatorsArg.getValue();
562         int state = SignalDrawable.getState(
563                 level, CellSignalStrength.getNumSignalStrengthLevels(), !inet);
564         assertEquals("Signal icon in status bar", state, expected.statusIcon.icon);
565         assertEquals("Data icon in status bar", typeIcon, expected.statusType);
566         assertEquals("Visibility in status bar", visible, expected.statusIcon.visible);
567     }
568 
verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon, boolean qsVisible, int qsIcon, int qsTypeIcon, boolean dataIn, boolean dataOut)569     protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon,
570             boolean qsVisible, int qsIcon, int qsTypeIcon, boolean dataIn, boolean dataOut) {
571         verifyLastMobileDataIndicators(
572                 visible, icon, typeIcon, qsVisible, qsIcon, qsTypeIcon, dataIn, dataOut, false);
573     }
574 
verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon, boolean qsVisible, int qsIcon, int qsTypeIcon, boolean dataIn, boolean dataOut, boolean cutOut)575     protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon,
576             boolean qsVisible, int qsIcon, int qsTypeIcon, boolean dataIn, boolean dataOut,
577             boolean cutOut) {
578         verifyLastMobileDataIndicators(
579                 visible, icon, typeIcon, qsVisible, qsIcon, qsTypeIcon, dataIn, dataOut, cutOut,
580                 null, null, visible);
581     }
582 
verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon, boolean qsVisible, int qsIcon, int qsTypeIcon, boolean dataIn, boolean dataOut, boolean cutOut, CharSequence typeContentDescription, CharSequence typeContentDescriptionHtml, boolean showQs)583     protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon,
584             boolean qsVisible, int qsIcon, int qsTypeIcon, boolean dataIn, boolean dataOut,
585             boolean cutOut, CharSequence typeContentDescription,
586             CharSequence typeContentDescriptionHtml, boolean showQs) {
587         ArgumentCaptor<MobileDataIndicators> indicatorsArg =
588                 ArgumentCaptor.forClass(MobileDataIndicators.class);
589         ArgumentCaptor<IconState> iconArg = ArgumentCaptor.forClass(IconState.class);
590         ArgumentCaptor<Integer> typeIconArg = ArgumentCaptor.forClass(Integer.class);
591         ArgumentCaptor<IconState> qsIconArg = ArgumentCaptor.forClass(IconState.class);
592         ArgumentCaptor<Integer> qsTypeIconArg = ArgumentCaptor.forClass(Integer.class);
593         ArgumentCaptor<Boolean> dataInArg = ArgumentCaptor.forClass(Boolean.class);
594         ArgumentCaptor<Boolean> dataOutArg = ArgumentCaptor.forClass(Boolean.class);
595         ArgumentCaptor<CharSequence> typeContentDescriptionArg =
596                 ArgumentCaptor.forClass(CharSequence.class);
597         ArgumentCaptor<CharSequence> typeContentDescriptionHtmlArg =
598                 ArgumentCaptor.forClass(CharSequence.class);
599 
600         verify(mCallbackHandler, Mockito.atLeastOnce()).setMobileDataIndicators(
601                 indicatorsArg.capture());
602 
603         MobileDataIndicators expected = indicatorsArg.getValue();
604 
605         int numSignalStrengthBins = CellSignalStrength.getNumSignalStrengthLevels();
606         if (mMobileSignalController.mInflateSignalStrengths) {
607             numSignalStrengthBins++;
608             icon++;
609         }
610         int state = SignalDrawable.getState(icon, numSignalStrengthBins, cutOut);
611         assertEquals("Data icon in status bar", typeIcon, expected.statusType);
612         assertEquals("Signal icon in status bar", state, expected.statusIcon.icon);
613         assertEquals("Visibility in status bar", visible, expected.statusIcon.visible);
614 
615         if (showQs) {
616             assertEquals("Visibility in quick settings", qsVisible, expected.qsIcon.visible);
617             assertEquals("Signal icon in quick settings", state, expected.qsIcon.icon);
618         } else {
619             assertEquals("Cellular is not default", null, expected.qsIcon);
620         }
621         assertEquals("Data icon in quick settings", qsTypeIcon, expected.qsType);
622         assertEquals("Data direction in in quick settings", dataIn,
623                 expected.activityIn);
624         assertEquals("Data direction out in quick settings", dataOut,
625                 expected.activityOut);
626         if (typeContentDescription != null) { // Only check if it was provided
627             assertEquals("Type content description", typeContentDescription,
628                     expected.typeContentDescription);
629         }
630         if (typeContentDescriptionHtml != null) { // Only check if it was provided
631             assertEquals("Type content description (html)", typeContentDescriptionHtml,
632                     expected.typeContentDescriptionHtml);
633         }
634     }
635 
verifyLastCallStrength(int icon)636     protected void verifyLastCallStrength(int icon) {
637         ArgumentCaptor<IconState> iconArg = ArgumentCaptor.forClass(IconState.class);
638         verify(mCallbackHandler, Mockito.atLeastOnce()).setCallIndicator(
639                 iconArg.capture(),
640                 anyInt());
641         assertEquals("Call strength, in status bar", icon, (int) iconArg.getValue().icon);
642     }
643 
assertNetworkNameEquals(String expected)644     protected void assertNetworkNameEquals(String expected) {
645         assertEquals("Network name", expected, mMobileSignalController.getState().networkName);
646     }
647 
assertDataNetworkNameEquals(String expected)648     protected void assertDataNetworkNameEquals(String expected) {
649         assertEquals("Data network name", expected, mNetworkController.getMobileDataNetworkName());
650     }
651 
652 }
653