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; 18 19import static com.android.internal.telephony.RILConstants.*; 20import static android.telephony.TelephonyManager.NETWORK_TYPE_UNKNOWN; 21import static android.telephony.TelephonyManager.NETWORK_TYPE_EDGE; 22import static android.telephony.TelephonyManager.NETWORK_TYPE_GPRS; 23import static android.telephony.TelephonyManager.NETWORK_TYPE_UMTS; 24import static android.telephony.TelephonyManager.NETWORK_TYPE_HSDPA; 25import static android.telephony.TelephonyManager.NETWORK_TYPE_HSUPA; 26import static android.telephony.TelephonyManager.NETWORK_TYPE_HSPA; 27 28import android.content.BroadcastReceiver; 29import android.content.Context; 30import android.content.Intent; 31import android.content.IntentFilter; 32import android.hardware.display.DisplayManager; 33import android.net.ConnectivityManager; 34import android.net.LocalSocket; 35import android.net.LocalSocketAddress; 36import android.os.AsyncResult; 37import android.os.Handler; 38import android.os.HandlerThread; 39import android.os.Looper; 40import android.os.Message; 41import android.os.Parcel; 42import android.os.PowerManager; 43import android.os.SystemProperties; 44import android.os.PowerManager.WakeLock; 45import android.provider.Settings.SettingNotFoundException; 46import android.telephony.CellInfo; 47import android.telephony.NeighboringCellInfo; 48import android.telephony.PhoneNumberUtils; 49import android.telephony.Rlog; 50import android.telephony.SignalStrength; 51import android.telephony.SmsManager; 52import android.telephony.SmsMessage; 53import android.text.TextUtils; 54import android.util.SparseArray; 55import android.view.Display; 56 57import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo; 58import com.android.internal.telephony.gsm.SuppServiceNotification; 59import com.android.internal.telephony.uicc.IccCardApplicationStatus; 60import com.android.internal.telephony.uicc.IccCardStatus; 61import com.android.internal.telephony.uicc.IccIoResult; 62import com.android.internal.telephony.uicc.IccRefreshResponse; 63import com.android.internal.telephony.uicc.IccUtils; 64import com.android.internal.telephony.cdma.CdmaCallWaitingNotification; 65import com.android.internal.telephony.cdma.CdmaInformationRecords; 66import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo; 67import com.android.internal.telephony.dataconnection.DcFailCause; 68import com.android.internal.telephony.dataconnection.DataCallResponse; 69import com.android.internal.telephony.dataconnection.DataProfile; 70import com.android.internal.telephony.TelephonyDevController; 71import com.android.internal.telephony.HardwareConfig; 72 73import java.io.ByteArrayInputStream; 74import java.io.DataInputStream; 75import java.io.FileDescriptor; 76import java.io.IOException; 77import java.io.InputStream; 78import java.io.PrintWriter; 79import java.util.ArrayList; 80import java.util.Collections; 81import java.util.concurrent.atomic.AtomicBoolean; 82import java.util.concurrent.atomic.AtomicInteger; 83import java.util.Random; 84 85/** 86 * {@hide} 87 */ 88class RILRequest { 89 static final String LOG_TAG = "RilRequest"; 90 91 //***** Class Variables 92 static Random sRandom = new Random(); 93 static AtomicInteger sNextSerial = new AtomicInteger(0); 94 private static Object sPoolSync = new Object(); 95 private static RILRequest sPool = null; 96 private static int sPoolSize = 0; 97 private static final int MAX_POOL_SIZE = 4; 98 private Context mContext; 99 100 //***** Instance Variables 101 int mSerial; 102 int mRequest; 103 Message mResult; 104 Parcel mParcel; 105 RILRequest mNext; 106 107 /** 108 * Retrieves a new RILRequest instance from the pool. 109 * 110 * @param request RIL_REQUEST_* 111 * @param result sent when operation completes 112 * @return a RILRequest instance from the pool. 113 */ 114 static RILRequest obtain(int request, Message result) { 115 RILRequest rr = null; 116 117 synchronized(sPoolSync) { 118 if (sPool != null) { 119 rr = sPool; 120 sPool = rr.mNext; 121 rr.mNext = null; 122 sPoolSize--; 123 } 124 } 125 126 if (rr == null) { 127 rr = new RILRequest(); 128 } 129 130 rr.mSerial = sNextSerial.getAndIncrement(); 131 132 rr.mRequest = request; 133 rr.mResult = result; 134 rr.mParcel = Parcel.obtain(); 135 136 if (result != null && result.getTarget() == null) { 137 throw new NullPointerException("Message target must not be null"); 138 } 139 140 // first elements in any RIL Parcel 141 rr.mParcel.writeInt(request); 142 rr.mParcel.writeInt(rr.mSerial); 143 144 return rr; 145 } 146 147 /** 148 * Returns a RILRequest instance to the pool. 149 * 150 * Note: This should only be called once per use. 151 */ 152 void release() { 153 synchronized (sPoolSync) { 154 if (sPoolSize < MAX_POOL_SIZE) { 155 mNext = sPool; 156 sPool = this; 157 sPoolSize++; 158 mResult = null; 159 } 160 } 161 } 162 163 private RILRequest() { 164 } 165 166 static void 167 resetSerial() { 168 // use a random so that on recovery we probably don't mix old requests 169 // with new. 170 sNextSerial.set(sRandom.nextInt()); 171 } 172 173 String 174 serialString() { 175 //Cheesy way to do %04d 176 StringBuilder sb = new StringBuilder(8); 177 String sn; 178 179 long adjustedSerial = (((long)mSerial) - Integer.MIN_VALUE)%10000; 180 181 sn = Long.toString(adjustedSerial); 182 183 //sb.append("J["); 184 sb.append('['); 185 for (int i = 0, s = sn.length() ; i < 4 - s; i++) { 186 sb.append('0'); 187 } 188 189 sb.append(sn); 190 sb.append(']'); 191 return sb.toString(); 192 } 193 194 void 195 onError(int error, Object ret) { 196 CommandException ex; 197 198 ex = CommandException.fromRilErrno(error); 199 200 if (RIL.RILJ_LOGD) Rlog.d(LOG_TAG, serialString() + "< " 201 + RIL.requestToString(mRequest) 202 + " error: " + ex + " ret=" + RIL.retToString(mRequest, ret)); 203 204 if (mResult != null) { 205 AsyncResult.forMessage(mResult, ret, ex); 206 mResult.sendToTarget(); 207 } 208 209 if (mParcel != null) { 210 mParcel.recycle(); 211 mParcel = null; 212 } 213 } 214} 215 216 217/** 218 * RIL implementation of the CommandsInterface. 219 * 220 * {@hide} 221 */ 222public final class RIL extends BaseCommands implements CommandsInterface { 223 static final String RILJ_LOG_TAG = "RILJ"; 224 static final boolean RILJ_LOGD = true; 225 static final boolean RILJ_LOGV = false; // STOPSHIP if true 226 227 /** 228 * Wake lock timeout should be longer than the longest timeout in 229 * the vendor ril. 230 */ 231 private static final int DEFAULT_WAKE_LOCK_TIMEOUT = 60000; 232 233 //***** Instance Variables 234 235 LocalSocket mSocket; 236 HandlerThread mSenderThread; 237 RILSender mSender; 238 Thread mReceiverThread; 239 RILReceiver mReceiver; 240 Display mDefaultDisplay; 241 int mDefaultDisplayState = Display.STATE_UNKNOWN; 242 WakeLock mWakeLock; 243 final int mWakeLockTimeout; 244 // The number of wakelock requests currently active. Don't release the lock 245 // until dec'd to 0 246 int mWakeLockCount; 247 248 SparseArray<RILRequest> mRequestList = new SparseArray<RILRequest>(); 249 250 Object mLastNITZTimeInfo; 251 252 // When we are testing emergency calls 253 AtomicBoolean mTestingEmergencyCall = new AtomicBoolean(false); 254 255 private Integer mInstanceId; 256 257 //***** Events 258 259 static final int EVENT_SEND = 1; 260 static final int EVENT_WAKE_LOCK_TIMEOUT = 2; 261 262 //***** Constants 263 264 // match with constant in ril.cpp 265 static final int RIL_MAX_COMMAND_BYTES = (8 * 1024); 266 static final int RESPONSE_SOLICITED = 0; 267 static final int RESPONSE_UNSOLICITED = 1; 268 269 static final String[] SOCKET_NAME_RIL = {"rild", "rild2", "rild3"}; 270 271 static final int SOCKET_OPEN_RETRY_MILLIS = 4 * 1000; 272 273 // The number of the required config values for broadcast SMS stored in the C struct 274 // RIL_CDMA_BroadcastServiceInfo 275 private static final int CDMA_BSI_NO_OF_INTS_STRUCT = 3; 276 277 private static final int CDMA_BROADCAST_SMS_NO_OF_SERVICE_CATEGORIES = 31; 278 279 private final DisplayManager.DisplayListener mDisplayListener = 280 new DisplayManager.DisplayListener() { 281 @Override 282 public void onDisplayAdded(int displayId) { } 283 284 @Override 285 public void onDisplayRemoved(int displayId) { } 286 287 @Override 288 public void onDisplayChanged(int displayId) { 289 if (displayId == Display.DEFAULT_DISPLAY) { 290 updateScreenState(); 291 } 292 } 293 }; 294 295 class RILSender extends Handler implements Runnable { 296 public RILSender(Looper looper) { 297 super(looper); 298 } 299 300 // Only allocated once 301 byte[] dataLength = new byte[4]; 302 303 //***** Runnable implementation 304 @Override 305 public void 306 run() { 307 //setup if needed 308 } 309 310 311 //***** Handler implementation 312 @Override public void 313 handleMessage(Message msg) { 314 RILRequest rr = (RILRequest)(msg.obj); 315 RILRequest req = null; 316 317 switch (msg.what) { 318 case EVENT_SEND: 319 try { 320 LocalSocket s; 321 322 s = mSocket; 323 324 if (s == null) { 325 rr.onError(RADIO_NOT_AVAILABLE, null); 326 rr.release(); 327 decrementWakeLock(); 328 return; 329 } 330 331 synchronized (mRequestList) { 332 mRequestList.append(rr.mSerial, rr); 333 } 334 335 byte[] data; 336 337 data = rr.mParcel.marshall(); 338 rr.mParcel.recycle(); 339 rr.mParcel = null; 340 341 if (data.length > RIL_MAX_COMMAND_BYTES) { 342 throw new RuntimeException( 343 "Parcel larger than max bytes allowed! " 344 + data.length); 345 } 346 347 // parcel length in big endian 348 dataLength[0] = dataLength[1] = 0; 349 dataLength[2] = (byte)((data.length >> 8) & 0xff); 350 dataLength[3] = (byte)((data.length) & 0xff); 351 352 //Rlog.v(RILJ_LOG_TAG, "writing packet: " + data.length + " bytes"); 353 354 s.getOutputStream().write(dataLength); 355 s.getOutputStream().write(data); 356 } catch (IOException ex) { 357 Rlog.e(RILJ_LOG_TAG, "IOException", ex); 358 req = findAndRemoveRequestFromList(rr.mSerial); 359 // make sure this request has not already been handled, 360 // eg, if RILReceiver cleared the list. 361 if (req != null) { 362 rr.onError(RADIO_NOT_AVAILABLE, null); 363 rr.release(); 364 decrementWakeLock(); 365 } 366 } catch (RuntimeException exc) { 367 Rlog.e(RILJ_LOG_TAG, "Uncaught exception ", exc); 368 req = findAndRemoveRequestFromList(rr.mSerial); 369 // make sure this request has not already been handled, 370 // eg, if RILReceiver cleared the list. 371 if (req != null) { 372 rr.onError(GENERIC_FAILURE, null); 373 rr.release(); 374 decrementWakeLock(); 375 } 376 } 377 378 break; 379 380 case EVENT_WAKE_LOCK_TIMEOUT: 381 // Haven't heard back from the last request. Assume we're 382 // not getting a response and release the wake lock. 383 384 // The timer of WAKE_LOCK_TIMEOUT is reset with each 385 // new send request. So when WAKE_LOCK_TIMEOUT occurs 386 // all requests in mRequestList already waited at 387 // least DEFAULT_WAKE_LOCK_TIMEOUT but no response. 388 // 389 // Note: Keep mRequestList so that delayed response 390 // can still be handled when response finally comes. 391 392 synchronized (mRequestList) { 393 if (clearWakeLock()) { 394 if (RILJ_LOGD) { 395 int count = mRequestList.size(); 396 Rlog.d(RILJ_LOG_TAG, "WAKE_LOCK_TIMEOUT " + 397 " mRequestList=" + count); 398 for (int i = 0; i < count; i++) { 399 rr = mRequestList.valueAt(i); 400 Rlog.d(RILJ_LOG_TAG, i + ": [" + rr.mSerial + "] " 401 + requestToString(rr.mRequest)); 402 } 403 } 404 } 405 } 406 break; 407 } 408 } 409 } 410 411 /** 412 * Reads in a single RIL message off the wire. A RIL message consists 413 * of a 4-byte little-endian length and a subsequent series of bytes. 414 * The final message (length header omitted) is read into 415 * <code>buffer</code> and the length of the final message (less header) 416 * is returned. A return value of -1 indicates end-of-stream. 417 * 418 * @param is non-null; Stream to read from 419 * @param buffer Buffer to fill in. Must be as large as maximum 420 * message size, or an ArrayOutOfBounds exception will be thrown. 421 * @return Length of message less header, or -1 on end of stream. 422 * @throws IOException 423 */ 424 private static int readRilMessage(InputStream is, byte[] buffer) 425 throws IOException { 426 int countRead; 427 int offset; 428 int remaining; 429 int messageLength; 430 431 // First, read in the length of the message 432 offset = 0; 433 remaining = 4; 434 do { 435 countRead = is.read(buffer, offset, remaining); 436 437 if (countRead < 0 ) { 438 Rlog.e(RILJ_LOG_TAG, "Hit EOS reading message length"); 439 return -1; 440 } 441 442 offset += countRead; 443 remaining -= countRead; 444 } while (remaining > 0); 445 446 messageLength = ((buffer[0] & 0xff) << 24) 447 | ((buffer[1] & 0xff) << 16) 448 | ((buffer[2] & 0xff) << 8) 449 | (buffer[3] & 0xff); 450 451 // Then, re-use the buffer and read in the message itself 452 offset = 0; 453 remaining = messageLength; 454 do { 455 countRead = is.read(buffer, offset, remaining); 456 457 if (countRead < 0 ) { 458 Rlog.e(RILJ_LOG_TAG, "Hit EOS reading message. messageLength=" + messageLength 459 + " remaining=" + remaining); 460 return -1; 461 } 462 463 offset += countRead; 464 remaining -= countRead; 465 } while (remaining > 0); 466 467 return messageLength; 468 } 469 470 class RILReceiver implements Runnable { 471 byte[] buffer; 472 473 RILReceiver() { 474 buffer = new byte[RIL_MAX_COMMAND_BYTES]; 475 } 476 477 @Override 478 public void 479 run() { 480 int retryCount = 0; 481 String rilSocket = "rild"; 482 483 try {for (;;) { 484 LocalSocket s = null; 485 LocalSocketAddress l; 486 487 if (mInstanceId == null || mInstanceId == 0 ) { 488 rilSocket = SOCKET_NAME_RIL[0]; 489 } else { 490 rilSocket = SOCKET_NAME_RIL[mInstanceId]; 491 } 492 493 try { 494 s = new LocalSocket(); 495 l = new LocalSocketAddress(rilSocket, 496 LocalSocketAddress.Namespace.RESERVED); 497 s.connect(l); 498 } catch (IOException ex){ 499 try { 500 if (s != null) { 501 s.close(); 502 } 503 } catch (IOException ex2) { 504 //ignore failure to close after failure to connect 505 } 506 507 // don't print an error message after the the first time 508 // or after the 8th time 509 510 if (retryCount == 8) { 511 Rlog.e (RILJ_LOG_TAG, 512 "Couldn't find '" + rilSocket 513 + "' socket after " + retryCount 514 + " times, continuing to retry silently"); 515 } else if (retryCount > 0 && retryCount < 8) { 516 Rlog.i (RILJ_LOG_TAG, 517 "Couldn't find '" + rilSocket 518 + "' socket; retrying after timeout"); 519 } 520 521 try { 522 Thread.sleep(SOCKET_OPEN_RETRY_MILLIS); 523 } catch (InterruptedException er) { 524 } 525 526 retryCount++; 527 continue; 528 } 529 530 retryCount = 0; 531 532 mSocket = s; 533 Rlog.i(RILJ_LOG_TAG, "Connected to '" + rilSocket + "' socket"); 534 535 int length = 0; 536 try { 537 InputStream is = mSocket.getInputStream(); 538 539 for (;;) { 540 Parcel p; 541 542 length = readRilMessage(is, buffer); 543 544 if (length < 0) { 545 // End-of-stream reached 546 break; 547 } 548 549 p = Parcel.obtain(); 550 p.unmarshall(buffer, 0, length); 551 p.setDataPosition(0); 552 553 //Rlog.v(RILJ_LOG_TAG, "Read packet: " + length + " bytes"); 554 555 processResponse(p); 556 p.recycle(); 557 } 558 } catch (java.io.IOException ex) { 559 Rlog.i(RILJ_LOG_TAG, "'" + rilSocket + "' socket closed", 560 ex); 561 } catch (Throwable tr) { 562 Rlog.e(RILJ_LOG_TAG, "Uncaught exception read length=" + length + 563 "Exception:" + tr.toString()); 564 } 565 566 Rlog.i(RILJ_LOG_TAG, "Disconnected from '" + rilSocket 567 + "' socket"); 568 569 setRadioState (RadioState.RADIO_UNAVAILABLE); 570 571 try { 572 mSocket.close(); 573 } catch (IOException ex) { 574 } 575 576 mSocket = null; 577 RILRequest.resetSerial(); 578 579 // Clear request list on close 580 clearRequestList(RADIO_NOT_AVAILABLE, false); 581 }} catch (Throwable tr) { 582 Rlog.e(RILJ_LOG_TAG,"Uncaught exception", tr); 583 } 584 585 /* We're disconnected so we don't know the ril version */ 586 notifyRegistrantsRilConnectionChanged(-1); 587 } 588 } 589 590 591 592 //***** Constructors 593 594 public RIL(Context context, int preferredNetworkType, int cdmaSubscription) { 595 this(context, preferredNetworkType, cdmaSubscription, null); 596 } 597 598 public RIL(Context context, int preferredNetworkType, 599 int cdmaSubscription, Integer instanceId) { 600 super(context); 601 if (RILJ_LOGD) { 602 riljLog("RIL(context, preferredNetworkType=" + preferredNetworkType + 603 " cdmaSubscription=" + cdmaSubscription + ")"); 604 } 605 606 mContext = context; 607 mCdmaSubscription = cdmaSubscription; 608 mPreferredNetworkType = preferredNetworkType; 609 mPhoneType = RILConstants.NO_PHONE; 610 mInstanceId = instanceId; 611 612 PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE); 613 mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, RILJ_LOG_TAG); 614 mWakeLock.setReferenceCounted(false); 615 mWakeLockTimeout = SystemProperties.getInt(TelephonyProperties.PROPERTY_WAKE_LOCK_TIMEOUT, 616 DEFAULT_WAKE_LOCK_TIMEOUT); 617 mWakeLockCount = 0; 618 619 mSenderThread = new HandlerThread("RILSender"); 620 mSenderThread.start(); 621 622 Looper looper = mSenderThread.getLooper(); 623 mSender = new RILSender(looper); 624 625 ConnectivityManager cm = (ConnectivityManager)context.getSystemService( 626 Context.CONNECTIVITY_SERVICE); 627 if (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE) == false) { 628 riljLog("Not starting RILReceiver: wifi-only"); 629 } else { 630 riljLog("Starting RILReceiver"); 631 mReceiver = new RILReceiver(); 632 mReceiverThread = new Thread(mReceiver, "RILReceiver"); 633 mReceiverThread.start(); 634 635 DisplayManager dm = (DisplayManager)context.getSystemService( 636 Context.DISPLAY_SERVICE); 637 mDefaultDisplay = dm.getDisplay(Display.DEFAULT_DISPLAY); 638 dm.registerDisplayListener(mDisplayListener, null); 639 } 640 641 TelephonyDevController tdc = TelephonyDevController.getInstance(); 642 tdc.registerRIL(this); 643 } 644 645 //***** CommandsInterface implementation 646 647 @Override 648 public void getVoiceRadioTechnology(Message result) { 649 RILRequest rr = RILRequest.obtain(RIL_REQUEST_VOICE_RADIO_TECH, result); 650 651 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 652 653 send(rr); 654 } 655 656 657 public void getImsRegistrationState(Message result) { 658 RILRequest rr = RILRequest.obtain(RIL_REQUEST_IMS_REGISTRATION_STATE, result); 659 660 if (RILJ_LOGD) { 661 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 662 } 663 send(rr); 664 } 665 666 @Override public void 667 setOnNITZTime(Handler h, int what, Object obj) { 668 super.setOnNITZTime(h, what, obj); 669 670 // Send the last NITZ time if we have it 671 if (mLastNITZTimeInfo != null) { 672 mNITZTimeRegistrant 673 .notifyRegistrant( 674 new AsyncResult (null, mLastNITZTimeInfo, null)); 675 mLastNITZTimeInfo = null; 676 } 677 } 678 679 @Override 680 public void 681 getIccCardStatus(Message result) { 682 //Note: This RIL request has not been renamed to ICC, 683 // but this request is also valid for SIM and RUIM 684 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_SIM_STATUS, result); 685 686 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 687 688 send(rr); 689 } 690 691 public void setUiccSubscription(int slotId, int appIndex, int subId, 692 int subStatus, Message result) { 693 //Note: This RIL request is also valid for SIM and RUIM (ICC card) 694 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_UICC_SUBSCRIPTION, result); 695 696 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 697 + " slot: " + slotId + " appIndex: " + appIndex 698 + " subId: " + subId + " subStatus: " + subStatus); 699 700 rr.mParcel.writeInt(slotId); 701 rr.mParcel.writeInt(appIndex); 702 rr.mParcel.writeInt(subId); 703 rr.mParcel.writeInt(subStatus); 704 705 send(rr); 706 } 707 708 // FIXME This API should take an AID and slot ID 709 public void setDataAllowed(boolean allowed, Message result) { 710 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ALLOW_DATA, result); 711 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 712 713 rr.mParcel.writeInt(1); 714 rr.mParcel.writeInt(allowed ? 1 : 0); 715 send(rr); 716 } 717 718 @Override public void 719 supplyIccPin(String pin, Message result) { 720 supplyIccPinForApp(pin, null, result); 721 } 722 723 @Override public void 724 supplyIccPinForApp(String pin, String aid, Message result) { 725 //Note: This RIL request has not been renamed to ICC, 726 // but this request is also valid for SIM and RUIM 727 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PIN, result); 728 729 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 730 731 rr.mParcel.writeInt(2); 732 rr.mParcel.writeString(pin); 733 rr.mParcel.writeString(aid); 734 735 send(rr); 736 } 737 738 @Override public void 739 supplyIccPuk(String puk, String newPin, Message result) { 740 supplyIccPukForApp(puk, newPin, null, result); 741 } 742 743 @Override public void 744 supplyIccPukForApp(String puk, String newPin, String aid, Message result) { 745 //Note: This RIL request has not been renamed to ICC, 746 // but this request is also valid for SIM and RUIM 747 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PUK, result); 748 749 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 750 751 rr.mParcel.writeInt(3); 752 rr.mParcel.writeString(puk); 753 rr.mParcel.writeString(newPin); 754 rr.mParcel.writeString(aid); 755 756 send(rr); 757 } 758 759 @Override public void 760 supplyIccPin2(String pin, Message result) { 761 supplyIccPin2ForApp(pin, null, result); 762 } 763 764 @Override public void 765 supplyIccPin2ForApp(String pin, String aid, Message result) { 766 //Note: This RIL request has not been renamed to ICC, 767 // but this request is also valid for SIM and RUIM 768 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PIN2, result); 769 770 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 771 772 rr.mParcel.writeInt(2); 773 rr.mParcel.writeString(pin); 774 rr.mParcel.writeString(aid); 775 776 send(rr); 777 } 778 779 @Override public void 780 supplyIccPuk2(String puk2, String newPin2, Message result) { 781 supplyIccPuk2ForApp(puk2, newPin2, null, result); 782 } 783 784 @Override public void 785 supplyIccPuk2ForApp(String puk, String newPin2, String aid, Message result) { 786 //Note: This RIL request has not been renamed to ICC, 787 // but this request is also valid for SIM and RUIM 788 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PUK2, result); 789 790 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 791 792 rr.mParcel.writeInt(3); 793 rr.mParcel.writeString(puk); 794 rr.mParcel.writeString(newPin2); 795 rr.mParcel.writeString(aid); 796 797 send(rr); 798 } 799 800 @Override public void 801 changeIccPin(String oldPin, String newPin, Message result) { 802 changeIccPinForApp(oldPin, newPin, null, result); 803 } 804 805 @Override public void 806 changeIccPinForApp(String oldPin, String newPin, String aid, Message result) { 807 //Note: This RIL request has not been renamed to ICC, 808 // but this request is also valid for SIM and RUIM 809 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_SIM_PIN, result); 810 811 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 812 813 rr.mParcel.writeInt(3); 814 rr.mParcel.writeString(oldPin); 815 rr.mParcel.writeString(newPin); 816 rr.mParcel.writeString(aid); 817 818 send(rr); 819 } 820 821 @Override public void 822 changeIccPin2(String oldPin2, String newPin2, Message result) { 823 changeIccPin2ForApp(oldPin2, newPin2, null, result); 824 } 825 826 @Override public void 827 changeIccPin2ForApp(String oldPin2, String newPin2, String aid, Message result) { 828 //Note: This RIL request has not been renamed to ICC, 829 // but this request is also valid for SIM and RUIM 830 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_SIM_PIN2, result); 831 832 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 833 834 rr.mParcel.writeInt(3); 835 rr.mParcel.writeString(oldPin2); 836 rr.mParcel.writeString(newPin2); 837 rr.mParcel.writeString(aid); 838 839 send(rr); 840 } 841 842 @Override 843 public void 844 changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) { 845 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_BARRING_PASSWORD, result); 846 847 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 848 849 rr.mParcel.writeInt(3); 850 rr.mParcel.writeString(facility); 851 rr.mParcel.writeString(oldPwd); 852 rr.mParcel.writeString(newPwd); 853 854 send(rr); 855 } 856 857 @Override 858 public void 859 supplyNetworkDepersonalization(String netpin, Message result) { 860 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION, result); 861 862 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 863 864 rr.mParcel.writeInt(1); 865 rr.mParcel.writeString(netpin); 866 867 send(rr); 868 } 869 870 @Override 871 public void 872 getCurrentCalls (Message result) { 873 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_CURRENT_CALLS, result); 874 875 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 876 877 send(rr); 878 } 879 880 @Override 881 @Deprecated public void 882 getPDPContextList(Message result) { 883 getDataCallList(result); 884 } 885 886 @Override 887 public void 888 getDataCallList(Message result) { 889 RILRequest rr = RILRequest.obtain(RIL_REQUEST_DATA_CALL_LIST, result); 890 891 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 892 893 send(rr); 894 } 895 896 @Override 897 public void 898 dial (String address, int clirMode, Message result) { 899 dial(address, clirMode, null, result); 900 } 901 902 @Override 903 public void 904 dial(String address, int clirMode, UUSInfo uusInfo, Message result) { 905 RILRequest rr = RILRequest.obtain(RIL_REQUEST_DIAL, result); 906 907 rr.mParcel.writeString(address); 908 rr.mParcel.writeInt(clirMode); 909 910 if (uusInfo == null) { 911 rr.mParcel.writeInt(0); // UUS information is absent 912 } else { 913 rr.mParcel.writeInt(1); // UUS information is present 914 rr.mParcel.writeInt(uusInfo.getType()); 915 rr.mParcel.writeInt(uusInfo.getDcs()); 916 rr.mParcel.writeByteArray(uusInfo.getUserData()); 917 } 918 919 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 920 921 send(rr); 922 } 923 924 @Override 925 public void 926 getIMSI(Message result) { 927 getIMSIForApp(null, result); 928 } 929 930 @Override 931 public void 932 getIMSIForApp(String aid, Message result) { 933 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_IMSI, result); 934 935 rr.mParcel.writeInt(1); 936 rr.mParcel.writeString(aid); 937 938 if (RILJ_LOGD) riljLog(rr.serialString() + 939 "> getIMSI: " + requestToString(rr.mRequest) 940 + " aid: " + aid); 941 942 send(rr); 943 } 944 945 @Override 946 public void 947 getIMEI(Message result) { 948 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_IMEI, result); 949 950 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 951 952 send(rr); 953 } 954 955 @Override 956 public void 957 getIMEISV(Message result) { 958 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_IMEISV, result); 959 960 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 961 962 send(rr); 963 } 964 965 966 @Override 967 public void 968 hangupConnection (int gsmIndex, Message result) { 969 if (RILJ_LOGD) riljLog("hangupConnection: gsmIndex=" + gsmIndex); 970 971 RILRequest rr = RILRequest.obtain(RIL_REQUEST_HANGUP, result); 972 973 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + 974 gsmIndex); 975 976 rr.mParcel.writeInt(1); 977 rr.mParcel.writeInt(gsmIndex); 978 979 send(rr); 980 } 981 982 @Override 983 public void 984 hangupWaitingOrBackground (Message result) { 985 RILRequest rr = RILRequest.obtain(RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND, 986 result); 987 988 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 989 990 send(rr); 991 } 992 993 @Override 994 public void 995 hangupForegroundResumeBackground (Message result) { 996 RILRequest rr 997 = RILRequest.obtain( 998 RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND, 999 result); 1000 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1001 1002 send(rr); 1003 } 1004 1005 @Override 1006 public void 1007 switchWaitingOrHoldingAndActive (Message result) { 1008 RILRequest rr 1009 = RILRequest.obtain( 1010 RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, 1011 result); 1012 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1013 1014 send(rr); 1015 } 1016 1017 @Override 1018 public void 1019 conference (Message result) { 1020 RILRequest rr 1021 = RILRequest.obtain(RIL_REQUEST_CONFERENCE, result); 1022 1023 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1024 1025 send(rr); 1026 } 1027 1028 1029 @Override 1030 public void setPreferredVoicePrivacy(boolean enable, Message result) { 1031 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE, 1032 result); 1033 1034 rr.mParcel.writeInt(1); 1035 rr.mParcel.writeInt(enable ? 1:0); 1036 1037 send(rr); 1038 } 1039 1040 @Override 1041 public void getPreferredVoicePrivacy(Message result) { 1042 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE, 1043 result); 1044 send(rr); 1045 } 1046 1047 @Override 1048 public void 1049 separateConnection (int gsmIndex, Message result) { 1050 RILRequest rr 1051 = RILRequest.obtain(RIL_REQUEST_SEPARATE_CONNECTION, result); 1052 1053 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1054 + " " + gsmIndex); 1055 1056 rr.mParcel.writeInt(1); 1057 rr.mParcel.writeInt(gsmIndex); 1058 1059 send(rr); 1060 } 1061 1062 @Override 1063 public void 1064 acceptCall (Message result) { 1065 RILRequest rr 1066 = RILRequest.obtain(RIL_REQUEST_ANSWER, result); 1067 1068 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1069 1070 send(rr); 1071 } 1072 1073 @Override 1074 public void 1075 rejectCall (Message result) { 1076 RILRequest rr 1077 = RILRequest.obtain(RIL_REQUEST_UDUB, result); 1078 1079 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1080 1081 send(rr); 1082 } 1083 1084 @Override 1085 public void 1086 explicitCallTransfer (Message result) { 1087 RILRequest rr 1088 = RILRequest.obtain(RIL_REQUEST_EXPLICIT_CALL_TRANSFER, result); 1089 1090 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1091 1092 send(rr); 1093 } 1094 1095 @Override 1096 public void 1097 getLastCallFailCause (Message result) { 1098 RILRequest rr 1099 = RILRequest.obtain(RIL_REQUEST_LAST_CALL_FAIL_CAUSE, result); 1100 1101 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1102 1103 send(rr); 1104 } 1105 1106 /** 1107 * @deprecated 1108 */ 1109 @Deprecated 1110 @Override 1111 public void 1112 getLastPdpFailCause (Message result) { 1113 getLastDataCallFailCause (result); 1114 } 1115 1116 /** 1117 * The preferred new alternative to getLastPdpFailCause 1118 */ 1119 @Override 1120 public void 1121 getLastDataCallFailCause (Message result) { 1122 RILRequest rr 1123 = RILRequest.obtain(RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE, result); 1124 1125 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1126 1127 send(rr); 1128 } 1129 1130 @Override 1131 public void 1132 setMute (boolean enableMute, Message response) { 1133 RILRequest rr 1134 = RILRequest.obtain(RIL_REQUEST_SET_MUTE, response); 1135 1136 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1137 + " " + enableMute); 1138 1139 rr.mParcel.writeInt(1); 1140 rr.mParcel.writeInt(enableMute ? 1 : 0); 1141 1142 send(rr); 1143 } 1144 1145 @Override 1146 public void 1147 getMute (Message response) { 1148 RILRequest rr 1149 = RILRequest.obtain(RIL_REQUEST_GET_MUTE, response); 1150 1151 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1152 1153 send(rr); 1154 } 1155 1156 @Override 1157 public void 1158 getSignalStrength (Message result) { 1159 RILRequest rr 1160 = RILRequest.obtain(RIL_REQUEST_SIGNAL_STRENGTH, result); 1161 1162 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1163 1164 send(rr); 1165 } 1166 1167 @Override 1168 public void 1169 getVoiceRegistrationState (Message result) { 1170 RILRequest rr 1171 = RILRequest.obtain(RIL_REQUEST_VOICE_REGISTRATION_STATE, result); 1172 1173 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1174 1175 send(rr); 1176 } 1177 1178 @Override 1179 public void 1180 getDataRegistrationState (Message result) { 1181 RILRequest rr 1182 = RILRequest.obtain(RIL_REQUEST_DATA_REGISTRATION_STATE, result); 1183 1184 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1185 1186 send(rr); 1187 } 1188 1189 @Override 1190 public void 1191 getOperator(Message result) { 1192 RILRequest rr 1193 = RILRequest.obtain(RIL_REQUEST_OPERATOR, result); 1194 1195 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1196 1197 send(rr); 1198 } 1199 1200 @Override 1201 public void 1202 getHardwareConfig (Message result) { 1203 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_HARDWARE_CONFIG, result); 1204 1205 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1206 1207 send(rr); 1208 } 1209 1210 @Override 1211 public void 1212 sendDtmf(char c, Message result) { 1213 RILRequest rr 1214 = RILRequest.obtain(RIL_REQUEST_DTMF, result); 1215 1216 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1217 1218 rr.mParcel.writeString(Character.toString(c)); 1219 1220 send(rr); 1221 } 1222 1223 @Override 1224 public void 1225 startDtmf(char c, Message result) { 1226 RILRequest rr 1227 = RILRequest.obtain(RIL_REQUEST_DTMF_START, result); 1228 1229 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1230 1231 rr.mParcel.writeString(Character.toString(c)); 1232 1233 send(rr); 1234 } 1235 1236 @Override 1237 public void 1238 stopDtmf(Message result) { 1239 RILRequest rr 1240 = RILRequest.obtain(RIL_REQUEST_DTMF_STOP, result); 1241 1242 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1243 1244 send(rr); 1245 } 1246 1247 @Override 1248 public void 1249 sendBurstDtmf(String dtmfString, int on, int off, Message result) { 1250 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_BURST_DTMF, result); 1251 1252 rr.mParcel.writeInt(3); 1253 rr.mParcel.writeString(dtmfString); 1254 rr.mParcel.writeString(Integer.toString(on)); 1255 rr.mParcel.writeString(Integer.toString(off)); 1256 1257 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1258 + " : " + dtmfString); 1259 1260 send(rr); 1261 } 1262 1263 private void 1264 constructGsmSendSmsRilRequest (RILRequest rr, String smscPDU, String pdu) { 1265 rr.mParcel.writeInt(2); 1266 rr.mParcel.writeString(smscPDU); 1267 rr.mParcel.writeString(pdu); 1268 } 1269 1270 public void 1271 sendSMS (String smscPDU, String pdu, Message result) { 1272 RILRequest rr 1273 = RILRequest.obtain(RIL_REQUEST_SEND_SMS, result); 1274 1275 constructGsmSendSmsRilRequest(rr, smscPDU, pdu); 1276 1277 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1278 1279 send(rr); 1280 } 1281 1282 @Override 1283 public void 1284 sendSMSExpectMore (String smscPDU, String pdu, Message result) { 1285 RILRequest rr 1286 = RILRequest.obtain(RIL_REQUEST_SEND_SMS_EXPECT_MORE, result); 1287 1288 constructGsmSendSmsRilRequest(rr, smscPDU, pdu); 1289 1290 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1291 1292 send(rr); 1293 } 1294 1295 private void 1296 constructCdmaSendSmsRilRequest(RILRequest rr, byte[] pdu) { 1297 int address_nbr_of_digits; 1298 int subaddr_nbr_of_digits; 1299 int bearerDataLength; 1300 ByteArrayInputStream bais = new ByteArrayInputStream(pdu); 1301 DataInputStream dis = new DataInputStream(bais); 1302 1303 try { 1304 rr.mParcel.writeInt(dis.readInt()); //teleServiceId 1305 rr.mParcel.writeByte((byte) dis.readInt()); //servicePresent 1306 rr.mParcel.writeInt(dis.readInt()); //serviceCategory 1307 rr.mParcel.writeInt(dis.read()); //address_digit_mode 1308 rr.mParcel.writeInt(dis.read()); //address_nbr_mode 1309 rr.mParcel.writeInt(dis.read()); //address_ton 1310 rr.mParcel.writeInt(dis.read()); //address_nbr_plan 1311 address_nbr_of_digits = (byte) dis.read(); 1312 rr.mParcel.writeByte((byte) address_nbr_of_digits); 1313 for(int i=0; i < address_nbr_of_digits; i++){ 1314 rr.mParcel.writeByte(dis.readByte()); // address_orig_bytes[i] 1315 } 1316 rr.mParcel.writeInt(dis.read()); //subaddressType 1317 rr.mParcel.writeByte((byte) dis.read()); //subaddr_odd 1318 subaddr_nbr_of_digits = (byte) dis.read(); 1319 rr.mParcel.writeByte((byte) subaddr_nbr_of_digits); 1320 for(int i=0; i < subaddr_nbr_of_digits; i++){ 1321 rr.mParcel.writeByte(dis.readByte()); //subaddr_orig_bytes[i] 1322 } 1323 1324 bearerDataLength = dis.read(); 1325 rr.mParcel.writeInt(bearerDataLength); 1326 for(int i=0; i < bearerDataLength; i++){ 1327 rr.mParcel.writeByte(dis.readByte()); //bearerData[i] 1328 } 1329 }catch (IOException ex){ 1330 if (RILJ_LOGD) riljLog("sendSmsCdma: conversion from input stream to object failed: " 1331 + ex); 1332 } 1333 } 1334 1335 public void 1336 sendCdmaSms(byte[] pdu, Message result) { 1337 RILRequest rr 1338 = RILRequest.obtain(RIL_REQUEST_CDMA_SEND_SMS, result); 1339 1340 constructCdmaSendSmsRilRequest(rr, pdu); 1341 1342 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1343 1344 send(rr); 1345 } 1346 1347 public void 1348 sendImsGsmSms (String smscPDU, String pdu, int retry, int messageRef, 1349 Message result) { 1350 RILRequest rr = RILRequest.obtain(RIL_REQUEST_IMS_SEND_SMS, result); 1351 1352 rr.mParcel.writeInt(RILConstants.GSM_PHONE); 1353 rr.mParcel.writeByte((byte)retry); 1354 rr.mParcel.writeInt(messageRef); 1355 1356 constructGsmSendSmsRilRequest(rr, smscPDU, pdu); 1357 1358 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1359 1360 send(rr); 1361 } 1362 1363 public void 1364 sendImsCdmaSms(byte[] pdu, int retry, int messageRef, Message result) { 1365 RILRequest rr = RILRequest.obtain(RIL_REQUEST_IMS_SEND_SMS, result); 1366 1367 rr.mParcel.writeInt(RILConstants.CDMA_PHONE); 1368 rr.mParcel.writeByte((byte)retry); 1369 rr.mParcel.writeInt(messageRef); 1370 1371 constructCdmaSendSmsRilRequest(rr, pdu); 1372 1373 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1374 1375 send(rr); 1376 } 1377 1378 @Override 1379 public void deleteSmsOnSim(int index, Message response) { 1380 RILRequest rr = RILRequest.obtain(RIL_REQUEST_DELETE_SMS_ON_SIM, 1381 response); 1382 1383 rr.mParcel.writeInt(1); 1384 rr.mParcel.writeInt(index); 1385 1386 if (RILJ_LOGV) riljLog(rr.serialString() + "> " 1387 + requestToString(rr.mRequest) 1388 + " " + index); 1389 1390 send(rr); 1391 } 1392 1393 @Override 1394 public void deleteSmsOnRuim(int index, Message response) { 1395 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM, 1396 response); 1397 1398 rr.mParcel.writeInt(1); 1399 rr.mParcel.writeInt(index); 1400 1401 if (RILJ_LOGV) riljLog(rr.serialString() + "> " 1402 + requestToString(rr.mRequest) 1403 + " " + index); 1404 1405 send(rr); 1406 } 1407 1408 @Override 1409 public void writeSmsToSim(int status, String smsc, String pdu, Message response) { 1410 status = translateStatus(status); 1411 1412 RILRequest rr = RILRequest.obtain(RIL_REQUEST_WRITE_SMS_TO_SIM, 1413 response); 1414 1415 rr.mParcel.writeInt(status); 1416 rr.mParcel.writeString(pdu); 1417 rr.mParcel.writeString(smsc); 1418 1419 if (RILJ_LOGV) riljLog(rr.serialString() + "> " 1420 + requestToString(rr.mRequest) 1421 + " " + status); 1422 1423 send(rr); 1424 } 1425 1426 @Override 1427 public void writeSmsToRuim(int status, String pdu, Message response) { 1428 status = translateStatus(status); 1429 1430 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM, 1431 response); 1432 1433 rr.mParcel.writeInt(status); 1434 rr.mParcel.writeString(pdu); 1435 1436 if (RILJ_LOGV) riljLog(rr.serialString() + "> " 1437 + requestToString(rr.mRequest) 1438 + " " + status); 1439 1440 send(rr); 1441 } 1442 1443 /** 1444 * Translates EF_SMS status bits to a status value compatible with 1445 * SMS AT commands. See TS 27.005 3.1. 1446 */ 1447 private int translateStatus(int status) { 1448 switch(status & 0x7) { 1449 case SmsManager.STATUS_ON_ICC_READ: 1450 return 1; 1451 case SmsManager.STATUS_ON_ICC_UNREAD: 1452 return 0; 1453 case SmsManager.STATUS_ON_ICC_SENT: 1454 return 3; 1455 case SmsManager.STATUS_ON_ICC_UNSENT: 1456 return 2; 1457 } 1458 1459 // Default to READ. 1460 return 1; 1461 } 1462 1463 @Override 1464 public void 1465 setupDataCall(String radioTechnology, String profile, String apn, 1466 String user, String password, String authType, String protocol, 1467 Message result) { 1468 RILRequest rr 1469 = RILRequest.obtain(RIL_REQUEST_SETUP_DATA_CALL, result); 1470 1471 rr.mParcel.writeInt(7); 1472 1473 rr.mParcel.writeString(radioTechnology); 1474 rr.mParcel.writeString(profile); 1475 rr.mParcel.writeString(apn); 1476 rr.mParcel.writeString(user); 1477 rr.mParcel.writeString(password); 1478 rr.mParcel.writeString(authType); 1479 rr.mParcel.writeString(protocol); 1480 1481 if (RILJ_LOGD) riljLog(rr.serialString() + "> " 1482 + requestToString(rr.mRequest) + " " + radioTechnology + " " 1483 + profile + " " + apn + " " + user + " " 1484 + password + " " + authType + " " + protocol); 1485 1486 send(rr); 1487 } 1488 1489 @Override 1490 public void 1491 deactivateDataCall(int cid, int reason, Message result) { 1492 RILRequest rr 1493 = RILRequest.obtain(RIL_REQUEST_DEACTIVATE_DATA_CALL, result); 1494 1495 rr.mParcel.writeInt(2); 1496 rr.mParcel.writeString(Integer.toString(cid)); 1497 rr.mParcel.writeString(Integer.toString(reason)); 1498 1499 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + 1500 requestToString(rr.mRequest) + " " + cid + " " + reason); 1501 1502 send(rr); 1503 } 1504 1505 @Override 1506 public void 1507 setRadioPower(boolean on, Message result) { 1508 RILRequest rr = RILRequest.obtain(RIL_REQUEST_RADIO_POWER, result); 1509 1510 rr.mParcel.writeInt(1); 1511 rr.mParcel.writeInt(on ? 1 : 0); 1512 1513 if (RILJ_LOGD) { 1514 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1515 + (on ? " on" : " off")); 1516 } 1517 1518 send(rr); 1519 } 1520 1521 @Override 1522 public void requestShutdown(Message result) { 1523 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SHUTDOWN, result); 1524 1525 if (RILJ_LOGD) 1526 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1527 1528 send(rr); 1529 } 1530 1531 @Override 1532 public void 1533 setSuppServiceNotifications(boolean enable, Message result) { 1534 RILRequest rr 1535 = RILRequest.obtain(RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION, result); 1536 1537 rr.mParcel.writeInt(1); 1538 rr.mParcel.writeInt(enable ? 1 : 0); 1539 1540 if (RILJ_LOGD) riljLog(rr.serialString() + "> " 1541 + requestToString(rr.mRequest)); 1542 1543 send(rr); 1544 } 1545 1546 @Override 1547 public void 1548 acknowledgeLastIncomingGsmSms(boolean success, int cause, Message result) { 1549 RILRequest rr 1550 = RILRequest.obtain(RIL_REQUEST_SMS_ACKNOWLEDGE, result); 1551 1552 rr.mParcel.writeInt(2); 1553 rr.mParcel.writeInt(success ? 1 : 0); 1554 rr.mParcel.writeInt(cause); 1555 1556 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1557 + " " + success + " " + cause); 1558 1559 send(rr); 1560 } 1561 1562 @Override 1563 public void 1564 acknowledgeLastIncomingCdmaSms(boolean success, int cause, Message result) { 1565 RILRequest rr 1566 = RILRequest.obtain(RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE, result); 1567 1568 rr.mParcel.writeInt(success ? 0 : 1); //RIL_CDMA_SMS_ErrorClass 1569 // cause code according to X.S004-550E 1570 rr.mParcel.writeInt(cause); 1571 1572 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1573 + " " + success + " " + cause); 1574 1575 send(rr); 1576 } 1577 1578 @Override 1579 public void 1580 acknowledgeIncomingGsmSmsWithPdu(boolean success, String ackPdu, Message result) { 1581 RILRequest rr 1582 = RILRequest.obtain(RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU, result); 1583 1584 rr.mParcel.writeInt(2); 1585 rr.mParcel.writeString(success ? "1" : "0"); 1586 rr.mParcel.writeString(ackPdu); 1587 1588 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1589 + ' ' + success + " [" + ackPdu + ']'); 1590 1591 send(rr); 1592 } 1593 1594 @Override 1595 public void 1596 iccIO (int command, int fileid, String path, int p1, int p2, int p3, 1597 String data, String pin2, Message result) { 1598 iccIOForApp(command, fileid, path, p1, p2, p3, data, pin2, null, result); 1599 } 1600 @Override 1601 public void 1602 iccIOForApp (int command, int fileid, String path, int p1, int p2, int p3, 1603 String data, String pin2, String aid, Message result) { 1604 //Note: This RIL request has not been renamed to ICC, 1605 // but this request is also valid for SIM and RUIM 1606 RILRequest rr 1607 = RILRequest.obtain(RIL_REQUEST_SIM_IO, result); 1608 1609 rr.mParcel.writeInt(command); 1610 rr.mParcel.writeInt(fileid); 1611 rr.mParcel.writeString(path); 1612 rr.mParcel.writeInt(p1); 1613 rr.mParcel.writeInt(p2); 1614 rr.mParcel.writeInt(p3); 1615 rr.mParcel.writeString(data); 1616 rr.mParcel.writeString(pin2); 1617 rr.mParcel.writeString(aid); 1618 1619 if (RILJ_LOGD) riljLog(rr.serialString() + "> iccIO: " 1620 + requestToString(rr.mRequest) 1621 + " 0x" + Integer.toHexString(command) 1622 + " 0x" + Integer.toHexString(fileid) + " " 1623 + " path: " + path + "," 1624 + p1 + "," + p2 + "," + p3 1625 + " aid: " + aid); 1626 1627 send(rr); 1628 } 1629 1630 @Override 1631 public void 1632 getCLIR(Message result) { 1633 RILRequest rr 1634 = RILRequest.obtain(RIL_REQUEST_GET_CLIR, result); 1635 1636 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1637 1638 send(rr); 1639 } 1640 1641 @Override 1642 public void 1643 setCLIR(int clirMode, Message result) { 1644 RILRequest rr 1645 = RILRequest.obtain(RIL_REQUEST_SET_CLIR, result); 1646 1647 // count ints 1648 rr.mParcel.writeInt(1); 1649 1650 rr.mParcel.writeInt(clirMode); 1651 1652 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1653 + " " + clirMode); 1654 1655 send(rr); 1656 } 1657 1658 @Override 1659 public void 1660 queryCallWaiting(int serviceClass, Message response) { 1661 RILRequest rr 1662 = RILRequest.obtain(RIL_REQUEST_QUERY_CALL_WAITING, response); 1663 1664 rr.mParcel.writeInt(1); 1665 rr.mParcel.writeInt(serviceClass); 1666 1667 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1668 + " " + serviceClass); 1669 1670 send(rr); 1671 } 1672 1673 @Override 1674 public void 1675 setCallWaiting(boolean enable, int serviceClass, Message response) { 1676 RILRequest rr 1677 = RILRequest.obtain(RIL_REQUEST_SET_CALL_WAITING, response); 1678 1679 rr.mParcel.writeInt(2); 1680 rr.mParcel.writeInt(enable ? 1 : 0); 1681 rr.mParcel.writeInt(serviceClass); 1682 1683 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1684 + " " + enable + ", " + serviceClass); 1685 1686 send(rr); 1687 } 1688 1689 @Override 1690 public void 1691 setNetworkSelectionModeAutomatic(Message response) { 1692 RILRequest rr 1693 = RILRequest.obtain(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, 1694 response); 1695 1696 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1697 1698 send(rr); 1699 } 1700 1701 @Override 1702 public void 1703 setNetworkSelectionModeManual(String operatorNumeric, Message response) { 1704 RILRequest rr 1705 = RILRequest.obtain(RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL, 1706 response); 1707 1708 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1709 + " " + operatorNumeric); 1710 1711 rr.mParcel.writeString(operatorNumeric); 1712 1713 send(rr); 1714 } 1715 1716 @Override 1717 public void 1718 getNetworkSelectionMode(Message response) { 1719 RILRequest rr 1720 = RILRequest.obtain(RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE, 1721 response); 1722 1723 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1724 1725 send(rr); 1726 } 1727 1728 @Override 1729 public void 1730 getAvailableNetworks(Message response) { 1731 RILRequest rr 1732 = RILRequest.obtain(RIL_REQUEST_QUERY_AVAILABLE_NETWORKS, 1733 response); 1734 1735 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1736 1737 send(rr); 1738 } 1739 1740 @Override 1741 public void 1742 setCallForward(int action, int cfReason, int serviceClass, 1743 String number, int timeSeconds, Message response) { 1744 RILRequest rr 1745 = RILRequest.obtain(RIL_REQUEST_SET_CALL_FORWARD, response); 1746 1747 rr.mParcel.writeInt(action); 1748 rr.mParcel.writeInt(cfReason); 1749 rr.mParcel.writeInt(serviceClass); 1750 rr.mParcel.writeInt(PhoneNumberUtils.toaFromString(number)); 1751 rr.mParcel.writeString(number); 1752 rr.mParcel.writeInt (timeSeconds); 1753 1754 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1755 + " " + action + " " + cfReason + " " + serviceClass 1756 + timeSeconds); 1757 1758 send(rr); 1759 } 1760 1761 @Override 1762 public void 1763 queryCallForwardStatus(int cfReason, int serviceClass, 1764 String number, Message response) { 1765 RILRequest rr 1766 = RILRequest.obtain(RIL_REQUEST_QUERY_CALL_FORWARD_STATUS, response); 1767 1768 rr.mParcel.writeInt(2); // 2 is for query action, not in used anyway 1769 rr.mParcel.writeInt(cfReason); 1770 rr.mParcel.writeInt(serviceClass); 1771 rr.mParcel.writeInt(PhoneNumberUtils.toaFromString(number)); 1772 rr.mParcel.writeString(number); 1773 rr.mParcel.writeInt (0); 1774 1775 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1776 + " " + cfReason + " " + serviceClass); 1777 1778 send(rr); 1779 } 1780 1781 @Override 1782 public void 1783 queryCLIP(Message response) { 1784 RILRequest rr 1785 = RILRequest.obtain(RIL_REQUEST_QUERY_CLIP, response); 1786 1787 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1788 1789 send(rr); 1790 } 1791 1792 1793 @Override 1794 public void 1795 getBasebandVersion (Message response) { 1796 RILRequest rr 1797 = RILRequest.obtain(RIL_REQUEST_BASEBAND_VERSION, response); 1798 1799 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1800 1801 send(rr); 1802 } 1803 1804 @Override 1805 public void 1806 queryFacilityLock(String facility, String password, int serviceClass, 1807 Message response) { 1808 queryFacilityLockForApp(facility, password, serviceClass, null, response); 1809 } 1810 1811 @Override 1812 public void 1813 queryFacilityLockForApp(String facility, String password, int serviceClass, String appId, 1814 Message response) { 1815 RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_FACILITY_LOCK, response); 1816 1817 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1818 + " [" + facility + " " + serviceClass 1819 + " " + appId + "]"); 1820 1821 // count strings 1822 rr.mParcel.writeInt(4); 1823 1824 rr.mParcel.writeString(facility); 1825 rr.mParcel.writeString(password); 1826 1827 rr.mParcel.writeString(Integer.toString(serviceClass)); 1828 rr.mParcel.writeString(appId); 1829 1830 send(rr); 1831 } 1832 1833 @Override 1834 public void 1835 setFacilityLock (String facility, boolean lockState, String password, 1836 int serviceClass, Message response) { 1837 setFacilityLockForApp(facility, lockState, password, serviceClass, null, response); 1838 } 1839 1840 @Override 1841 public void 1842 setFacilityLockForApp(String facility, boolean lockState, String password, 1843 int serviceClass, String appId, Message response) { 1844 String lockString; 1845 RILRequest rr 1846 = RILRequest.obtain(RIL_REQUEST_SET_FACILITY_LOCK, response); 1847 1848 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1849 + " [" + facility + " " + lockState 1850 + " " + serviceClass + " " + appId + "]"); 1851 1852 // count strings 1853 rr.mParcel.writeInt(5); 1854 1855 rr.mParcel.writeString(facility); 1856 lockString = (lockState)?"1":"0"; 1857 rr.mParcel.writeString(lockString); 1858 rr.mParcel.writeString(password); 1859 rr.mParcel.writeString(Integer.toString(serviceClass)); 1860 rr.mParcel.writeString(appId); 1861 1862 send(rr); 1863 1864 } 1865 1866 @Override 1867 public void 1868 sendUSSD (String ussdString, Message response) { 1869 RILRequest rr 1870 = RILRequest.obtain(RIL_REQUEST_SEND_USSD, response); 1871 1872 if (RILJ_LOGD) { 1873 String logUssdString = "*******"; 1874 if (RILJ_LOGV) logUssdString = ussdString; 1875 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1876 + " " + logUssdString); 1877 } 1878 1879 rr.mParcel.writeString(ussdString); 1880 1881 send(rr); 1882 } 1883 1884 // inherited javadoc suffices 1885 @Override 1886 public void cancelPendingUssd (Message response) { 1887 RILRequest rr 1888 = RILRequest.obtain(RIL_REQUEST_CANCEL_USSD, response); 1889 1890 if (RILJ_LOGD) riljLog(rr.serialString() 1891 + "> " + requestToString(rr.mRequest)); 1892 1893 send(rr); 1894 } 1895 1896 1897 @Override 1898 public void resetRadio(Message result) { 1899 RILRequest rr 1900 = RILRequest.obtain(RIL_REQUEST_RESET_RADIO, result); 1901 1902 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1903 1904 send(rr); 1905 } 1906 1907 @Override 1908 public void invokeOemRilRequestRaw(byte[] data, Message response) { 1909 RILRequest rr 1910 = RILRequest.obtain(RIL_REQUEST_OEM_HOOK_RAW, response); 1911 1912 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1913 + "[" + IccUtils.bytesToHexString(data) + "]"); 1914 1915 rr.mParcel.writeByteArray(data); 1916 1917 send(rr); 1918 1919 } 1920 1921 @Override 1922 public void invokeOemRilRequestStrings(String[] strings, Message response) { 1923 RILRequest rr 1924 = RILRequest.obtain(RIL_REQUEST_OEM_HOOK_STRINGS, response); 1925 1926 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1927 1928 rr.mParcel.writeStringArray(strings); 1929 1930 send(rr); 1931 } 1932 1933 /** 1934 * Assign a specified band for RF configuration. 1935 * 1936 * @param bandMode one of BM_*_BAND 1937 * @param response is callback message 1938 */ 1939 @Override 1940 public void setBandMode (int bandMode, Message response) { 1941 RILRequest rr 1942 = RILRequest.obtain(RIL_REQUEST_SET_BAND_MODE, response); 1943 1944 rr.mParcel.writeInt(1); 1945 rr.mParcel.writeInt(bandMode); 1946 1947 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 1948 + " " + bandMode); 1949 1950 send(rr); 1951 } 1952 1953 /** 1954 * Query the list of band mode supported by RF. 1955 * 1956 * @param response is callback message 1957 * ((AsyncResult)response.obj).result is an int[] where int[0] is 1958 * the size of the array and the rest of each element representing 1959 * one available BM_*_BAND 1960 */ 1961 @Override 1962 public void queryAvailableBandMode (Message response) { 1963 RILRequest rr 1964 = RILRequest.obtain(RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE, 1965 response); 1966 1967 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1968 1969 send(rr); 1970 } 1971 1972 /** 1973 * {@inheritDoc} 1974 */ 1975 @Override 1976 public void sendTerminalResponse(String contents, Message response) { 1977 RILRequest rr = RILRequest.obtain( 1978 RILConstants.RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE, response); 1979 1980 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1981 1982 rr.mParcel.writeString(contents); 1983 send(rr); 1984 } 1985 1986 /** 1987 * {@inheritDoc} 1988 */ 1989 @Override 1990 public void sendEnvelope(String contents, Message response) { 1991 RILRequest rr = RILRequest.obtain( 1992 RILConstants.RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND, response); 1993 1994 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 1995 1996 rr.mParcel.writeString(contents); 1997 send(rr); 1998 } 1999 2000 /** 2001 * {@inheritDoc} 2002 */ 2003 @Override 2004 public void sendEnvelopeWithStatus(String contents, Message response) { 2005 RILRequest rr = RILRequest.obtain( 2006 RILConstants.RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS, response); 2007 2008 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 2009 + '[' + contents + ']'); 2010 2011 rr.mParcel.writeString(contents); 2012 send(rr); 2013 } 2014 2015 /** 2016 * {@inheritDoc} 2017 */ 2018 @Override 2019 public void handleCallSetupRequestFromSim( 2020 boolean accept, Message response) { 2021 2022 RILRequest rr = RILRequest.obtain( 2023 RILConstants.RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM, 2024 response); 2025 2026 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2027 2028 int[] param = new int[1]; 2029 param[0] = accept ? 1 : 0; 2030 rr.mParcel.writeIntArray(param); 2031 send(rr); 2032 } 2033 2034 /** 2035 * {@inheritDoc} 2036 */ 2037 @Override 2038 public void setPreferredNetworkType(int networkType , Message response) { 2039 RILRequest rr = RILRequest.obtain( 2040 RILConstants.RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, response); 2041 2042 rr.mParcel.writeInt(1); 2043 rr.mParcel.writeInt(networkType); 2044 2045 mPreferredNetworkType = networkType; 2046 2047 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 2048 + " : " + networkType); 2049 2050 send(rr); 2051 } 2052 2053 /** 2054 * {@inheritDoc} 2055 */ 2056 @Override 2057 public void getPreferredNetworkType(Message response) { 2058 RILRequest rr = RILRequest.obtain( 2059 RILConstants.RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE, response); 2060 2061 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2062 2063 send(rr); 2064 } 2065 2066 /** 2067 * {@inheritDoc} 2068 */ 2069 @Override 2070 public void getNeighboringCids(Message response) { 2071 RILRequest rr = RILRequest.obtain( 2072 RILConstants.RIL_REQUEST_GET_NEIGHBORING_CELL_IDS, response); 2073 2074 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2075 2076 send(rr); 2077 } 2078 2079 /** 2080 * {@inheritDoc} 2081 */ 2082 @Override 2083 public void setLocationUpdates(boolean enable, Message response) { 2084 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_LOCATION_UPDATES, response); 2085 rr.mParcel.writeInt(1); 2086 rr.mParcel.writeInt(enable ? 1 : 0); 2087 2088 if (RILJ_LOGD) riljLog(rr.serialString() + "> " 2089 + requestToString(rr.mRequest) + ": " + enable); 2090 2091 send(rr); 2092 } 2093 2094 /** 2095 * {@inheritDoc} 2096 */ 2097 @Override 2098 public void getSmscAddress(Message result) { 2099 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_SMSC_ADDRESS, result); 2100 2101 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2102 2103 send(rr); 2104 } 2105 2106 /** 2107 * {@inheritDoc} 2108 */ 2109 @Override 2110 public void setSmscAddress(String address, Message result) { 2111 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_SMSC_ADDRESS, result); 2112 2113 rr.mParcel.writeString(address); 2114 2115 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 2116 + " : " + address); 2117 2118 send(rr); 2119 } 2120 2121 /** 2122 * {@inheritDoc} 2123 */ 2124 @Override 2125 public void reportSmsMemoryStatus(boolean available, Message result) { 2126 RILRequest rr = RILRequest.obtain(RIL_REQUEST_REPORT_SMS_MEMORY_STATUS, result); 2127 rr.mParcel.writeInt(1); 2128 rr.mParcel.writeInt(available ? 1 : 0); 2129 2130 if (RILJ_LOGD) riljLog(rr.serialString() + "> " 2131 + requestToString(rr.mRequest) + ": " + available); 2132 2133 send(rr); 2134 } 2135 2136 /** 2137 * {@inheritDoc} 2138 */ 2139 @Override 2140 public void reportStkServiceIsRunning(Message result) { 2141 RILRequest rr = RILRequest.obtain(RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING, result); 2142 2143 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2144 2145 send(rr); 2146 } 2147 2148 /** 2149 * {@inheritDoc} 2150 */ 2151 @Override 2152 public void getGsmBroadcastConfig(Message response) { 2153 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GSM_GET_BROADCAST_CONFIG, response); 2154 2155 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2156 2157 send(rr); 2158 } 2159 2160 /** 2161 * {@inheritDoc} 2162 */ 2163 @Override 2164 public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) { 2165 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GSM_SET_BROADCAST_CONFIG, response); 2166 2167 int numOfConfig = config.length; 2168 rr.mParcel.writeInt(numOfConfig); 2169 2170 for(int i = 0; i < numOfConfig; i++) { 2171 rr.mParcel.writeInt(config[i].getFromServiceId()); 2172 rr.mParcel.writeInt(config[i].getToServiceId()); 2173 rr.mParcel.writeInt(config[i].getFromCodeScheme()); 2174 rr.mParcel.writeInt(config[i].getToCodeScheme()); 2175 rr.mParcel.writeInt(config[i].isSelected() ? 1 : 0); 2176 } 2177 2178 if (RILJ_LOGD) { 2179 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 2180 + " with " + numOfConfig + " configs : "); 2181 for (int i = 0; i < numOfConfig; i++) { 2182 riljLog(config[i].toString()); 2183 } 2184 } 2185 2186 send(rr); 2187 } 2188 2189 /** 2190 * {@inheritDoc} 2191 */ 2192 @Override 2193 public void setGsmBroadcastActivation(boolean activate, Message response) { 2194 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GSM_BROADCAST_ACTIVATION, response); 2195 2196 rr.mParcel.writeInt(1); 2197 rr.mParcel.writeInt(activate ? 0 : 1); 2198 2199 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 2200 2201 send(rr); 2202 } 2203 2204 //***** Private Methods 2205 2206 // TODO(jeffbrown): Delete me. 2207 // The RIL should *not* be listening for screen state changes since they are 2208 // becoming increasingly ambiguous on our devices. The RIL_REQUEST_SCREEN_STATE 2209 // message should be deleted and replaced with more precise messages to control 2210 // behavior such as signal strength reporting or power managements based on 2211 // more robust signals. 2212 private void updateScreenState() { 2213 final int oldState = mDefaultDisplayState; 2214 mDefaultDisplayState = mDefaultDisplay.getState(); 2215 if (mDefaultDisplayState != oldState) { 2216 if (oldState != Display.STATE_ON 2217 && mDefaultDisplayState == Display.STATE_ON) { 2218 sendScreenState(true); 2219 } else if ((oldState == Display.STATE_ON || oldState == Display.STATE_UNKNOWN) 2220 && mDefaultDisplayState != Display.STATE_ON) { 2221 sendScreenState(false); 2222 } 2223 } 2224 } 2225 2226 private void sendScreenState(boolean on) { 2227 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SCREEN_STATE, null); 2228 rr.mParcel.writeInt(1); 2229 rr.mParcel.writeInt(on ? 1 : 0); 2230 2231 if (RILJ_LOGD) riljLog(rr.serialString() 2232 + "> " + requestToString(rr.mRequest) + ": " + on); 2233 2234 send(rr); 2235 } 2236 2237 @Override 2238 protected void 2239 onRadioAvailable() { 2240 // In case screen state was lost (due to process crash), 2241 // this ensures that the RIL knows the correct screen state. 2242 updateScreenState(); 2243 } 2244 2245 private RadioState getRadioStateFromInt(int stateInt) { 2246 RadioState state; 2247 2248 /* RIL_RadioState ril.h */ 2249 switch(stateInt) { 2250 case 0: state = RadioState.RADIO_OFF; break; 2251 case 1: state = RadioState.RADIO_UNAVAILABLE; break; 2252 case 10: state = RadioState.RADIO_ON; break; 2253 2254 default: 2255 throw new RuntimeException( 2256 "Unrecognized RIL_RadioState: " + stateInt); 2257 } 2258 return state; 2259 } 2260 2261 private void switchToRadioState(RadioState newState) { 2262 setRadioState(newState); 2263 } 2264 2265 /** 2266 * Holds a PARTIAL_WAKE_LOCK whenever 2267 * a) There is outstanding RIL request sent to RIL deamon and no replied 2268 * b) There is a request pending to be sent out. 2269 * 2270 * There is a WAKE_LOCK_TIMEOUT to release the lock, though it shouldn't 2271 * happen often. 2272 */ 2273 2274 private void 2275 acquireWakeLock() { 2276 synchronized (mWakeLock) { 2277 mWakeLock.acquire(); 2278 mWakeLockCount++; 2279 2280 mSender.removeMessages(EVENT_WAKE_LOCK_TIMEOUT); 2281 Message msg = mSender.obtainMessage(EVENT_WAKE_LOCK_TIMEOUT); 2282 mSender.sendMessageDelayed(msg, mWakeLockTimeout); 2283 } 2284 } 2285 2286 private void 2287 decrementWakeLock() { 2288 synchronized (mWakeLock) { 2289 if (mWakeLockCount > 1) { 2290 mWakeLockCount--; 2291 } else { 2292 mWakeLockCount = 0; 2293 mWakeLock.release(); 2294 mSender.removeMessages(EVENT_WAKE_LOCK_TIMEOUT); 2295 } 2296 } 2297 } 2298 2299 // true if we had the wakelock 2300 private boolean 2301 clearWakeLock() { 2302 synchronized (mWakeLock) { 2303 if (mWakeLockCount == 0 && mWakeLock.isHeld() == false) return false; 2304 Rlog.d(RILJ_LOG_TAG, "NOTE: mWakeLockCount is " + mWakeLockCount + "at time of clearing"); 2305 mWakeLockCount = 0; 2306 mWakeLock.release(); 2307 mSender.removeMessages(EVENT_WAKE_LOCK_TIMEOUT); 2308 return true; 2309 } 2310 } 2311 2312 private void 2313 send(RILRequest rr) { 2314 Message msg; 2315 2316 if (mSocket == null) { 2317 rr.onError(RADIO_NOT_AVAILABLE, null); 2318 rr.release(); 2319 return; 2320 } 2321 2322 msg = mSender.obtainMessage(EVENT_SEND, rr); 2323 2324 acquireWakeLock(); 2325 2326 msg.sendToTarget(); 2327 } 2328 2329 private void 2330 processResponse (Parcel p) { 2331 int type; 2332 2333 type = p.readInt(); 2334 2335 if (type == RESPONSE_UNSOLICITED) { 2336 processUnsolicited (p); 2337 } else if (type == RESPONSE_SOLICITED) { 2338 RILRequest rr = processSolicited (p); 2339 if (rr != null) { 2340 rr.release(); 2341 decrementWakeLock(); 2342 } 2343 } 2344 } 2345 2346 /** 2347 * Release each request in mRequestList then clear the list 2348 * @param error is the RIL_Errno sent back 2349 * @param loggable true means to print all requests in mRequestList 2350 */ 2351 private void clearRequestList(int error, boolean loggable) { 2352 RILRequest rr; 2353 synchronized (mRequestList) { 2354 int count = mRequestList.size(); 2355 if (RILJ_LOGD && loggable) { 2356 Rlog.d(RILJ_LOG_TAG, "clearRequestList " + 2357 " mWakeLockCount=" + mWakeLockCount + 2358 " mRequestList=" + count); 2359 } 2360 2361 for (int i = 0; i < count ; i++) { 2362 rr = mRequestList.valueAt(i); 2363 if (RILJ_LOGD && loggable) { 2364 Rlog.d(RILJ_LOG_TAG, i + ": [" + rr.mSerial + "] " + 2365 requestToString(rr.mRequest)); 2366 } 2367 rr.onError(error, null); 2368 rr.release(); 2369 decrementWakeLock(); 2370 } 2371 mRequestList.clear(); 2372 } 2373 } 2374 2375 private RILRequest findAndRemoveRequestFromList(int serial) { 2376 RILRequest rr = null; 2377 synchronized (mRequestList) { 2378 rr = mRequestList.get(serial); 2379 if (rr != null) { 2380 mRequestList.remove(serial); 2381 } 2382 } 2383 2384 return rr; 2385 } 2386 2387 private RILRequest 2388 processSolicited (Parcel p) { 2389 int serial, error; 2390 boolean found = false; 2391 2392 serial = p.readInt(); 2393 error = p.readInt(); 2394 2395 RILRequest rr; 2396 2397 rr = findAndRemoveRequestFromList(serial); 2398 2399 if (rr == null) { 2400 Rlog.w(RILJ_LOG_TAG, "Unexpected solicited response! sn: " 2401 + serial + " error: " + error); 2402 return null; 2403 } 2404 2405 Object ret = null; 2406 2407 if (error == 0 || p.dataAvail() > 0) { 2408 // either command succeeds or command fails but with data payload 2409 try {switch (rr.mRequest) { 2410 /* 2411 cat libs/telephony/ril_commands.h \ 2412 | egrep "^ *{RIL_" \ 2413 | sed -re 's/\{([^,]+),[^,]+,([^}]+).+/case \1: ret = \2(p); break;/' 2414 */ 2415 case RIL_REQUEST_GET_SIM_STATUS: ret = responseIccCardStatus(p); break; 2416 case RIL_REQUEST_ENTER_SIM_PIN: ret = responseInts(p); break; 2417 case RIL_REQUEST_ENTER_SIM_PUK: ret = responseInts(p); break; 2418 case RIL_REQUEST_ENTER_SIM_PIN2: ret = responseInts(p); break; 2419 case RIL_REQUEST_ENTER_SIM_PUK2: ret = responseInts(p); break; 2420 case RIL_REQUEST_CHANGE_SIM_PIN: ret = responseInts(p); break; 2421 case RIL_REQUEST_CHANGE_SIM_PIN2: ret = responseInts(p); break; 2422 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: ret = responseInts(p); break; 2423 case RIL_REQUEST_GET_CURRENT_CALLS: ret = responseCallList(p); break; 2424 case RIL_REQUEST_DIAL: ret = responseVoid(p); break; 2425 case RIL_REQUEST_GET_IMSI: ret = responseString(p); break; 2426 case RIL_REQUEST_HANGUP: ret = responseVoid(p); break; 2427 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: ret = responseVoid(p); break; 2428 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: { 2429 if (mTestingEmergencyCall.getAndSet(false)) { 2430 if (mEmergencyCallbackModeRegistrant != null) { 2431 riljLog("testing emergency call, notify ECM Registrants"); 2432 mEmergencyCallbackModeRegistrant.notifyRegistrant(); 2433 } 2434 } 2435 ret = responseVoid(p); 2436 break; 2437 } 2438 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: ret = responseVoid(p); break; 2439 case RIL_REQUEST_CONFERENCE: ret = responseVoid(p); break; 2440 case RIL_REQUEST_UDUB: ret = responseVoid(p); break; 2441 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: ret = responseInts(p); break; 2442 case RIL_REQUEST_SIGNAL_STRENGTH: ret = responseSignalStrength(p); break; 2443 case RIL_REQUEST_VOICE_REGISTRATION_STATE: ret = responseStrings(p); break; 2444 case RIL_REQUEST_DATA_REGISTRATION_STATE: ret = responseStrings(p); break; 2445 case RIL_REQUEST_OPERATOR: ret = responseStrings(p); break; 2446 case RIL_REQUEST_RADIO_POWER: ret = responseVoid(p); break; 2447 case RIL_REQUEST_DTMF: ret = responseVoid(p); break; 2448 case RIL_REQUEST_SEND_SMS: ret = responseSMS(p); break; 2449 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: ret = responseSMS(p); break; 2450 case RIL_REQUEST_SETUP_DATA_CALL: ret = responseSetupDataCall(p); break; 2451 case RIL_REQUEST_SIM_IO: ret = responseICC_IO(p); break; 2452 case RIL_REQUEST_SEND_USSD: ret = responseVoid(p); break; 2453 case RIL_REQUEST_CANCEL_USSD: ret = responseVoid(p); break; 2454 case RIL_REQUEST_GET_CLIR: ret = responseInts(p); break; 2455 case RIL_REQUEST_SET_CLIR: ret = responseVoid(p); break; 2456 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: ret = responseCallForward(p); break; 2457 case RIL_REQUEST_SET_CALL_FORWARD: ret = responseVoid(p); break; 2458 case RIL_REQUEST_QUERY_CALL_WAITING: ret = responseInts(p); break; 2459 case RIL_REQUEST_SET_CALL_WAITING: ret = responseVoid(p); break; 2460 case RIL_REQUEST_SMS_ACKNOWLEDGE: ret = responseVoid(p); break; 2461 case RIL_REQUEST_GET_IMEI: ret = responseString(p); break; 2462 case RIL_REQUEST_GET_IMEISV: ret = responseString(p); break; 2463 case RIL_REQUEST_ANSWER: ret = responseVoid(p); break; 2464 case RIL_REQUEST_DEACTIVATE_DATA_CALL: ret = responseVoid(p); break; 2465 case RIL_REQUEST_QUERY_FACILITY_LOCK: ret = responseInts(p); break; 2466 case RIL_REQUEST_SET_FACILITY_LOCK: ret = responseInts(p); break; 2467 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: ret = responseVoid(p); break; 2468 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: ret = responseInts(p); break; 2469 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: ret = responseVoid(p); break; 2470 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: ret = responseVoid(p); break; 2471 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : ret = responseOperatorInfos(p); break; 2472 case RIL_REQUEST_DTMF_START: ret = responseVoid(p); break; 2473 case RIL_REQUEST_DTMF_STOP: ret = responseVoid(p); break; 2474 case RIL_REQUEST_BASEBAND_VERSION: ret = responseString(p); break; 2475 case RIL_REQUEST_SEPARATE_CONNECTION: ret = responseVoid(p); break; 2476 case RIL_REQUEST_SET_MUTE: ret = responseVoid(p); break; 2477 case RIL_REQUEST_GET_MUTE: ret = responseInts(p); break; 2478 case RIL_REQUEST_QUERY_CLIP: ret = responseInts(p); break; 2479 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: ret = responseInts(p); break; 2480 case RIL_REQUEST_DATA_CALL_LIST: ret = responseDataCallList(p); break; 2481 case RIL_REQUEST_RESET_RADIO: ret = responseVoid(p); break; 2482 case RIL_REQUEST_OEM_HOOK_RAW: ret = responseRaw(p); break; 2483 case RIL_REQUEST_OEM_HOOK_STRINGS: ret = responseStrings(p); break; 2484 case RIL_REQUEST_SCREEN_STATE: ret = responseVoid(p); break; 2485 case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: ret = responseVoid(p); break; 2486 case RIL_REQUEST_WRITE_SMS_TO_SIM: ret = responseInts(p); break; 2487 case RIL_REQUEST_DELETE_SMS_ON_SIM: ret = responseVoid(p); break; 2488 case RIL_REQUEST_SET_BAND_MODE: ret = responseVoid(p); break; 2489 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: ret = responseInts(p); break; 2490 case RIL_REQUEST_STK_GET_PROFILE: ret = responseString(p); break; 2491 case RIL_REQUEST_STK_SET_PROFILE: ret = responseVoid(p); break; 2492 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: ret = responseString(p); break; 2493 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: ret = responseVoid(p); break; 2494 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: ret = responseInts(p); break; 2495 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: ret = responseVoid(p); break; 2496 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: ret = responseVoid(p); break; 2497 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: ret = responseGetPreferredNetworkType(p); break; 2498 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: ret = responseCellList(p); break; 2499 case RIL_REQUEST_SET_LOCATION_UPDATES: ret = responseVoid(p); break; 2500 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: ret = responseVoid(p); break; 2501 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: ret = responseVoid(p); break; 2502 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: ret = responseInts(p); break; 2503 case RIL_REQUEST_SET_TTY_MODE: ret = responseVoid(p); break; 2504 case RIL_REQUEST_QUERY_TTY_MODE: ret = responseInts(p); break; 2505 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: ret = responseVoid(p); break; 2506 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: ret = responseInts(p); break; 2507 case RIL_REQUEST_CDMA_FLASH: ret = responseVoid(p); break; 2508 case RIL_REQUEST_CDMA_BURST_DTMF: ret = responseVoid(p); break; 2509 case RIL_REQUEST_CDMA_SEND_SMS: ret = responseSMS(p); break; 2510 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE: ret = responseVoid(p); break; 2511 case RIL_REQUEST_GSM_GET_BROADCAST_CONFIG: ret = responseGmsBroadcastConfig(p); break; 2512 case RIL_REQUEST_GSM_SET_BROADCAST_CONFIG: ret = responseVoid(p); break; 2513 case RIL_REQUEST_GSM_BROADCAST_ACTIVATION: ret = responseVoid(p); break; 2514 case RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG: ret = responseCdmaBroadcastConfig(p); break; 2515 case RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG: ret = responseVoid(p); break; 2516 case RIL_REQUEST_CDMA_BROADCAST_ACTIVATION: ret = responseVoid(p); break; 2517 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: ret = responseVoid(p); break; 2518 case RIL_REQUEST_CDMA_SUBSCRIPTION: ret = responseStrings(p); break; 2519 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: ret = responseInts(p); break; 2520 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: ret = responseVoid(p); break; 2521 case RIL_REQUEST_DEVICE_IDENTITY: ret = responseStrings(p); break; 2522 case RIL_REQUEST_GET_SMSC_ADDRESS: ret = responseString(p); break; 2523 case RIL_REQUEST_SET_SMSC_ADDRESS: ret = responseVoid(p); break; 2524 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: ret = responseVoid(p); break; 2525 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: ret = responseVoid(p); break; 2526 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: ret = responseVoid(p); break; 2527 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: ret = responseInts(p); break; 2528 case RIL_REQUEST_ISIM_AUTHENTICATION: ret = responseString(p); break; 2529 case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: ret = responseVoid(p); break; 2530 case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: ret = responseICC_IO(p); break; 2531 case RIL_REQUEST_VOICE_RADIO_TECH: ret = responseInts(p); break; 2532 case RIL_REQUEST_GET_CELL_INFO_LIST: ret = responseCellInfoList(p); break; 2533 case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: ret = responseVoid(p); break; 2534 case RIL_REQUEST_SET_INITIAL_ATTACH_APN: ret = responseVoid(p); break; 2535 case RIL_REQUEST_SET_DATA_PROFILE: ret = responseVoid(p); break; 2536 case RIL_REQUEST_IMS_REGISTRATION_STATE: ret = responseInts(p); break; 2537 case RIL_REQUEST_IMS_SEND_SMS: ret = responseSMS(p); break; 2538 case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: ret = responseICC_IO(p); break; 2539 case RIL_REQUEST_SIM_OPEN_CHANNEL: ret = responseInts(p); break; 2540 case RIL_REQUEST_SIM_CLOSE_CHANNEL: ret = responseVoid(p); break; 2541 case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: ret = responseICC_IO(p); break; 2542 case RIL_REQUEST_NV_READ_ITEM: ret = responseString(p); break; 2543 case RIL_REQUEST_NV_WRITE_ITEM: ret = responseVoid(p); break; 2544 case RIL_REQUEST_NV_WRITE_CDMA_PRL: ret = responseVoid(p); break; 2545 case RIL_REQUEST_NV_RESET_CONFIG: ret = responseVoid(p); break; 2546 case RIL_REQUEST_SET_UICC_SUBSCRIPTION: ret = responseVoid(p); break; 2547 case RIL_REQUEST_ALLOW_DATA: ret = responseVoid(p); break; 2548 case RIL_REQUEST_GET_HARDWARE_CONFIG: ret = responseHardwareConfig(p); break; 2549 case RIL_REQUEST_SIM_AUTHENTICATION: ret = responseICC_IOBase64(p); break; 2550 case RIL_REQUEST_SHUTDOWN: ret = responseVoid(p); break; 2551 default: 2552 throw new RuntimeException("Unrecognized solicited response: " + rr.mRequest); 2553 //break; 2554 }} catch (Throwable tr) { 2555 // Exceptions here usually mean invalid RIL responses 2556 2557 Rlog.w(RILJ_LOG_TAG, rr.serialString() + "< " 2558 + requestToString(rr.mRequest) 2559 + " exception, possible invalid RIL response", tr); 2560 2561 if (rr.mResult != null) { 2562 AsyncResult.forMessage(rr.mResult, null, tr); 2563 rr.mResult.sendToTarget(); 2564 } 2565 return rr; 2566 } 2567 } 2568 2569 if (rr.mRequest == RIL_REQUEST_SHUTDOWN) { 2570 // Set RADIO_STATE to RADIO_UNAVAILABLE to continue shutdown process 2571 // regardless of error code to continue shutdown procedure. 2572 riljLog("Response to RIL_REQUEST_SHUTDOWN received. Error is " + 2573 error + " Setting Radio State to Unavailable regardless of error."); 2574 setRadioState(RadioState.RADIO_UNAVAILABLE); 2575 } 2576 2577 // Here and below fake RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, see b/7255789. 2578 // This is needed otherwise we don't automatically transition to the main lock 2579 // screen when the pin or puk is entered incorrectly. 2580 switch (rr.mRequest) { 2581 case RIL_REQUEST_ENTER_SIM_PUK: 2582 case RIL_REQUEST_ENTER_SIM_PUK2: 2583 if (mIccStatusChangedRegistrants != null) { 2584 if (RILJ_LOGD) { 2585 riljLog("ON enter sim puk fakeSimStatusChanged: reg count=" 2586 + mIccStatusChangedRegistrants.size()); 2587 } 2588 mIccStatusChangedRegistrants.notifyRegistrants(); 2589 } 2590 break; 2591 } 2592 2593 if (error != 0) { 2594 switch (rr.mRequest) { 2595 case RIL_REQUEST_ENTER_SIM_PIN: 2596 case RIL_REQUEST_ENTER_SIM_PIN2: 2597 case RIL_REQUEST_CHANGE_SIM_PIN: 2598 case RIL_REQUEST_CHANGE_SIM_PIN2: 2599 case RIL_REQUEST_SET_FACILITY_LOCK: 2600 if (mIccStatusChangedRegistrants != null) { 2601 if (RILJ_LOGD) { 2602 riljLog("ON some errors fakeSimStatusChanged: reg count=" 2603 + mIccStatusChangedRegistrants.size()); 2604 } 2605 mIccStatusChangedRegistrants.notifyRegistrants(); 2606 } 2607 break; 2608 } 2609 2610 rr.onError(error, ret); 2611 } else { 2612 2613 if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest) 2614 + " " + retToString(rr.mRequest, ret)); 2615 2616 if (rr.mResult != null) { 2617 AsyncResult.forMessage(rr.mResult, ret, null); 2618 rr.mResult.sendToTarget(); 2619 } 2620 } 2621 return rr; 2622 } 2623 2624 static String 2625 retToString(int req, Object ret) { 2626 if (ret == null) return ""; 2627 switch (req) { 2628 // Don't log these return values, for privacy's sake. 2629 case RIL_REQUEST_GET_IMSI: 2630 case RIL_REQUEST_GET_IMEI: 2631 case RIL_REQUEST_GET_IMEISV: 2632 case RIL_REQUEST_SIM_OPEN_CHANNEL: 2633 case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: 2634 2635 if (!RILJ_LOGV) { 2636 // If not versbose logging just return and don't display IMSI and IMEI, IMEISV 2637 return ""; 2638 } 2639 } 2640 2641 StringBuilder sb; 2642 String s; 2643 int length; 2644 if (ret instanceof int[]){ 2645 int[] intArray = (int[]) ret; 2646 length = intArray.length; 2647 sb = new StringBuilder("{"); 2648 if (length > 0) { 2649 int i = 0; 2650 sb.append(intArray[i++]); 2651 while ( i < length) { 2652 sb.append(", ").append(intArray[i++]); 2653 } 2654 } 2655 sb.append("}"); 2656 s = sb.toString(); 2657 } else if (ret instanceof String[]) { 2658 String[] strings = (String[]) ret; 2659 length = strings.length; 2660 sb = new StringBuilder("{"); 2661 if (length > 0) { 2662 int i = 0; 2663 sb.append(strings[i++]); 2664 while ( i < length) { 2665 sb.append(", ").append(strings[i++]); 2666 } 2667 } 2668 sb.append("}"); 2669 s = sb.toString(); 2670 }else if (req == RIL_REQUEST_GET_CURRENT_CALLS) { 2671 ArrayList<DriverCall> calls = (ArrayList<DriverCall>) ret; 2672 sb = new StringBuilder(" "); 2673 for (DriverCall dc : calls) { 2674 sb.append("[").append(dc).append("] "); 2675 } 2676 s = sb.toString(); 2677 } else if (req == RIL_REQUEST_GET_NEIGHBORING_CELL_IDS) { 2678 ArrayList<NeighboringCellInfo> cells; 2679 cells = (ArrayList<NeighboringCellInfo>) ret; 2680 sb = new StringBuilder(" "); 2681 for (NeighboringCellInfo cell : cells) { 2682 sb.append(cell).append(" "); 2683 } 2684 s = sb.toString(); 2685 } else if (req == RIL_REQUEST_GET_HARDWARE_CONFIG) { 2686 ArrayList<HardwareConfig> hwcfgs = (ArrayList<HardwareConfig>) ret; 2687 sb = new StringBuilder(" "); 2688 for (HardwareConfig hwcfg : hwcfgs) { 2689 sb.append("[").append(hwcfg).append("] "); 2690 } 2691 s = sb.toString(); 2692 } else { 2693 s = ret.toString(); 2694 } 2695 return s; 2696 } 2697 2698 private void 2699 processUnsolicited (Parcel p) { 2700 int response; 2701 Object ret; 2702 2703 response = p.readInt(); 2704 2705 try {switch(response) { 2706/* 2707 cat libs/telephony/ril_unsol_commands.h \ 2708 | egrep "^ *{RIL_" \ 2709 | sed -re 's/\{([^,]+),[^,]+,([^}]+).+/case \1: \2(rr, p); break;/' 2710*/ 2711 2712 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: ret = responseVoid(p); break; 2713 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: ret = responseVoid(p); break; 2714 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: ret = responseVoid(p); break; 2715 case RIL_UNSOL_RESPONSE_NEW_SMS: ret = responseString(p); break; 2716 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: ret = responseString(p); break; 2717 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: ret = responseInts(p); break; 2718 case RIL_UNSOL_ON_USSD: ret = responseStrings(p); break; 2719 case RIL_UNSOL_NITZ_TIME_RECEIVED: ret = responseString(p); break; 2720 case RIL_UNSOL_SIGNAL_STRENGTH: ret = responseSignalStrength(p); break; 2721 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: ret = responseDataCallList(p);break; 2722 case RIL_UNSOL_SUPP_SVC_NOTIFICATION: ret = responseSuppServiceNotification(p); break; 2723 case RIL_UNSOL_STK_SESSION_END: ret = responseVoid(p); break; 2724 case RIL_UNSOL_STK_PROACTIVE_COMMAND: ret = responseString(p); break; 2725 case RIL_UNSOL_STK_EVENT_NOTIFY: ret = responseString(p); break; 2726 case RIL_UNSOL_STK_CALL_SETUP: ret = responseInts(p); break; 2727 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: ret = responseVoid(p); break; 2728 case RIL_UNSOL_SIM_REFRESH: ret = responseSimRefresh(p); break; 2729 case RIL_UNSOL_CALL_RING: ret = responseCallRing(p); break; 2730 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: ret = responseInts(p); break; 2731 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: ret = responseVoid(p); break; 2732 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: ret = responseCdmaSms(p); break; 2733 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: ret = responseRaw(p); break; 2734 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: ret = responseVoid(p); break; 2735 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: ret = responseVoid(p); break; 2736 case RIL_UNSOL_CDMA_CALL_WAITING: ret = responseCdmaCallWaiting(p); break; 2737 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: ret = responseInts(p); break; 2738 case RIL_UNSOL_CDMA_INFO_REC: ret = responseCdmaInformationRecord(p); break; 2739 case RIL_UNSOL_OEM_HOOK_RAW: ret = responseRaw(p); break; 2740 case RIL_UNSOL_RINGBACK_TONE: ret = responseInts(p); break; 2741 case RIL_UNSOL_RESEND_INCALL_MUTE: ret = responseVoid(p); break; 2742 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: ret = responseInts(p); break; 2743 case RIL_UNSOl_CDMA_PRL_CHANGED: ret = responseInts(p); break; 2744 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: ret = responseVoid(p); break; 2745 case RIL_UNSOL_RIL_CONNECTED: ret = responseInts(p); break; 2746 case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: ret = responseInts(p); break; 2747 case RIL_UNSOL_CELL_INFO_LIST: ret = responseCellInfoList(p); break; 2748 case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: ret = responseVoid(p); break; 2749 case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: ret = responseInts(p); break; 2750 case RIL_UNSOL_SRVCC_STATE_NOTIFY: ret = responseInts(p); break; 2751 case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: ret = responseHardwareConfig(p); break; 2752 2753 default: 2754 throw new RuntimeException("Unrecognized unsol response: " + response); 2755 //break; (implied) 2756 }} catch (Throwable tr) { 2757 Rlog.e(RILJ_LOG_TAG, "Exception processing unsol response: " + response + 2758 "Exception:" + tr.toString()); 2759 return; 2760 } 2761 2762 switch(response) { 2763 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: 2764 /* has bonus radio state int */ 2765 RadioState newState = getRadioStateFromInt(p.readInt()); 2766 if (RILJ_LOGD) unsljLogMore(response, newState.toString()); 2767 2768 switchToRadioState(newState); 2769 break; 2770 case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: 2771 if (RILJ_LOGD) unsljLog(response); 2772 2773 mImsNetworkStateChangedRegistrants 2774 .notifyRegistrants(new AsyncResult(null, null, null)); 2775 break; 2776 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: 2777 if (RILJ_LOGD) unsljLog(response); 2778 2779 mCallStateRegistrants 2780 .notifyRegistrants(new AsyncResult(null, null, null)); 2781 break; 2782 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: 2783 if (RILJ_LOGD) unsljLog(response); 2784 2785 mVoiceNetworkStateRegistrants 2786 .notifyRegistrants(new AsyncResult(null, null, null)); 2787 break; 2788 case RIL_UNSOL_RESPONSE_NEW_SMS: { 2789 if (RILJ_LOGD) unsljLog(response); 2790 2791 // FIXME this should move up a layer 2792 String a[] = new String[2]; 2793 2794 a[1] = (String)ret; 2795 2796 SmsMessage sms; 2797 2798 sms = SmsMessage.newFromCMT(a); 2799 if (mGsmSmsRegistrant != null) { 2800 mGsmSmsRegistrant 2801 .notifyRegistrant(new AsyncResult(null, sms, null)); 2802 } 2803 break; 2804 } 2805 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: 2806 if (RILJ_LOGD) unsljLogRet(response, ret); 2807 2808 if (mSmsStatusRegistrant != null) { 2809 mSmsStatusRegistrant.notifyRegistrant( 2810 new AsyncResult(null, ret, null)); 2811 } 2812 break; 2813 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: 2814 if (RILJ_LOGD) unsljLogRet(response, ret); 2815 2816 int[] smsIndex = (int[])ret; 2817 2818 if(smsIndex.length == 1) { 2819 if (mSmsOnSimRegistrant != null) { 2820 mSmsOnSimRegistrant. 2821 notifyRegistrant(new AsyncResult(null, smsIndex, null)); 2822 } 2823 } else { 2824 if (RILJ_LOGD) riljLog(" NEW_SMS_ON_SIM ERROR with wrong length " 2825 + smsIndex.length); 2826 } 2827 break; 2828 case RIL_UNSOL_ON_USSD: 2829 String[] resp = (String[])ret; 2830 2831 if (resp.length < 2) { 2832 resp = new String[2]; 2833 resp[0] = ((String[])ret)[0]; 2834 resp[1] = null; 2835 } 2836 if (RILJ_LOGD) unsljLogMore(response, resp[0]); 2837 if (mUSSDRegistrant != null) { 2838 mUSSDRegistrant.notifyRegistrant( 2839 new AsyncResult (null, resp, null)); 2840 } 2841 break; 2842 case RIL_UNSOL_NITZ_TIME_RECEIVED: 2843 if (RILJ_LOGD) unsljLogRet(response, ret); 2844 2845 // has bonus long containing milliseconds since boot that the NITZ 2846 // time was received 2847 long nitzReceiveTime = p.readLong(); 2848 2849 Object[] result = new Object[2]; 2850 2851 result[0] = ret; 2852 result[1] = Long.valueOf(nitzReceiveTime); 2853 2854 boolean ignoreNitz = SystemProperties.getBoolean( 2855 TelephonyProperties.PROPERTY_IGNORE_NITZ, false); 2856 2857 if (ignoreNitz) { 2858 if (RILJ_LOGD) riljLog("ignoring UNSOL_NITZ_TIME_RECEIVED"); 2859 } else { 2860 if (mNITZTimeRegistrant != null) { 2861 2862 mNITZTimeRegistrant 2863 .notifyRegistrant(new AsyncResult (null, result, null)); 2864 } else { 2865 // in case NITZ time registrant isnt registered yet 2866 mLastNITZTimeInfo = result; 2867 } 2868 } 2869 break; 2870 2871 case RIL_UNSOL_SIGNAL_STRENGTH: 2872 // Note this is set to "verbose" because it happens 2873 // frequently 2874 if (RILJ_LOGV) unsljLogvRet(response, ret); 2875 2876 if (mSignalStrengthRegistrant != null) { 2877 mSignalStrengthRegistrant.notifyRegistrant( 2878 new AsyncResult (null, ret, null)); 2879 } 2880 break; 2881 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: 2882 if (RILJ_LOGD) unsljLogRet(response, ret); 2883 2884 mDataNetworkStateRegistrants.notifyRegistrants(new AsyncResult(null, ret, null)); 2885 break; 2886 2887 case RIL_UNSOL_SUPP_SVC_NOTIFICATION: 2888 if (RILJ_LOGD) unsljLogRet(response, ret); 2889 2890 if (mSsnRegistrant != null) { 2891 mSsnRegistrant.notifyRegistrant( 2892 new AsyncResult (null, ret, null)); 2893 } 2894 break; 2895 2896 case RIL_UNSOL_STK_SESSION_END: 2897 if (RILJ_LOGD) unsljLog(response); 2898 2899 if (mCatSessionEndRegistrant != null) { 2900 mCatSessionEndRegistrant.notifyRegistrant( 2901 new AsyncResult (null, ret, null)); 2902 } 2903 break; 2904 2905 case RIL_UNSOL_STK_PROACTIVE_COMMAND: 2906 if (RILJ_LOGD) unsljLog(response); 2907 2908 if (mCatProCmdRegistrant != null) { 2909 mCatProCmdRegistrant.notifyRegistrant( 2910 new AsyncResult (null, ret, null)); 2911 } 2912 break; 2913 2914 case RIL_UNSOL_STK_EVENT_NOTIFY: 2915 if (RILJ_LOGD) unsljLog(response); 2916 2917 if (mCatEventRegistrant != null) { 2918 mCatEventRegistrant.notifyRegistrant( 2919 new AsyncResult (null, ret, null)); 2920 } 2921 break; 2922 2923 case RIL_UNSOL_STK_CALL_SETUP: 2924 if (RILJ_LOGD) unsljLogRet(response, ret); 2925 2926 if (mCatCallSetUpRegistrant != null) { 2927 mCatCallSetUpRegistrant.notifyRegistrant( 2928 new AsyncResult (null, ret, null)); 2929 } 2930 break; 2931 2932 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: 2933 if (RILJ_LOGD) unsljLog(response); 2934 2935 if (mIccSmsFullRegistrant != null) { 2936 mIccSmsFullRegistrant.notifyRegistrant(); 2937 } 2938 break; 2939 2940 case RIL_UNSOL_SIM_REFRESH: 2941 if (RILJ_LOGD) unsljLogRet(response, ret); 2942 2943 if (mIccRefreshRegistrants != null) { 2944 mIccRefreshRegistrants.notifyRegistrants( 2945 new AsyncResult (null, ret, null)); 2946 } 2947 break; 2948 2949 case RIL_UNSOL_CALL_RING: 2950 if (RILJ_LOGD) unsljLogRet(response, ret); 2951 2952 if (mRingRegistrant != null) { 2953 mRingRegistrant.notifyRegistrant( 2954 new AsyncResult (null, ret, null)); 2955 } 2956 break; 2957 2958 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: 2959 if (RILJ_LOGD) unsljLogvRet(response, ret); 2960 if (mRestrictedStateRegistrant != null) { 2961 mRestrictedStateRegistrant.notifyRegistrant( 2962 new AsyncResult (null, ret, null)); 2963 } 2964 break; 2965 2966 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: 2967 if (RILJ_LOGD) unsljLog(response); 2968 2969 if (mIccStatusChangedRegistrants != null) { 2970 mIccStatusChangedRegistrants.notifyRegistrants(); 2971 } 2972 break; 2973 2974 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: 2975 if (RILJ_LOGD) unsljLog(response); 2976 2977 SmsMessage sms = (SmsMessage) ret; 2978 2979 if (mCdmaSmsRegistrant != null) { 2980 mCdmaSmsRegistrant 2981 .notifyRegistrant(new AsyncResult(null, sms, null)); 2982 } 2983 break; 2984 2985 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: 2986 if (RILJ_LOGD) unsljLog(response); 2987 2988 if (mGsmBroadcastSmsRegistrant != null) { 2989 mGsmBroadcastSmsRegistrant 2990 .notifyRegistrant(new AsyncResult(null, ret, null)); 2991 } 2992 break; 2993 2994 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: 2995 if (RILJ_LOGD) unsljLog(response); 2996 2997 if (mIccSmsFullRegistrant != null) { 2998 mIccSmsFullRegistrant.notifyRegistrant(); 2999 } 3000 break; 3001 3002 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: 3003 if (RILJ_LOGD) unsljLog(response); 3004 3005 if (mEmergencyCallbackModeRegistrant != null) { 3006 mEmergencyCallbackModeRegistrant.notifyRegistrant(); 3007 } 3008 break; 3009 3010 case RIL_UNSOL_CDMA_CALL_WAITING: 3011 if (RILJ_LOGD) unsljLogRet(response, ret); 3012 3013 if (mCallWaitingInfoRegistrants != null) { 3014 mCallWaitingInfoRegistrants.notifyRegistrants( 3015 new AsyncResult (null, ret, null)); 3016 } 3017 break; 3018 3019 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: 3020 if (RILJ_LOGD) unsljLogRet(response, ret); 3021 3022 if (mOtaProvisionRegistrants != null) { 3023 mOtaProvisionRegistrants.notifyRegistrants( 3024 new AsyncResult (null, ret, null)); 3025 } 3026 break; 3027 3028 case RIL_UNSOL_CDMA_INFO_REC: 3029 ArrayList<CdmaInformationRecords> listInfoRecs; 3030 3031 try { 3032 listInfoRecs = (ArrayList<CdmaInformationRecords>)ret; 3033 } catch (ClassCastException e) { 3034 Rlog.e(RILJ_LOG_TAG, "Unexpected exception casting to listInfoRecs", e); 3035 break; 3036 } 3037 3038 for (CdmaInformationRecords rec : listInfoRecs) { 3039 if (RILJ_LOGD) unsljLogRet(response, rec); 3040 notifyRegistrantsCdmaInfoRec(rec); 3041 } 3042 break; 3043 3044 case RIL_UNSOL_OEM_HOOK_RAW: 3045 if (RILJ_LOGD) unsljLogvRet(response, IccUtils.bytesToHexString((byte[])ret)); 3046 if (mUnsolOemHookRawRegistrant != null) { 3047 mUnsolOemHookRawRegistrant.notifyRegistrant(new AsyncResult(null, ret, null)); 3048 } 3049 break; 3050 3051 case RIL_UNSOL_RINGBACK_TONE: 3052 if (RILJ_LOGD) unsljLogvRet(response, ret); 3053 if (mRingbackToneRegistrants != null) { 3054 boolean playtone = (((int[])ret)[0] == 1); 3055 mRingbackToneRegistrants.notifyRegistrants( 3056 new AsyncResult (null, playtone, null)); 3057 } 3058 break; 3059 3060 case RIL_UNSOL_RESEND_INCALL_MUTE: 3061 if (RILJ_LOGD) unsljLogRet(response, ret); 3062 3063 if (mResendIncallMuteRegistrants != null) { 3064 mResendIncallMuteRegistrants.notifyRegistrants( 3065 new AsyncResult (null, ret, null)); 3066 } 3067 break; 3068 3069 case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: 3070 if (RILJ_LOGD) unsljLogRet(response, ret); 3071 3072 if (mVoiceRadioTechChangedRegistrants != null) { 3073 mVoiceRadioTechChangedRegistrants.notifyRegistrants( 3074 new AsyncResult(null, ret, null)); 3075 } 3076 break; 3077 3078 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: 3079 if (RILJ_LOGD) unsljLogRet(response, ret); 3080 3081 if (mCdmaSubscriptionChangedRegistrants != null) { 3082 mCdmaSubscriptionChangedRegistrants.notifyRegistrants( 3083 new AsyncResult (null, ret, null)); 3084 } 3085 break; 3086 3087 case RIL_UNSOl_CDMA_PRL_CHANGED: 3088 if (RILJ_LOGD) unsljLogRet(response, ret); 3089 3090 if (mCdmaPrlChangedRegistrants != null) { 3091 mCdmaPrlChangedRegistrants.notifyRegistrants( 3092 new AsyncResult (null, ret, null)); 3093 } 3094 break; 3095 3096 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: 3097 if (RILJ_LOGD) unsljLogRet(response, ret); 3098 3099 if (mExitEmergencyCallbackModeRegistrants != null) { 3100 mExitEmergencyCallbackModeRegistrants.notifyRegistrants( 3101 new AsyncResult (null, null, null)); 3102 } 3103 break; 3104 3105 case RIL_UNSOL_RIL_CONNECTED: { 3106 if (RILJ_LOGD) unsljLogRet(response, ret); 3107 3108 // Initial conditions 3109 setRadioPower(false, null); 3110 setPreferredNetworkType(mPreferredNetworkType, null); 3111 setCdmaSubscriptionSource(mCdmaSubscription, null); 3112 setCellInfoListRate(Integer.MAX_VALUE, null); 3113 notifyRegistrantsRilConnectionChanged(((int[])ret)[0]); 3114 break; 3115 } 3116 case RIL_UNSOL_CELL_INFO_LIST: { 3117 if (RILJ_LOGD) unsljLogRet(response, ret); 3118 3119 if (mRilCellInfoListRegistrants != null) { 3120 mRilCellInfoListRegistrants.notifyRegistrants( 3121 new AsyncResult (null, ret, null)); 3122 } 3123 break; 3124 } 3125 case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: { 3126 if (RILJ_LOGD) unsljLogRet(response, ret); 3127 3128 if (mSubscriptionStatusRegistrants != null) { 3129 mSubscriptionStatusRegistrants.notifyRegistrants( 3130 new AsyncResult (null, ret, null)); 3131 } 3132 break; 3133 } 3134 case RIL_UNSOL_SRVCC_STATE_NOTIFY: { 3135 if (RILJ_LOGD) unsljLogRet(response, ret); 3136 3137 if (mSrvccStateRegistrants != null) { 3138 mSrvccStateRegistrants 3139 .notifyRegistrants(new AsyncResult(null, ret, null)); 3140 } 3141 break; 3142 } 3143 case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: 3144 if (RILJ_LOGD) unsljLogRet(response, ret); 3145 3146 if (mHardwareConfigChangeRegistrants != null) { 3147 mHardwareConfigChangeRegistrants.notifyRegistrants( 3148 new AsyncResult (null, ret, null)); 3149 } 3150 break; 3151 } 3152 } 3153 3154 /** 3155 * Notifiy all registrants that the ril has connected or disconnected. 3156 * 3157 * @param rilVer is the version of the ril or -1 if disconnected. 3158 */ 3159 private void notifyRegistrantsRilConnectionChanged(int rilVer) { 3160 mRilVersion = rilVer; 3161 if (mRilConnectedRegistrants != null) { 3162 mRilConnectedRegistrants.notifyRegistrants( 3163 new AsyncResult (null, new Integer(rilVer), null)); 3164 } 3165 } 3166 3167 private Object 3168 responseInts(Parcel p) { 3169 int numInts; 3170 int response[]; 3171 3172 numInts = p.readInt(); 3173 3174 response = new int[numInts]; 3175 3176 for (int i = 0 ; i < numInts ; i++) { 3177 response[i] = p.readInt(); 3178 } 3179 3180 return response; 3181 } 3182 3183 3184 private Object 3185 responseVoid(Parcel p) { 3186 return null; 3187 } 3188 3189 private Object 3190 responseCallForward(Parcel p) { 3191 int numInfos; 3192 CallForwardInfo infos[]; 3193 3194 numInfos = p.readInt(); 3195 3196 infos = new CallForwardInfo[numInfos]; 3197 3198 for (int i = 0 ; i < numInfos ; i++) { 3199 infos[i] = new CallForwardInfo(); 3200 3201 infos[i].status = p.readInt(); 3202 infos[i].reason = p.readInt(); 3203 infos[i].serviceClass = p.readInt(); 3204 infos[i].toa = p.readInt(); 3205 infos[i].number = p.readString(); 3206 infos[i].timeSeconds = p.readInt(); 3207 } 3208 3209 return infos; 3210 } 3211 3212 private Object 3213 responseSuppServiceNotification(Parcel p) { 3214 SuppServiceNotification notification = new SuppServiceNotification(); 3215 3216 notification.notificationType = p.readInt(); 3217 notification.code = p.readInt(); 3218 notification.index = p.readInt(); 3219 notification.type = p.readInt(); 3220 notification.number = p.readString(); 3221 3222 return notification; 3223 } 3224 3225 private Object 3226 responseCdmaSms(Parcel p) { 3227 SmsMessage sms; 3228 sms = SmsMessage.newFromParcel(p); 3229 3230 return sms; 3231 } 3232 3233 private Object 3234 responseString(Parcel p) { 3235 String response; 3236 3237 response = p.readString(); 3238 3239 return response; 3240 } 3241 3242 private Object 3243 responseStrings(Parcel p) { 3244 int num; 3245 String response[]; 3246 3247 response = p.readStringArray(); 3248 3249 return response; 3250 } 3251 3252 private Object 3253 responseRaw(Parcel p) { 3254 int num; 3255 byte response[]; 3256 3257 response = p.createByteArray(); 3258 3259 return response; 3260 } 3261 3262 private Object 3263 responseSMS(Parcel p) { 3264 int messageRef, errorCode; 3265 String ackPDU; 3266 3267 messageRef = p.readInt(); 3268 ackPDU = p.readString(); 3269 errorCode = p.readInt(); 3270 3271 SmsResponse response = new SmsResponse(messageRef, ackPDU, errorCode); 3272 3273 return response; 3274 } 3275 3276 3277 private Object 3278 responseICC_IO(Parcel p) { 3279 int sw1, sw2; 3280 Message ret; 3281 3282 sw1 = p.readInt(); 3283 sw2 = p.readInt(); 3284 3285 String s = p.readString(); 3286 3287 if (RILJ_LOGV) riljLog("< iccIO: " 3288 + " 0x" + Integer.toHexString(sw1) 3289 + " 0x" + Integer.toHexString(sw2) + " " 3290 + s); 3291 3292 return new IccIoResult(sw1, sw2, s); 3293 } 3294 3295 private Object 3296 responseICC_IOBase64(Parcel p) { 3297 int sw1, sw2; 3298 Message ret; 3299 3300 sw1 = p.readInt(); 3301 sw2 = p.readInt(); 3302 3303 String s = p.readString(); 3304 3305 if (RILJ_LOGV) riljLog("< iccIO: " 3306 + " 0x" + Integer.toHexString(sw1) 3307 + " 0x" + Integer.toHexString(sw2) + " " 3308 + s); 3309 3310 3311 return new IccIoResult(sw1, sw2, android.util.Base64.decode(s, android.util.Base64.DEFAULT)); 3312 } 3313 3314 private Object 3315 responseIccCardStatus(Parcel p) { 3316 IccCardApplicationStatus appStatus; 3317 3318 IccCardStatus cardStatus = new IccCardStatus(); 3319 cardStatus.setCardState(p.readInt()); 3320 cardStatus.setUniversalPinState(p.readInt()); 3321 cardStatus.mGsmUmtsSubscriptionAppIndex = p.readInt(); 3322 cardStatus.mCdmaSubscriptionAppIndex = p.readInt(); 3323 cardStatus.mImsSubscriptionAppIndex = p.readInt(); 3324 int numApplications = p.readInt(); 3325 3326 // limit to maximum allowed applications 3327 if (numApplications > IccCardStatus.CARD_MAX_APPS) { 3328 numApplications = IccCardStatus.CARD_MAX_APPS; 3329 } 3330 cardStatus.mApplications = new IccCardApplicationStatus[numApplications]; 3331 for (int i = 0 ; i < numApplications ; i++) { 3332 appStatus = new IccCardApplicationStatus(); 3333 appStatus.app_type = appStatus.AppTypeFromRILInt(p.readInt()); 3334 appStatus.app_state = appStatus.AppStateFromRILInt(p.readInt()); 3335 appStatus.perso_substate = appStatus.PersoSubstateFromRILInt(p.readInt()); 3336 appStatus.aid = p.readString(); 3337 appStatus.app_label = p.readString(); 3338 appStatus.pin1_replaced = p.readInt(); 3339 appStatus.pin1 = appStatus.PinStateFromRILInt(p.readInt()); 3340 appStatus.pin2 = appStatus.PinStateFromRILInt(p.readInt()); 3341 cardStatus.mApplications[i] = appStatus; 3342 } 3343 return cardStatus; 3344 } 3345 3346 private Object 3347 responseSimRefresh(Parcel p) { 3348 IccRefreshResponse response = new IccRefreshResponse(); 3349 3350 response.refreshResult = p.readInt(); 3351 response.efId = p.readInt(); 3352 response.aid = p.readString(); 3353 return response; 3354 } 3355 3356 private Object 3357 responseCallList(Parcel p) { 3358 int num; 3359 int voiceSettings; 3360 ArrayList<DriverCall> response; 3361 DriverCall dc; 3362 3363 num = p.readInt(); 3364 response = new ArrayList<DriverCall>(num); 3365 3366 if (RILJ_LOGV) { 3367 riljLog("responseCallList: num=" + num + 3368 " mEmergencyCallbackModeRegistrant=" + mEmergencyCallbackModeRegistrant + 3369 " mTestingEmergencyCall=" + mTestingEmergencyCall.get()); 3370 } 3371 for (int i = 0 ; i < num ; i++) { 3372 dc = new DriverCall(); 3373 3374 dc.state = DriverCall.stateFromCLCC(p.readInt()); 3375 dc.index = p.readInt(); 3376 dc.TOA = p.readInt(); 3377 dc.isMpty = (0 != p.readInt()); 3378 dc.isMT = (0 != p.readInt()); 3379 dc.als = p.readInt(); 3380 voiceSettings = p.readInt(); 3381 dc.isVoice = (0 == voiceSettings) ? false : true; 3382 dc.isVoicePrivacy = (0 != p.readInt()); 3383 dc.number = p.readString(); 3384 int np = p.readInt(); 3385 dc.numberPresentation = DriverCall.presentationFromCLIP(np); 3386 dc.name = p.readString(); 3387 // according to ril.h, namePresentation should be handled as numberPresentation; 3388 dc.namePresentation = DriverCall.presentationFromCLIP(p.readInt()); 3389 int uusInfoPresent = p.readInt(); 3390 if (uusInfoPresent == 1) { 3391 dc.uusInfo = new UUSInfo(); 3392 dc.uusInfo.setType(p.readInt()); 3393 dc.uusInfo.setDcs(p.readInt()); 3394 byte[] userData = p.createByteArray(); 3395 dc.uusInfo.setUserData(userData); 3396 riljLogv(String.format("Incoming UUS : type=%d, dcs=%d, length=%d", 3397 dc.uusInfo.getType(), dc.uusInfo.getDcs(), 3398 dc.uusInfo.getUserData().length)); 3399 riljLogv("Incoming UUS : data (string)=" 3400 + new String(dc.uusInfo.getUserData())); 3401 riljLogv("Incoming UUS : data (hex): " 3402 + IccUtils.bytesToHexString(dc.uusInfo.getUserData())); 3403 } else { 3404 riljLogv("Incoming UUS : NOT present!"); 3405 } 3406 3407 // Make sure there's a leading + on addresses with a TOA of 145 3408 dc.number = PhoneNumberUtils.stringFromStringAndTOA(dc.number, dc.TOA); 3409 3410 response.add(dc); 3411 3412 if (dc.isVoicePrivacy) { 3413 mVoicePrivacyOnRegistrants.notifyRegistrants(); 3414 riljLog("InCall VoicePrivacy is enabled"); 3415 } else { 3416 mVoicePrivacyOffRegistrants.notifyRegistrants(); 3417 riljLog("InCall VoicePrivacy is disabled"); 3418 } 3419 } 3420 3421 Collections.sort(response); 3422 3423 if ((num == 0) && mTestingEmergencyCall.getAndSet(false)) { 3424 if (mEmergencyCallbackModeRegistrant != null) { 3425 riljLog("responseCallList: call ended, testing emergency call," + 3426 " notify ECM Registrants"); 3427 mEmergencyCallbackModeRegistrant.notifyRegistrant(); 3428 } 3429 } 3430 3431 return response; 3432 } 3433 3434 private DataCallResponse getDataCallResponse(Parcel p, int version) { 3435 DataCallResponse dataCall = new DataCallResponse(); 3436 3437 dataCall.version = version; 3438 if (version < 5) { 3439 dataCall.cid = p.readInt(); 3440 dataCall.active = p.readInt(); 3441 dataCall.type = p.readString(); 3442 String addresses = p.readString(); 3443 if (!TextUtils.isEmpty(addresses)) { 3444 dataCall.addresses = addresses.split(" "); 3445 } 3446 } else { 3447 dataCall.status = p.readInt(); 3448 dataCall.suggestedRetryTime = p.readInt(); 3449 dataCall.cid = p.readInt(); 3450 dataCall.active = p.readInt(); 3451 dataCall.type = p.readString(); 3452 dataCall.ifname = p.readString(); 3453 if ((dataCall.status == DcFailCause.NONE.getErrorCode()) && 3454 TextUtils.isEmpty(dataCall.ifname)) { 3455 throw new RuntimeException("getDataCallResponse, no ifname"); 3456 } 3457 String addresses = p.readString(); 3458 if (!TextUtils.isEmpty(addresses)) { 3459 dataCall.addresses = addresses.split(" "); 3460 } 3461 String dnses = p.readString(); 3462 if (!TextUtils.isEmpty(dnses)) { 3463 dataCall.dnses = dnses.split(" "); 3464 } 3465 String gateways = p.readString(); 3466 if (!TextUtils.isEmpty(gateways)) { 3467 dataCall.gateways = gateways.split(" "); 3468 } 3469 if (version >= 10) { 3470 String pcscf = p.readString(); 3471 if (!TextUtils.isEmpty(pcscf)) { 3472 dataCall.pcscf = pcscf.split(" "); 3473 } 3474 } 3475 if (version >= 11) { 3476 dataCall.mtu = p.readInt(); 3477 } 3478 } 3479 return dataCall; 3480 } 3481 3482 private Object 3483 responseDataCallList(Parcel p) { 3484 ArrayList<DataCallResponse> response; 3485 3486 int ver = p.readInt(); 3487 int num = p.readInt(); 3488 riljLog("responseDataCallList ver=" + ver + " num=" + num); 3489 3490 response = new ArrayList<DataCallResponse>(num); 3491 for (int i = 0; i < num; i++) { 3492 response.add(getDataCallResponse(p, ver)); 3493 } 3494 3495 return response; 3496 } 3497 3498 private Object 3499 responseSetupDataCall(Parcel p) { 3500 int ver = p.readInt(); 3501 int num = p.readInt(); 3502 if (RILJ_LOGV) riljLog("responseSetupDataCall ver=" + ver + " num=" + num); 3503 3504 DataCallResponse dataCall; 3505 3506 if (ver < 5) { 3507 dataCall = new DataCallResponse(); 3508 dataCall.version = ver; 3509 dataCall.cid = Integer.parseInt(p.readString()); 3510 dataCall.ifname = p.readString(); 3511 if (TextUtils.isEmpty(dataCall.ifname)) { 3512 throw new RuntimeException( 3513 "RIL_REQUEST_SETUP_DATA_CALL response, no ifname"); 3514 } 3515 String addresses = p.readString(); 3516 if (!TextUtils.isEmpty(addresses)) { 3517 dataCall.addresses = addresses.split(" "); 3518 } 3519 if (num >= 4) { 3520 String dnses = p.readString(); 3521 if (RILJ_LOGD) riljLog("responseSetupDataCall got dnses=" + dnses); 3522 if (!TextUtils.isEmpty(dnses)) { 3523 dataCall.dnses = dnses.split(" "); 3524 } 3525 } 3526 if (num >= 5) { 3527 String gateways = p.readString(); 3528 if (RILJ_LOGD) riljLog("responseSetupDataCall got gateways=" + gateways); 3529 if (!TextUtils.isEmpty(gateways)) { 3530 dataCall.gateways = gateways.split(" "); 3531 } 3532 } 3533 if (num >= 6) { 3534 String pcscf = p.readString(); 3535 if (RILJ_LOGD) riljLog("responseSetupDataCall got pcscf=" + pcscf); 3536 if (!TextUtils.isEmpty(pcscf)) { 3537 dataCall.pcscf = pcscf.split(" "); 3538 } 3539 } 3540 } else { 3541 if (num != 1) { 3542 throw new RuntimeException( 3543 "RIL_REQUEST_SETUP_DATA_CALL response expecting 1 RIL_Data_Call_response_v5" 3544 + " got " + num); 3545 } 3546 dataCall = getDataCallResponse(p, ver); 3547 } 3548 3549 return dataCall; 3550 } 3551 3552 private Object 3553 responseOperatorInfos(Parcel p) { 3554 String strings[] = (String [])responseStrings(p); 3555 ArrayList<OperatorInfo> ret; 3556 3557 if (strings.length % 4 != 0) { 3558 throw new RuntimeException( 3559 "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS: invalid response. Got " 3560 + strings.length + " strings, expected multible of 4"); 3561 } 3562 3563 ret = new ArrayList<OperatorInfo>(strings.length / 4); 3564 3565 for (int i = 0 ; i < strings.length ; i += 4) { 3566 ret.add ( 3567 new OperatorInfo( 3568 strings[i+0], 3569 strings[i+1], 3570 strings[i+2], 3571 strings[i+3])); 3572 } 3573 3574 return ret; 3575 } 3576 3577 private Object 3578 responseCellList(Parcel p) { 3579 int num, rssi; 3580 String location; 3581 ArrayList<NeighboringCellInfo> response; 3582 NeighboringCellInfo cell; 3583 3584 num = p.readInt(); 3585 response = new ArrayList<NeighboringCellInfo>(); 3586 3587 // Determine the radio access type 3588 String radioString = SystemProperties.get( 3589 TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, "unknown"); 3590 int radioType; 3591 if (radioString.equals("GPRS")) { 3592 radioType = NETWORK_TYPE_GPRS; 3593 } else if (radioString.equals("EDGE")) { 3594 radioType = NETWORK_TYPE_EDGE; 3595 } else if (radioString.equals("UMTS")) { 3596 radioType = NETWORK_TYPE_UMTS; 3597 } else if (radioString.equals("HSDPA")) { 3598 radioType = NETWORK_TYPE_HSDPA; 3599 } else if (radioString.equals("HSUPA")) { 3600 radioType = NETWORK_TYPE_HSUPA; 3601 } else if (radioString.equals("HSPA")) { 3602 radioType = NETWORK_TYPE_HSPA; 3603 } else { 3604 radioType = NETWORK_TYPE_UNKNOWN; 3605 } 3606 3607 // Interpret the location based on radio access type 3608 if (radioType != NETWORK_TYPE_UNKNOWN) { 3609 for (int i = 0 ; i < num ; i++) { 3610 rssi = p.readInt(); 3611 location = p.readString(); 3612 cell = new NeighboringCellInfo(rssi, location, radioType); 3613 response.add(cell); 3614 } 3615 } 3616 return response; 3617 } 3618 3619 private Object responseGetPreferredNetworkType(Parcel p) { 3620 int [] response = (int[]) responseInts(p); 3621 3622 if (response.length >= 1) { 3623 // Since this is the response for getPreferredNetworkType 3624 // we'll assume that it should be the value we want the 3625 // vendor ril to take if we reestablish a connection to it. 3626 mPreferredNetworkType = response[0]; 3627 } 3628 return response; 3629 } 3630 3631 private Object responseGmsBroadcastConfig(Parcel p) { 3632 int num; 3633 ArrayList<SmsBroadcastConfigInfo> response; 3634 SmsBroadcastConfigInfo info; 3635 3636 num = p.readInt(); 3637 response = new ArrayList<SmsBroadcastConfigInfo>(num); 3638 3639 for (int i = 0; i < num; i++) { 3640 int fromId = p.readInt(); 3641 int toId = p.readInt(); 3642 int fromScheme = p.readInt(); 3643 int toScheme = p.readInt(); 3644 boolean selected = (p.readInt() == 1); 3645 3646 info = new SmsBroadcastConfigInfo(fromId, toId, fromScheme, 3647 toScheme, selected); 3648 response.add(info); 3649 } 3650 return response; 3651 } 3652 3653 private Object 3654 responseCdmaBroadcastConfig(Parcel p) { 3655 int numServiceCategories; 3656 int response[]; 3657 3658 numServiceCategories = p.readInt(); 3659 3660 if (numServiceCategories == 0) { 3661 // TODO: The logic of providing default values should 3662 // not be done by this transport layer. And needs to 3663 // be done by the vendor ril or application logic. 3664 int numInts; 3665 numInts = CDMA_BROADCAST_SMS_NO_OF_SERVICE_CATEGORIES * CDMA_BSI_NO_OF_INTS_STRUCT + 1; 3666 response = new int[numInts]; 3667 3668 // Faking a default record for all possible records. 3669 response[0] = CDMA_BROADCAST_SMS_NO_OF_SERVICE_CATEGORIES; 3670 3671 // Loop over CDMA_BROADCAST_SMS_NO_OF_SERVICE_CATEGORIES set 'english' as 3672 // default language and selection status to false for all. 3673 for (int i = 1; i < numInts; i += CDMA_BSI_NO_OF_INTS_STRUCT ) { 3674 response[i + 0] = i / CDMA_BSI_NO_OF_INTS_STRUCT; 3675 response[i + 1] = 1; 3676 response[i + 2] = 0; 3677 } 3678 } else { 3679 int numInts; 3680 numInts = (numServiceCategories * CDMA_BSI_NO_OF_INTS_STRUCT) + 1; 3681 response = new int[numInts]; 3682 3683 response[0] = numServiceCategories; 3684 for (int i = 1 ; i < numInts; i++) { 3685 response[i] = p.readInt(); 3686 } 3687 } 3688 3689 return response; 3690 } 3691 3692 private Object 3693 responseSignalStrength(Parcel p) { 3694 // Assume this is gsm, but doesn't matter as ServiceStateTracker 3695 // sets the proper value. 3696 SignalStrength signalStrength = SignalStrength.makeSignalStrengthFromRilParcel(p); 3697 return signalStrength; 3698 } 3699 3700 private ArrayList<CdmaInformationRecords> 3701 responseCdmaInformationRecord(Parcel p) { 3702 int numberOfInfoRecs; 3703 ArrayList<CdmaInformationRecords> response; 3704 3705 /** 3706 * Loop through all of the information records unmarshalling them 3707 * and converting them to Java Objects. 3708 */ 3709 numberOfInfoRecs = p.readInt(); 3710 response = new ArrayList<CdmaInformationRecords>(numberOfInfoRecs); 3711 3712 for (int i = 0; i < numberOfInfoRecs; i++) { 3713 CdmaInformationRecords InfoRec = new CdmaInformationRecords(p); 3714 response.add(InfoRec); 3715 } 3716 3717 return response; 3718 } 3719 3720 private Object 3721 responseCdmaCallWaiting(Parcel p) { 3722 CdmaCallWaitingNotification notification = new CdmaCallWaitingNotification(); 3723 3724 notification.number = p.readString(); 3725 notification.numberPresentation = 3726 CdmaCallWaitingNotification.presentationFromCLIP(p.readInt()); 3727 notification.name = p.readString(); 3728 notification.namePresentation = notification.numberPresentation; 3729 notification.isPresent = p.readInt(); 3730 notification.signalType = p.readInt(); 3731 notification.alertPitch = p.readInt(); 3732 notification.signal = p.readInt(); 3733 notification.numberType = p.readInt(); 3734 notification.numberPlan = p.readInt(); 3735 3736 return notification; 3737 } 3738 3739 private Object 3740 responseCallRing(Parcel p){ 3741 char response[] = new char[4]; 3742 3743 response[0] = (char) p.readInt(); // isPresent 3744 response[1] = (char) p.readInt(); // signalType 3745 response[2] = (char) p.readInt(); // alertPitch 3746 response[3] = (char) p.readInt(); // signal 3747 3748 return response; 3749 } 3750 3751 private void 3752 notifyRegistrantsCdmaInfoRec(CdmaInformationRecords infoRec) { 3753 int response = RIL_UNSOL_CDMA_INFO_REC; 3754 if (infoRec.record instanceof CdmaInformationRecords.CdmaDisplayInfoRec) { 3755 if (mDisplayInfoRegistrants != null) { 3756 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3757 mDisplayInfoRegistrants.notifyRegistrants( 3758 new AsyncResult (null, infoRec.record, null)); 3759 } 3760 } else if (infoRec.record instanceof CdmaInformationRecords.CdmaSignalInfoRec) { 3761 if (mSignalInfoRegistrants != null) { 3762 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3763 mSignalInfoRegistrants.notifyRegistrants( 3764 new AsyncResult (null, infoRec.record, null)); 3765 } 3766 } else if (infoRec.record instanceof CdmaInformationRecords.CdmaNumberInfoRec) { 3767 if (mNumberInfoRegistrants != null) { 3768 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3769 mNumberInfoRegistrants.notifyRegistrants( 3770 new AsyncResult (null, infoRec.record, null)); 3771 } 3772 } else if (infoRec.record instanceof CdmaInformationRecords.CdmaRedirectingNumberInfoRec) { 3773 if (mRedirNumInfoRegistrants != null) { 3774 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3775 mRedirNumInfoRegistrants.notifyRegistrants( 3776 new AsyncResult (null, infoRec.record, null)); 3777 } 3778 } else if (infoRec.record instanceof CdmaInformationRecords.CdmaLineControlInfoRec) { 3779 if (mLineControlInfoRegistrants != null) { 3780 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3781 mLineControlInfoRegistrants.notifyRegistrants( 3782 new AsyncResult (null, infoRec.record, null)); 3783 } 3784 } else if (infoRec.record instanceof CdmaInformationRecords.CdmaT53ClirInfoRec) { 3785 if (mT53ClirInfoRegistrants != null) { 3786 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3787 mT53ClirInfoRegistrants.notifyRegistrants( 3788 new AsyncResult (null, infoRec.record, null)); 3789 } 3790 } else if (infoRec.record instanceof CdmaInformationRecords.CdmaT53AudioControlInfoRec) { 3791 if (mT53AudCntrlInfoRegistrants != null) { 3792 if (RILJ_LOGD) unsljLogRet(response, infoRec.record); 3793 mT53AudCntrlInfoRegistrants.notifyRegistrants( 3794 new AsyncResult (null, infoRec.record, null)); 3795 } 3796 } 3797 } 3798 3799 private ArrayList<CellInfo> responseCellInfoList(Parcel p) { 3800 int numberOfInfoRecs; 3801 ArrayList<CellInfo> response; 3802 3803 /** 3804 * Loop through all of the information records unmarshalling them 3805 * and converting them to Java Objects. 3806 */ 3807 numberOfInfoRecs = p.readInt(); 3808 response = new ArrayList<CellInfo>(numberOfInfoRecs); 3809 3810 for (int i = 0; i < numberOfInfoRecs; i++) { 3811 CellInfo InfoRec = CellInfo.CREATOR.createFromParcel(p); 3812 response.add(InfoRec); 3813 } 3814 3815 return response; 3816 } 3817 3818 private Object 3819 responseHardwareConfig(Parcel p) { 3820 int num; 3821 ArrayList<HardwareConfig> response; 3822 HardwareConfig hw; 3823 3824 num = p.readInt(); 3825 response = new ArrayList<HardwareConfig>(num); 3826 3827 if (RILJ_LOGV) { 3828 riljLog("responseHardwareConfig: num=" + num); 3829 } 3830 for (int i = 0 ; i < num ; i++) { 3831 int type = p.readInt(); 3832 switch(type) { 3833 case HardwareConfig.DEV_HARDWARE_TYPE_MODEM: { 3834 hw = new HardwareConfig(type); 3835 hw.assignModem(p.readString(), p.readInt(), p.readInt(), 3836 p.readInt(), p.readInt(), p.readInt(), p.readInt()); 3837 break; 3838 } 3839 case HardwareConfig.DEV_HARDWARE_TYPE_SIM: { 3840 hw = new HardwareConfig(type); 3841 hw.assignSim(p.readString(), p.readInt(), p.readString()); 3842 break; 3843 } 3844 default: { 3845 throw new RuntimeException( 3846 "RIL_REQUEST_GET_HARDWARE_CONFIG invalid hardward type:" + type); 3847 } 3848 } 3849 3850 response.add(hw); 3851 } 3852 3853 return response; 3854 } 3855 3856 static String 3857 requestToString(int request) { 3858/* 3859 cat libs/telephony/ril_commands.h \ 3860 | egrep "^ *{RIL_" \ 3861 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/' 3862*/ 3863 switch(request) { 3864 case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS"; 3865 case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN"; 3866 case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK"; 3867 case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2"; 3868 case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2"; 3869 case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN"; 3870 case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2"; 3871 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION"; 3872 case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS"; 3873 case RIL_REQUEST_DIAL: return "DIAL"; 3874 case RIL_REQUEST_GET_IMSI: return "GET_IMSI"; 3875 case RIL_REQUEST_HANGUP: return "HANGUP"; 3876 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND"; 3877 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND"; 3878 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE"; 3879 case RIL_REQUEST_CONFERENCE: return "CONFERENCE"; 3880 case RIL_REQUEST_UDUB: return "UDUB"; 3881 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE"; 3882 case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH"; 3883 case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE"; 3884 case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE"; 3885 case RIL_REQUEST_OPERATOR: return "OPERATOR"; 3886 case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER"; 3887 case RIL_REQUEST_DTMF: return "DTMF"; 3888 case RIL_REQUEST_SEND_SMS: return "SEND_SMS"; 3889 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE"; 3890 case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL"; 3891 case RIL_REQUEST_SIM_IO: return "SIM_IO"; 3892 case RIL_REQUEST_SEND_USSD: return "SEND_USSD"; 3893 case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD"; 3894 case RIL_REQUEST_GET_CLIR: return "GET_CLIR"; 3895 case RIL_REQUEST_SET_CLIR: return "SET_CLIR"; 3896 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS"; 3897 case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD"; 3898 case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING"; 3899 case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING"; 3900 case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE"; 3901 case RIL_REQUEST_GET_IMEI: return "GET_IMEI"; 3902 case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV"; 3903 case RIL_REQUEST_ANSWER: return "ANSWER"; 3904 case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL"; 3905 case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK"; 3906 case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK"; 3907 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD"; 3908 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE"; 3909 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC"; 3910 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL"; 3911 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS "; 3912 case RIL_REQUEST_DTMF_START: return "DTMF_START"; 3913 case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP"; 3914 case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION"; 3915 case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION"; 3916 case RIL_REQUEST_SET_MUTE: return "SET_MUTE"; 3917 case RIL_REQUEST_GET_MUTE: return "GET_MUTE"; 3918 case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP"; 3919 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE"; 3920 case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST"; 3921 case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO"; 3922 case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW"; 3923 case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS"; 3924 case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE"; 3925 case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: return "SET_SUPP_SVC_NOTIFICATION"; 3926 case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM"; 3927 case RIL_REQUEST_DELETE_SMS_ON_SIM: return "DELETE_SMS_ON_SIM"; 3928 case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE"; 3929 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE"; 3930 case RIL_REQUEST_STK_GET_PROFILE: return "REQUEST_STK_GET_PROFILE"; 3931 case RIL_REQUEST_STK_SET_PROFILE: return "REQUEST_STK_SET_PROFILE"; 3932 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "REQUEST_STK_SEND_ENVELOPE_COMMAND"; 3933 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "REQUEST_STK_SEND_TERMINAL_RESPONSE"; 3934 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM"; 3935 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "REQUEST_EXPLICIT_CALL_TRANSFER"; 3936 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "REQUEST_SET_PREFERRED_NETWORK_TYPE"; 3937 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "REQUEST_GET_PREFERRED_NETWORK_TYPE"; 3938 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "REQUEST_GET_NEIGHBORING_CELL_IDS"; 3939 case RIL_REQUEST_SET_LOCATION_UPDATES: return "REQUEST_SET_LOCATION_UPDATES"; 3940 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: return "RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE"; 3941 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: return "RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE"; 3942 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: return "RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE"; 3943 case RIL_REQUEST_SET_TTY_MODE: return "RIL_REQUEST_SET_TTY_MODE"; 3944 case RIL_REQUEST_QUERY_TTY_MODE: return "RIL_REQUEST_QUERY_TTY_MODE"; 3945 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: return "RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE"; 3946 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: return "RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE"; 3947 case RIL_REQUEST_CDMA_FLASH: return "RIL_REQUEST_CDMA_FLASH"; 3948 case RIL_REQUEST_CDMA_BURST_DTMF: return "RIL_REQUEST_CDMA_BURST_DTMF"; 3949 case RIL_REQUEST_CDMA_SEND_SMS: return "RIL_REQUEST_CDMA_SEND_SMS"; 3950 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE: return "RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE"; 3951 case RIL_REQUEST_GSM_GET_BROADCAST_CONFIG: return "RIL_REQUEST_GSM_GET_BROADCAST_CONFIG"; 3952 case RIL_REQUEST_GSM_SET_BROADCAST_CONFIG: return "RIL_REQUEST_GSM_SET_BROADCAST_CONFIG"; 3953 case RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG: return "RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG"; 3954 case RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG: return "RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG"; 3955 case RIL_REQUEST_GSM_BROADCAST_ACTIVATION: return "RIL_REQUEST_GSM_BROADCAST_ACTIVATION"; 3956 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return "RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY"; 3957 case RIL_REQUEST_CDMA_BROADCAST_ACTIVATION: return "RIL_REQUEST_CDMA_BROADCAST_ACTIVATION"; 3958 case RIL_REQUEST_CDMA_SUBSCRIPTION: return "RIL_REQUEST_CDMA_SUBSCRIPTION"; 3959 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM"; 3960 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM"; 3961 case RIL_REQUEST_DEVICE_IDENTITY: return "RIL_REQUEST_DEVICE_IDENTITY"; 3962 case RIL_REQUEST_GET_SMSC_ADDRESS: return "RIL_REQUEST_GET_SMSC_ADDRESS"; 3963 case RIL_REQUEST_SET_SMSC_ADDRESS: return "RIL_REQUEST_SET_SMSC_ADDRESS"; 3964 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "REQUEST_EXIT_EMERGENCY_CALLBACK_MODE"; 3965 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "RIL_REQUEST_REPORT_SMS_MEMORY_STATUS"; 3966 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING"; 3967 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE"; 3968 case RIL_REQUEST_ISIM_AUTHENTICATION: return "RIL_REQUEST_ISIM_AUTHENTICATION"; 3969 case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU"; 3970 case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS"; 3971 case RIL_REQUEST_VOICE_RADIO_TECH: return "RIL_REQUEST_VOICE_RADIO_TECH"; 3972 case RIL_REQUEST_GET_CELL_INFO_LIST: return "RIL_REQUEST_GET_CELL_INFO_LIST"; 3973 case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return "RIL_REQUEST_SET_CELL_INFO_LIST_RATE"; 3974 case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN"; 3975 case RIL_REQUEST_SET_DATA_PROFILE: return "RIL_REQUEST_SET_DATA_PROFILE"; 3976 case RIL_REQUEST_IMS_REGISTRATION_STATE: return "RIL_REQUEST_IMS_REGISTRATION_STATE"; 3977 case RIL_REQUEST_IMS_SEND_SMS: return "RIL_REQUEST_IMS_SEND_SMS"; 3978 case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC"; 3979 case RIL_REQUEST_SIM_OPEN_CHANNEL: return "RIL_REQUEST_SIM_OPEN_CHANNEL"; 3980 case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "RIL_REQUEST_SIM_CLOSE_CHANNEL"; 3981 case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL"; 3982 case RIL_REQUEST_NV_READ_ITEM: return "RIL_REQUEST_NV_READ_ITEM"; 3983 case RIL_REQUEST_NV_WRITE_ITEM: return "RIL_REQUEST_NV_WRITE_ITEM"; 3984 case RIL_REQUEST_NV_WRITE_CDMA_PRL: return "RIL_REQUEST_NV_WRITE_CDMA_PRL"; 3985 case RIL_REQUEST_NV_RESET_CONFIG: return "RIL_REQUEST_NV_RESET_CONFIG"; 3986 case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "RIL_REQUEST_SET_UICC_SUBSCRIPTION"; 3987 case RIL_REQUEST_ALLOW_DATA: return "RIL_REQUEST_ALLOW_DATA"; 3988 case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG"; 3989 case RIL_REQUEST_SIM_AUTHENTICATION: return "RIL_REQUEST_SIM_AUTHENTICATION"; 3990 case RIL_REQUEST_SHUTDOWN: return "RIL_REQUEST_SHUTDOWN"; 3991 default: return "<unknown request>"; 3992 } 3993 } 3994 3995 static String 3996 responseToString(int request) 3997 { 3998/* 3999 cat libs/telephony/ril_unsol_commands.h \ 4000 | egrep "^ *{RIL_" \ 4001 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/' 4002*/ 4003 switch(request) { 4004 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED"; 4005 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED"; 4006 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED"; 4007 case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS"; 4008 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT"; 4009 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM"; 4010 case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD"; 4011 case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST"; 4012 case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED"; 4013 case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH"; 4014 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED"; 4015 case RIL_UNSOL_SUPP_SVC_NOTIFICATION: return "UNSOL_SUPP_SVC_NOTIFICATION"; 4016 case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END"; 4017 case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND"; 4018 case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY"; 4019 case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP"; 4020 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FULL"; 4021 case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH"; 4022 case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING"; 4023 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED"; 4024 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_RESPONSE_CDMA_NEW_SMS"; 4025 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_RESPONSE_NEW_BROADCAST_SMS"; 4026 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL"; 4027 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED"; 4028 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE"; 4029 case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING"; 4030 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS"; 4031 case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC"; 4032 case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW"; 4033 case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE"; 4034 case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE"; 4035 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "CDMA_SUBSCRIPTION_SOURCE_CHANGED"; 4036 case RIL_UNSOl_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED"; 4037 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE"; 4038 case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED"; 4039 case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED"; 4040 case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST"; 4041 case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: 4042 return "UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED"; 4043 case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: 4044 return "RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED"; 4045 case RIL_UNSOL_SRVCC_STATE_NOTIFY: 4046 return "UNSOL_SRVCC_STATE_NOTIFY"; 4047 case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "RIL_UNSOL_HARDWARE_CONFIG_CHANGED"; 4048 default: return "<unknown response>"; 4049 } 4050 } 4051 4052 private void riljLog(String msg) { 4053 Rlog.d(RILJ_LOG_TAG, msg 4054 + (mInstanceId != null ? (" [SUB" + mInstanceId + "]") : "")); 4055 } 4056 4057 private void riljLogv(String msg) { 4058 Rlog.v(RILJ_LOG_TAG, msg 4059 + (mInstanceId != null ? (" [SUB" + mInstanceId + "]") : "")); 4060 } 4061 4062 private void unsljLog(int response) { 4063 riljLog("[UNSL]< " + responseToString(response)); 4064 } 4065 4066 private void unsljLogMore(int response, String more) { 4067 riljLog("[UNSL]< " + responseToString(response) + " " + more); 4068 } 4069 4070 private void unsljLogRet(int response, Object ret) { 4071 riljLog("[UNSL]< " + responseToString(response) + " " + retToString(response, ret)); 4072 } 4073 4074 private void unsljLogvRet(int response, Object ret) { 4075 riljLogv("[UNSL]< " + responseToString(response) + " " + retToString(response, ret)); 4076 } 4077 4078 4079 // ***** Methods for CDMA support 4080 @Override 4081 public void 4082 getDeviceIdentity(Message response) { 4083 RILRequest rr = RILRequest.obtain(RIL_REQUEST_DEVICE_IDENTITY, response); 4084 4085 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4086 4087 send(rr); 4088 } 4089 4090 @Override 4091 public void 4092 getCDMASubscription(Message response) { 4093 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SUBSCRIPTION, response); 4094 4095 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4096 4097 send(rr); 4098 } 4099 4100 @Override 4101 public void setPhoneType(int phoneType) { // Called by CDMAPhone and GSMPhone constructor 4102 if (RILJ_LOGD) riljLog("setPhoneType=" + phoneType + " old value=" + mPhoneType); 4103 mPhoneType = phoneType; 4104 } 4105 4106 /** 4107 * {@inheritDoc} 4108 */ 4109 @Override 4110 public void queryCdmaRoamingPreference(Message response) { 4111 RILRequest rr = RILRequest.obtain( 4112 RILConstants.RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE, response); 4113 4114 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4115 4116 send(rr); 4117 } 4118 4119 /** 4120 * {@inheritDoc} 4121 */ 4122 @Override 4123 public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { 4124 RILRequest rr = RILRequest.obtain( 4125 RILConstants.RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE, response); 4126 4127 rr.mParcel.writeInt(1); 4128 rr.mParcel.writeInt(cdmaRoamingType); 4129 4130 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4131 + " : " + cdmaRoamingType); 4132 4133 send(rr); 4134 } 4135 4136 /** 4137 * {@inheritDoc} 4138 */ 4139 @Override 4140 public void setCdmaSubscriptionSource(int cdmaSubscription , Message response) { 4141 RILRequest rr = RILRequest.obtain( 4142 RILConstants.RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE, response); 4143 4144 rr.mParcel.writeInt(1); 4145 rr.mParcel.writeInt(cdmaSubscription); 4146 4147 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4148 + " : " + cdmaSubscription); 4149 4150 send(rr); 4151 } 4152 4153 /** 4154 * {@inheritDoc} 4155 */ 4156 @Override 4157 public void getCdmaSubscriptionSource(Message response) { 4158 RILRequest rr = RILRequest.obtain( 4159 RILConstants.RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE, response); 4160 4161 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4162 4163 send(rr); 4164 } 4165 4166 /** 4167 * {@inheritDoc} 4168 */ 4169 @Override 4170 public void queryTTYMode(Message response) { 4171 RILRequest rr = RILRequest.obtain( 4172 RILConstants.RIL_REQUEST_QUERY_TTY_MODE, response); 4173 4174 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4175 4176 send(rr); 4177 } 4178 4179 /** 4180 * {@inheritDoc} 4181 */ 4182 @Override 4183 public void setTTYMode(int ttyMode, Message response) { 4184 RILRequest rr = RILRequest.obtain( 4185 RILConstants.RIL_REQUEST_SET_TTY_MODE, response); 4186 4187 rr.mParcel.writeInt(1); 4188 rr.mParcel.writeInt(ttyMode); 4189 4190 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4191 + " : " + ttyMode); 4192 4193 send(rr); 4194 } 4195 4196 /** 4197 * {@inheritDoc} 4198 */ 4199 @Override 4200 public void 4201 sendCDMAFeatureCode(String FeatureCode, Message response) { 4202 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_FLASH, response); 4203 4204 rr.mParcel.writeString(FeatureCode); 4205 4206 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4207 + " : " + FeatureCode); 4208 4209 send(rr); 4210 } 4211 4212 @Override 4213 public void getCdmaBroadcastConfig(Message response) { 4214 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG, response); 4215 4216 send(rr); 4217 } 4218 4219 @Override 4220 public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) { 4221 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG, response); 4222 4223 // Convert to 1 service category per config (the way RIL takes is) 4224 ArrayList<CdmaSmsBroadcastConfigInfo> processedConfigs = 4225 new ArrayList<CdmaSmsBroadcastConfigInfo>(); 4226 for (CdmaSmsBroadcastConfigInfo config : configs) { 4227 for (int i = config.getFromServiceCategory(); i <= config.getToServiceCategory(); i++) { 4228 processedConfigs.add(new CdmaSmsBroadcastConfigInfo(i, 4229 i, 4230 config.getLanguage(), 4231 config.isSelected())); 4232 } 4233 } 4234 4235 CdmaSmsBroadcastConfigInfo[] rilConfigs = processedConfigs.toArray(configs); 4236 rr.mParcel.writeInt(rilConfigs.length); 4237 for(int i = 0; i < rilConfigs.length; i++) { 4238 rr.mParcel.writeInt(rilConfigs[i].getFromServiceCategory()); 4239 rr.mParcel.writeInt(rilConfigs[i].getLanguage()); 4240 rr.mParcel.writeInt(rilConfigs[i].isSelected() ? 1 : 0); 4241 } 4242 4243 if (RILJ_LOGD) { 4244 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4245 + " with " + rilConfigs.length + " configs : "); 4246 for (int i = 0; i < rilConfigs.length; i++) { 4247 riljLog(rilConfigs[i].toString()); 4248 } 4249 } 4250 4251 send(rr); 4252 } 4253 4254 @Override 4255 public void setCdmaBroadcastActivation(boolean activate, Message response) { 4256 RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_BROADCAST_ACTIVATION, response); 4257 4258 rr.mParcel.writeInt(1); 4259 rr.mParcel.writeInt(activate ? 0 :1); 4260 4261 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4262 4263 send(rr); 4264 } 4265 4266 /** 4267 * {@inheritDoc} 4268 */ 4269 @Override 4270 public void exitEmergencyCallbackMode(Message response) { 4271 RILRequest rr = RILRequest.obtain(RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE, response); 4272 4273 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4274 4275 send(rr); 4276 } 4277 4278 @Override 4279 public void requestIsimAuthentication(String nonce, Message response) { 4280 RILRequest rr = RILRequest.obtain(RIL_REQUEST_ISIM_AUTHENTICATION, response); 4281 4282 rr.mParcel.writeString(nonce); 4283 4284 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4285 4286 send(rr); 4287 } 4288 4289 @Override 4290 public void requestIccSimAuthentication(int authContext, String data, String aid, 4291 Message response) { 4292 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_AUTHENTICATION, response); 4293 4294 rr.mParcel.writeInt(authContext); 4295 rr.mParcel.writeString(data); 4296 rr.mParcel.writeString(aid); 4297 4298 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4299 4300 send(rr); 4301 } 4302 4303 /** 4304 * {@inheritDoc} 4305 */ 4306 @Override 4307 public void getCellInfoList(Message result) { 4308 RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_CELL_INFO_LIST, result); 4309 4310 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4311 4312 send(rr); 4313 } 4314 4315 /** 4316 * {@inheritDoc} 4317 */ 4318 @Override 4319 public void setCellInfoListRate(int rateInMillis, Message response) { 4320 if (RILJ_LOGD) riljLog("setCellInfoListRate: " + rateInMillis); 4321 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE, response); 4322 4323 rr.mParcel.writeInt(1); 4324 rr.mParcel.writeInt(rateInMillis); 4325 4326 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4327 4328 send(rr); 4329 } 4330 4331 public void setInitialAttachApn(String apn, String protocol, int authType, String username, 4332 String password, Message result) { 4333 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_INITIAL_ATTACH_APN, null); 4334 4335 if (RILJ_LOGD) riljLog("Set RIL_REQUEST_SET_INITIAL_ATTACH_APN"); 4336 4337 rr.mParcel.writeString(apn); 4338 rr.mParcel.writeString(protocol); 4339 rr.mParcel.writeInt(authType); 4340 rr.mParcel.writeString(username); 4341 rr.mParcel.writeString(password); 4342 4343 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4344 + ", apn:" + apn + ", protocol:" + protocol + ", authType:" + authType 4345 + ", username:" + username + ", password:" + password); 4346 4347 send(rr); 4348 } 4349 4350 public void setDataProfile(DataProfile[] dps, Message result) { 4351 if (RILJ_LOGD) riljLog("Set RIL_REQUEST_SET_DATA_PROFILE"); 4352 4353 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_DATA_PROFILE, null); 4354 DataProfile.toParcel(rr.mParcel, dps); 4355 4356 if (RILJ_LOGD) { 4357 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4358 + " with " + dps + " Data Profiles : "); 4359 for (int i = 0; i < dps.length; i++) { 4360 riljLog(dps[i].toString()); 4361 } 4362 } 4363 4364 send(rr); 4365 } 4366 4367 /* (non-Javadoc) 4368 * @see com.android.internal.telephony.BaseCommands#testingEmergencyCall() 4369 */ 4370 @Override 4371 public void testingEmergencyCall() { 4372 if (RILJ_LOGD) riljLog("testingEmergencyCall"); 4373 mTestingEmergencyCall.set(true); 4374 } 4375 4376 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 4377 pw.println("RIL: " + this); 4378 pw.println(" mSocket=" + mSocket); 4379 pw.println(" mSenderThread=" + mSenderThread); 4380 pw.println(" mSender=" + mSender); 4381 pw.println(" mReceiverThread=" + mReceiverThread); 4382 pw.println(" mReceiver=" + mReceiver); 4383 pw.println(" mWakeLock=" + mWakeLock); 4384 pw.println(" mWakeLockTimeout=" + mWakeLockTimeout); 4385 synchronized (mRequestList) { 4386 synchronized (mWakeLock) { 4387 pw.println(" mWakeLockCount=" + mWakeLockCount); 4388 } 4389 int count = mRequestList.size(); 4390 pw.println(" mRequestList count=" + count); 4391 for (int i = 0; i < count; i++) { 4392 RILRequest rr = mRequestList.valueAt(i); 4393 pw.println(" [" + rr.mSerial + "] " + requestToString(rr.mRequest)); 4394 } 4395 } 4396 pw.println(" mLastNITZTimeInfo=" + mLastNITZTimeInfo); 4397 pw.println(" mTestingEmergencyCall=" + mTestingEmergencyCall.get()); 4398 } 4399 4400 /** 4401 * {@inheritDoc} 4402 */ 4403 @Override 4404 public void iccOpenLogicalChannel(String AID, Message response) { 4405 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_OPEN_CHANNEL, response); 4406 rr.mParcel.writeString(AID); 4407 4408 if (RILJ_LOGD) 4409 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4410 4411 send(rr); 4412 } 4413 4414 /** 4415 * {@inheritDoc} 4416 */ 4417 @Override 4418 public void iccCloseLogicalChannel(int channel, Message response) { 4419 RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_CLOSE_CHANNEL, response); 4420 rr.mParcel.writeInt(1); 4421 rr.mParcel.writeInt(channel); 4422 4423 if (RILJ_LOGD) 4424 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4425 4426 send(rr); 4427 } 4428 4429 /** 4430 * {@inheritDoc} 4431 */ 4432 @Override 4433 public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction, 4434 int p1, int p2, int p3, String data, Message response) { 4435 if (channel <= 0) { 4436 throw new RuntimeException( 4437 "Invalid channel in iccTransmitApduLogicalChannel: " + channel); 4438 } 4439 4440 iccTransmitApduHelper(RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL, channel, cla, 4441 instruction, p1, p2, p3, data, response); 4442 } 4443 4444 /** 4445 * {@inheritDoc} 4446 */ 4447 @Override 4448 public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2, 4449 int p3, String data, Message response) { 4450 iccTransmitApduHelper(RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC, 0, cla, instruction, 4451 p1, p2, p3, data, response); 4452 } 4453 4454 /* 4455 * Helper function for the iccTransmitApdu* commands above. 4456 */ 4457 private void iccTransmitApduHelper(int rilCommand, int channel, int cla, 4458 int instruction, int p1, int p2, int p3, String data, Message response) { 4459 RILRequest rr = RILRequest.obtain(rilCommand, response); 4460 rr.mParcel.writeInt(channel); 4461 rr.mParcel.writeInt(cla); 4462 rr.mParcel.writeInt(instruction); 4463 rr.mParcel.writeInt(p1); 4464 rr.mParcel.writeInt(p2); 4465 rr.mParcel.writeInt(p3); 4466 rr.mParcel.writeString(data); 4467 4468 if (RILJ_LOGD) 4469 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); 4470 4471 send(rr); 4472 } 4473 4474 @Override 4475 public void nvReadItem(int itemID, Message response) { 4476 RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_READ_ITEM, response); 4477 4478 rr.mParcel.writeInt(itemID); 4479 4480 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4481 + ' ' + itemID); 4482 4483 send(rr); 4484 } 4485 4486 @Override 4487 public void nvWriteItem(int itemID, String itemValue, Message response) { 4488 RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_WRITE_ITEM, response); 4489 4490 rr.mParcel.writeInt(itemID); 4491 rr.mParcel.writeString(itemValue); 4492 4493 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4494 + ' ' + itemID + ": " + itemValue); 4495 4496 send(rr); 4497 } 4498 4499 @Override 4500 public void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response) { 4501 RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_WRITE_CDMA_PRL, response); 4502 4503 rr.mParcel.writeByteArray(preferredRoamingList); 4504 4505 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4506 + " (" + preferredRoamingList.length + " bytes)"); 4507 4508 send(rr); 4509 } 4510 4511 @Override 4512 public void nvResetConfig(int resetType, Message response) { 4513 RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_RESET_CONFIG, response); 4514 4515 rr.mParcel.writeInt(1); 4516 rr.mParcel.writeInt(resetType); 4517 4518 if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) 4519 + ' ' + resetType); 4520 4521 send(rr); 4522 } 4523} 4524