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