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