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