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