SimulatedCommands.java revision 40d1d394302d83eb56f66cf08daecc612c97cd28
1/* 2 * Copyright (C) 2006 The Android Open Source Project 3 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package com.android.internal.telephony.test; 19 20import android.os.AsyncResult; 21import android.os.HandlerThread; 22import android.os.Looper; 23import android.os.Message; 24import android.telephony.Rlog; 25 26import com.android.internal.telephony.BaseCommands; 27import com.android.internal.telephony.CommandException; 28import com.android.internal.telephony.CommandsInterface; 29import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo; 30import com.android.internal.telephony.dataconnection.DataCallResponse; 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[] with every 825 * element representing one available BM_*_BAND 826 */ 827 @Override 828 public void queryAvailableBandMode (Message result) { 829 int ret[] = new int [4]; 830 831 ret[0] = 4; 832 ret[1] = Phone.BM_US_BAND; 833 ret[2] = Phone.BM_JPN_BAND; 834 ret[3] = Phone.BM_AUS_BAND; 835 836 resultSuccess(result, ret); 837 } 838 839 /** 840 * {@inheritDoc} 841 */ 842 @Override 843 public void sendTerminalResponse(String contents, Message response) { 844 resultSuccess(response, null); 845 } 846 847 /** 848 * {@inheritDoc} 849 */ 850 @Override 851 public void sendEnvelope(String contents, Message response) { 852 resultSuccess(response, null); 853 } 854 855 /** 856 * {@inheritDoc} 857 */ 858 @Override 859 public void sendEnvelopeWithStatus(String contents, Message response) { 860 resultSuccess(response, null); 861 } 862 863 /** 864 * {@inheritDoc} 865 */ 866 @Override 867 public void handleCallSetupRequestFromSim( 868 boolean accept, Message response) { 869 resultSuccess(response, null); 870 } 871 872 /** 873 * response.obj.result is an String[14] 874 * See ril.h for details 875 * 876 * Please note that registration state 4 ("unknown") is treated 877 * as "out of service" above 878 */ 879 @Override 880 public void getVoiceRegistrationState (Message result) { 881 String ret[] = new String[14]; 882 883 ret[0] = "5"; // registered roam 884 ret[1] = null; 885 ret[2] = null; 886 ret[3] = null; 887 ret[4] = null; 888 ret[5] = null; 889 ret[6] = null; 890 ret[7] = null; 891 ret[8] = null; 892 ret[9] = null; 893 ret[10] = null; 894 ret[11] = null; 895 ret[12] = null; 896 ret[13] = null; 897 898 resultSuccess(result, ret); 899 } 900 901 /** 902 * response.obj.result is an String[4] 903 * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2 904 * response.obj.result[1] is LAC if registered or NULL if not 905 * response.obj.result[2] is CID if registered or NULL if not 906 * response.obj.result[3] indicates the available radio technology, where: 907 * 0 == unknown 908 * 1 == GPRS only 909 * 2 == EDGE 910 * 3 == UMTS 911 * 912 * valid LAC are 0x0000 - 0xffff 913 * valid CID are 0x00000000 - 0xffffffff 914 * 915 * Please note that registration state 4 ("unknown") is treated 916 * as "out of service" in the Android telephony system 917 */ 918 @Override 919 public void getDataRegistrationState (Message result) { 920 String ret[] = new String[4]; 921 922 ret[0] = "5"; // registered roam 923 ret[1] = null; 924 ret[2] = null; 925 ret[3] = "2"; 926 927 resultSuccess(result, ret); 928 } 929 930 /** 931 * response.obj.result is a String[3] 932 * response.obj.result[0] is long alpha or null if unregistered 933 * response.obj.result[1] is short alpha or null if unregistered 934 * response.obj.result[2] is numeric or null if unregistered 935 */ 936 @Override 937 public void getOperator(Message result) { 938 String[] ret = new String[3]; 939 940 ret[0] = "El Telco Loco"; 941 ret[1] = "Telco Loco"; 942 ret[2] = "001001"; 943 944 resultSuccess(result, ret); 945 } 946 947 /** 948 * ar.exception carries exception on failure 949 * ar.userObject contains the original value of result.obj 950 * ar.result is null on success and failure 951 */ 952 @Override 953 public void sendDtmf(char c, Message result) { 954 resultSuccess(result, null); 955 } 956 957 /** 958 * ar.exception carries exception on failure 959 * ar.userObject contains the original value of result.obj 960 * ar.result is null on success and failure 961 */ 962 @Override 963 public void startDtmf(char c, Message result) { 964 resultSuccess(result, null); 965 } 966 967 /** 968 * ar.exception carries exception on failure 969 * ar.userObject contains the original value of result.obj 970 * ar.result is null on success and failure 971 */ 972 @Override 973 public void stopDtmf(Message result) { 974 resultSuccess(result, null); 975 } 976 977 /** 978 * ar.exception carries exception on failure 979 * ar.userObject contains the original value of result.obj 980 * ar.result is null on success and failure 981 */ 982 @Override 983 public void sendBurstDtmf(String dtmfString, int on, int off, Message result) { 984 resultSuccess(result, null); 985 } 986 987 /** 988 * smscPDU is smsc address in PDU form GSM BCD format prefixed 989 * by a length byte (as expected by TS 27.005) or NULL for default SMSC 990 * pdu is SMS in PDU format as an ASCII hex string 991 * less the SMSC address 992 */ 993 @Override 994 public void sendSMS (String smscPDU, String pdu, Message result) {unimplemented(result);} 995 996 @Override 997 public void deleteSmsOnSim(int index, Message response) { 998 Rlog.d(LOG_TAG, "Delete message at index " + index); 999 unimplemented(response); 1000 } 1001 1002 @Override 1003 public void deleteSmsOnRuim(int index, Message response) { 1004 Rlog.d(LOG_TAG, "Delete RUIM message at index " + index); 1005 unimplemented(response); 1006 } 1007 1008 @Override 1009 public void writeSmsToSim(int status, String smsc, String pdu, Message response) { 1010 Rlog.d(LOG_TAG, "Write SMS to SIM with status " + status); 1011 unimplemented(response); 1012 } 1013 1014 @Override 1015 public void writeSmsToRuim(int status, String pdu, Message response) { 1016 Rlog.d(LOG_TAG, "Write SMS to RUIM with status " + status); 1017 unimplemented(response); 1018 } 1019 1020 @Override 1021 public void setupDataCall(String radioTechnology, String profile, 1022 String apn, String user, String password, String authType, 1023 String protocol, Message result) { 1024 unimplemented(result); 1025 } 1026 1027 @Override 1028 public void deactivateDataCall(int cid, int reason, Message result) {unimplemented(result);} 1029 1030 @Override 1031 public void setPreferredNetworkType(int networkType , Message result) { 1032 mNetworkType = networkType; 1033 resultSuccess(result, null); 1034 } 1035 1036 @Override 1037 public void getPreferredNetworkType(Message result) { 1038 int ret[] = new int[1]; 1039 1040 ret[0] = mNetworkType; 1041 resultSuccess(result, ret); 1042 } 1043 1044 @Override 1045 public void getNeighboringCids(Message result) { 1046 int ret[] = new int[7]; 1047 1048 ret[0] = 6; 1049 for (int i = 1; i<7; i++) { 1050 ret[i] = i; 1051 } 1052 resultSuccess(result, ret); 1053 } 1054 1055 @Override 1056 public void setLocationUpdates(boolean enable, Message response) { 1057 unimplemented(response); 1058 } 1059 1060 @Override 1061 public void getSmscAddress(Message result) { 1062 unimplemented(result); 1063 } 1064 1065 @Override 1066 public void setSmscAddress(String address, Message result) { 1067 unimplemented(result); 1068 } 1069 1070 @Override 1071 public void reportSmsMemoryStatus(boolean available, Message result) { 1072 unimplemented(result); 1073 } 1074 1075 @Override 1076 public void reportStkServiceIsRunning(Message result) { 1077 resultSuccess(result, null); 1078 } 1079 1080 @Override 1081 public void getCdmaSubscriptionSource(Message result) { 1082 unimplemented(result); 1083 } 1084 1085 private boolean isSimLocked() { 1086 if (mSimLockedState != SimLockState.NONE) { 1087 return true; 1088 } 1089 return false; 1090 } 1091 1092 @Override 1093 public void setRadioPower(boolean on, Message result) { 1094 if(on) { 1095 setRadioState(RadioState.RADIO_ON); 1096 } else { 1097 setRadioState(RadioState.RADIO_OFF); 1098 } 1099 } 1100 1101 1102 @Override 1103 public void acknowledgeLastIncomingGsmSms(boolean success, int cause, Message result) { 1104 unimplemented(result); 1105 } 1106 1107 @Override 1108 public void acknowledgeLastIncomingCdmaSms(boolean success, int cause, Message result) { 1109 unimplemented(result); 1110 } 1111 1112 @Override 1113 public void acknowledgeIncomingGsmSmsWithPdu(boolean success, String ackPdu, 1114 Message result) { 1115 unimplemented(result); 1116 } 1117 1118 @Override 1119 public void iccIO(int command, int fileid, String path, int p1, int p2, int p3, String data, 1120 String pin2, Message response) { 1121 iccIOForApp(command, fileid, path, p1, p2, p3, data,pin2, null, response); 1122 } 1123 1124 /** 1125 * parameters equivalent to 27.007 AT+CRSM command 1126 * response.obj will be an AsyncResult 1127 * response.obj.userObj will be a SimIoResult on success 1128 */ 1129 @Override 1130 public void iccIOForApp (int command, int fileid, String path, int p1, int p2, 1131 int p3, String data, String pin2, String aid, Message result) { 1132 unimplemented(result); 1133 } 1134 1135 /** 1136 * (AsyncResult)response.obj).result is an int[] with element [0] set to 1137 * 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned". 1138 * 1139 * @param response is callback message 1140 */ 1141 @Override 1142 public void queryCLIP(Message response) { unimplemented(response); } 1143 1144 1145 /** 1146 * response.obj will be a an int[2] 1147 * 1148 * response.obj[0] will be TS 27.007 +CLIR parameter 'n' 1149 * 0 presentation indicator is used according to the subscription of the CLIR service 1150 * 1 CLIR invocation 1151 * 2 CLIR suppression 1152 * 1153 * response.obj[1] will be TS 27.007 +CLIR parameter 'm' 1154 * 0 CLIR not provisioned 1155 * 1 CLIR provisioned in permanent mode 1156 * 2 unknown (e.g. no network, etc.) 1157 * 3 CLIR temporary mode presentation restricted 1158 * 4 CLIR temporary mode presentation allowed 1159 */ 1160 1161 @Override 1162 public void getCLIR(Message result) {unimplemented(result);} 1163 1164 /** 1165 * clirMode is one of the CLIR_* constants above 1166 * 1167 * response.obj is null 1168 */ 1169 1170 @Override 1171 public void setCLIR(int clirMode, Message result) {unimplemented(result);} 1172 1173 /** 1174 * (AsyncResult)response.obj).result is an int[] with element [0] set to 1175 * 0 for disabled, 1 for enabled. 1176 * 1177 * @param serviceClass is a sum of SERVICE_CLASS_* 1178 * @param response is callback message 1179 */ 1180 1181 @Override 1182 public void queryCallWaiting(int serviceClass, Message response) { 1183 unimplemented(response); 1184 } 1185 1186 /** 1187 * @param enable is true to enable, false to disable 1188 * @param serviceClass is a sum of SERVICE_CLASS_* 1189 * @param response is callback message 1190 */ 1191 1192 @Override 1193 public void setCallWaiting(boolean enable, int serviceClass, 1194 Message response) { 1195 unimplemented(response); 1196 } 1197 1198 /** 1199 * @param action is one of CF_ACTION_* 1200 * @param cfReason is one of CF_REASON_* 1201 * @param serviceClass is a sum of SERVICE_CLASSS_* 1202 */ 1203 @Override 1204 public void setCallForward(int action, int cfReason, int serviceClass, 1205 String number, int timeSeconds, Message result) {unimplemented(result);} 1206 1207 /** 1208 * cfReason is one of CF_REASON_* 1209 * 1210 * ((AsyncResult)response.obj).result will be an array of 1211 * CallForwardInfo's 1212 * 1213 * An array of length 0 means "disabled for all codes" 1214 */ 1215 @Override 1216 public void queryCallForwardStatus(int cfReason, int serviceClass, 1217 String number, Message result) {unimplemented(result);} 1218 1219 @Override 1220 public void setNetworkSelectionModeAutomatic(Message result) {unimplemented(result);} 1221 @Override 1222 public void exitEmergencyCallbackMode(Message result) {unimplemented(result);} 1223 @Override 1224 public void setNetworkSelectionModeManual( 1225 String operatorNumeric, Message result) {unimplemented(result);} 1226 1227 /** 1228 * Queries whether the current network selection mode is automatic 1229 * or manual 1230 * 1231 * ((AsyncResult)response.obj).result is an int[] with element [0] being 1232 * a 0 for automatic selection and a 1 for manual selection 1233 */ 1234 1235 @Override 1236 public void getNetworkSelectionMode(Message result) { 1237 int ret[] = new int[1]; 1238 1239 ret[0] = 0; 1240 resultSuccess(result, ret); 1241 } 1242 1243 /** 1244 * Queries the currently available networks 1245 * 1246 * ((AsyncResult)response.obj).result is a List of NetworkInfo objects 1247 */ 1248 @Override 1249 public void getAvailableNetworks(Message result) {unimplemented(result);} 1250 1251 @Override 1252 public void getBasebandVersion (Message result) { 1253 resultSuccess(result, "SimulatedCommands"); 1254 } 1255 1256 /** 1257 * Simulates an incoming USSD message 1258 * @param statusCode Status code string. See <code>setOnUSSD</code> 1259 * in CommandsInterface.java 1260 * @param message Message text to send or null if none 1261 */ 1262 @Override 1263 public void triggerIncomingUssd(String statusCode, String message) { 1264 if (mUSSDRegistrant != null) { 1265 String[] result = {statusCode, message}; 1266 mUSSDRegistrant.notifyResult(result); 1267 } 1268 } 1269 1270 1271 @Override 1272 public void sendUSSD (String ussdString, Message result) { 1273 1274 // We simulate this particular sequence 1275 if (ussdString.equals("#646#")) { 1276 resultSuccess(result, null); 1277 1278 // 0 == USSD-Notify 1279 triggerIncomingUssd("0", "You have NNN minutes remaining."); 1280 } else { 1281 resultSuccess(result, null); 1282 1283 triggerIncomingUssd("0", "All Done"); 1284 } 1285 } 1286 1287 // inherited javadoc suffices 1288 @Override 1289 public void cancelPendingUssd (Message response) { 1290 resultSuccess(response, null); 1291 } 1292 1293 1294 @Override 1295 public void resetRadio(Message result) { 1296 unimplemented(result); 1297 } 1298 1299 @Override 1300 public void invokeOemRilRequestRaw(byte[] data, Message response) { 1301 // Just echo back data 1302 if (response != null) { 1303 AsyncResult.forMessage(response).result = data; 1304 response.sendToTarget(); 1305 } 1306 } 1307 1308 @Override 1309 public void invokeOemRilRequestStrings(String[] strings, Message response) { 1310 // Just echo back data 1311 if (response != null) { 1312 AsyncResult.forMessage(response).result = strings; 1313 response.sendToTarget(); 1314 } 1315 } 1316 1317 //***** SimulatedRadioControl 1318 1319 1320 /** Start the simulated phone ringing */ 1321 @Override 1322 public void 1323 triggerRing(String number) { 1324 simulatedCallState.triggerRing(number); 1325 mCallStateRegistrants.notifyRegistrants(); 1326 } 1327 1328 @Override 1329 public void 1330 progressConnectingCallState() { 1331 simulatedCallState.progressConnectingCallState(); 1332 mCallStateRegistrants.notifyRegistrants(); 1333 } 1334 1335 /** If a call is DIALING or ALERTING, progress it all the way to ACTIVE */ 1336 @Override 1337 public void 1338 progressConnectingToActive() { 1339 simulatedCallState.progressConnectingToActive(); 1340 mCallStateRegistrants.notifyRegistrants(); 1341 } 1342 1343 /** automatically progress mobile originated calls to ACTIVE. 1344 * default to true 1345 */ 1346 @Override 1347 public void 1348 setAutoProgressConnectingCall(boolean b) { 1349 simulatedCallState.setAutoProgressConnectingCall(b); 1350 } 1351 1352 @Override 1353 public void 1354 setNextDialFailImmediately(boolean b) { 1355 simulatedCallState.setNextDialFailImmediately(b); 1356 } 1357 1358 @Override 1359 public void 1360 setNextCallFailCause(int gsmCause) { 1361 mNextCallFailCause = gsmCause; 1362 } 1363 1364 @Override 1365 public void 1366 triggerHangupForeground() { 1367 simulatedCallState.triggerHangupForeground(); 1368 mCallStateRegistrants.notifyRegistrants(); 1369 } 1370 1371 /** hangup holding calls */ 1372 @Override 1373 public void 1374 triggerHangupBackground() { 1375 simulatedCallState.triggerHangupBackground(); 1376 mCallStateRegistrants.notifyRegistrants(); 1377 } 1378 1379 @Override 1380 public void triggerSsn(int type, int code) { 1381 SuppServiceNotification not = new SuppServiceNotification(); 1382 not.notificationType = type; 1383 not.code = code; 1384 mSsnRegistrant.notifyRegistrant(new AsyncResult(null, not, null)); 1385 } 1386 1387 @Override 1388 public void 1389 shutdown() { 1390 setRadioState(RadioState.RADIO_UNAVAILABLE); 1391 Looper looper = mHandlerThread.getLooper(); 1392 if (looper != null) { 1393 looper.quit(); 1394 } 1395 } 1396 1397 /** hangup all */ 1398 1399 @Override 1400 public void 1401 triggerHangupAll() { 1402 simulatedCallState.triggerHangupAll(); 1403 mCallStateRegistrants.notifyRegistrants(); 1404 } 1405 1406 @Override 1407 public void 1408 triggerIncomingSMS(String message) { 1409 //TODO 1410 } 1411 1412 @Override 1413 public void 1414 pauseResponses() { 1415 mPausedResponseCount++; 1416 } 1417 1418 @Override 1419 public void 1420 resumeResponses() { 1421 mPausedResponseCount--; 1422 1423 if (mPausedResponseCount == 0) { 1424 for (int i = 0, s = mPausedResponses.size(); i < s ; i++) { 1425 mPausedResponses.get(i).sendToTarget(); 1426 } 1427 mPausedResponses.clear(); 1428 } else { 1429 Rlog.e("GSM", "SimulatedCommands.resumeResponses < 0"); 1430 } 1431 } 1432 1433 //***** Private Methods 1434 1435 private void unimplemented(Message result) { 1436 if (result != null) { 1437 AsyncResult.forMessage(result).exception 1438 = new RuntimeException("Unimplemented"); 1439 1440 if (mPausedResponseCount > 0) { 1441 mPausedResponses.add(result); 1442 } else { 1443 result.sendToTarget(); 1444 } 1445 } 1446 } 1447 1448 private void resultSuccess(Message result, Object ret) { 1449 if (result != null) { 1450 AsyncResult.forMessage(result).result = ret; 1451 if (mPausedResponseCount > 0) { 1452 mPausedResponses.add(result); 1453 } else { 1454 result.sendToTarget(); 1455 } 1456 } 1457 } 1458 1459 private void resultFail(Message result, Throwable tr) { 1460 if (result != null) { 1461 AsyncResult.forMessage(result).exception = tr; 1462 if (mPausedResponseCount > 0) { 1463 mPausedResponses.add(result); 1464 } else { 1465 result.sendToTarget(); 1466 } 1467 } 1468 } 1469 1470 // ***** Methods for CDMA support 1471 @Override 1472 public void 1473 getDeviceIdentity(Message response) { 1474 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1475 unimplemented(response); 1476 } 1477 1478 @Override 1479 public void 1480 getCDMASubscription(Message response) { 1481 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1482 unimplemented(response); 1483 } 1484 1485 @Override 1486 public void 1487 setCdmaSubscriptionSource(int cdmaSubscriptionType, Message response) { 1488 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1489 unimplemented(response); 1490 } 1491 1492 @Override 1493 public void queryCdmaRoamingPreference(Message response) { 1494 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1495 unimplemented(response); 1496 } 1497 1498 @Override 1499 public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { 1500 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1501 unimplemented(response); 1502 } 1503 1504 @Override 1505 public void 1506 setPhoneType(int phoneType) { 1507 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1508 } 1509 1510 @Override 1511 public void getPreferredVoicePrivacy(Message result) { 1512 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1513 unimplemented(result); 1514 } 1515 1516 @Override 1517 public void setPreferredVoicePrivacy(boolean enable, Message result) { 1518 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1519 unimplemented(result); 1520 } 1521 1522 /** 1523 * Set the TTY mode 1524 * 1525 * @param ttyMode is one of the following: 1526 * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} 1527 * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} 1528 * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} 1529 * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO} 1530 * @param response is callback message 1531 */ 1532 @Override 1533 public void setTTYMode(int ttyMode, Message response) { 1534 Rlog.w(LOG_TAG, "Not implemented in SimulatedCommands"); 1535 unimplemented(response); 1536 } 1537 1538 /** 1539 * Query the TTY mode 1540 * (AsyncResult)response.obj).result is an int[] with element [0] set to 1541 * tty mode: 1542 * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} 1543 * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} 1544 * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} 1545 * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO} 1546 * @param response is callback message 1547 */ 1548 @Override 1549 public void queryTTYMode(Message response) { 1550 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1551 unimplemented(response); 1552 } 1553 1554 /** 1555 * {@inheritDoc} 1556 */ 1557 @Override 1558 public void sendCDMAFeatureCode(String FeatureCode, Message response) { 1559 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1560 unimplemented(response); 1561 } 1562 1563 /** 1564 * {@inheritDoc} 1565 */ 1566 @Override 1567 public void sendCdmaSms(byte[] pdu, Message response){ 1568 Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); 1569 } 1570 1571 @Override 1572 public void setCdmaBroadcastActivation(boolean activate, Message response) { 1573 unimplemented(response); 1574 1575 } 1576 1577 @Override 1578 public void getCdmaBroadcastConfig(Message response) { 1579 unimplemented(response); 1580 1581 } 1582 1583 @Override 1584 public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) { 1585 unimplemented(response); 1586 } 1587 1588 public void forceDataDormancy(Message response) { 1589 unimplemented(response); 1590 } 1591 1592 1593 @Override 1594 public void setGsmBroadcastActivation(boolean activate, Message response) { 1595 unimplemented(response); 1596 } 1597 1598 1599 @Override 1600 public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) { 1601 unimplemented(response); 1602 } 1603 1604 @Override 1605 public void getGsmBroadcastConfig(Message response) { 1606 unimplemented(response); 1607 } 1608 1609 @Override 1610 public void supplyIccPinForApp(String pin, String aid, Message response) { 1611 unimplemented(response); 1612 } 1613 1614 @Override 1615 public void supplyIccPukForApp(String puk, String newPin, String aid, Message response) { 1616 unimplemented(response); 1617 } 1618 1619 @Override 1620 public void supplyIccPin2ForApp(String pin2, String aid, Message response) { 1621 unimplemented(response); 1622 } 1623 1624 @Override 1625 public void supplyIccPuk2ForApp(String puk2, String newPin2, String aid, Message response) { 1626 unimplemented(response); 1627 } 1628 1629 @Override 1630 public void changeIccPinForApp(String oldPin, String newPin, String aidPtr, Message response) { 1631 unimplemented(response); 1632 } 1633 1634 @Override 1635 public void changeIccPin2ForApp(String oldPin2, String newPin2, String aidPtr, 1636 Message response) { 1637 unimplemented(response); 1638 } 1639 1640 @Override 1641 public void requestIsimAuthentication(String nonce, Message response) { 1642 unimplemented(response); 1643 } 1644 1645 @Override 1646 public void getVoiceRadioTechnology(Message response) { 1647 unimplemented(response); 1648 } 1649 1650 @Override 1651 public void getCellInfoList(Message response) { 1652 unimplemented(response); 1653 } 1654 1655 @Override 1656 public void setCellInfoListRate(int rateInMillis, Message response) { 1657 unimplemented(response); 1658 } 1659 1660 @Override 1661 public void setInitialAttachApn(String apn, String protocol, int authType, String username, 1662 String password, Message result) { 1663 } 1664 1665 @Override 1666 public void getImsRegistrationState(Message response) { 1667 unimplemented(response); 1668 } 1669 1670 @Override 1671 public void sendImsCdmaSms(byte[] pdu, int retry, int messageRef, 1672 Message response){ 1673 unimplemented(response); 1674 } 1675 1676 @Override 1677 public void sendImsGsmSms(String smscPDU, String pdu, 1678 int retry, int messageRef, Message response){ 1679 unimplemented(response); 1680 } 1681 1682 @Override 1683 public void iccOpenLogicalChannel(String AID, Message response) { 1684 unimplemented(response); 1685 } 1686 1687 @Override 1688 public void iccCloseLogicalChannel(int channel, Message response) { 1689 unimplemented(response); 1690 } 1691 1692 @Override 1693 public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction, 1694 int p1, int p2, int p3, String data, Message response) { 1695 unimplemented(response); 1696 } 1697 1698 @Override 1699 public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2, 1700 int p3, String data, Message response) { 1701 unimplemented(response); 1702 } 1703} 1704