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