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