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