NetworkControllerBaseTest.java revision 5504d39b7f880fa8b8660e5d4b014ec559124cf9 
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
17package com.android.systemui.statusbar.policy;
18
19import static org.mockito.Mockito.mock;
20import static org.mockito.Mockito.when;
21
22import android.content.Intent;
23import android.net.ConnectivityManager;
24import android.net.NetworkCapabilities;
25import android.net.wifi.WifiManager;
26import android.telephony.PhoneStateListener;
27import android.telephony.ServiceState;
28import android.telephony.SignalStrength;
29import android.telephony.SubscriptionInfo;
30import android.telephony.SubscriptionManager;
31import android.telephony.TelephonyManager;
32import android.util.Log;
33
34import com.android.internal.telephony.IccCardConstants;
35import com.android.internal.telephony.cdma.EriInfo;
36import com.android.systemui.SysuiTestCase;
37import com.android.systemui.statusbar.policy.NetworkController.NetworkSignalChangedCallback;
38import com.android.systemui.statusbar.policy.NetworkControllerImpl.Config;
39import com.android.systemui.statusbar.policy.NetworkControllerImpl.SignalCluster;
40
41import org.mockito.ArgumentCaptor;
42import org.mockito.Mockito;
43
44import java.io.PrintWriter;
45import java.io.StringWriter;
46import java.util.ArrayList;
47import java.util.List;
48
49public class NetworkControllerBaseTest extends SysuiTestCase {
50    private static final String TAG = "NetworkControllerBaseTest";
51    protected static final int DEFAULT_LEVEL = 2;
52    protected static final int DEFAULT_SIGNAL_STRENGTH =
53            TelephonyIcons.TELEPHONY_SIGNAL_STRENGTH[1][DEFAULT_LEVEL];
54    protected static final int DEFAULT_QS_SIGNAL_STRENGTH =
55            TelephonyIcons.QS_TELEPHONY_SIGNAL_STRENGTH[1][DEFAULT_LEVEL];
56    protected static final int DEFAULT_ICON = TelephonyIcons.ICON_3G;
57    protected static final int DEFAULT_QS_ICON = TelephonyIcons.QS_ICON_3G;
58
59    protected NetworkControllerImpl mNetworkController;
60    protected MobileSignalController mMobileSignalController;
61    protected PhoneStateListener mPhoneStateListener;
62    protected SignalCluster mSignalCluster;
63    protected NetworkSignalChangedCallback mNetworkSignalChangedCallback;
64    private SignalStrength mSignalStrength;
65    private ServiceState mServiceState;
66    protected ConnectivityManager mMockCm;
67    protected WifiManager mMockWm;
68    protected SubscriptionManager mMockSm;
69    protected TelephonyManager mMockTm;
70    protected Config mConfig;
71
72    protected int mSubId;
73
74    private NetworkCapabilities mNetCapabilities;
75
76    @Override
77    protected void setUp() throws Exception {
78        super.setUp();
79
80        mMockWm = mock(WifiManager.class);
81        mMockTm = mock(TelephonyManager.class);
82        mMockSm = mock(SubscriptionManager.class);
83        mMockCm = mock(ConnectivityManager.class);
84        mNetCapabilities = new NetworkCapabilities();
85        when(mMockCm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE)).thenReturn(true);
86        when(mMockCm.getDefaultNetworkCapabilitiesForUser(0)).thenReturn(
87                new NetworkCapabilities[] { mNetCapabilities });
88
89        mSignalStrength = mock(SignalStrength.class);
90        mServiceState = mock(ServiceState.class);
91
92        mConfig = new Config();
93        mConfig.hspaDataDistinguishable = true;
94        mNetworkController = new NetworkControllerImpl(mContext, mMockCm, mMockTm, mMockWm, mMockSm,
95                mConfig, mock(AccessPointControllerImpl.class),
96                mock(MobileDataControllerImpl.class));
97        setupNetworkController();
98    }
99
100    protected void setupNetworkController() {
101        // For now just pretend to be the data sim, so we can test that too.
102        mSubId = SubscriptionManager.getDefaultDataSubId();
103        SubscriptionInfo subscription = mock(SubscriptionInfo.class);
104        List<SubscriptionInfo> subs = new ArrayList<SubscriptionInfo>();
105        when(subscription.getSubscriptionId()).thenReturn(mSubId);
106        subs.add(subscription);
107        mNetworkController.setCurrentSubscriptions(subs);
108        mMobileSignalController = mNetworkController.mMobileSignalControllers.get(mSubId);
109        mPhoneStateListener = mMobileSignalController.mPhoneStateListener;
110        mSignalCluster = mock(SignalCluster.class);
111        mNetworkSignalChangedCallback = mock(NetworkSignalChangedCallback.class);
112        mNetworkController.addSignalCluster(mSignalCluster);
113        mNetworkController.addNetworkSignalChangedCallback(mNetworkSignalChangedCallback);
114    }
115
116    protected NetworkControllerImpl setUpNoMobileData() {
117      when(mMockCm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE)).thenReturn(false);
118      NetworkControllerImpl networkControllerNoMobile
119              = new NetworkControllerImpl(mContext, mMockCm, mMockTm, mMockWm, mMockSm,
120                        mConfig, mock(AccessPointControllerImpl.class),
121                        mock(MobileDataControllerImpl.class));
122
123      setupNetworkController();
124
125      return networkControllerNoMobile;
126
127    }
128
129    @Override
130    protected void tearDown() throws Exception {
131        StringWriter sw = new StringWriter();
132        PrintWriter pw = new PrintWriter(sw);
133        mNetworkController.dump(null, pw, null);
134        pw.flush();
135        Log.d(TAG, sw.toString());
136        super.tearDown();
137    }
138
139    // 2 Bars 3G GSM.
140    public void setupDefaultSignal() {
141        setIsGsm(true);
142        setVoiceRegState(ServiceState.STATE_IN_SERVICE);
143        setGsmRoaming(false);
144        setLevel(DEFAULT_LEVEL);
145        updateDataConnectionState(TelephonyManager.DATA_CONNECTED,
146                TelephonyManager.NETWORK_TYPE_UMTS);
147        setConnectivity(100, ConnectivityManager.TYPE_MOBILE, true);
148    }
149
150    public void setConnectivity(int inetCondition, int networkType, boolean isConnected) {
151        Intent i = new Intent(ConnectivityManager.INET_CONDITION_ACTION);
152        // TODO: Separate out into several NetworkCapabilities.
153        if (isConnected) {
154            mNetCapabilities.addTransportType(networkType);
155        } else {
156            mNetCapabilities.removeTransportType(networkType);
157        }
158        if (inetCondition != 0) {
159            mNetCapabilities.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
160        } else {
161            mNetCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
162        }
163
164        mNetworkController.onReceive(mContext, i);
165    }
166
167    public void setGsmRoaming(boolean isRoaming) {
168        when(mServiceState.getRoaming()).thenReturn(isRoaming);
169        updateServiceState();
170    }
171
172    public void setCdmaRoaming(boolean isRoaming) {
173        when(mServiceState.getCdmaEriIconIndex()).thenReturn(isRoaming ?
174                EriInfo.ROAMING_INDICATOR_ON : EriInfo.ROAMING_INDICATOR_OFF);
175        when(mServiceState.getCdmaEriIconMode()).thenReturn(isRoaming ?
176                EriInfo.ROAMING_ICON_MODE_NORMAL : -1);
177        updateServiceState();
178    }
179
180    public void setVoiceRegState(int voiceRegState) {
181        when(mServiceState.getVoiceRegState()).thenReturn(voiceRegState);
182        updateServiceState();
183    }
184
185    public void setDataRegState(int dataRegState) {
186        when(mServiceState.getDataRegState()).thenReturn(dataRegState);
187        updateServiceState();
188    }
189
190    public void setIsEmergencyOnly(boolean isEmergency) {
191        when(mServiceState.isEmergencyOnly()).thenReturn(isEmergency);
192        updateServiceState();
193    }
194
195    public void setCdmaLevel(int level) {
196        when(mSignalStrength.getCdmaLevel()).thenReturn(level);
197        updateSignalStrength();
198    }
199
200    public void setLevel(int level) {
201        when(mSignalStrength.getLevel()).thenReturn(level);
202        updateSignalStrength();
203    }
204
205    public void setIsGsm(boolean gsm) {
206        when(mSignalStrength.isGsm()).thenReturn(gsm);
207        updateSignalStrength();
208    }
209
210    public void setCdmaEri(int index, int mode) {
211        // TODO: Figure this out.
212    }
213
214    private void updateSignalStrength() {
215        Log.d(TAG, "Sending Signal Strength: " + mSignalStrength);
216        mPhoneStateListener.onSignalStrengthsChanged(mSignalStrength);
217    }
218
219    private void updateServiceState() {
220        Log.d(TAG, "Sending Service State: " + mServiceState);
221        mPhoneStateListener.onServiceStateChanged(mServiceState);
222    }
223
224    public void updateCallState(int state) {
225        // Inputs not currently used in NetworkControllerImpl.
226        mPhoneStateListener.onCallStateChanged(state, "0123456789");
227    }
228
229    public void updateDataConnectionState(int dataState, int dataNetType) {
230        mPhoneStateListener.onDataConnectionStateChanged(dataState, dataNetType);
231    }
232
233    public void updateDataActivity(int dataActivity) {
234        mPhoneStateListener.onDataActivity(dataActivity);
235    }
236
237    public void setCarrierNetworkChange(boolean enable) {
238        Log.d(TAG, "setCarrierNetworkChange(" + enable + ")");
239        mPhoneStateListener.onCarrierNetworkChange(enable);
240    }
241
242    protected void verifyHasNoSims(boolean hasNoSimsVisible) {
243        ArgumentCaptor<Boolean> hasNoSimsArg = ArgumentCaptor.forClass(Boolean.class);
244
245        Mockito.verify(mSignalCluster, Mockito.atLeastOnce()).setNoSims(hasNoSimsArg.capture());
246        assertEquals("No sims in status bar", hasNoSimsVisible, (boolean) hasNoSimsArg.getValue());
247
248        Mockito.verify(mNetworkSignalChangedCallback, Mockito.atLeastOnce())
249                .onNoSimVisibleChanged(hasNoSimsArg.capture());
250        assertEquals("No sims in quick settings", hasNoSimsVisible,
251                (boolean) hasNoSimsArg.getValue());
252    }
253
254    protected void verifyLastQsMobileDataIndicators(boolean visible, int icon, int typeIcon,
255            boolean dataIn, boolean dataOut) {
256        ArgumentCaptor<Integer> iconArg = ArgumentCaptor.forClass(Integer.class);
257        ArgumentCaptor<Integer> typeIconArg = ArgumentCaptor.forClass(Integer.class);
258        ArgumentCaptor<Boolean> visibleArg = ArgumentCaptor.forClass(Boolean.class);
259        ArgumentCaptor<Boolean> dataInArg = ArgumentCaptor.forClass(Boolean.class);
260        ArgumentCaptor<Boolean> dataOutArg = ArgumentCaptor.forClass(Boolean.class);
261
262        Mockito.verify(mNetworkSignalChangedCallback, Mockito.atLeastOnce())
263                .onMobileDataSignalChanged(visibleArg.capture(), iconArg.capture(),
264                        ArgumentCaptor.forClass(String.class).capture(),
265                        typeIconArg.capture(),
266                        dataInArg.capture(),
267                        dataOutArg.capture(),
268                        ArgumentCaptor.forClass(String.class).capture(),
269                        ArgumentCaptor.forClass(String.class).capture(),
270                        ArgumentCaptor.forClass(Boolean.class).capture());
271        assertEquals("Visibility in, quick settings", visible, (boolean) visibleArg.getValue());
272        assertEquals("Signal icon in, quick settings", icon, (int) iconArg.getValue());
273        assertEquals("Data icon in, quick settings", typeIcon, (int) typeIconArg.getValue());
274        assertEquals("Data direction in, in quick settings", dataIn,
275                (boolean) dataInArg.getValue());
276        assertEquals("Data direction out, in quick settings", dataOut,
277                (boolean) dataOutArg.getValue());
278    }
279
280    protected void verifyLastMobileDataIndicators(boolean visible, int icon, int typeIcon) {
281        verifyLastMobileDataIndicators(visible, icon, icon, typeIcon);
282    }
283
284    protected void verifyLastMobileDataIndicators(boolean visible, int strengthIcon,
285            int darkStrengthIcon, int typeIcon) {
286        ArgumentCaptor<Integer> strengthIconArg = ArgumentCaptor.forClass(Integer.class);
287        ArgumentCaptor<Integer> darkStrengthIconArg = ArgumentCaptor.forClass(Integer.class);
288        ArgumentCaptor<Integer> typeIconArg = ArgumentCaptor.forClass(Integer.class);
289        ArgumentCaptor<Boolean> visibleArg = ArgumentCaptor.forClass(Boolean.class);
290
291        // TODO: Verify all fields.
292        Mockito.verify(mSignalCluster, Mockito.atLeastOnce()).setMobileDataIndicators(
293                visibleArg.capture(), strengthIconArg.capture(), darkStrengthIconArg.capture(),
294                typeIconArg.capture(),
295                ArgumentCaptor.forClass(String.class).capture(),
296                ArgumentCaptor.forClass(String.class).capture(),
297                ArgumentCaptor.forClass(Boolean.class).capture(),
298                ArgumentCaptor.forClass(Integer.class).capture());
299
300        assertEquals("Signal strength icon in status bar", strengthIcon,
301                (int) strengthIconArg.getValue());
302        assertEquals("Signal strength icon (dark mode) in status bar", darkStrengthIcon,
303                (int) darkStrengthIconArg.getValue());
304        assertEquals("Data icon in status bar", typeIcon, (int) typeIconArg.getValue());
305        assertEquals("Visibility in status bar", visible, (boolean) visibleArg.getValue());
306    }
307
308   protected void assertNetworkNameEquals(String expected) {
309       assertEquals("Network name", expected, mNetworkController.getMobileDataNetworkName());
310   }
311}
312