1/*
2 * Copyright (C) 2016 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.internal.telephony;
18
19import android.app.IAlarmManager;
20import android.content.Context;
21import android.content.Intent;
22import android.os.AsyncResult;
23import android.os.Bundle;
24import android.os.Handler;
25import android.os.HandlerThread;
26import android.os.IBinder;
27import android.os.Message;
28import android.os.Parcel;
29import android.os.SystemClock;
30import android.os.UserHandle;
31import android.platform.test.annotations.Postsubmit;
32import android.telephony.CellInfo;
33import android.telephony.CellInfoGsm;
34import android.telephony.ServiceState;
35import android.telephony.SignalStrength;
36import android.telephony.SubscriptionManager;
37import android.telephony.gsm.GsmCellLocation;
38import android.test.suitebuilder.annotation.MediumTest;
39import android.test.suitebuilder.annotation.SmallTest;
40import android.util.Pair;
41
42import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager;
43import com.android.internal.telephony.dataconnection.DcTracker;
44import com.android.internal.telephony.test.SimulatedCommands;
45import com.android.internal.telephony.uicc.IccCardApplicationStatus;
46
47import org.junit.After;
48import org.junit.Before;
49import org.junit.Test;
50import org.mockito.ArgumentCaptor;
51import org.mockito.Mock;
52
53import java.util.ArrayList;
54
55import static com.android.internal.telephony.TelephonyTestUtils.waitForMs;
56import static org.junit.Assert.assertEquals;
57import static org.junit.Assert.assertFalse;
58import static org.junit.Assert.assertTrue;
59import static org.mockito.Matchers.any;
60import static org.mockito.Matchers.anyLong;
61import static org.mockito.Matchers.anyString;
62import static org.mockito.Mockito.anyInt;
63import static org.mockito.Mockito.atLeast;
64import static org.mockito.Mockito.doReturn;
65import static org.mockito.Mockito.eq;
66import static org.mockito.Mockito.times;
67import static org.mockito.Mockito.verify;
68
69public class ServiceStateTrackerTest extends TelephonyTest {
70
71    @Mock
72    private DcTracker mDct;
73    @Mock
74    private ProxyController mProxyController;
75    @Mock
76    private Handler mTestHandler;
77    @Mock
78    protected IAlarmManager mAlarmManager;
79
80    private ServiceStateTracker sst;
81    private ServiceStateTrackerTestHandler mSSTTestHandler;
82
83    private static final int EVENT_REGISTERED_TO_NETWORK = 1;
84    private static final int EVENT_SUBSCRIPTION_INFO_READY = 2;
85    private static final int EVENT_ROAMING_ON = 3;
86    private static final int EVENT_ROAMING_OFF = 4;
87    private static final int EVENT_DATA_CONNECTION_ATTACHED = 5;
88    private static final int EVENT_DATA_CONNECTION_DETACHED = 6;
89    private static final int EVENT_DATA_RAT_CHANGED = 7;
90    private static final int EVENT_PS_RESTRICT_ENABLED = 8;
91    private static final int EVENT_PS_RESTRICT_DISABLED = 9;
92
93    private class ServiceStateTrackerTestHandler extends HandlerThread {
94
95        private ServiceStateTrackerTestHandler(String name) {
96            super(name);
97        }
98
99        @Override
100        public void onLooperPrepared() {
101            sst = new ServiceStateTracker(mPhone, mSimulatedCommands);
102            setReady(true);
103        }
104    }
105
106    @Before
107    public void setUp() throws Exception {
108
109        logd("ServiceStateTrackerTest +Setup!");
110        super.setUp("ServiceStateTrackerTest");
111
112        doReturn(true).when(mDct).isDisconnected();
113        mPhone.mDcTracker = mDct;
114
115        replaceInstance(ProxyController.class, "sProxyController", null, mProxyController);
116
117        mContextFixture.putStringArrayResource(
118                com.android.internal.R.array.config_sameNamedOperatorConsideredRoaming,
119                new String[]{"123456"});
120
121        mContextFixture.putStringArrayResource(
122                com.android.internal.R.array.config_operatorConsideredNonRoaming,
123                new String[]{"123456"});
124
125        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
126        mSimulatedCommands.setVoiceRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA);
127        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
128        mSimulatedCommands.setDataRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA);
129
130        int dds = SubscriptionManager.getDefaultDataSubscriptionId();
131        doReturn(dds).when(mPhone).getSubId();
132
133        mSSTTestHandler = new ServiceStateTrackerTestHandler(getClass().getSimpleName());
134        mSSTTestHandler.start();
135        waitUntilReady();
136        waitForMs(600);
137        logd("ServiceStateTrackerTest -Setup!");
138    }
139
140    @After
141    public void tearDown() throws Exception {
142        sst = null;
143        mSSTTestHandler.quitSafely();
144        super.tearDown();
145    }
146
147    @Test
148    @MediumTest
149    public void testSetRadioPower() {
150        boolean oldState = mSimulatedCommands.getRadioState().isOn();
151        sst.setRadioPower(!oldState);
152        waitForMs(100);
153        assertTrue(oldState != mSimulatedCommands.getRadioState().isOn());
154    }
155
156    @Test
157    @MediumTest
158    public void testSetRadioPowerFromCarrier() {
159        // Carrier disable radio power
160        sst.setRadioPowerFromCarrier(false);
161        waitForMs(100);
162        assertFalse(mSimulatedCommands.getRadioState().isOn());
163        assertTrue(sst.getDesiredPowerState());
164        assertFalse(sst.getPowerStateFromCarrier());
165
166        // User toggle radio power will not overrides carrier settings
167        sst.setRadioPower(true);
168        waitForMs(100);
169        assertFalse(mSimulatedCommands.getRadioState().isOn());
170        assertTrue(sst.getDesiredPowerState());
171        assertFalse(sst.getPowerStateFromCarrier());
172
173        // Carrier re-enable radio power
174        sst.setRadioPowerFromCarrier(true);
175        waitForMs(100);
176        assertTrue(mSimulatedCommands.getRadioState().isOn());
177        assertTrue(sst.getDesiredPowerState());
178        assertTrue(sst.getPowerStateFromCarrier());
179
180        // User toggle radio power off (airplane mode) and set carrier on
181        sst.setRadioPower(false);
182        sst.setRadioPowerFromCarrier(true);
183        waitForMs(100);
184        assertFalse(mSimulatedCommands.getRadioState().isOn());
185        assertFalse(sst.getDesiredPowerState());
186        assertTrue(sst.getPowerStateFromCarrier());
187    }
188
189    @Test
190    @MediumTest
191    public void testRilTrafficAfterSetRadioPower() {
192        sst.setRadioPower(true);
193        final int getOperatorCallCount = mSimulatedCommands.getGetOperatorCallCount();
194        final int getDataRegistrationStateCallCount =
195                mSimulatedCommands.getGetDataRegistrationStateCallCount();
196        final int getVoiceRegistrationStateCallCount =
197                mSimulatedCommands.getGetVoiceRegistrationStateCallCount();
198        final int getNetworkSelectionModeCallCount =
199                mSimulatedCommands.getGetNetworkSelectionModeCallCount();
200        sst.setRadioPower(false);
201
202        waitForMs(500);
203        sst.pollState();
204        waitForMs(250);
205
206        // This test was meant to be for *no* ril traffic. However, RADIO_STATE_CHANGED is
207        // considered a modem triggered action and that causes a pollState() to be done
208        assertEquals(getOperatorCallCount + 1, mSimulatedCommands.getGetOperatorCallCount());
209        assertEquals(getDataRegistrationStateCallCount + 1,
210                mSimulatedCommands.getGetDataRegistrationStateCallCount());
211        assertEquals(getVoiceRegistrationStateCallCount + 1,
212                mSimulatedCommands.getGetVoiceRegistrationStateCallCount());
213        assertEquals(getNetworkSelectionModeCallCount + 1,
214                mSimulatedCommands.getGetNetworkSelectionModeCallCount());
215
216        // Note that if the poll is triggered by a network change notification
217        // and the modem is supposed to be off, we should still do the poll
218        mSimulatedCommands.notifyVoiceNetworkStateChanged();
219        waitForMs(250);
220
221        assertEquals(getOperatorCallCount + 2 , mSimulatedCommands.getGetOperatorCallCount());
222        assertEquals(getDataRegistrationStateCallCount + 2,
223                mSimulatedCommands.getGetDataRegistrationStateCallCount());
224        assertEquals(getVoiceRegistrationStateCallCount + 2,
225                mSimulatedCommands.getGetVoiceRegistrationStateCallCount());
226        assertEquals(getNetworkSelectionModeCallCount + 2,
227                mSimulatedCommands.getGetNetworkSelectionModeCallCount());
228    }
229
230    @Test
231    @MediumTest
232    public void testSpnUpdateShowPlmnOnly() {
233        doReturn(0x02).when(mSimRecords).getDisplayRule(anyString());
234        doReturn(IccCardApplicationStatus.AppState.APPSTATE_UNKNOWN).
235                when(mUiccCardApplication3gpp).getState();
236
237        sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_NETWORK_STATE_CHANGED, null));
238
239        waitForMs(750);
240
241        ArgumentCaptor<Intent> intentArgumentCaptor = ArgumentCaptor.forClass(Intent.class);
242        verify(mContextFixture.getTestDouble(), atLeast(2)).
243                sendStickyBroadcastAsUser(intentArgumentCaptor.capture(), eq(UserHandle.ALL));
244
245        // We only want to verify the intent SPN_STRINGS_UPDATED_ACTION.
246        Intent intent = intentArgumentCaptor.getValue();
247        assertEquals(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION, intent.getAction());
248        assertEquals(Intent.FLAG_RECEIVER_REPLACE_PENDING, intent.getFlags());
249
250        Bundle b = intent.getExtras();
251
252        // For boolean we need to make sure the key exists first
253        assertTrue(b.containsKey(TelephonyIntents.EXTRA_SHOW_SPN));
254        assertFalse(b.getBoolean(TelephonyIntents.EXTRA_SHOW_SPN));
255
256        assertEquals(null, b.getString(TelephonyIntents.EXTRA_SPN));
257        assertEquals(null, b.getString(TelephonyIntents.EXTRA_DATA_SPN));
258
259        // For boolean we need to make sure the key exists first
260        assertTrue(b.containsKey(TelephonyIntents.EXTRA_SHOW_PLMN));
261        assertTrue(b.getBoolean(TelephonyIntents.EXTRA_SHOW_PLMN));
262
263        assertEquals(SimulatedCommands.FAKE_LONG_NAME, b.getString(TelephonyIntents.EXTRA_PLMN));
264
265        ArgumentCaptor<Integer> intArgumentCaptor = ArgumentCaptor.forClass(Integer.class);
266        verify(mTelephonyManager).setDataNetworkTypeForPhone(anyInt(), intArgumentCaptor.capture());
267        assertEquals(ServiceState.RIL_RADIO_TECHNOLOGY_HSPA,
268                intArgumentCaptor.getValue().intValue());
269    }
270
271    @Test
272    @MediumTest
273    public void testCellInfoList() {
274        Parcel p = Parcel.obtain();
275        p.writeInt(1);
276        p.writeInt(1);
277        p.writeInt(2);
278        p.writeLong(1453510289108L);
279        p.writeInt(310);
280        p.writeInt(260);
281        p.writeInt(123);
282        p.writeInt(456);
283        p.writeInt(99);
284        p.writeInt(3);
285        p.setDataPosition(0);
286
287        CellInfoGsm cellInfo = CellInfoGsm.CREATOR.createFromParcel(p);
288
289        ArrayList<CellInfo> list = new ArrayList();
290        list.add(cellInfo);
291        mSimulatedCommands.setCellInfoList(list);
292
293        assertEquals(sst.getAllCellInfo(), list);
294    }
295
296    @Test
297    @MediumTest
298    public void testImsRegState() {
299        // Simulate IMS registered
300        mSimulatedCommands.setImsRegistrationState(new int[]{1, PhoneConstants.PHONE_TYPE_GSM});
301
302        sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_STATE_CHANGED, null));
303        waitForMs(200);
304
305        assertTrue(sst.isImsRegistered());
306
307        // Simulate IMS unregistered
308        mSimulatedCommands.setImsRegistrationState(new int[]{0, PhoneConstants.PHONE_TYPE_GSM});
309
310        sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_IMS_STATE_CHANGED, null));
311        waitForMs(200);
312
313        assertFalse(sst.isImsRegistered());
314    }
315
316    @Postsubmit
317    @Test
318    @MediumTest
319    public void testSignalStrength() {
320        SignalStrength ss = new SignalStrength(
321                30, // gsmSignalStrength
322                0,  // gsmBitErrorRate
323                -1, // cdmaDbm
324                -1, // cdmaEcio
325                -1, // evdoDbm
326                -1, // evdoEcio
327                -1, // evdoSnr
328                99, // lteSignalStrength
329                SignalStrength.INVALID,     // lteRsrp
330                SignalStrength.INVALID,     // lteRsrq
331                SignalStrength.INVALID,     // lteRssnr
332                SignalStrength.INVALID,     // lteCqi
333                SignalStrength.INVALID,     // tdScdmaRscp
334                true                        // gsmFlag
335        );
336
337        mSimulatedCommands.setSignalStrength(ss);
338        mSimulatedCommands.notifySignalStrength();
339        waitForMs(300);
340        assertEquals(sst.getSignalStrength(), ss);
341        assertEquals(sst.getSignalStrength().isGsm(), true);
342
343        // switch to CDMA
344        doReturn(false).when(mPhone).isPhoneTypeGsm();
345        doReturn(true).when(mPhone).isPhoneTypeCdmaLte();
346        sst.updatePhoneType();
347        sst.mSS.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_LTE);
348
349        mSimulatedCommands.notifySignalStrength();
350        waitForMs(200);
351        assertEquals(sst.getSignalStrength(), ss);
352        assertEquals(sst.getSignalStrength().isGsm(), true);
353
354        // notify signal strength again, but this time data RAT is not LTE
355        sst.mSS.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD);
356        mSimulatedCommands.notifySignalStrength();
357        waitForMs(200);
358        assertEquals(sst.getSignalStrength(), ss);
359        assertEquals(sst.getSignalStrength().isGsm(), false);
360    }
361
362    @Test
363    @MediumTest
364    public void testGsmCellLocation() {
365
366        sst.sendMessage(sst.obtainMessage(ServiceStateTracker.EVENT_GET_LOC_DONE,
367                new AsyncResult(null, new String[]{"1", "2", "3", "4", "5", "6", "7", "8", "9",
368                        "10", "11", "12", "13", "14", "15"}, null)));
369
370        waitForMs(200);
371        GsmCellLocation cl = (GsmCellLocation) sst.getCellLocation();
372        assertEquals(2, cl.getLac());
373        assertEquals(3, cl.getCid());
374    }
375
376    @Test
377    @MediumTest
378    public void testUpdatePhoneType() {
379        doReturn(false).when(mPhone).isPhoneTypeGsm();
380        doReturn(true).when(mPhone).isPhoneTypeCdmaLte();
381        doReturn(CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM).when(mCdmaSSM).
382                getCdmaSubscriptionSource();
383
384        logd("Calling updatePhoneType");
385        // switch to CDMA
386        sst.updatePhoneType();
387
388        ArgumentCaptor<Integer> integerArgumentCaptor = ArgumentCaptor.forClass(Integer.class);
389        verify(mRuimRecords).registerForRecordsLoaded(eq(sst), integerArgumentCaptor.capture(),
390                any(Object.class));
391
392        // response for mRuimRecords.registerForRecordsLoaded()
393        Message msg = Message.obtain();
394        msg.what = integerArgumentCaptor.getValue();
395        msg.obj = new AsyncResult(null, null, null);
396        sst.sendMessage(msg);
397        waitForMs(100);
398
399        // on RUIM_RECORDS_LOADED, sst is expected to call following apis
400        verify(mRuimRecords, times(1)).isProvisioned();
401
402        // switch back to GSM
403        doReturn(true).when(mPhone).isPhoneTypeGsm();
404        doReturn(false).when(mPhone).isPhoneTypeCdmaLte();
405
406        // response for mRuimRecords.registerForRecordsLoaded() can be sent after switching to GSM
407        msg = Message.obtain();
408        msg.what = integerArgumentCaptor.getValue();
409        msg.obj = new AsyncResult(null, null, null);
410        sst.sendMessage(msg);
411
412        // There's no easy way to check if the msg was handled or discarded. Wait to make sure sst
413        // did not crash, and then verify that the functions called records loaded are not called
414        // again
415        waitForMs(200);
416
417        verify(mRuimRecords, times(1)).isProvisioned();
418    }
419
420    @Test
421    @MediumTest
422    public void testRegAndUnregForVoiceRoamingOn() throws Exception {
423        sst.registerForVoiceRoamingOn(mTestHandler, EVENT_ROAMING_ON, null);
424
425        // Enable roaming and trigger events to notify handler registered
426        doReturn(true).when(mPhone).isPhoneTypeGsm();
427        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
428        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
429        mSimulatedCommands.notifyVoiceNetworkStateChanged();
430
431        waitForMs(100);
432
433        // verify if registered handler has message posted to it
434        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
435        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
436        assertEquals(EVENT_ROAMING_ON, messageArgumentCaptor.getValue().what);
437
438        // Disable roaming
439        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
440        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
441        mSimulatedCommands.notifyVoiceNetworkStateChanged();
442
443        waitForMs(100);
444
445        // Unregister registrant
446        sst.unregisterForVoiceRoamingOn(mTestHandler);
447
448        // Enable roaming
449        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
450        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
451        mSimulatedCommands.notifyVoiceNetworkStateChanged();
452
453        waitForMs(100);
454
455        // verify that no new message posted to handler
456        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
457    }
458
459    @Test
460    @MediumTest
461    public void testRegAndUnregForVoiceRoamingOff() throws Exception {
462        // Enable roaming
463        doReturn(true).when(mPhone).isPhoneTypeGsm();
464        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
465        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
466        mSimulatedCommands.notifyVoiceNetworkStateChanged();
467
468        waitForMs(100);
469
470        sst.registerForVoiceRoamingOff(mTestHandler, EVENT_ROAMING_OFF, null);
471
472        // Disable roaming
473        doReturn(true).when(mPhone).isPhoneTypeGsm();
474        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
475        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
476        mSimulatedCommands.notifyVoiceNetworkStateChanged();
477
478        waitForMs(100);
479
480        // verify if registered handler has message posted to it
481        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
482        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
483        assertEquals(EVENT_ROAMING_OFF, messageArgumentCaptor.getValue().what);
484
485        // Enable roaming
486        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
487        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
488        mSimulatedCommands.notifyVoiceNetworkStateChanged();
489
490        waitForMs(100);
491
492        // Unregister registrant
493        sst.unregisterForVoiceRoamingOff(mTestHandler);
494
495        // Disable roaming
496        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
497        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
498        mSimulatedCommands.notifyVoiceNetworkStateChanged();
499
500        waitForMs(100);
501
502        // verify that no new message posted to handler
503        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
504    }
505
506    @Test
507    @MediumTest
508    public void testRegAndUnregForDataRoamingOn() throws Exception {
509        sst.registerForDataRoamingOn(mTestHandler, EVENT_ROAMING_ON, null);
510
511        // Enable roaming and trigger events to notify handler registered
512        doReturn(true).when(mPhone).isPhoneTypeGsm();
513        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
514        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
515        mSimulatedCommands.notifyVoiceNetworkStateChanged();
516
517        waitForMs(100);
518
519        // verify if registered handler has message posted to it
520        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
521        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
522        assertEquals(EVENT_ROAMING_ON, messageArgumentCaptor.getValue().what);
523
524        // Disable roaming
525        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
526        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
527        mSimulatedCommands.notifyVoiceNetworkStateChanged();
528
529        waitForMs(100);
530
531        // Unregister registrant
532        sst.unregisterForDataRoamingOn(mTestHandler);
533
534        // Enable roaming
535        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
536        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
537        mSimulatedCommands.notifyVoiceNetworkStateChanged();
538
539        waitForMs(100);
540
541        // verify that no new message posted to handler
542        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
543    }
544
545    @Test
546    @MediumTest
547    public void testRegAndUnregForDataRoamingOff() throws Exception {
548        // Enable roaming
549        doReturn(true).when(mPhone).isPhoneTypeGsm();
550        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
551        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
552        mSimulatedCommands.notifyVoiceNetworkStateChanged();
553
554        waitForMs(100);
555
556        sst.registerForDataRoamingOff(mTestHandler, EVENT_ROAMING_OFF, null);
557
558        // Disable roaming
559        doReturn(true).when(mPhone).isPhoneTypeGsm();
560        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
561        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
562        mSimulatedCommands.notifyVoiceNetworkStateChanged();
563
564        waitForMs(100);
565
566        // verify if registered handler has message posted to it
567        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
568        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
569        assertEquals(EVENT_ROAMING_OFF, messageArgumentCaptor.getValue().what);
570
571        // Enable roaming
572        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
573        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
574        mSimulatedCommands.notifyVoiceNetworkStateChanged();
575
576        waitForMs(100);
577
578        // Unregister registrant
579        sst.unregisterForDataRoamingOff(mTestHandler);
580
581        // Disable roaming
582        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_HOME);
583        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_HOME);
584        mSimulatedCommands.notifyVoiceNetworkStateChanged();
585
586        waitForMs(100);
587
588        // verify that no new message posted to handler
589        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
590    }
591
592    @Test
593    @MediumTest
594    public void testRegAndUnregForDataConnAttach() throws Exception {
595        // Initially set service state out of service
596        doReturn(true).when(mPhone).isPhoneTypeGsm();
597        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
598        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
599        mSimulatedCommands.notifyVoiceNetworkStateChanged();
600
601        waitForMs(100);
602
603        sst.registerForDataConnectionAttached(mTestHandler, EVENT_DATA_CONNECTION_ATTACHED, null);
604
605        // set service state in service and trigger events to post message on handler
606        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
607        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
608        mSimulatedCommands.notifyVoiceNetworkStateChanged();
609
610        waitForMs(200);
611
612        // verify if registered handler has message posted to it
613        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
614        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
615        assertEquals(EVENT_DATA_CONNECTION_ATTACHED, messageArgumentCaptor.getValue().what);
616
617        // set service state out of service
618        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
619        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
620        mSimulatedCommands.notifyVoiceNetworkStateChanged();
621
622        waitForMs(100);
623
624        // Unregister registrant
625        sst.unregisterForDataConnectionAttached(mTestHandler);
626
627        // set service state in service
628        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
629        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
630        mSimulatedCommands.notifyVoiceNetworkStateChanged();
631
632        waitForMs(100);
633
634        // verify that no new message posted to handler
635        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
636    }
637
638    @Test
639    @MediumTest
640    public void testRegAndUnregForDataConnDetach() throws Exception {
641        // Initially set service state in service
642        doReturn(true).when(mPhone).isPhoneTypeGsm();
643        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
644        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
645        mSimulatedCommands.notifyVoiceNetworkStateChanged();
646
647        sst.registerForDataConnectionDetached(mTestHandler, EVENT_DATA_CONNECTION_DETACHED, null);
648
649        // set service state out of service and trigger events to post message on handler
650        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
651        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
652        mSimulatedCommands.notifyVoiceNetworkStateChanged();
653
654        waitForMs(100);
655
656        // verify if registered handler has message posted to it
657        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
658        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
659        assertEquals(EVENT_DATA_CONNECTION_DETACHED, messageArgumentCaptor.getValue().what);
660
661        // set service state in service
662        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
663        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
664        mSimulatedCommands.notifyVoiceNetworkStateChanged();
665
666        waitForMs(100);
667
668        // Unregister registrant
669        sst.unregisterForDataConnectionDetached(mTestHandler);
670
671        // set service state out of service
672        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
673        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
674        mSimulatedCommands.notifyVoiceNetworkStateChanged();
675
676        waitForMs(100);
677
678        // verify that no new message posted to handler
679        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
680    }
681
682    @Test
683    @MediumTest
684    public void testRegisterForDataRegStateOrRatChange() {
685        int drs = sst.mSS.RIL_REG_STATE_HOME;
686        int rat = sst.mSS.RIL_RADIO_TECHNOLOGY_LTE;
687        sst.mSS.setRilDataRadioTechnology(rat);
688        sst.mSS.setDataRegState(drs);
689        sst.registerForDataRegStateOrRatChanged(mTestHandler, EVENT_DATA_RAT_CHANGED, null);
690
691        waitForMs(100);
692
693        // Verify if message was posted to handler and value of result
694        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
695        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
696        assertEquals(EVENT_DATA_RAT_CHANGED, messageArgumentCaptor.getValue().what);
697        assertEquals(new Pair<Integer, Integer>(drs, rat),
698                ((AsyncResult)messageArgumentCaptor.getValue().obj).result);
699    }
700
701    @Test
702    @MediumTest
703    public void testRegAndUnregForNetworkAttached() throws Exception {
704        // Initially set service state out of service
705        doReturn(true).when(mPhone).isPhoneTypeGsm();
706        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
707        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
708        mSimulatedCommands.notifyVoiceNetworkStateChanged();
709
710        waitForMs(100);
711
712        sst.registerForNetworkAttached(mTestHandler, EVENT_REGISTERED_TO_NETWORK, null);
713
714        // set service state in service and trigger events to post message on handler
715        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
716        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
717        mSimulatedCommands.notifyVoiceNetworkStateChanged();
718
719        waitForMs(100);
720
721        // verify if registered handler has message posted to it
722        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
723        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
724        assertEquals(EVENT_REGISTERED_TO_NETWORK, messageArgumentCaptor.getValue().what);
725
726        // set service state out of service
727        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
728        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_UNKNOWN);
729        mSimulatedCommands.notifyVoiceNetworkStateChanged();
730
731        waitForMs(100);
732
733        // Unregister registrant
734        sst.unregisterForNetworkAttached(mTestHandler);
735
736        // set service state in service
737        mSimulatedCommands.setVoiceRegState(ServiceState.RIL_REG_STATE_ROAMING);
738        mSimulatedCommands.setDataRegState(ServiceState.RIL_REG_STATE_ROAMING);
739        mSimulatedCommands.notifyVoiceNetworkStateChanged();
740
741        waitForMs(100);
742
743        // verify that no new message posted to handler
744        verify(mTestHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());
745    }
746
747    @Test
748    @MediumTest
749    public void testRegisterForPsRestrictedEnabled() throws Exception {
750        sst.mRestrictedState.setPsRestricted(true);
751        // Since PsRestricted is set to true, registerForPsRestrictedEnabled will
752        // also post message to handler
753        sst.registerForPsRestrictedEnabled(mTestHandler, EVENT_PS_RESTRICT_ENABLED, null);
754
755        waitForMs(100);
756
757        // verify posted message
758        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
759        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
760        assertEquals(EVENT_PS_RESTRICT_ENABLED, messageArgumentCaptor.getValue().what);
761    }
762
763    @Test
764    @MediumTest
765    public void testRegisterForPsRestrictedDisabled() throws Exception {
766        sst.mRestrictedState.setPsRestricted(true);
767        // Since PsRestricted is set to true, registerForPsRestrictedDisabled will
768        // also post message to handler
769        sst.registerForPsRestrictedDisabled(mTestHandler, EVENT_PS_RESTRICT_DISABLED, null);
770
771        waitForMs(100);
772
773        // verify posted message
774        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
775        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
776        assertEquals(EVENT_PS_RESTRICT_DISABLED, messageArgumentCaptor.getValue().what);
777    }
778
779    @Test
780    @MediumTest
781    public void testRegisterForSubscriptionInfoReady() {
782        sst.registerForSubscriptionInfoReady(mTestHandler, EVENT_SUBSCRIPTION_INFO_READY, null);
783
784        // Call functions which would trigger posting of message on test handler
785        doReturn(false).when(mPhone).isPhoneTypeGsm();
786        sst.updatePhoneType();
787        mSimulatedCommands.notifyOtaProvisionStatusChanged();
788
789        waitForMs(200);
790
791        // verify posted message
792        ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class);
793        verify(mTestHandler).sendMessageAtTime(messageArgumentCaptor.capture(), anyLong());
794        assertEquals(EVENT_SUBSCRIPTION_INFO_READY, messageArgumentCaptor.getValue().what);
795    }
796
797    @Test
798    @SmallTest
799    public void testGetDesiredPowerState() {
800        sst.setRadioPower(true);
801        assertEquals(sst.getDesiredPowerState(), true);
802    }
803
804    @Test
805    @MediumTest
806    public void testEnableLocationUpdates() throws Exception {
807        sst.enableLocationUpdates();
808        verify(mSimulatedCommandsVerifier, times(1)).setLocationUpdates(eq(true),
809                any(Message.class));
810    }
811
812    @Test
813    @SmallTest
814    public void testDisableLocationUpdates() throws Exception {
815        sst.disableLocationUpdates();
816        verify(mSimulatedCommandsVerifier, times(1)).setLocationUpdates(eq(false),
817                any(Message.class));
818    }
819
820    @Test
821    @SmallTest
822    public void testGetCurrentDataRegState() throws Exception {
823        sst.mSS.setDataRegState(ServiceState.STATE_OUT_OF_SERVICE);
824        assertEquals(sst.getCurrentDataConnectionState(), ServiceState.STATE_OUT_OF_SERVICE);
825    }
826
827    @Test
828    @SmallTest
829    public void testIsConcurrentVoiceAndDataAllowed() {
830        // Verify all 3 branches in the function isConcurrentVoiceAndDataAllowed
831        doReturn(true).when(mPhone).isPhoneTypeGsm();
832        sst.mSS.setRilVoiceRadioTechnology(sst.mSS.RIL_RADIO_TECHNOLOGY_HSPA);
833        assertEquals(true, sst.isConcurrentVoiceAndDataAllowed());
834
835        doReturn(false).when(mPhone).isPhoneTypeGsm();
836        doReturn(true).when(mPhone).isPhoneTypeCdma();
837        assertEquals(false, sst.isConcurrentVoiceAndDataAllowed());
838
839        doReturn(false).when(mPhone).isPhoneTypeGsm();
840        doReturn(false).when(mPhone).isPhoneTypeCdma();
841        sst.mSS.setCssIndicator(1);
842        assertEquals(true, sst.isConcurrentVoiceAndDataAllowed());
843        sst.mSS.setCssIndicator(0);
844        assertEquals(false, sst.isConcurrentVoiceAndDataAllowed());
845    }
846
847    @Test
848    @MediumTest
849    public void testIsImsRegistered() throws Exception {
850        mSimulatedCommands.setImsRegistrationState(new int[]{1, PhoneConstants.PHONE_TYPE_GSM});
851        mSimulatedCommands.notifyImsNetworkStateChanged();
852        waitForMs(200);
853        assertEquals(sst.isImsRegistered(), true);
854    }
855
856    @Test
857    @SmallTest
858    public void testIsDeviceShuttingDown() throws Exception {
859        sst.requestShutdown();
860        assertEquals(true, sst.isDeviceShuttingDown());
861    }
862
863    @Test
864    @SmallTest
865    public void testSetTimeFromNITZStr() throws Exception {
866        doReturn(mAlarmManager).when(mIBinder).queryLocalInterface(anyString());
867        mServiceManagerMockedServices.put(Context.ALARM_SERVICE, mIBinder);
868
869        // Mock sending incorrect nitz str from RIL
870        mSimulatedCommands.triggerNITZupdate("38/06/20,00:00:00+0");
871        waitForMs(100);
872        // AlarmManger.setTime is triggered by SystemClock.setCurrentTimeMillis().
873        // Verify system time is not set to incorrect NITZ time
874        verify(mAlarmManager, times(0)).setTime(anyLong());
875
876        // Mock sending correct nitz str from RIL
877        mSimulatedCommands.triggerNITZupdate("15/06/20,00:00:00+0");
878        waitForMs(100);
879        verify(mAlarmManager, times(1)).setTime(anyLong());
880    }
881}
882