1/*
2 * Copyright (C) 2007 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 GSMTestHandler.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.gsm;
18
19import android.os.AsyncResult;
20import android.os.Handler;
21import android.os.HandlerThread;
22import android.os.Looper;
23import android.os.Message;
24import android.os.Process;
25import android.telephony.ServiceState;
26import android.test.AndroidTestCase;
27import android.test.PerformanceTestCase;
28import android.util.Log;
29
30import com.android.internal.telephony.Call;
31import com.android.internal.telephony.CallStateException;
32import com.android.internal.telephony.Connection;
33import com.android.internal.telephony.MmiCode;
34import com.android.internal.telephony.Phone;
35import com.android.internal.telephony.TestPhoneNotifier;
36import com.android.internal.telephony.gsm.CallFailCause;
37import com.android.internal.telephony.gsm.GSMPhone;
38import com.android.internal.telephony.gsm.GSMTestHandler;
39import com.android.internal.telephony.gsm.GsmMmiCode;
40import com.android.internal.telephony.gsm.SuppServiceNotification;
41import com.android.internal.telephony.test.SimulatedCommands;
42import com.android.internal.telephony.test.SimulatedRadioControl;
43
44import java.util.List;
45
46
47public class GSMPhoneTest extends AndroidTestCase implements PerformanceTestCase {
48    private SimulatedRadioControl mRadioControl;
49    private GSMPhone mGSMPhone;
50    private GSMTestHandler mGSMTestHandler;
51    private Handler mHandler;
52
53    private static final int EVENT_PHONE_STATE_CHANGED = 1;
54    private static final int EVENT_DISCONNECT = 2;
55    private static final int EVENT_RINGING = 3;
56    private static final int EVENT_CHANNEL_OPENED = 4;
57    private static final int EVENT_POST_DIAL = 5;
58    private static final int EVENT_DONE = 6;
59    private static final int EVENT_SSN = 7;
60    private static final int EVENT_MMI_INITIATE = 8;
61    private static final int EVENT_MMI_COMPLETE = 9;
62    private static final int EVENT_IN_SERVICE = 10;
63    private static final int SUPP_SERVICE_FAILED = 11;
64    private static final int SERVICE_STATE_CHANGED = 12;
65    private static final int EVENT_OEM_RIL_MESSAGE = 13;
66    public static final int ANY_MESSAGE = -1;
67
68    @Override
69    protected void setUp() throws Exception {
70        super.setUp();
71        mGSMTestHandler = new GSMTestHandler(mContext);
72
73        mGSMTestHandler.start();
74        synchronized (mGSMTestHandler) {
75            do {
76                mGSMTestHandler.wait();
77            } while (mGSMTestHandler.getGSMPhone() == null);
78        }
79
80        mGSMPhone = mGSMTestHandler.getGSMPhone();
81        mRadioControl = mGSMTestHandler.getSimulatedCommands();
82
83        mHandler = mGSMTestHandler.getHandler();
84        mGSMPhone.registerForPreciseCallStateChanged(mHandler, EVENT_PHONE_STATE_CHANGED, null);
85        mGSMPhone.registerForNewRingingConnection(mHandler, EVENT_RINGING, null);
86        mGSMPhone.registerForDisconnect(mHandler, EVENT_DISCONNECT, null);
87
88        mGSMPhone.setOnPostDialCharacter(mHandler, EVENT_POST_DIAL, null);
89
90        mGSMPhone.registerForSuppServiceNotification(mHandler, EVENT_SSN, null);
91        mGSMPhone.registerForMmiInitiate(mHandler, EVENT_MMI_INITIATE, null);
92        mGSMPhone.registerForMmiComplete(mHandler, EVENT_MMI_COMPLETE, null);
93        mGSMPhone.registerForSuppServiceFailed(mHandler, SUPP_SERVICE_FAILED, null);
94
95        mGSMPhone.registerForServiceStateChanged(mHandler, SERVICE_STATE_CHANGED, null);
96
97        // wait until we get phone in both voice and data service
98        Message msg;
99        ServiceState state;
100
101        do {
102            msg = mGSMTestHandler.waitForMessage(SERVICE_STATE_CHANGED);
103            assertNotNull("Message Time Out", msg);
104            state = (ServiceState) ((AsyncResult) msg.obj).result;
105        } while (state.getState() != ServiceState.STATE_IN_SERVICE);
106    }
107
108    @Override
109    protected void tearDown() throws Exception {
110        mRadioControl.shutdown();
111
112        mGSMPhone.unregisterForPreciseCallStateChanged(mHandler);
113        mGSMPhone.unregisterForNewRingingConnection(mHandler);
114        mGSMPhone.unregisterForDisconnect(mHandler);
115        mGSMPhone.setOnPostDialCharacter(mHandler, 0, null);
116        mGSMPhone.unregisterForSuppServiceNotification(mHandler);
117        mGSMPhone.unregisterForMmiInitiate(mHandler);
118        mGSMPhone.unregisterForMmiComplete(mHandler);
119
120        mGSMPhone = null;
121        mRadioControl = null;
122        mHandler = null;
123        mGSMTestHandler.cleanup();
124
125        super.tearDown();
126    }
127
128    // These test can only be run once.
129    public int startPerformance(Intermediates intermediates) {
130        return 1;
131    }
132
133    public boolean isPerformanceOnly() {
134        return false;
135    }
136
137
138    //This test is causing the emulator screen to turn off. I don't understand
139    //why, but I'm removing it until we can figure it out.
140    public void brokenTestGeneral() throws Exception {
141        Connection cn;
142        Message msg;
143        AsyncResult ar;
144
145        // IDLE state
146
147        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
148        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
149        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
150        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
151
152        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
153        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
154        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
155
156        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
157        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
158        assertFalse(mGSMPhone.canConference());
159
160        // One DIALING connection
161
162        mRadioControl.setAutoProgressConnectingCall(false);
163
164        mGSMPhone.dial("+13125551212");
165
166        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
167
168        msg = mGSMTestHandler.waitForMessage(EVENT_PHONE_STATE_CHANGED);
169        assertNotNull("Message Time Out", msg);
170
171        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
172        assertEquals(Call.State.DIALING, mGSMPhone.getForegroundCall().getState());
173        assertTrue(mGSMPhone.getForegroundCall().isDialingOrAlerting());
174
175        /*do {
176            mGSMTestHandler.waitForMessage(ANY_MESSAGE);
177        } while (mGSMPhone.getForegroundCall().getConnections().size() == 0);*/
178
179        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
180        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
181        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
182
183        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
184        assertEquals(Call.State.DIALING,
185                mGSMPhone.getForegroundCall().getState());
186        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
187
188        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
189        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
190
191        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
192        assertTrue(!cn.isIncoming());
193        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
194
195        assertEquals(Connection.DisconnectCause.NOT_DISCONNECTED, cn.getDisconnectCause());
196
197        assertFalse(mGSMPhone.canConference());
198
199        // One ALERTING connection
200
201        mRadioControl.progressConnectingCallState();
202
203        do {
204            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
205        }
206        while (mGSMPhone.getForegroundCall().getState() != Call.State.ALERTING);
207
208        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
209        assertTrue(mGSMPhone.getForegroundCall().isDialingOrAlerting());
210
211        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
212        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
213        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
214
215        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
216        assertEquals(Call.State.ALERTING, mGSMPhone.getForegroundCall().getState());
217        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
218
219        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
220        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
221
222        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
223        assertTrue(!cn.isIncoming());
224        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
225        assertFalse(mGSMPhone.canConference());
226
227        // One ACTIVE connection
228
229        mRadioControl.progressConnectingCallState();
230
231        do {
232            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
233        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
234
235        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
236        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
237
238        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
239        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
240        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
241
242        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
243        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
244        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
245
246        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
247        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
248
249        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
250        assertTrue(!cn.isIncoming());
251        assertEquals(Connection.PostDialState.COMPLETE, cn.getPostDialState());
252        assertFalse(mGSMPhone.canConference());
253
254        // One disconnected connection
255        mGSMPhone.getForegroundCall().hangup();
256
257        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
258        assertNotNull("Message Time Out", msg);
259
260        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
261        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
262
263        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
264        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
265        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
266
267        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
268        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
269        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
270
271        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
272        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
273
274        assertFalse(mGSMPhone.canConference());
275
276        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
277
278        assertEquals(Call.State.DISCONNECTED, cn.getState());
279
280        // Back to idle state
281
282        mGSMPhone.clearDisconnected();
283
284        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
285        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
286
287        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
288        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
289        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
290
291        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
292        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
293        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
294
295        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
296        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
297
298        assertFalse(mGSMPhone.canConference());
299
300        // cn left over from before phone.clearDisconnected();
301
302        assertEquals(Call.State.DISCONNECTED, cn.getState());
303
304        // One ringing (INCOMING) call
305
306        mRadioControl.triggerRing("18005551212");
307
308        msg = mGSMTestHandler.waitForMessage(EVENT_RINGING);
309        assertNotNull("Message Time Out", msg);
310
311        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
312        assertTrue(mGSMPhone.getRingingCall().isRinging());
313
314        ar = (AsyncResult) msg.obj;
315        cn = (Connection) ar.result;
316        assertTrue(cn.isRinging());
317        assertEquals(mGSMPhone.getRingingCall(), cn.getCall());
318
319        assertEquals(1, mGSMPhone.getRingingCall().getConnections().size());
320        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
321        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
322
323        assertEquals(Call.State.INCOMING, mGSMPhone.getRingingCall().getState());
324        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
325        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
326
327        assertTrue(mGSMPhone.getRingingCall().getEarliestCreateTime() > 0);
328        assertEquals(0, mGSMPhone.getRingingCall().getEarliestConnectTime());
329
330        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
331        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
332
333        cn = mGSMPhone.getRingingCall().getConnections().get(0);
334        assertTrue(cn.isIncoming());
335        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
336
337        assertFalse(mGSMPhone.canConference());
338
339        // One mobile terminated active call
340        mGSMPhone.acceptCall();
341
342        do {
343            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
344        } while (mGSMPhone.getRingingCall().getConnections().size() == 1);
345
346        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
347        assertFalse(mGSMPhone.getRingingCall().isRinging());
348
349        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
350        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
351        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
352
353        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
354        assertEquals(Call.State.ACTIVE,
355                mGSMPhone.getForegroundCall().getState());
356        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
357
358        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
359        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
360
361        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
362        assertTrue(cn.isIncoming());
363        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
364
365        assertFalse(mGSMPhone.canConference());
366
367        // One disconnected (local hangup) call
368
369        try {
370            Connection conn;
371            conn = mGSMPhone.getForegroundCall().getConnections().get(0);
372            conn.hangup();
373        } catch (CallStateException ex) {
374            ex.printStackTrace();
375            fail("unexpected ex");
376        }
377
378        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
379        assertNotNull("Message Time Out", msg);
380
381        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
382        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
383        assertFalse(mGSMPhone.getRingingCall().isRinging());
384
385        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
386        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
387        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
388
389        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
390        assertEquals(Call.State.DISCONNECTED,
391                mGSMPhone.getForegroundCall().getState());
392        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
393
394        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
395        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
396
397        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
398
399        assertEquals(Call.State.DISCONNECTED, cn.getState());
400
401        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
402
403        assertFalse(mGSMPhone.canConference());
404
405        // Back to idle state
406
407        mGSMPhone.clearDisconnected();
408
409        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
410        assertFalse(mGSMPhone.getRingingCall().isRinging());
411
412        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
413        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
414        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
415
416        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
417        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
418        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
419
420        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
421        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
422        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
423
424        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
425        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
426
427        assertFalse(mGSMPhone.canConference());
428
429        // cn left over from before phone.clearDisconnected();
430
431        assertEquals(Call.State.DISCONNECTED, cn.getState());
432
433        // One ringing call
434
435        mRadioControl.triggerRing("18005551212");
436
437        do {
438            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
439        } while (mGSMPhone.getRingingCall().getConnections().isEmpty());
440
441        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
442        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
443        assertTrue(mGSMPhone.getRingingCall().isRinging());
444
445        assertEquals(1, mGSMPhone.getRingingCall().getConnections().size());
446        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
447        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
448
449        assertEquals(Call.State.INCOMING, mGSMPhone.getRingingCall().getState());
450        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
451        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
452
453        assertTrue(mGSMPhone.getRingingCall().getEarliestCreateTime() > 0);
454        assertEquals(0, mGSMPhone.getRingingCall().getEarliestConnectTime());
455
456        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
457        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
458
459        assertFalse(mGSMPhone.canConference());
460
461        // One rejected call
462        mGSMPhone.rejectCall();
463
464        do {
465            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
466        } while (mGSMPhone.getState() != Phone.State.IDLE);
467
468        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
469        assertFalse(mGSMPhone.getRingingCall().isRinging());
470
471        assertEquals(1, mGSMPhone.getRingingCall().getConnections().size());
472        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
473        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
474
475        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getRingingCall().getState());
476        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
477        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
478
479        assertTrue(mGSMPhone.getRingingCall().getEarliestCreateTime() > 0);
480        assertEquals(0, mGSMPhone.getRingingCall().getEarliestConnectTime());
481
482        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
483        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
484
485        cn = mGSMPhone.getRingingCall().getEarliestConnection();
486        assertEquals(Call.State.DISCONNECTED, cn.getState());
487
488        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
489
490        assertFalse(mGSMPhone.canConference());
491
492        // Back to idle state
493
494        mGSMPhone.clearDisconnected();
495
496        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
497        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
498        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
499
500        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
501        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
502        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
503
504        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
505        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
506        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
507
508        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
509        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
510
511        assertFalse(mGSMPhone.canConference());
512        assertEquals(Call.State.DISCONNECTED, cn.getState());
513
514        // One ringing call
515
516        mRadioControl.triggerRing("18005551212");
517
518        do {
519            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
520        } while (mGSMPhone.getRingingCall().getConnections().isEmpty());
521
522        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
523        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
524        assertTrue(mGSMPhone.getRingingCall().isRinging());
525
526        cn = mGSMPhone.getRingingCall().getEarliestConnection();
527
528        // Ringing call disconnects
529
530        mRadioControl.triggerHangupForeground();
531
532        do {
533            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
534        } while (mGSMPhone.getState() != Phone.State.IDLE);
535
536        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
537
538        // One Ringing Call
539
540        mRadioControl.triggerRing("18005551212");
541
542        do {
543            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
544        } while (mGSMPhone.getState() != Phone.State.RINGING);
545
546
547        cn = mGSMPhone.getRingingCall().getEarliestConnection();
548
549        // One answered call
550        mGSMPhone.acceptCall();
551
552        do {
553            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
554        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
555
556        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
557        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
558
559        // one holding call
560        mGSMPhone.switchHoldingAndActive();
561
562        do {
563            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
564        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
565
566
567        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
568        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
569
570        // one active call
571        mGSMPhone.switchHoldingAndActive();
572
573        do {
574            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
575        }
576        while (mGSMPhone.getBackgroundCall().getState() == Call.State.HOLDING);
577
578        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
579        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
580
581        // One disconnected call in the foreground slot
582
583        mRadioControl.triggerHangupAll();
584
585        do {
586            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
587        } while (mGSMPhone.getState() != Phone.State.IDLE);
588
589        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
590        assertEquals(Connection.DisconnectCause.NORMAL, cn.getDisconnectCause());
591
592        // Test missed calls
593
594        mRadioControl.triggerRing("18005551212");
595
596        do {
597            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
598        } while (mGSMPhone.getState() != Phone.State.RINGING);
599
600        mGSMPhone.rejectCall();
601
602        do {
603            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
604        } while (msg.what != EVENT_DISCONNECT);
605
606        ar = (AsyncResult) msg.obj;
607        cn = (Connection) ar.result;
608
609        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
610        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
611        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getRingingCall().getState());
612
613        // Test incoming not missed calls
614
615        mRadioControl.triggerRing("18005551212");
616
617        do {
618            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
619        } while (mGSMPhone.getState() != Phone.State.RINGING);
620
621        cn = mGSMPhone.getRingingCall().getEarliestConnection();
622
623        mGSMPhone.acceptCall();
624
625        do {
626            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
627        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
628
629        assertEquals(Connection.DisconnectCause.NOT_DISCONNECTED, cn.getDisconnectCause());
630        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
631        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
632
633        try {
634            mGSMPhone.getForegroundCall().hangup();
635        } catch (CallStateException ex) {
636            ex.printStackTrace();
637            fail("unexpected ex");
638        }
639
640        do {
641            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
642        } while (mGSMPhone.getForegroundCall().getState()
643                != Call.State.DISCONNECTED);
644
645        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
646
647        //
648        // Test held and hangup held calls
649        //
650
651        // One ALERTING call
652        mGSMPhone.dial("+13125551212");
653
654        do {
655            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
656        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
657
658        assertTrue(mGSMPhone.getForegroundCall().isDialingOrAlerting());
659
660        mRadioControl.progressConnectingCallState();
661        mRadioControl.progressConnectingCallState();
662
663        // One ACTIVE call
664
665        do {
666            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
667        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
668
669        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
670
671        // One ACTIVE call, one ringing call
672
673        mRadioControl.triggerRing("18005551212");
674
675        do {
676            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
677        } while (mGSMPhone.getState() != Phone.State.RINGING);
678
679        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
680        assertTrue(mGSMPhone.getRingingCall().isRinging());
681
682        // One HOLDING call, one ACTIVE call
683        mGSMPhone.acceptCall();
684
685        do {
686            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
687        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
688
689        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
690
691        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
692        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
693        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
694        assertTrue(mGSMPhone.canConference());
695
696        // Conference the two
697        mGSMPhone.conference();
698
699        do {
700            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
701        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
702
703        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
704
705        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
706        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
707        assertTrue(mGSMPhone.getForegroundCall().isMultiparty());
708        assertFalse(mGSMPhone.canConference());
709
710        // Hold the multiparty call
711        mGSMPhone.switchHoldingAndActive();
712
713        do {
714            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
715        }
716        while (mGSMPhone.getBackgroundCall().getState() != Call.State.HOLDING);
717
718        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
719        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
720        assertTrue(mGSMPhone.getBackgroundCall().isMultiparty());
721        assertFalse(mGSMPhone.canConference());
722
723        // Multiparty call on hold, call waiting added
724
725        mRadioControl.triggerRing("18005558355");
726
727        do {
728            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
729        } while (mGSMPhone.getState() != Phone.State.RINGING);
730
731        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
732        assertTrue(mGSMPhone.getRingingCall().isRinging());
733
734        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
735        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
736        assertTrue(mGSMPhone.getBackgroundCall().isMultiparty());
737        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
738        assertFalse(mGSMPhone.canConference());
739
740        // Hangup conference call, ringing call still around
741        mGSMPhone.getBackgroundCall().hangup();
742
743        do {
744            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
745        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.DISCONNECTED);
746
747        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
748        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getBackgroundCall().getState());
749
750        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
751        assertTrue(mGSMPhone.getRingingCall().isRinging());
752
753        // Reject waiting call
754        mGSMPhone.rejectCall();
755
756        do {
757            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
758        } while (mGSMPhone.getState() != Phone.State.IDLE);
759
760        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
761        assertFalse(mGSMPhone.getRingingCall().isRinging());
762    }
763
764    public void testOutgoingCallFailImmediately() throws Exception {
765        Message msg;
766
767        // Test outgoing call fail-immediately edge case
768        // This happens when a call terminated before ever appearing in a
769        // call list
770        // This should land the immediately-failing call in the
771        // ForegroundCall list as an IDLE call
772        mRadioControl.setNextDialFailImmediately(true);
773
774        Connection cn = mGSMPhone.dial("+13125551212");
775
776        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
777        assertNotNull("Message Time Out", msg);
778        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
779
780        assertEquals(Connection.DisconnectCause.NORMAL, cn.getDisconnectCause());
781
782        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
783        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
784        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
785
786        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
787        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
788        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
789
790        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
791        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
792    }
793
794    public void testHangupOnOutgoing() throws Exception {
795        Connection cn;
796        Message msg;
797
798        mRadioControl.setAutoProgressConnectingCall(false);
799
800        // Test 1: local hangup in "DIALING" state
801        mGSMPhone.dial("+13125551212");
802
803        do {
804            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
805        }
806        while (mGSMPhone.getForegroundCall().getState() != Call.State.DIALING);
807
808        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
809
810        mGSMPhone.getForegroundCall().hangup();
811
812        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
813        assertNotNull("Message Time Out", msg);
814        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
815
816        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
817        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
818
819        // Test 2: local hangup in "ALERTING" state
820        mGSMPhone.dial("+13125551212");
821
822        do {
823            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
824        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
825
826        mRadioControl.progressConnectingCallState();
827
828        do {
829            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
830        }
831        while (mGSMPhone.getForegroundCall().getState() != Call.State.ALERTING);
832
833        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
834
835        mGSMPhone.getForegroundCall().hangup();
836
837        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
838        assertNotNull("Message Time Out", msg);
839
840        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
841
842        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
843        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
844
845        // Test 3: local immediate hangup before GSM index is
846        // assigned (CallTracker.hangupPendingMO case)
847
848        mRadioControl.pauseResponses();
849
850        cn = mGSMPhone.dial("+13125551212");
851
852        cn.hangup();
853
854        mRadioControl.resumeResponses();
855
856        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
857        assertNotNull("Message Time Out", msg);
858        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
859
860        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
861
862        assertEquals(Connection.DisconnectCause.LOCAL,
863                mGSMPhone.getForegroundCall().getEarliestConnection().getDisconnectCause());
864    }
865
866    public void testHangupOnChannelClose() throws Exception {
867        mGSMPhone.dial("+13125551212");
868
869        do {
870            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
871        } while (mGSMPhone.getForegroundCall().getConnections().isEmpty());
872
873        mRadioControl.shutdown();
874
875        do {
876            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
877            mGSMPhone.clearDisconnected();
878        } while (!mGSMPhone.getForegroundCall().getConnections().isEmpty());
879    }
880
881    public void testIncallMmiCallDeflection() throws Exception {
882        Message msg;
883
884        // establish an active call
885        mGSMPhone.dial("+13125551212");
886
887        do {
888            mRadioControl.progressConnectingCallState();
889            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
890        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
891
892        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
893        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
894
895        // establish a ringing (WAITING) call
896
897        mRadioControl.triggerRing("18005551212");
898
899        msg = mGSMTestHandler.waitForMessage(EVENT_RINGING);
900        assertNotNull("Message Time Out", msg);
901
902        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
903        assertTrue(mGSMPhone.getRingingCall().isRinging());
904        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
905        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
906        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
907
908        // Simulate entering 0 followed by SEND: release all held calls
909        // or sets UDUB for a waiting call.
910        mGSMPhone.handleInCallMmiCommands("0");
911
912        do {
913            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
914        } while (mGSMPhone.getRingingCall().getState() == Call.State.WAITING);
915
916        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
917        assertFalse(mGSMPhone.getRingingCall().isRinging());
918        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getRingingCall().getState());
919        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
920        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
921
922        // change the active call to holding call
923        mGSMPhone.switchHoldingAndActive();
924
925        do {
926            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
927        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
928
929
930        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
931        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
932
933        // Simulate entering 0 followed by SEND: release all held calls
934        // or sets UDUB for a waiting call.
935        mGSMPhone.handleInCallMmiCommands("0");
936
937        do {
938            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
939        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.HOLDING);
940
941        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
942        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
943        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getBackgroundCall().getState());
944    }
945
946    public void testIncallMmiCallWaiting() throws Exception {
947        Message msg;
948
949        // establish an active call
950        mGSMPhone.dial("+13125551212");
951
952        do {
953            mRadioControl.progressConnectingCallState();
954            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
955        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
956
957        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
958        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
959
960        // establish a ringing (WAITING) call
961
962        mRadioControl.triggerRing("18005551212");
963
964        do {
965            msg = mGSMTestHandler.waitForMessage(ANY_MESSAGE);
966            assertNotNull("Message Time Out", msg);
967        } while (msg.what != EVENT_RINGING);
968
969        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
970        assertTrue(mGSMPhone.getRingingCall().isRinging());
971        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
972        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
973        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
974
975        // Simulate entering 1 followed by SEND: release all active calls
976        // (if any exist) and accepts the other (held or waiting) call.
977
978        mGSMPhone.handleInCallMmiCommands("1");
979
980        do {
981            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
982        } while (mGSMPhone.getRingingCall().getState() == Call.State.WAITING);
983
984        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
985        assertFalse(mGSMPhone.getRingingCall().isRinging());
986        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
987        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
988        assertEquals("18005551212",
989                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
990
991        // change the active call to holding call
992        mGSMPhone.switchHoldingAndActive();
993
994        do {
995            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
996        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
997
998        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
999        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1000
1001        // Simulate entering 1 followed by SEND: release all active calls
1002        // (if any exist) and accepts the other (held or waiting) call.
1003        mGSMPhone.handleInCallMmiCommands("1");
1004
1005        do {
1006            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1007        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
1008
1009        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
1010        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1011        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1012        assertEquals("18005551212",
1013                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1014
1015        // at this point, the active call with number==18005551212 should
1016        // have the gsm index of 2
1017
1018        mRadioControl.triggerRing("16505550100");
1019
1020        msg = mGSMTestHandler.waitForMessage(EVENT_RINGING);
1021        assertNotNull("Message Time Out", msg);
1022
1023        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
1024        assertTrue(mGSMPhone.getRingingCall().isRinging());
1025        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
1026        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1027        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1028
1029        // Simulate entering "12" followed by SEND: release the call with
1030        // gsm index equals to 2.
1031        mGSMPhone.handleInCallMmiCommands("12");
1032
1033        do {
1034            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1035        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
1036
1037        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
1038        assertTrue(mGSMPhone.getRingingCall().isRinging());
1039        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
1040        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1041        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1042
1043        mGSMPhone.acceptCall();
1044
1045        do {
1046            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1047        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
1048
1049        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
1050        assertFalse(mGSMPhone.getRingingCall().isRinging());
1051        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
1052        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1053        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1054
1055        // at this point, the call with number==16505550100 should
1056        // have the gsm index of 1
1057        mGSMPhone.dial("+13125551212");
1058
1059        do {
1060            mRadioControl.progressConnectingCallState();
1061            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1062        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE ||
1063                mGSMPhone.getBackgroundCall().getState() != Call.State.HOLDING);
1064
1065        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1066        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1067
1068        // at this point, the active call with number==13125551212 should
1069        // have the gsm index of 2
1070
1071        // Simulate entering "11" followed by SEND: release the call with
1072        // gsm index equals to 1. This should not be allowed, and a
1073        // Supplementary Service notification must be received.
1074        mGSMPhone.handleInCallMmiCommands("11");
1075
1076        msg = mGSMTestHandler.waitForMessage(SUPP_SERVICE_FAILED);
1077        assertNotNull("Message Time Out", msg);
1078        assertFalse("IncallMmiCallWaiting: command should not work on holding call", msg == null);
1079
1080        // Simulate entering "12" followed by SEND: release the call with
1081        // gsm index equals to 2.
1082        mGSMPhone.handleInCallMmiCommands("12");
1083
1084        do {
1085            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1086        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
1087
1088        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1089        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1090
1091        // Simulate entering 1 followed by SEND: release all active calls
1092        // (if any exist) and accepts the other (held or waiting) call.
1093        mGSMPhone.handleInCallMmiCommands("1");
1094
1095        do {
1096            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1097        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
1098
1099        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
1100        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1101        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1102        assertEquals("16505550100",
1103                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1104
1105        // Simulate entering "11" followed by SEND: release the call with
1106        // gsm index equals to 1.
1107        mGSMPhone.handleInCallMmiCommands("11");
1108
1109        do {
1110            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1111        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
1112
1113        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1114        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1115    }
1116
1117    public void testIncallMmiCallHold() throws Exception {
1118        Message msg;
1119
1120        // establish an active call
1121        mGSMPhone.dial("13125551212");
1122
1123        do {
1124            mRadioControl.progressConnectingCallState();
1125            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1126        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
1127
1128        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1129        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1130
1131        // establish a ringing (WAITING) call
1132
1133        mRadioControl.triggerRing("18005551212");
1134
1135        msg = mGSMTestHandler.waitForMessage(EVENT_RINGING);
1136        assertNotNull("Message Time Out", msg);
1137
1138        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
1139        assertTrue(mGSMPhone.getRingingCall().isRinging());
1140        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
1141        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1142        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1143
1144        // simulate entering 2 followed by SEND: place all active calls
1145        // (if any exist) on hold and accepts the other (held or waiting)
1146        // call
1147
1148        mGSMPhone.handleInCallMmiCommands("2");
1149
1150        do {
1151            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1152        } while (mGSMPhone.getRingingCall().getState() == Call.State.WAITING);
1153
1154
1155        assertFalse(mGSMPhone.getRingingCall().isRinging());
1156        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
1157        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
1158        assertEquals(Call.State.ACTIVE,
1159                mGSMPhone.getForegroundCall().getState());
1160        assertEquals("18005551212",
1161                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1162        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1163        assertEquals("13125551212",
1164                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
1165
1166        // swap the active and holding calls
1167        mGSMPhone.handleInCallMmiCommands("2");
1168
1169        msg = mGSMTestHandler.waitForMessage(EVENT_PHONE_STATE_CHANGED);
1170        assertNotNull("Message Time Out", msg);
1171
1172        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1173        assertEquals("13125551212",
1174                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1175        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1176        assertEquals("18005551212",
1177                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
1178
1179        // merge the calls
1180        mGSMPhone.conference();
1181
1182        do {
1183            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1184        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
1185
1186        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1187        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1188        assertEquals(2, mGSMPhone.getForegroundCall().getConnections().size());
1189
1190        // at this point, we have an active conference call, with
1191        // call(1) = 13125551212 and call(2) = 18005551212
1192
1193        // Simulate entering "23" followed by SEND: places all active call
1194        // on hold except call 3. This should fail and a supplementary service
1195        // failed notification should be received.
1196
1197        mGSMPhone.handleInCallMmiCommands("23");
1198
1199        msg = mGSMTestHandler.waitForMessage(SUPP_SERVICE_FAILED);
1200        assertNotNull("Message Time Out", msg);
1201        assertFalse("IncallMmiCallHold: separate should have failed!", msg == null);
1202
1203        // Simulate entering "21" followed by SEND: places all active call
1204        // on hold except call 1.
1205        mGSMPhone.handleInCallMmiCommands("21");
1206
1207        do {
1208            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1209        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
1210
1211        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1212        assertEquals("13125551212",
1213                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1214        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1215        assertEquals("18005551212",
1216                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
1217    }
1218
1219    public void testIncallMmiMultipartyServices() throws Exception {
1220        // establish an active call
1221        mGSMPhone.dial("13125551212");
1222
1223        do {
1224            mRadioControl.progressConnectingCallState();
1225            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1226        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
1227
1228        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1229        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1230
1231        // dial another call
1232        mGSMPhone.dial("18005551212");
1233
1234        do {
1235            mRadioControl.progressConnectingCallState();
1236            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1237        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
1238
1239        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1240        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1241
1242        mGSMPhone.handleInCallMmiCommands("3");
1243
1244        do {
1245            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1246        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
1247
1248        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
1249        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1250        assertEquals("18005551212",
1251                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1252        assertEquals("13125551212",
1253                mGSMPhone.getForegroundCall().getConnections().get(1).getAddress());
1254        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1255    }
1256
1257    public void testCallIndex() throws Exception {
1258        Message msg;
1259
1260        // establish the first call
1261        mGSMPhone.dial("16505550100");
1262
1263        do {
1264            mRadioControl.progressConnectingCallState();
1265            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1266        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
1267
1268        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1269        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1270
1271        String baseNumber = "1650555010";
1272
1273        for (int i = 1; i < 6; i++) {
1274            String number = baseNumber + i;
1275
1276            mGSMPhone.dial(number);
1277
1278            do {
1279                mRadioControl.progressConnectingCallState();
1280                assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1281            } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
1282
1283            assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1284            assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1285
1286            if (mGSMPhone.getBackgroundCall().getConnections().size() >= 5) {
1287                break;
1288            }
1289
1290            mGSMPhone.conference();
1291
1292            do {
1293                assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1294            } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
1295
1296            assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1297            assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1298        }
1299
1300        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1301        assertEquals("16505550105",
1302                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1303        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1304
1305        // create an incoming call, this call should have the call index
1306        // of 7
1307        mRadioControl.triggerRing("18005551212");
1308
1309        msg = mGSMTestHandler.waitForMessage(EVENT_RINGING);
1310        assertNotNull("Message Time Out", msg);
1311
1312        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
1313        assertTrue(mGSMPhone.getRingingCall().isRinging());
1314        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
1315        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1316        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1317
1318        // hangup the background call and accept the ringing call
1319        mGSMPhone.getBackgroundCall().hangup();
1320        mGSMPhone.acceptCall();
1321
1322        do {
1323            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1324        } while (mGSMPhone.getRingingCall().getState() != Call.State.IDLE);
1325
1326        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1327        assertEquals("18005551212",
1328                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
1329        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1330        assertEquals("16505550105",
1331                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
1332
1333        mGSMPhone.handleInCallMmiCommands("17");
1334
1335        do {
1336            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1337        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
1338
1339        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1340        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
1341        assertEquals("16505550105",
1342                mGSMPhone.getBackgroundCall().getConnections().get(0).
1343                        getAddress());
1344
1345        mGSMPhone.handleInCallMmiCommands("1");
1346
1347        do {
1348            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1349        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
1350
1351        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
1352        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1353
1354        mGSMPhone.handleInCallMmiCommands("16");
1355
1356        do {
1357            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1358        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
1359
1360        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1361        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1362    }
1363
1364    public void testPostDialSequences() throws Exception {
1365        Message msg;
1366        AsyncResult ar;
1367        Connection cn;
1368
1369        mGSMPhone.dial("+13125551212,1234;5N8xx");
1370
1371        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1372        assertNotNull("Message Time Out", msg);
1373        ar = (AsyncResult) (msg.obj);
1374        cn = (Connection) (ar.result);
1375        assertEquals(',', msg.arg1);
1376        assertEquals("1234;5N8", cn.getRemainingPostDialString());
1377
1378
1379        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1380        assertNotNull("Message Time Out", msg);
1381        assertEquals('1', msg.arg1);
1382        ar = (AsyncResult) (msg.obj);
1383        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1384
1385
1386        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1387        assertNotNull("Message Time Out", msg);
1388        assertEquals('2', msg.arg1);
1389        ar = (AsyncResult) (msg.obj);
1390        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1391
1392
1393        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1394        assertNotNull("Message Time Out", msg);
1395        assertEquals('3', msg.arg1);
1396        ar = (AsyncResult) (msg.obj);
1397        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1398
1399
1400        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1401        assertNotNull("Message Time Out", msg);
1402        assertEquals('4', msg.arg1);
1403        ar = (AsyncResult) (msg.obj);
1404        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1405
1406
1407        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1408        assertNotNull("Message Time Out", msg);
1409        assertEquals(';', msg.arg1);
1410        ar = (AsyncResult) (msg.obj);
1411        cn = (Connection) (ar.result);
1412        assertEquals(Connection.PostDialState.WAIT, cn.getPostDialState());
1413        assertEquals(Connection.PostDialState.WAIT, ar.userObj);
1414        cn.proceedAfterWaitChar();
1415
1416
1417        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1418        assertNotNull("Message Time Out", msg);
1419        assertEquals('5', msg.arg1);
1420        ar = (AsyncResult) (msg.obj);
1421        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1422
1423
1424        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1425        assertEquals('N', msg.arg1);
1426        ar = (AsyncResult) (msg.obj);
1427        cn = (Connection) (ar.result);
1428        assertEquals(Connection.PostDialState.WILD, cn.getPostDialState());
1429        assertEquals(Connection.PostDialState.WILD, ar.userObj);
1430        cn.proceedAfterWildChar(",6;7");
1431
1432
1433        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1434        assertNotNull("Message Time Out", msg);
1435        ar = (AsyncResult) (msg.obj);
1436        cn = (Connection) (ar.result);
1437        assertEquals(',', msg.arg1);
1438        assertEquals("6;78", cn.getRemainingPostDialString());
1439
1440        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1441        assertNotNull("Message Time Out", msg);
1442        assertEquals('6', msg.arg1);
1443        ar = (AsyncResult) (msg.obj);
1444        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1445
1446        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1447        assertNotNull("Message Time Out", msg);
1448        assertEquals(';', msg.arg1);
1449        ar = (AsyncResult) (msg.obj);
1450        cn = (Connection) (ar.result);
1451        assertEquals(Connection.PostDialState.WAIT, cn.getPostDialState());
1452        assertEquals(Connection.PostDialState.WAIT, ar.userObj);
1453        cn.proceedAfterWaitChar();
1454
1455        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1456        assertNotNull("Message Time Out", msg);
1457        assertEquals('7', msg.arg1);
1458        ar = (AsyncResult) (msg.obj);
1459        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1460
1461        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1462        assertNotNull("Message Time Out", msg);
1463        assertEquals('8', msg.arg1);
1464        ar = (AsyncResult) (msg.obj);
1465        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
1466
1467        // Bogus chars at end should be ignored
1468        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1469        assertNotNull("Message Time Out", msg);
1470        assertEquals(0, msg.arg1);
1471        ar = (AsyncResult) (msg.obj);
1472        cn = (Connection) (ar.result);
1473        assertEquals(Connection.PostDialState.COMPLETE,
1474                cn.getPostDialState());
1475        assertEquals(Connection.PostDialState.COMPLETE, ar.userObj);
1476    }
1477
1478    public void testPostDialCancel() throws Exception {
1479        Message msg;
1480        AsyncResult ar;
1481        Connection cn;
1482
1483        mGSMPhone.dial("+13125551212,N");
1484        mRadioControl.progressConnectingToActive();
1485
1486        mRadioControl.progressConnectingToActive();
1487
1488        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1489        assertNotNull("Message Time Out", msg);
1490        assertEquals(',', msg.arg1);
1491
1492        msg = mGSMTestHandler.waitForMessage(EVENT_POST_DIAL);
1493        assertEquals('N', msg.arg1);
1494        ar = (AsyncResult) (msg.obj);
1495        cn = (Connection) (ar.result);
1496        assertEquals(Connection.PostDialState.WILD, cn.getPostDialState());
1497        cn.cancelPostDial();
1498
1499        assertEquals(Connection.PostDialState.CANCELLED, cn.getPostDialState());
1500    }
1501
1502    public void testOutgoingCallFail() throws Exception {
1503        Message msg;
1504        /*
1505        * normal clearing
1506        */
1507
1508        mRadioControl.setNextCallFailCause(CallFailCause.NORMAL_CLEARING);
1509        mRadioControl.setAutoProgressConnectingCall(false);
1510
1511        Connection cn = mGSMPhone.dial("+13125551212");
1512
1513        mRadioControl.progressConnectingCallState();
1514
1515        // I'm just progressing the call state to
1516        // ensure getCurrentCalls() gets processed...
1517        // Normally these failure conditions would happen in DIALING
1518        // not ALERTING
1519        do {
1520            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1521        } while (cn.getState() == Call.State.DIALING);
1522
1523
1524        mRadioControl.triggerHangupAll();
1525        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
1526        assertNotNull("Message Time Out", msg);
1527        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
1528
1529        assertEquals(Connection.DisconnectCause.NORMAL, cn.getDisconnectCause());
1530
1531        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
1532        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
1533        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
1534
1535        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
1536        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1537        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1538
1539        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
1540        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
1541
1542        /*
1543        * busy
1544        */
1545
1546        mRadioControl.setNextCallFailCause(CallFailCause.USER_BUSY);
1547        mRadioControl.setAutoProgressConnectingCall(false);
1548
1549        cn = mGSMPhone.dial("+13125551212");
1550
1551        mRadioControl.progressConnectingCallState();
1552
1553        // I'm just progressing the call state to
1554        // ensure getCurrentCalls() gets processed...
1555        // Normally these failure conditions would happen in DIALING
1556        // not ALERTING
1557        do {
1558            assertNotNull("Message Time Out", mGSMTestHandler.waitForMessage(ANY_MESSAGE));
1559        } while (cn.getState() == Call.State.DIALING);
1560
1561
1562        mRadioControl.triggerHangupAll();
1563        msg = mGSMTestHandler.waitForMessage(EVENT_DISCONNECT);
1564        assertNotNull("Message Time Out", msg);
1565        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
1566
1567        assertEquals(Connection.DisconnectCause.BUSY, cn.getDisconnectCause());
1568
1569        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
1570        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
1571        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
1572
1573        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
1574        assertEquals(Call.State.DISCONNECTED,
1575                mGSMPhone.getForegroundCall().getState());
1576        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1577
1578        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
1579        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
1580
1581        /*
1582        * congestion
1583        */
1584
1585        mRadioControl.setNextCallFailCause(CallFailCause.NO_CIRCUIT_AVAIL);
1586        mRadioControl.setAutoProgressConnectingCall(false);
1587
1588        cn = mGSMPhone.dial("+13125551212");
1589
1590        mRadioControl.progressConnectingCallState();
1591
1592        // I'm just progressing the call state to
1593        // ensure getCurrentCalls() gets processed...
1594        // Normally these failure conditions would happen in DIALING
1595        // not ALERTING
1596        do {
1597            msg = mGSMTestHandler.waitForMessage(ANY_MESSAGE);
1598            assertNotNull("Message Time Out", msg);
1599        } while (cn.getState() == Call.State.DIALING);
1600
1601
1602        mRadioControl.triggerHangupAll();
1603
1604        // Unlike the while loops above, this one waits
1605        // for a "phone state changed" message back to "idle"
1606        do {
1607            msg = mGSMTestHandler.waitForMessage(ANY_MESSAGE);
1608            assertNotNull("Message Time Out", msg);
1609        } while (!(msg.what == EVENT_PHONE_STATE_CHANGED
1610                && mGSMPhone.getState() == Phone.State.IDLE));
1611
1612        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
1613
1614        assertEquals(Connection.DisconnectCause.CONGESTION, cn.getDisconnectCause());
1615
1616        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
1617        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
1618        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
1619
1620        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
1621        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
1622        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
1623
1624        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
1625        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
1626    }
1627
1628    public void testSSNotification() throws Exception {
1629        // MO
1630        runTest(0, SuppServiceNotification.MO_CODE_UNCONDITIONAL_CF_ACTIVE);
1631        runTest(0, SuppServiceNotification.MO_CODE_CALL_IS_WAITING);
1632        runTest(0, SuppServiceNotification.MO_CODE_CALL_DEFLECTED);
1633
1634        // MT
1635        runTest(1, SuppServiceNotification.MT_CODE_FORWARDED_CALL);
1636        runTest(1, SuppServiceNotification.MT_CODE_CALL_CONNECTED_ECT);
1637        runTest(1, SuppServiceNotification.MT_CODE_ADDITIONAL_CALL_FORWARDED);
1638    }
1639
1640    private void runTest(int type, int code) {
1641        Message msg;
1642
1643        mRadioControl.triggerSsn(type, code);
1644
1645        msg = mGSMTestHandler.waitForMessage(EVENT_SSN);
1646        assertNotNull("Message Time Out", msg);
1647        AsyncResult ar = (AsyncResult) msg.obj;
1648
1649        assertNull(ar.exception);
1650
1651        SuppServiceNotification notification =
1652                (SuppServiceNotification) ar.result;
1653
1654        assertEquals(type, notification.notificationType);
1655        assertEquals(code, notification.code);
1656    }
1657
1658    public void testUssd() throws Exception {
1659        // Quick hack to work around a race condition in this test:
1660        // We may initiate a USSD MMI before GSMPhone receives its initial
1661        // GSMTestHandler.EVENT_RADIO_OFF_OR_NOT_AVAILABLE event.  When the phone sees this
1662        // event, it will cancel the just issued USSD MMI, which we don't
1663        // want.  So sleep a little first.
1664        try {
1665            Thread.sleep(1000);
1666        } catch (InterruptedException ex) {
1667            // do nothing
1668        }
1669
1670        verifyNormal();
1671        verifyCancel();
1672        varifyNetworkInitiated();
1673    }
1674
1675    private void varifyNetworkInitiated() {
1676        Message msg;
1677        AsyncResult ar;
1678        MmiCode mmi;
1679
1680        // Receive an incoming NOTIFY
1681        mRadioControl.triggerIncomingUssd("0", "NOTIFY message");
1682        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1683        assertNotNull("Message Time Out", msg);
1684        ar = (AsyncResult) msg.obj;
1685        mmi = (MmiCode) ar.result;
1686
1687        assertFalse(mmi.isUssdRequest());
1688
1689        // Receive a REQUEST and send response
1690        mRadioControl.triggerIncomingUssd("1", "REQUEST Message");
1691        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1692        assertNotNull("Message Time Out", msg);
1693        ar = (AsyncResult) msg.obj;
1694        mmi = (MmiCode) ar.result;
1695
1696        assertTrue(mmi.isUssdRequest());
1697
1698        mGSMPhone.sendUssdResponse("## TEST: TEST_GSMPhone responding...");
1699        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_INITIATE);
1700        assertNotNull("Message Time Out", msg);
1701        ar = (AsyncResult) msg.obj;
1702        mmi = (MmiCode) ar.result;
1703
1704        GsmMmiCode gsmMmi = (GsmMmiCode) mmi;
1705        assertTrue(gsmMmi.isPendingUSSD());
1706        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1707        assertNotNull("Message Time Out", msg);
1708        ar = (AsyncResult) msg.obj;
1709        mmi = (MmiCode) ar.result;
1710
1711        assertNull(ar.exception);
1712        assertFalse(mmi.isUssdRequest());
1713
1714        // Receive a REQUEST and cancel
1715        mRadioControl.triggerIncomingUssd("1", "REQUEST Message");
1716        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1717        assertNotNull("Message Time Out", msg);
1718        ar = (AsyncResult) msg.obj;
1719        mmi = (MmiCode) ar.result;
1720
1721        assertTrue(mmi.isUssdRequest());
1722
1723        mmi.cancel();
1724        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1725        assertNotNull("Message Time Out", msg);
1726
1727        ar = (AsyncResult) msg.obj;
1728        mmi = (MmiCode) ar.result;
1729
1730        assertNull(ar.exception);
1731        assertEquals(MmiCode.State.CANCELLED, mmi.getState());
1732
1733        List mmiList = mGSMPhone.getPendingMmiCodes();
1734        assertEquals(0, mmiList.size());
1735    }
1736
1737    private void verifyNormal() throws CallStateException {
1738        Message msg;
1739        AsyncResult ar;
1740        MmiCode mmi;
1741
1742        mGSMPhone.dial("#646#");
1743
1744        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_INITIATE);
1745        assertNotNull("Message Time Out", msg);
1746
1747        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1748        assertNotNull("Message Time Out", msg);
1749
1750        ar = (AsyncResult) msg.obj;
1751        mmi = (MmiCode) ar.result;
1752        assertEquals(MmiCode.State.COMPLETE, mmi.getState());
1753    }
1754
1755
1756    private void verifyCancel() throws CallStateException {
1757        /**
1758         * This case makes an assumption that dial() will add the USSD
1759         * to the "pending MMI codes" list before it returns.  This seems
1760         * like reasonable semantics. It also assumes that the USSD
1761         * request in question won't complete until we get back to the
1762         * event loop, thus cancel() is safe.
1763         */
1764        Message msg;
1765
1766        mGSMPhone.dial("#646#");
1767
1768        List<? extends MmiCode> pendingMmis = mGSMPhone.getPendingMmiCodes();
1769
1770        assertEquals(1, pendingMmis.size());
1771
1772        MmiCode mmi = pendingMmis.get(0);
1773        assertTrue(mmi.isCancelable());
1774        mmi.cancel();
1775
1776        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_INITIATE);
1777        assertNotNull("Message Time Out", msg);
1778
1779        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1780        assertNotNull("Message Time Out", msg);
1781
1782        AsyncResult ar = (AsyncResult) msg.obj;
1783        mmi = (MmiCode) ar.result;
1784
1785        assertEquals(MmiCode.State.CANCELLED, mmi.getState());
1786    }
1787
1788    public void testRilHooks() throws Exception {
1789        //
1790        // These test cases all assume the RIL OEM hooks
1791        // just echo back their input
1792        //
1793
1794        Message msg;
1795        AsyncResult ar;
1796
1797        // null byte array
1798
1799        mGSMPhone.invokeOemRilRequestRaw(null, mHandler.obtainMessage(EVENT_OEM_RIL_MESSAGE));
1800
1801        msg = mGSMTestHandler.waitForMessage(EVENT_OEM_RIL_MESSAGE);
1802        assertNotNull("Message Time Out", msg);
1803
1804        ar = ((AsyncResult) msg.obj);
1805
1806        assertNull(ar.result);
1807        assertNull(ar.exception);
1808
1809        // empty byte array
1810
1811        mGSMPhone.invokeOemRilRequestRaw(new byte[0], mHandler.obtainMessage(EVENT_OEM_RIL_MESSAGE));
1812
1813        msg = mGSMTestHandler.waitForMessage(EVENT_OEM_RIL_MESSAGE);
1814        assertNotNull("Message Time Out", msg);
1815
1816        ar = ((AsyncResult) msg.obj);
1817
1818        assertEquals(0, ((byte[]) (ar.result)).length);
1819        assertNull(ar.exception);
1820
1821        // byte array with data
1822
1823        mGSMPhone.invokeOemRilRequestRaw("Hello".getBytes("utf-8"),
1824                mHandler.obtainMessage(EVENT_OEM_RIL_MESSAGE));
1825
1826        msg = mGSMTestHandler.waitForMessage(EVENT_OEM_RIL_MESSAGE);
1827        assertNotNull("Message Time Out", msg);
1828
1829        ar = ((AsyncResult) msg.obj);
1830
1831        assertEquals("Hello", new String(((byte[]) (ar.result)), "utf-8"));
1832        assertNull(ar.exception);
1833
1834        // null strings
1835
1836        mGSMPhone.invokeOemRilRequestStrings(null, mHandler.obtainMessage(EVENT_OEM_RIL_MESSAGE));
1837
1838        msg = mGSMTestHandler.waitForMessage(EVENT_OEM_RIL_MESSAGE);
1839        assertNotNull("Message Time Out", msg);
1840
1841        ar = ((AsyncResult) msg.obj);
1842
1843        assertNull(ar.result);
1844        assertNull(ar.exception);
1845
1846        // empty byte array
1847
1848        mGSMPhone.invokeOemRilRequestStrings(new String[0],
1849                mHandler.obtainMessage(EVENT_OEM_RIL_MESSAGE));
1850
1851        msg = mGSMTestHandler.waitForMessage(EVENT_OEM_RIL_MESSAGE);
1852        assertNotNull("Message Time Out", msg);
1853
1854        ar = ((AsyncResult) msg.obj);
1855
1856        assertEquals(0, ((String[]) (ar.result)).length);
1857        assertNull(ar.exception);
1858
1859        // Strings with data
1860
1861        String s[] = new String[1];
1862
1863        s[0] = "Hello";
1864
1865        mGSMPhone.invokeOemRilRequestStrings(s, mHandler.obtainMessage(EVENT_OEM_RIL_MESSAGE));
1866
1867        msg = mGSMTestHandler.waitForMessage(EVENT_OEM_RIL_MESSAGE);
1868        assertNotNull("Message Time Out", msg);
1869
1870        ar = ((AsyncResult) msg.obj);
1871
1872        assertEquals("Hello", ((String[]) (ar.result))[0]);
1873        assertEquals(1, ((String[]) (ar.result)).length);
1874        assertNull(ar.exception);
1875    }
1876
1877    public void testMmi() throws Exception {
1878        mRadioControl.setAutoProgressConnectingCall(false);
1879
1880        // "valid" MMI sequences
1881        runValidMmi("*#67#", false);
1882        runValidMmi("##43*11#", false);
1883        runValidMmi("#33*1234*11#", false);
1884        runValidMmi("*21*6505551234**5#", false);
1885        runValidMmi("**03**1234*4321*4321#", false);
1886        // pound string
1887        runValidMmi("5308234092307540923#", true);
1888        // short code
1889        runValidMmi("22", true);
1890        // as part of call setup
1891        runValidMmiWithConnect("*31#6505551234");
1892
1893        // invalid MMI sequences
1894        runNotMmi("6505551234");
1895        runNotMmi("1234#*12#34566654");
1896        runNotMmi("*#*#12#*");
1897    }
1898
1899    private void runValidMmi(String dialString, boolean cancelable) throws CallStateException {
1900        Connection c = mGSMPhone.dial(dialString);
1901        assertNull(c);
1902        Message msg = mGSMTestHandler.waitForMessage(EVENT_MMI_INITIATE);
1903        assertNotNull("Message Time Out", msg);
1904        // Should not be cancelable.
1905        AsyncResult ar = (AsyncResult) msg.obj;
1906        MmiCode mmi = (MmiCode) ar.result;
1907        assertEquals(cancelable, mmi.isCancelable());
1908
1909        msg = mGSMTestHandler.waitForMessage(EVENT_MMI_COMPLETE);
1910        assertNotNull("Message Time Out", msg);
1911    }
1912
1913    private void runValidMmiWithConnect(String dialString) throws CallStateException {
1914        mRadioControl.pauseResponses();
1915
1916        Connection c = mGSMPhone.dial(dialString);
1917        assertNotNull(c);
1918
1919        hangup(c);
1920    }
1921
1922    private void hangup(Connection cn) throws CallStateException {
1923        cn.hangup();
1924
1925        mRadioControl.resumeResponses();
1926        assertNotNull(mGSMTestHandler.waitForMessage(EVENT_DISCONNECT));
1927
1928    }
1929
1930    private void runNotMmi(String dialString) throws CallStateException {
1931        mRadioControl.pauseResponses();
1932
1933        Connection c = mGSMPhone.dial(dialString);
1934        assertNotNull(c);
1935
1936        hangup(c);
1937    }
1938}
1939