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