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