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