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 17 package com.android.internal.telephony.gsm; 18 19 import android.os.AsyncResult; 20 import android.os.Handler; 21 import android.os.Message; 22 import android.telephony.ServiceState; 23 import android.test.AndroidTestCase; 24 import android.test.PerformanceTestCase; 25 26 import android.telephony.DisconnectCause; 27 28 import com.android.internal.telephony.Call; 29 import com.android.internal.telephony.CallStateException; 30 import com.android.internal.telephony.Connection; 31 import com.android.internal.telephony.MmiCode; 32 import com.android.internal.telephony.Phone; 33 import com.android.internal.telephony.PhoneConstants; 34 import com.android.internal.telephony.gsm.CallFailCause; 35 import com.android.internal.telephony.gsm.GSMPhone; 36 import com.android.internal.telephony.gsm.GSMTestHandler; 37 import com.android.internal.telephony.gsm.GsmMmiCode; 38 import com.android.internal.telephony.gsm.SuppServiceNotification; 39 import com.android.internal.telephony.test.SimulatedRadioControl; 40 41 import java.util.List; 42 43 44 public 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
