SimulatedCommands.java revision 6ad88a8a2caf739e78c8d5f7f50fc7fa84a07ca7
1/* 2 * Copyright (C) 2006 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 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.test; 18 19import android.os.AsyncResult; 20import android.os.HandlerThread; 21import android.os.Looper; 22import android.os.Message; 23import android.telephony.Rlog; 24 25import com.android.internal.telephony.BaseCommands; 26import com.android.internal.telephony.CommandException; 27import com.android.internal.telephony.CommandsInterface; 28import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo; 29import com.android.internal.telephony.dataconnection.DataCallResponse; 30import com.android.internal.telephony.dataconnection.DataProfile; 31import com.android.internal.telephony.Phone; 32import com.android.internal.telephony.UUSInfo; 33import com.android.internal.telephony.gsm.CallFailCause; 34import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo; 35import com.android.internal.telephony.gsm.SuppServiceNotification; 36 37import java.util.ArrayList; 38 39public final class SimulatedCommands extends BaseCommands 40 implements CommandsInterface, SimulatedRadioControl { 41 private final static String LOG_TAG = "SimulatedCommands"; 42 43 private enum SimLockState { 44 NONE, 45 REQUIRE_PIN, 46 REQUIRE_PUK, 47 SIM_PERM_LOCKED 48 } 49 50 private enum SimFdnState { 51 NONE, 52 REQUIRE_PIN2, 53 REQUIRE_PUK2, 54 SIM_PERM_LOCKED 55 } 56 57 private final static SimLockState INITIAL_LOCK_STATE = SimLockState.NONE; 58 private final static String DEFAULT_SIM_PIN_CODE = "1234"; 59 private final static String SIM_PUK_CODE = "12345678"; 60 private final static SimFdnState INITIAL_FDN_STATE = SimFdnState.NONE; 61 private final static String DEFAULT_SIM_PIN2_CODE = "5678"; 62 private final static String SIM_PUK2_CODE = "87654321"; 63 64 //***** Instance Variables 65 66 SimulatedGsmCallState simulatedCallState; 67 HandlerThread mHandlerThread; 68 SimLockState mSimLockedState; 69 boolean mSimLockEnabled; 70 int mPinUnlockAttempts; 71 int mPukUnlockAttempts; 72 String mPinCode; 73 SimFdnState mSimFdnEnabledState; 74 boolean mSimFdnEnabled; 75 int mPin2UnlockAttempts; 76 int mPuk2UnlockAttempts; 77 int mNetworkType; 78 String mPin2Code; 79 boolean mSsnNotifyOn = false; 80 81 int mPausedResponseCount; 82 ArrayList<Message> mPausedResponses = new ArrayList<Message>(); 83 84 int mNextCallFailCause = CallFailCause.NORMAL_CLEARING; 85 86 //***** Constructor 87 88 public 89 SimulatedCommands() { 90 super(null); // Don't log statistics 91 mHandlerThread = new HandlerThread("SimulatedCommands"); 92 mHandlerThread.start(); 93 Looper looper = mHandlerThread.getLooper(); 94 95 simulatedCallState = new SimulatedGsmCallState(looper); 96 97 setRadioState(RadioState.RADIO_OFF); 98 mSimLockedState = INITIAL_LOCK_STATE; 99 mSimLockEnabled = (mSimLockedState != SimLockState.NONE); 100 mPinCode = DEFAULT_SIM_PIN_CODE; 101 mSimFdnEnabledState = INITIAL_FDN_STATE; 102 mSimFdnEnabled = (mSimFdnEnabledState != SimFdnState.NONE); 103 mPin2Code = DEFAULT_SIM_PIN2_CODE; 104 } 105 106 //***** CommandsInterface implementation 107 108 @Override 109 public void getIccCardStatus(Message result) { 110 unimplemented(result); 111 } 112 113 @Override 114 public void supplyIccPin(String pin, Message result) { 115 if (mSimLockedState != SimLockState.REQUIRE_PIN) { 116 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: wrong state, state=" + 117 mSimLockedState); 118 CommandException ex = new CommandException( 119 CommandException.Error.PASSWORD_INCORRECT); 120 AsyncResult.forMessage(result, null, ex); 121 result.sendToTarget(); 122 return; 123 } 124 125 if (pin != null && pin.equals(mPinCode)) { 126 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: success!"); 127 mPinUnlockAttempts = 0; 128 mSimLockedState = SimLockState.NONE; 129 mIccStatusChangedRegistrants.notifyRegistrants(); 130 131 if (result != null) { 132 AsyncResult.forMessage(result, null, null); 133 result.sendToTarget(); 134 } 135 136 return; 137 } 138 139 if (result != null) { 140 mPinUnlockAttempts ++; 141 142 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: failed! attempt=" + 143 mPinUnlockAttempts); 144 if (mPinUnlockAttempts >= 3) { 145 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: set state to REQUIRE_PUK"); 146 mSimLockedState = SimLockState.REQUIRE_PUK; 147 } 148 149 CommandException ex = new CommandException( 150 CommandException.Error.PASSWORD_INCORRECT); 151 AsyncResult.forMessage(result, null, ex); 152 result.sendToTarget(); 153 } 154 } 155 156 @Override 157 public void supplyIccPuk(String puk, String newPin, Message result) { 158 if (mSimLockedState != SimLockState.REQUIRE_PUK) { 159 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: wrong state, state=" + 160 mSimLockedState); 161 CommandException ex = new CommandException( 162 CommandException.Error.PASSWORD_INCORRECT); 163 AsyncResult.forMessage(result, null, ex); 164 result.sendToTarget(); 165 return; 166 } 167 168 if (puk != null && puk.equals(SIM_PUK_CODE)) { 169 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: success!"); 170 mSimLockedState = SimLockState.NONE; 171 mPukUnlockAttempts = 0; 172 mIccStatusChangedRegistrants.notifyRegistrants(); 173 174 if (result != null) { 175 AsyncResult.forMessage(result, null, null); 176 result.sendToTarget(); 177 } 178 179 return; 180 } 181 182 if (result != null) { 183 mPukUnlockAttempts ++; 184 185 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: failed! attempt=" + 186 mPukUnlockAttempts); 187 if (mPukUnlockAttempts >= 10) { 188 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: set state to SIM_PERM_LOCKED"); 189 mSimLockedState = SimLockState.SIM_PERM_LOCKED; 190 } 191 192 CommandException ex = new CommandException( 193 CommandException.Error.PASSWORD_INCORRECT); 194 AsyncResult.forMessage(result, null, ex); 195 result.sendToTarget(); 196 } 197 } 198 199 @Override 200 public void supplyIccPin2(String pin2, Message result) { 201 if (mSimFdnEnabledState != SimFdnState.REQUIRE_PIN2) { 202 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: wrong state, state=" + 203 mSimFdnEnabledState); 204 CommandException ex = new CommandException( 205 CommandException.Error.PASSWORD_INCORRECT); 206 AsyncResult.forMessage(result, null, ex); 207 result.sendToTarget(); 208 return; 209 } 210 211 if (pin2 != null && pin2.equals(mPin2Code)) { 212 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: success!"); 213 mPin2UnlockAttempts = 0; 214 mSimFdnEnabledState = SimFdnState.NONE; 215 216 if (result != null) { 217 AsyncResult.forMessage(result, null, null); 218 result.sendToTarget(); 219 } 220 221 return; 222 } 223 224 if (result != null) { 225 mPin2UnlockAttempts ++; 226 227 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: failed! attempt=" + 228 mPin2UnlockAttempts); 229 if (mPin2UnlockAttempts >= 3) { 230 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: set state to REQUIRE_PUK2"); 231 mSimFdnEnabledState = SimFdnState.REQUIRE_PUK2; 232 } 233 234 CommandException ex = new CommandException( 235 CommandException.Error.PASSWORD_INCORRECT); 236 AsyncResult.forMessage(result, null, ex); 237 result.sendToTarget(); 238 } 239 } 240 241 @Override 242 public void supplyIccPuk2(String puk2, String newPin2, Message result) { 243 if (mSimFdnEnabledState != SimFdnState.REQUIRE_PUK2) { 244 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: wrong state, state=" + 245 mSimLockedState); 246 CommandException ex = new CommandException( 247 CommandException.Error.PASSWORD_INCORRECT); 248 AsyncResult.forMessage(result, null, ex); 249 result.sendToTarget(); 250 return; 251 } 252 253 if (puk2 != null && puk2.equals(SIM_PUK2_CODE)) { 254 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: success!"); 255 mSimFdnEnabledState = SimFdnState.NONE; 256 mPuk2UnlockAttempts = 0; 257 258 if (result != null) { 259 AsyncResult.forMessage(result, null, null); 260 result.sendToTarget(); 261 } 262 263 return; 264 } 265 266 if (result != null) { 267 mPuk2UnlockAttempts ++; 268 269 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: failed! attempt=" + 270 mPuk2UnlockAttempts); 271 if (mPuk2UnlockAttempts >= 10) { 272 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: set state to SIM_PERM_LOCKED"); 273 mSimFdnEnabledState = SimFdnState.SIM_PERM_LOCKED; 274 } 275 276 CommandException ex = new CommandException( 277 CommandException.Error.PASSWORD_INCORRECT); 278 AsyncResult.forMessage(result, null, ex); 279 result.sendToTarget(); 280 } 281 } 282 283 @Override 284 public void changeIccPin(String oldPin, String newPin, Message result) { 285 if (oldPin != null && oldPin.equals(mPinCode)) { 286 mPinCode = newPin; 287 if (result != null) { 288 AsyncResult.forMessage(result, null, null); 289 result.sendToTarget(); 290 } 291 292 return; 293 } 294 295 if (result != null) { 296 Rlog.i(LOG_TAG, "[SimCmd] changeIccPin: pin failed!"); 297 298 CommandException ex = new CommandException( 299 CommandException.Error.PASSWORD_INCORRECT); 300 AsyncResult.forMessage(result, null, ex); 301 result.sendToTarget(); 302 } 303 } 304 305 @Override 306 public void changeIccPin2(String oldPin2, String newPin2, Message result) { 307 if (oldPin2 != null && oldPin2.equals(mPin2Code)) { 308 mPin2Code = newPin2; 309 if (result != null) { 310 AsyncResult.forMessage(result, null, null); 311 result.sendToTarget(); 312 } 313 314 return; 315 } 316 317 if (result != null) { 318 Rlog.i(LOG_TAG, "[SimCmd] changeIccPin2: pin2 failed!"); 319 320 CommandException ex = new CommandException( 321 CommandException.Error.PASSWORD_INCORRECT); 322 AsyncResult.forMessage(result, null, ex); 323 result.sendToTarget(); 324 } 325 } 326 327 @Override 328 public void 329 changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) { 330 unimplemented(result); 331 } 332 333 @Override 334 public void 335 setSuppServiceNotifications(boolean enable, Message result) { 336 resultSuccess(result, null); 337 338 if (enable && mSsnNotifyOn) { 339 Rlog.w(LOG_TAG, "Supp Service Notifications already enabled!"); 340 } 341 342 mSsnNotifyOn = enable; 343 } 344 345 @Override 346 public void queryFacilityLock(String facility, String pin, 347 int serviceClass, Message result) { 348 queryFacilityLockForApp(facility, pin, serviceClass, null, result); 349 } 350 351 @Override 352 public void queryFacilityLockForApp(String facility, String pin, int serviceClass, 353 String appId, Message result) { 354 if (facility != null && facility.equals(CommandsInterface.CB_FACILITY_BA_SIM)) { 355 if (result != null) { 356 int[] r = new int[1]; 357 r[0] = (mSimLockEnabled ? 1 : 0); 358 Rlog.i(LOG_TAG, "[SimCmd] queryFacilityLock: SIM is " 359 + (r[0] == 0 ? "unlocked" : "locked")); 360 AsyncResult.forMessage(result, r, null); 361 result.sendToTarget(); 362 } 363 return; 364 } else if (facility != null && facility.equals(CommandsInterface.CB_FACILITY_BA_FD)) { 365 if (result != null) { 366 int[] r = new int[1]; 367 r[0] = (mSimFdnEnabled ? 1 : 0); 368 Rlog.i(LOG_TAG, "[SimCmd] queryFacilityLock: FDN is " 369 + (r[0] == 0 ? "disabled" : "enabled")); 370 AsyncResult.forMessage(result, r, null); 371 result.sendToTarget(); 372 } 373 return; 374 } 375 376 unimplemented(result); 377 } 378 379 @Override 380 public void setFacilityLock(String facility, boolean lockEnabled, String pin, int serviceClass, 381 Message result) { 382 setFacilityLockForApp(facility, lockEnabled, pin, serviceClass, null, result); 383 } 384 385 @Override 386 public void setFacilityLockForApp(String facility, boolean lockEnabled, 387 String pin, int serviceClass, String appId, 388 Message result) { 389 if (facility != null && 390 facility.equals(CommandsInterface.CB_FACILITY_BA_SIM)) { 391 if (pin != null && pin.equals(mPinCode)) { 392 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin is valid"); 393 mSimLockEnabled = lockEnabled; 394 395 if (result != null) { 396 AsyncResult.forMessage(result, null, null); 397 result.sendToTarget(); 398 } 399 400 return; 401 } 402 403 if (result != null) { 404 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin failed!"); 405 406 CommandException ex = new CommandException( 407 CommandException.Error.GENERIC_FAILURE); 408 AsyncResult.forMessage(result, null, ex); 409 result.sendToTarget(); 410 } 411 412 return; 413 } else if (facility != null && 414 facility.equals(CommandsInterface.CB_FACILITY_BA_FD)) { 415 if (pin != null && pin.equals(mPin2Code)) { 416 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin2 is valid"); 417 mSimFdnEnabled = lockEnabled; 418 419 if (result != null) { 420 AsyncResult.forMessage(result, null, null); 421 result.sendToTarget(); 422 } 423 424 return; 425 } 426 427 if (result != null) { 428 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin2 failed!"); 429 430 CommandException ex = new CommandException( 431 CommandException.Error.GENERIC_FAILURE); 432 AsyncResult.forMessage(result, null, ex); 433 result.sendToTarget(); 434 } 435 436 return; 437 } 438 439 unimplemented(result); 440 } 441 442 @Override 443 public void supplyNetworkDepersonalization(String netpin, Message result) { 444 unimplemented(result); 445 } 446 447 /** 448 * returned message 449 * retMsg.obj = AsyncResult ar 450 * ar.exception carries exception on failure 451 * ar.userObject contains the original value of result.obj 452 * ar.result contains a List of DriverCall 453 * The ar.result List is sorted by DriverCall.index 454 */ 455 @Override 456 public void getCurrentCalls (Message result) { 457 if ((mState == RadioState.RADIO_ON) && !isSimLocked()) { 458 //Rlog.i("GSM", "[SimCmds] getCurrentCalls"); 459 resultSuccess(result, simulatedCallState.getDriverCalls()); 460 } else { 461 //Rlog.i("GSM", "[SimCmds] getCurrentCalls: RADIO_OFF or SIM not ready!"); 462 resultFail(result, 463 new CommandException( 464 CommandException.Error.RADIO_NOT_AVAILABLE)); 465 } 466 } 467 468 /** 469 * @deprecated 470 */ 471 @Deprecated 472 @Override 473 public void getPDPContextList(Message result) { 474 getDataCallList(result); 475 } 476 477 /** 478 * returned message 479 * retMsg.obj = AsyncResult ar 480 * ar.exception carries exception on failure 481 * ar.userObject contains the original value of result.obj 482 * ar.result contains a List of DataCallResponse 483 */ 484 @Override 485 public void getDataCallList(Message result) { 486 resultSuccess(result, new ArrayList<DataCallResponse>(0)); 487 } 488 489 /** 490 * returned message 491 * retMsg.obj = AsyncResult ar 492 * ar.exception carries exception on failure 493 * ar.userObject contains the original value of result.obj 494 * ar.result is null on success and failure 495 * 496 * CLIR_DEFAULT == on "use subscription default value" 497 * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation) 498 * CLIR_INVOCATION == on "CLIR invocation" (restrict CLI presentation) 499 */ 500 @Override 501 public void dial (String address, int clirMode, Message result) { 502 simulatedCallState.onDial(address); 503 504 resultSuccess(result, null); 505 } 506 507 /** 508 * returned message 509 * retMsg.obj = AsyncResult ar 510 * ar.exception carries exception on failure 511 * ar.userObject contains the original value of result.obj 512 * ar.result is null on success and failure 513 * 514 * CLIR_DEFAULT == on "use subscription default value" 515 * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation) 516 * CLIR_INVOCATION == on "CLIR invocation" (restrict CLI presentation) 517 */ 518 @Override 519 public void dial(String address, int clirMode, UUSInfo uusInfo, Message result) { 520 simulatedCallState.onDial(address); 521 522 resultSuccess(result, null); 523 } 524 525 @Override 526 public void getIMSI(Message result) { 527 getIMSIForApp(null, result); 528 } 529 /** 530 * returned message 531 * retMsg.obj = AsyncResult ar 532 * ar.exception carries exception on failure 533 * ar.userObject contains the original value of result.obj 534 * ar.result is String containing IMSI on success 535 */ 536 @Override 537 public void getIMSIForApp(String aid, Message result) { 538 resultSuccess(result, "012345678901234"); 539 } 540 541 /** 542 * returned message 543 * retMsg.obj = AsyncResult ar 544 * ar.exception carries exception on failure 545 * ar.userObject contains the original value of result.obj 546 * ar.result is String containing IMEI on success 547 */ 548 @Override 549 public void getIMEI(Message result) { 550 resultSuccess(result, "012345678901234"); 551 } 552 553 /** 554 * returned message 555 * retMsg.obj = AsyncResult ar 556 * ar.exception carries exception on failure 557 * ar.userObject contains the original value of result.obj 558 * ar.result is String containing IMEISV on success 559 */ 560 @Override 561 public void getIMEISV(Message result) { 562 resultSuccess(result, "99"); 563 } 564 565 /** 566 * Hang up one individual connection. 567 * returned message 568 * retMsg.obj = AsyncResult ar 569 * ar.exception carries exception on failure 570 * ar.userObject contains the original value of result.obj 571 * ar.result is null on success and failure 572 * 573 * 3GPP 22.030 6.5.5 574 * "Releases a specific active call X" 575 */ 576 @Override 577 public void hangupConnection (int gsmIndex, Message result) { 578 boolean success; 579 580 success = simulatedCallState.onChld('1', (char)('0'+gsmIndex)); 581 582 if (!success){ 583 Rlog.i("GSM", "[SimCmd] hangupConnection: resultFail"); 584 resultFail(result, new RuntimeException("Hangup Error")); 585 } else { 586 Rlog.i("GSM", "[SimCmd] hangupConnection: resultSuccess"); 587 resultSuccess(result, null); 588 } 589 } 590 591 /** 592 * 3GPP 22.030 6.5.5 593 * "Releases all held calls or sets User Determined User Busy (UDUB) 594 * for a waiting call." 595 * ar.exception carries exception on failure 596 * ar.userObject contains the original value of result.obj 597 * ar.result is null on success and failure 598 */ 599 @Override 600 public void hangupWaitingOrBackground (Message result) { 601 boolean success; 602 603 success = simulatedCallState.onChld('0', '\0'); 604 605 if (!success){ 606 resultFail(result, new RuntimeException("Hangup Error")); 607 } else { 608 resultSuccess(result, null); 609 } 610 } 611 612 /** 613 * 3GPP 22.030 6.5.5 614 * "Releases all active calls (if any exist) and accepts 615 * the other (held or waiting) call." 616 * 617 * ar.exception carries exception on failure 618 * ar.userObject contains the original value of result.obj 619 * ar.result is null on success and failure 620 */ 621 @Override 622 public void hangupForegroundResumeBackground (Message result) { 623 boolean success; 624 625 success = simulatedCallState.onChld('1', '\0'); 626 627 if (!success){ 628 resultFail(result, new RuntimeException("Hangup Error")); 629 } else { 630 resultSuccess(result, null); 631 } 632 } 633 634 /** 635 * 3GPP 22.030 6.5.5 636 * "Places all active calls (if any exist) on hold and accepts 637 * the other (held or waiting) call." 638 * 639 * ar.exception carries exception on failure 640 * ar.userObject contains the original value of result.obj 641 * ar.result is null on success and failure 642 */ 643 @Override 644 public void switchWaitingOrHoldingAndActive (Message result) { 645 boolean success; 646 647 success = simulatedCallState.onChld('2', '\0'); 648 649 if (!success){ 650 resultFail(result, new RuntimeException("Hangup Error")); 651 } else { 652 resultSuccess(result, null); 653 } 654 } 655 656 /** 657 * 3GPP 22.030 6.5.5 658 * "Adds a held call to the conversation" 659 * 660 * ar.exception carries exception on failure 661 * ar.userObject contains the original value of result.obj 662 * ar.result is null on success and failure 663 */ 664 @Override 665 public void conference (Message result) { 666 boolean success; 667 668 success = simulatedCallState.onChld('3', '\0'); 669 670 if (!success){ 671 resultFail(result, new RuntimeException("Hangup Error")); 672 } else { 673 resultSuccess(result, null); 674 } 675 } 676 677 /** 678 * 3GPP 22.030 6.5.5 679 * "Connects the two calls and disconnects the subscriber from both calls" 680 * 681 * ar.exception carries exception on failure 682 * ar.userObject contains the original value of result.obj 683 * ar.result is null on success and failure 684 */ 685 @Override 686 public void explicitCallTransfer (Message result) { 687 boolean success; 688 689 success = simulatedCallState.onChld('4', '\0'); 690 691 if (!success){ 692 resultFail(result, new RuntimeException("Hangup Error")); 693 } else { 694 resultSuccess(result, null); 695 } 696 } 697 698 /** 699 * 3GPP 22.030 6.5.5 700 * "Places all active calls on hold except call X with which 701 * communication shall be supported." 702 */ 703 @Override 704 public void separateConnection (int gsmIndex, Message result) { 705 boolean success; 706 707 char ch = (char)(gsmIndex + '0'); 708 success = simulatedCallState.onChld('2', ch); 709 710 if (!success){ 711 resultFail(result, new RuntimeException("Hangup Error")); 712 } else { 713 resultSuccess(result, null); 714 } 715 } 716 717 /** 718 * 719 * ar.exception carries exception on failure 720 * ar.userObject contains the original value of result.obj 721 * ar.result is null on success and failure 722 */ 723 @Override 724 public void acceptCall (Message result) { 725 boolean success; 726 727 success = simulatedCallState.onAnswer(); 728 729 if (!success){ 730 resultFail(result, new RuntimeException("Hangup Error")); 731 } else { 732 resultSuccess(result, null); 733 } 734 } 735 736 /** 737 * also known as UDUB 738 * ar.exception carries exception on failure 739 * ar.userObject contains the original value of result.obj 740 * ar.result is null on success and failure 741 */ 742 @Override 743 public void rejectCall (Message result) { 744 boolean success; 745 746 success = simulatedCallState.onChld('0', '\0'); 747 748 if (!success){ 749 resultFail(result, new RuntimeException("Hangup Error")); 750 } else { 751 resultSuccess(result, null); 752 } 753 } 754 755 /** 756 * cause code returned as Integer in Message.obj.response 757 * Returns integer cause code defined in TS 24.008 758 * Annex H or closest approximation. 759 * Most significant codes: 760 * - Any defined in 22.001 F.4 (for generating busy/congestion) 761 * - Cause 68: ACM >= ACMMax 762 */ 763 @Override 764 public void getLastCallFailCause (Message result) { 765 int[] ret = new int[1]; 766 767 ret[0] = mNextCallFailCause; 768 resultSuccess(result, ret); 769 } 770 771 /** 772 * @deprecated 773 */ 774 @Deprecated 775 @Override 776 public void getLastPdpFailCause (Message result) { 777 unimplemented(result); 778 } 779 780 @Override 781 public void getLastDataCallFailCause(Message result) { 782 // 783 unimplemented(result); 784 } 785 786 @Override 787 public void setMute (boolean enableMute, Message result) {unimplemented(result);} 788 789 @Override 790 public void getMute (Message result) {unimplemented(result);} 791 792 /** 793 * response.obj is an AsyncResult 794 * response.obj.result is an int[2] 795 * response.obj.result[0] is received signal strength (0-31, 99) 796 * response.obj.result[1] is bit error rate (0-7, 99) 797 * as defined in TS 27.007 8.5 798 */ 799 @Override 800 public void getSignalStrength (Message result) { 801 int ret[] = new int[2]; 802 803 ret[0] = 23; 804 ret[1] = 0; 805 806 resultSuccess(result, ret); 807 } 808 809 /** 810 * Assign a specified band for RF configuration. 811 * 812 * @param bandMode one of BM_*_BAND 813 * @param result is callback message 814 */ 815 @Override 816 public void setBandMode (int bandMode, Message result) { 817 resultSuccess(result, null); 818 } 819 820 /** 821 * Query the list of band mode supported by RF. 822 * 823 * @param result is callback message 824 * ((AsyncResult)response.obj).result is an int[] where int[0] is 825 * the size of the array and the rest of each element representing 826 * one available BM_*_BAND 827 */ 828 @Override 829 public void queryAvailableBandMode (Message result) { 830 int ret[] = new int [4]; 831 832 ret[0] = 4; 833 ret[1] = Phone.BM_US_BAND; 834 ret[2] = Phone.BM_JPN_BAND; 835 ret[3] = Phone.BM_AUS_BAND; 836 837 resultSuccess(result, ret); 838 } 839 840 /** 841 * {@inheritDoc} 842 */ 843 @Override 844 public void sendTerminalResponse(String contents, Message response) { 845 resultSuccess(response, null); 846 } 847 848 /** 849 * {@inheritDoc} 850 */ 851 @Override 852 public void sendEnvelope(String contents, Message response) { 853 resultSuccess(response, null); 854 } 855 856 /** 857 * {@inheritDoc} 858 */ 859 @Override 860 public void sendEnvelopeWithStatus(String contents, Message response) { 861 resultSuccess(response, null); 862 } 863 864 /** 865 * {@inheritDoc} 866 */ 867 @Override 868 public void handleCallSetupRequestFromSim( 869 boolean accept, Message response) { 870 resultSuccess(response, null); 871 } 872 873 /** 874 * response.obj.result is an String[14] 875 * See ril.h for details 876 * 877 * Please note that registration state 4 ("unknown") is treated 878 * as "out of service" above 879 */ 880 @Override 881 public void getVoiceRegistrationState (Message result) { 882 String ret[] = new String[14]; 883 884 ret[0] = "5"; // registered roam 885 ret[1] = null; 886 ret[2] = null; 887 ret[3] = null; 888 ret[4] = null; 889 ret[5] = null; 890 ret[6] = null; 891 ret[7] = null; 892 ret[8] = null; 893 ret[9] = null; 894 ret[10] = null; 895 ret[11] = null; 896 ret[12] = null; 897 ret[13] = null; 898 899 resultSuccess(result, ret); 900 } 901 902 /** 903 * response.obj.result is an String[4] 904 * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2 905 * response.obj.result[1] is LAC if registered or NULL if not 906 * response.obj.result[2] is CID if registered or NULL if not 907 * response.obj.result[3] indicates the available radio technology, where: 908 * 0 == unknown 909 * 1 == GPRS only 910 * 2 == EDGE 911 * 3 == UMTS 912 * 913 * valid LAC are 0x0000 - 0xffff 914 * valid CID are 0x00000000 - 0xffffffff 915 * 916 * Please note that registration state 4 ("unknown") is treated 917 * as "out of service" in the Android telephony system 918 */ 919 @Override 920 public void getDataRegistrationState (Message result) { 921 String ret[] = new String[4]; 922 923 ret[0] = "5"; // registered roam 924 ret[1] = null; 925 ret[2] = null; 926 ret[3] = "2"; 927 928 resultSuccess(result, ret); 929 } 930 931 /** 932 * response.obj.result is a String[3] 933 * response.obj.result[0] is long alpha or null if unregistered 934 * response.obj.result[1] is short alpha or null if unregistered 935 * response.obj.result[2] is numeric or null if unregistered 936 */ 937 @Override 938 public void getOperator(Message result) { 939 String[] ret = new String[3]; 940 941 ret[0] = "El Telco Loco"; 942 ret[1] = "Telco Loco"; 943 ret[2] = "001001"; 944 945 resultSuccess(result, ret); 946 } 947 948 /** 949 * ar.exception carries exception on failure 950 * ar.userObject contains the original value of result.obj 951 * ar.result is null on success and failure 952 */ 953 @Override 954 public void sendDtmf(char c, Message result) { 955 resultSuccess(result, null); 956 } 957 958 /** 959 * ar.exception carries exception on failure 960 * ar.userObject contains the original value of result.obj 961 * ar.result is null on success and failure 962 */ 963 @Override 964 public void startDtmf(char c, Message result) { 965 resultSuccess(result, null); 966 } 967 968 /** 969 * ar.exception carries exception on failure 970 * ar.userObject contains the original value of result.obj 971 * ar.result is null on success and failure 972 */ 973 @Override 974 public void stopDtmf(Message result) { 975 resultSuccess(result, null); 976 } 977 978 /** 979 * ar.exception carries exception on failure 980 * ar.userObject contains the original value of result.obj 981 * ar.result is null on success and failure 982 */ 983 @Override 984 public void sendBurstDtmf(String dtmfString, int on, int off, Message result) { 985 resultSuccess(result, null); 986 } 987 988 /** 989 * smscPDU is smsc address in PDU form GSM BCD format prefixed 990 * by a length byte (as expected by TS 27.005) or NULL for default SMSC 991 * pdu is SMS in PDU format as an ASCII hex string 992 * less the SMSC address 993 */ 994 @Override 995 public void sendSMS (String smscPDU, String pdu, Message result) {unimplemented(result);} 996 997 /** 998 * Send an SMS message, Identical to sendSMS, 999 * except that more messages are expected to be sent soon 1000 * smscPDU is smsc address in PDU form GSM BCD format prefixed 1001 * by a length byte (as expected by TS 27.005) or NULL for default SMSC 1002 * pdu is SMS in PDU format as an ASCII hex string 1003 * less the SMSC address 1004 */ 1005 @Override 1006 public void sendSMSExpectMore (String smscPDU, String pdu, Message result) { 1007 unimplemented(result); 1008 } 1009 1010 @Override 1011 public void deleteSmsOnSim(int index, Message response) { 1012 Rlog.d(LOG_TAG, "Delete message at index " + index); 1013 unimplemented(response); 1014 } 1015 1016 @Override 1017 public void deleteSmsOnRuim(int index, Message response) { 1018 Rlog.d(LOG_TAG, "Delete RUIM message at index " + index); 1019 unimplemented(response); 1020 } 1021 1022 @Override 1023 public void writeSmsToSim(int status, String smsc, String pdu, Message response) { 1024 Rlog.d(LOG_TAG, "Write SMS to SIM with status " + status); 1025 unimplemented(response); 1026 } 1027 1028 @Override 1029 public void writeSmsToRuim(int status, String pdu, Message response) { 1030 Rlog.d(LOG_TAG, "Write SMS to RUIM with status " + status); 1031 unimplemented(response); 1032 } 1033 1034 @Override 1035 public void setupDataCall(String radioTechnology, String profile, 1036 String apn, String user, String password, String authType, 1037 String protocol, Message result) { 1038 unimplemented(result); 1039 } 1040 1041 @Override 1042 public void deactivateDataCall(int cid, int reason, Message result) {unimplemented(result);} 1043 1044 @Override 1045 public void setPreferredNetworkType(int networkType , Message result) { 1046 mNetworkType = networkType; 1047 resultSuccess(result, null); 1048 } 1049 1050 @Override 1051 public void getPreferredNetworkType(Message result) { 1052 int ret[] = new int[1]; 1053 1054 ret[0] = mNetworkType; 1055 resultSuccess(result, ret); 1056 } 1057 1058 @Override 1059 public void getNeighboringCids(Message result) { 1060 int ret[] = new int[7]; 1061 1062 ret[0] = 6; 1063 for (int i = 1; i<7; i++) { 1064 ret[i] = i; 1065 } 1066 resultSuccess(result, ret); 1067 } 1068 1069 @Override 1070 public void setLocationUpdates(boolean enable, Message response) { 1071 unimplemented(response); 1072 } 1073 1074 @Override 1075 public void getSmscAddress(Message result) { 1076 unimplemented(result); 1077 } 1078 1079 @Override 1080 public void setSmscAddress(String address, Message result) { 1081 unimplemented(result); 1082 } 1083 1084 @Override 1085 public void reportSmsMemoryStatus(boolean available, Message result) { 1086 unimplemented(result); 1087 } 1088 1089 @Override 1090 public void reportStkServiceIsRunning(Message result) { 1091 resultSuccess(result, null); 1092 } 1093 1094 @Override 1095 public void getCdmaSubscriptionSource(Message result) { 1096 unimplemented(result); 1097 } 1098 1099 private boolean isSimLocked() { 1100 if (mSimLockedState != SimLockState.NONE) { 1101 return true; 1102 } 1103 return false; 1104 } 1105 1106 @Override 1107 public void setRadioPower(boolean on, Message result) { 1108 if(on) { 1109 setRadioState(RadioState.RADIO_ON); 1110 } else { 1111 setRadioState(RadioState.RADIO_OFF); 1112 } 1113 } 1114 1115 1116 @Override 1117 public void acknowledgeLastIncomingGsmSms(boolean success, int cause, Message result) { 1118 unimplemented(result); 1119 } 1120 1121 @Override 1122 public void acknowledgeLastIncomingCdmaSms(boolean success, int cause, Message result) { 1123 unimplemented(result); 1124 } 1125 1126 @Override 1127 public void acknowledgeIncomingGsmSmsWithPdu(boolean success, String ackPdu, 1128 Message result) { 1129 unimplemented(result); 1130 } 1131 1132 @Override 1133 public void iccIO(int command, int fileid, String path, int p1, int p2, int p3, String data, 1134 String pin2, Message response) { 1135 iccIOForApp(command, fileid, path, p1, p2, p3, data,pin2, null, response); 1136 } 1137 1138 /** 1139 * parameters equivalent to 27.007 AT+CRSM command 1140 * response.obj will be an AsyncResult 1141 * response.obj.userObj will be a SimIoResult on success 1142 */ 1143 @Override 1144 public void iccIOForApp (int command, int fileid, String path, int p1, int p2, 1145 int p3, String data, String pin2, String aid, Message result) { 1146 unimplemented(result); 1147 } 1148 1149 /** 1150 * (AsyncResult)response.obj).result is an int[] with element [0] set to 1151 * 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned". 1152 * 1153 * @param response is callback message 1154 */ 1155 @Override 1156 public void queryCLIP(Message response) { unimplemented(response); } 1157 1158 1159 /** 1160 * response.obj will be a an int[2] 1161 * 1162 * response.obj[0] will be TS 27.007 +CLIR parameter 'n' 1163 * 0 presentation indicator is used according to the subscription of the CLIR service 1164 * 1 CLIR invocation 1165 * 2 CLIR suppression 1166 * 1167 * response.obj[1] will be TS 27.007 +CLIR parameter 'm' 1168 * 0 CLIR not provisioned 1169 * 1 CLIR provisioned in permanent mode 1170 * 2 unknown (e.g. no network, etc.) 1171 * 3 CLIR temporary mode presentation restricted 1172 * 4 CLIR temporary mode presentation allowed 1173 */ 1174 1175 @Override 1176 public void getCLIR(Message result) {unimplemented(result);} 1177 1178 /** 1179 * clirMode is one of the CLIR_* constants above 1180 * 1181 * response.obj is null 1182 */ 1183 1184 @Override 1185 public void setCLIR(int clirMode, Message result) {unimplemented(result);} 1186 1187 /** 1188 * (AsyncResult)response.obj).result is an int[] with element [0] set to 1189 * 0 for disabled, 1 for enabled. 1190 * 1191 * @param serviceClass is a sum of SERVICE_CLASS_* 1192 * @param response is callback message 1193 */ 1194 1195 @Override 1196 public void queryCallWaiting(int serviceClass, Message response) { 1197 unimplemented(response); 1198 } 1199 1200 /** 1201 * @param enable is true to enable, false to disable 1202 * @param serviceClass is a sum of SERVICE_CLASS_* 1203 * @param response is callback message 1204 */ 1205 1206 @Override 1207 public void setCallWaiting(boolean enable, int serviceClass, 1208 Message response) { 1209 unimplemented(response); 1210 } 1211 1212 /** 1213 * @param action is one of CF_ACTION_* 1214 * @param cfReason is one of CF_REASON_* 1215 * @param serviceClass is a sum of SERVICE_CLASSS_* 1216 */ 1217 @Override 1218 public void setCallForward(int action, int cfReason, int serviceClass, 1219 String number, int timeSeconds, Message result) {unimplemented(result);} 1220 1221 /** 1222 * cfReason is one of CF_REASON_* 1223 * 1224 * ((AsyncResult)response.obj).result will be an array of 1225 * CallForwardInfo's 1226 * 1227 * An array of length 0 means "disabled for all codes" 1228 */ 1229 @Override 1230 public void queryCallForwardStatus(int cfReason, int serviceClass, 1231 String number, Message result) {unimplemented(result);} 1232 1233 @Override 1234 public void setNetworkSelectionModeAutomatic(Message result) {unimplemented(result);} 1235 @Override 1236 public void exitEmergencyCallbackMode(Message result) {unimplemented(result);} 1237 @Override 1238 public void setNetworkSelectionModeManual( 1239 String operatorNumeric, Message result) {unimplemented(result);} 1240 1241 /** 1242 * Queries whether the current network selection mode is automatic 1243 * or manual 1244 * 1245 * ((AsyncResult)response.obj).result is an int[] with element [0] being 1246 * a 0 for automatic selection and a 1 for manual selection 1247 */ 1248 1249 @Override 1250 public void getNetworkSelectionMode(Message result) { 1251 int ret[] = new int[1]; 1252 1253 ret[0] = 0; 1254 resultSuccess(result, ret); 1255 } 1256 1257 /** 1258 * Queries the currently available networks 1259 * 1260 * ((AsyncResult)response.obj).result is a List of NetworkInfo objects 1261 */ 1262 @Override 1263 public void getAvailableNetworks(Message result) {unimplemented(result);} 1264 1265 @Override 1266 public void getBasebandVersion (Message result) { 1267 resultSuccess(result, "SimulatedCommands"); 1268 } 1269 1270 /** 1271 * Simulates an incoming USSD message 1272 * @param statusCode Status code string. See <code>setOnUSSD</code> 1273 * in CommandsInterface.java 1274 * @param message Message text to send or null if none 1275 */ 1276 @Override 1277 public void triggerIncomingUssd(String statusCode, String message) { 1278 if (mUSSDRegistrant != null) { 1279 String[] result = {statusCode, message}; 1280 mUSSDRegistrant.notifyResult(result); 1281 } 1282 } 1283 1284 1285 @Override 1286 public void sendUSSD (String ussdString, Message result) { 1287 1288 // We simulate this particular sequence 1289 if (ussdString.equals("#646#")) { 1290 resultSuccess(result, null); 1291 1292 // 0 == USSD-Notify 1293 triggerIncomingUssd("0", "You have NNN minutes remaining."); 1294 } else { 1295 resultSuccess(result, null); 1296 1297 triggerIncomingUssd("0", "All Done"); 1298 } 1299 } 1300 1301 // inherited javadoc suffices 1302 @Override 1303 public void cancelPendingUssd (Message response) { 1304 resultSuccess(response, null); 1305 } 1306 1307 1308 @Override 1309 public void resetRadio(Message result) { 1310 unimplemented(result); 1311 } 1312 1313 @Override 1314 public void invokeOemRilRequestRaw(byte[] data, Message response) { 1315 // Just echo back data 1316 if (response != null) { 1317 AsyncResult.forMessage(response).result = data; 1318 response.sendToTarget(); 1319 } 1320 } 1321 1322 @Override 1323 public void invokeOemRilRequestStrings(String[] strings, Message response) { 1324 // Just echo back data 1325 if (response != null) { 1326 AsyncResult.forMessage(response).result = strings; 1327 response.sendToTarget(); 1328 } 1329 } 1330 1331 //***** SimulatedRadioControl 1332 1333 1334 /** Start the simulated phone ringing */ 1335 @Override 1336 public void 1337 triggerRing(String number) { 1338 simulatedCallState.triggerRing(number); 1339 mCallStateRegistrants.notifyRegistrants(); 1340 } 1341 1342 @Override 1343 public void 1344 progressConnectingCallState() { 1345 simulatedCallState.progressConnectingCallState(); 1346 mCallStateRegistrants.notifyRegistrants(); 1347 } 1348 1349 /** If a call is DIALING or ALERTING, progress it all the way to ACTIVE */ 1350 @Override 1351 public void 1352 progressConnectingToActive() { 1353 simulatedCallState.progressConnectingToActive(); 1354 mCallStateRegistrants.notifyRegistrants(); 1355 } 1356 1357 /** automatically progress mobile originated calls to ACTIVE. 1358 * default to true 1359 */ 1360 @Override 1361 public void 1362 setAutoProgressConnectingCall(boolean b) { 1363 simulatedCallState.setAutoProgressConnectingCall(b); 1364 } 1365 1366 @Override 1367 public void 1368 setNextDialFailImmediately(boolean b) { 1369 simulatedCallState.setNextDialFailImmediately(b); 1370 } 1371 1372 @Override 1373 public void 1374 setNextCallFailCause(int gsmCause) { 1375 mNextCallFailCause = gsmCause; 1376 } 1377 1378 @Override 1379 public void 1380 triggerHangupForeground() { 1381 simulatedCallState.triggerHangupForeground(); 1382 mCallStateRegistrants.notifyRegistrants(); 1383 } 1384 1385 /** hangup holding calls */ 1386 @Override 1387 public void 1388 triggerHangupBackground() { 1389 simulatedCallState.triggerHangupBackground(); 1390 mCallStateRegistrants.notifyRegistrants(); 1391 } 1392 1393 @Override 1394 public void triggerSsn(int type, int code) { 1395 SuppServiceNotification not = new SuppServiceNotification(); 1396 not.notificationType = type; 1397 not.code = code; 1398 mSsnRegistrant.notifyRegistrant(new AsyncResult(null, not, null)); 1399 } 1400 1401 @Override 1402 public void 1403 shutdown() { 1404 setRadioState(RadioState.RADIO_UNAVAILABLE); 1405 Looper looper = mHandlerThread.getLooper(); 1406 if (looper != null) { 1407 looper.quit(); 1408 } 1409 } 1410 1411 /** hangup all */ 1412 1413 @Override 1414 public void 1415 triggerHangupAll() { 1416 simulatedCallState.triggerHangupAll(); 1417 mCallStateRegistrants.notifyRegistrants(); 1418 } 1419 1420 @Override 1421 public void 1422 triggerIncomingSMS(String message) { 1423 //TODO 1424 } 1425 1426 @Override 1427 public void 1428 pauseResponses() { 1429 mPausedResponseCount++; 1430 } 1431 1432 @Override 1433 public void 1434 resumeResponses() { 1435 mPausedResponseCount--; 1436 1437 if (mPausedResponseCount == 0) { 1438 for (int i = 0, s = mPausedResponses.size(); i < s ; i++) { 1439 mPausedResponses.get(i).sendToTarget(); 1440 } 1441 mPausedResponses.clear(); 1442 } else { 1443 Rlog.e("GSM", "SimulatedCommands.resumeResponses < 0"); 1444 } 1445 } 1446 1447 //***** Private Methods 1448 1449 private void unimplemented(Message result) { 1450 if (result != null) { 1451 AsyncResult.forMessage(result).exception 1452 = new RuntimeException("Unimplemented"); 1453 1454 if (mPausedResponseCount > 0) { 1455 mPausedResponses.add(result); 1456 } else { 1457 result.sendToTarget(); 1458 } 1459 } 1460 } 1461 1462 private void resultSuccess(Message result, Object ret) { 1463 if (result != null) { 1464 AsyncResult.forMessage(result).result = ret; 1465 if (mPausedResponseCount > 0) { 1466 mPausedResponses.add(result); 1467 } else { 1468 result.sendToTarget(); 1469 } 1470 } 1471 } 1472 1473 private void resultFail(Message result, Throwable tr) { 1474 if (result != null) { 1475 AsyncResult.forMessage(result).exception = tr; 1476 if (mPausedResponseCount > 0) { 1477 mPausedResponses.add(result); 1478 } else { 1479 result.sendToTarget(); 1480 } 1481 } 1482 } 1483 1484 // ***** Methods for CDMA support 1485 @Override 1486 public void 1487 getDeviceIdentity(Message response) { 1488 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1489 unimplemented(response); 1490 } 1491 1492 @Override 1493 public void 1494 getCDMASubscription(Message response) { 1495 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1496 unimplemented(response); 1497 } 1498 1499 @Override 1500 public void 1501 setCdmaSubscriptionSource(int cdmaSubscriptionType, Message response) { 1502 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1503 unimplemented(response); 1504 } 1505 1506 @Override 1507 public void queryCdmaRoamingPreference(Message response) { 1508 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1509 unimplemented(response); 1510 } 1511 1512 @Override 1513 public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { 1514 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1515 unimplemented(response); 1516 } 1517 1518 @Override 1519 public void 1520 setPhoneType(int phoneType) { 1521 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1522 } 1523 1524 @Override 1525 public void getPreferredVoicePrivacy(Message result) { 1526 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1527 unimplemented(result); 1528 } 1529 1530 @Override 1531 public void setPreferredVoicePrivacy(boolean enable, Message result) { 1532 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1533 unimplemented(result); 1534 } 1535 1536 /** 1537 * Set the TTY mode 1538 * 1539 * @param ttyMode is one of the following: 1540 * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} 1541 * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} 1542 * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} 1543 * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO} 1544 * @param response is callback message 1545 */ 1546 @Override 1547 public void setTTYMode(int ttyMode, Message response) { 1548 Rlog.w(LOG_TAG, "Not implemented in SimulatedCommands"); 1549 unimplemented(response); 1550 } 1551 1552 /** 1553 * Query the TTY mode 1554 * (AsyncResult)response.obj).result is an int[] with element [0] set to 1555 * tty mode: 1556 * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} 1557 * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} 1558 * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} 1559 * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO} 1560 * @param response is callback message 1561 */ 1562 @Override 1563 public void queryTTYMode(Message response) { 1564 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1565 unimplemented(response); 1566 } 1567 1568 /** 1569 * {@inheritDoc} 1570 */ 1571 @Override 1572 public void sendCDMAFeatureCode(String FeatureCode, Message response) { 1573 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1574 unimplemented(response); 1575 } 1576 1577 /** 1578 * {@inheritDoc} 1579 */ 1580 @Override 1581 public void sendCdmaSms(byte[] pdu, Message response){ 1582 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1583 } 1584 1585 @Override 1586 public void setCdmaBroadcastActivation(boolean activate, Message response) { 1587 unimplemented(response); 1588 1589 } 1590 1591 @Override 1592 public void getCdmaBroadcastConfig(Message response) { 1593 unimplemented(response); 1594 1595 } 1596 1597 @Override 1598 public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) { 1599 unimplemented(response); 1600 } 1601 1602 public void forceDataDormancy(Message response) { 1603 unimplemented(response); 1604 } 1605 1606 1607 @Override 1608 public void setGsmBroadcastActivation(boolean activate, Message response) { 1609 unimplemented(response); 1610 } 1611 1612 1613 @Override 1614 public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) { 1615 unimplemented(response); 1616 } 1617 1618 @Override 1619 public void getGsmBroadcastConfig(Message response) { 1620 unimplemented(response); 1621 } 1622 1623 @Override 1624 public void supplyIccPinForApp(String pin, String aid, Message response) { 1625 unimplemented(response); 1626 } 1627 1628 @Override 1629 public void supplyIccPukForApp(String puk, String newPin, String aid, Message response) { 1630 unimplemented(response); 1631 } 1632 1633 @Override 1634 public void supplyIccPin2ForApp(String pin2, String aid, Message response) { 1635 unimplemented(response); 1636 } 1637 1638 @Override 1639 public void supplyIccPuk2ForApp(String puk2, String newPin2, String aid, Message response) { 1640 unimplemented(response); 1641 } 1642 1643 @Override 1644 public void changeIccPinForApp(String oldPin, String newPin, String aidPtr, Message response) { 1645 unimplemented(response); 1646 } 1647 1648 @Override 1649 public void changeIccPin2ForApp(String oldPin2, String newPin2, String aidPtr, 1650 Message response) { 1651 unimplemented(response); 1652 } 1653 1654 @Override 1655 public void requestIsimAuthentication(String nonce, Message response) { 1656 unimplemented(response); 1657 } 1658 1659 @Override 1660 public void requestIccSimAuthentication(int authContext, String data, String aid, Message response) { 1661 unimplemented(response); 1662 } 1663 1664 @Override 1665 public void getVoiceRadioTechnology(Message response) { 1666 unimplemented(response); 1667 } 1668 1669 @Override 1670 public void getCellInfoList(Message response) { 1671 unimplemented(response); 1672 } 1673 1674 @Override 1675 public void setCellInfoListRate(int rateInMillis, Message response) { 1676 unimplemented(response); 1677 } 1678 1679 @Override 1680 public void setInitialAttachApn(String apn, String protocol, int authType, String username, 1681 String password, Message result) { 1682 } 1683 1684 @Override 1685 public void setDataProfile(DataProfile[] dps, Message result) { 1686 } 1687 1688 @Override 1689 public void getImsRegistrationState(Message response) { 1690 unimplemented(response); 1691 } 1692 1693 @Override 1694 public void sendImsCdmaSms(byte[] pdu, int retry, int messageRef, 1695 Message response){ 1696 unimplemented(response); 1697 } 1698 1699 @Override 1700 public void sendImsGsmSms(String smscPDU, String pdu, 1701 int retry, int messageRef, Message response){ 1702 unimplemented(response); 1703 } 1704 1705 @Override 1706 public void iccOpenLogicalChannel(String AID, Message response) { 1707 unimplemented(response); 1708 } 1709 1710 @Override 1711 public void iccCloseLogicalChannel(int channel, Message response) { 1712 unimplemented(response); 1713 } 1714 1715 @Override 1716 public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction, 1717 int p1, int p2, int p3, String data, Message response) { 1718 unimplemented(response); 1719 } 1720 1721 @Override 1722 public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2, 1723 int p3, String data, Message response) { 1724 unimplemented(response); 1725 } 1726 1727 @Override 1728 public void nvReadItem(int itemID, Message response) { 1729 unimplemented(response); 1730 } 1731 1732 @Override 1733 public void nvWriteItem(int itemID, String itemValue, Message response) { 1734 unimplemented(response); 1735 } 1736 1737 @Override 1738 public void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response) { 1739 unimplemented(response); 1740 } 1741 1742 @Override 1743 public void nvResetConfig(int resetType, Message response) { 1744 unimplemented(response); 1745 } 1746 1747 @Override 1748 public void getHardwareConfig(Message result) { 1749 unimplemented(result); 1750 } 1751 1752 @Override 1753 public void requestShutdown(Message result) { 1754 setRadioState(RadioState.RADIO_UNAVAILABLE); 1755 } 1756} 1757