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