3d14b86d9ec1cd554ba807ea27c8b780f44c9c17
[android/platform/frameworks/opt/telephony.git] / src / java / com / android / internal / telephony / CommandsInterface.java
1 /*
2  * Copyright (C) 2006 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.android.internal.telephony;
18
19 import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
20 import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
21 import com.android.internal.telephony.uicc.IccCardStatus;
22
23 import android.os.Message;
24 import android.os.Handler;
25
26 /**
27  * {@hide}
28  */
29 public interface CommandsInterface {
30     enum RadioState {
31         RADIO_OFF,         /* Radio explicitly powered off (eg CFUN=0) */
32         RADIO_UNAVAILABLE, /* Radio unavailable (eg, resetting or not booted) */
33         RADIO_ON;          /* Radio is on */
34
35         public boolean isOn() /* and available...*/ {
36             return this == RADIO_ON;
37         }
38
39         public boolean isAvailable() {
40             return this != RADIO_UNAVAILABLE;
41         }
42     }
43
44     //***** Constants
45
46     // Used as parameter to dial() and setCLIR() below
47     static final int CLIR_DEFAULT = 0;      // "use subscription default value"
48     static final int CLIR_INVOCATION = 1;   // (restrict CLI presentation)
49     static final int CLIR_SUPPRESSION = 2;  // (allow CLI presentation)
50
51
52     // Used as parameters for call forward methods below
53     static final int CF_ACTION_DISABLE          = 0;
54     static final int CF_ACTION_ENABLE           = 1;
55 //  static final int CF_ACTION_UNUSED           = 2;
56     static final int CF_ACTION_REGISTRATION     = 3;
57     static final int CF_ACTION_ERASURE          = 4;
58
59     static final int CF_REASON_UNCONDITIONAL    = 0;
60     static final int CF_REASON_BUSY             = 1;
61     static final int CF_REASON_NO_REPLY         = 2;
62     static final int CF_REASON_NOT_REACHABLE    = 3;
63     static final int CF_REASON_ALL              = 4;
64     static final int CF_REASON_ALL_CONDITIONAL  = 5;
65
66     // Used for call barring methods below
67     static final String CB_FACILITY_BAOC         = "AO";
68     static final String CB_FACILITY_BAOIC        = "OI";
69     static final String CB_FACILITY_BAOICxH      = "OX";
70     static final String CB_FACILITY_BAIC         = "AI";
71     static final String CB_FACILITY_BAICr        = "IR";
72     static final String CB_FACILITY_BA_ALL       = "AB";
73     static final String CB_FACILITY_BA_MO        = "AG";
74     static final String CB_FACILITY_BA_MT        = "AC";
75     static final String CB_FACILITY_BA_SIM       = "SC";
76     static final String CB_FACILITY_BA_FD        = "FD";
77
78
79     // Used for various supp services apis
80     // See 27.007 +CCFC or +CLCK
81     static final int SERVICE_CLASS_NONE     = 0; // no user input
82     static final int SERVICE_CLASS_VOICE    = (1 << 0);
83     static final int SERVICE_CLASS_DATA     = (1 << 1); //synonym for 16+32+64+128
84     static final int SERVICE_CLASS_FAX      = (1 << 2);
85     static final int SERVICE_CLASS_SMS      = (1 << 3);
86     static final int SERVICE_CLASS_DATA_SYNC = (1 << 4);
87     static final int SERVICE_CLASS_DATA_ASYNC = (1 << 5);
88     static final int SERVICE_CLASS_PACKET   = (1 << 6);
89     static final int SERVICE_CLASS_PAD      = (1 << 7);
90     static final int SERVICE_CLASS_MAX      = (1 << 7); // Max SERVICE_CLASS value
91
92     // Numeric representation of string values returned
93     // by messages sent to setOnUSSD handler
94     static final int USSD_MODE_NOTIFY       = 0;
95     static final int USSD_MODE_REQUEST      = 1;
96
97     // GSM SMS fail cause for acknowledgeLastIncomingSMS. From TS 23.040, 9.2.3.22.
98     static final int GSM_SMS_FAIL_CAUSE_MEMORY_CAPACITY_EXCEEDED    = 0xD3;
99     static final int GSM_SMS_FAIL_CAUSE_USIM_APP_TOOLKIT_BUSY       = 0xD4;
100     static final int GSM_SMS_FAIL_CAUSE_USIM_DATA_DOWNLOAD_ERROR    = 0xD5;
101     static final int GSM_SMS_FAIL_CAUSE_UNSPECIFIED_ERROR           = 0xFF;
102
103     // CDMA SMS fail cause for acknowledgeLastIncomingCdmaSms.  From TS N.S0005, 6.5.2.125.
104     static final int CDMA_SMS_FAIL_CAUSE_INVALID_TELESERVICE_ID     = 4;
105     static final int CDMA_SMS_FAIL_CAUSE_RESOURCE_SHORTAGE          = 35;
106     static final int CDMA_SMS_FAIL_CAUSE_OTHER_TERMINAL_PROBLEM     = 39;
107     static final int CDMA_SMS_FAIL_CAUSE_ENCODING_PROBLEM           = 96;
108
109     //***** Methods
110     RadioState getRadioState();
111
112     /**
113      * response.obj.result is an int[2]
114      *
115      * response.obj.result[0] is IMS registration state
116      *                        0 - Not registered
117      *                        1 - Registered
118      * response.obj.result[1] is of type RILConstants.GSM_PHONE or
119      *                                    RILConstants.CDMA_PHONE
120      */
121     void getImsRegistrationState(Message result);
122
123     /**
124      * Fires on any RadioState transition
125      * Always fires immediately as well
126      *
127      * do not attempt to calculate transitions by storing getRadioState() values
128      * on previous invocations of this notification. Instead, use the other
129      * registration methods
130      */
131     void registerForRadioStateChanged(Handler h, int what, Object obj);
132     void unregisterForRadioStateChanged(Handler h);
133
134     void registerForVoiceRadioTechChanged(Handler h, int what, Object obj);
135     void unregisterForVoiceRadioTechChanged(Handler h);
136     void registerForImsNetworkStateChanged(Handler h, int what, Object obj);
137     void unregisterForImsNetworkStateChanged(Handler h);
138
139     /**
140      * Fires on any transition into RadioState.isOn()
141      * Fires immediately if currently in that state
142      * In general, actions should be idempotent. State may change
143      * before event is received.
144      */
145     void registerForOn(Handler h, int what, Object obj);
146     void unregisterForOn(Handler h);
147
148     /**
149      * Fires on any transition out of RadioState.isAvailable()
150      * Fires immediately if currently in that state
151      * In general, actions should be idempotent. State may change
152      * before event is received.
153      */
154     void registerForAvailable(Handler h, int what, Object obj);
155     void unregisterForAvailable(Handler h);
156
157     /**
158      * Fires on any transition into !RadioState.isAvailable()
159      * Fires immediately if currently in that state
160      * In general, actions should be idempotent. State may change
161      * before event is received.
162      */
163     void registerForNotAvailable(Handler h, int what, Object obj);
164     void unregisterForNotAvailable(Handler h);
165
166     /**
167      * Fires on any transition into RADIO_OFF or !RadioState.isAvailable()
168      * Fires immediately if currently in that state
169      * In general, actions should be idempotent. State may change
170      * before event is received.
171      */
172     void registerForOffOrNotAvailable(Handler h, int what, Object obj);
173     void unregisterForOffOrNotAvailable(Handler h);
174
175     /**
176      * Fires on any change in ICC status
177      */
178     void registerForIccStatusChanged(Handler h, int what, Object obj);
179     void unregisterForIccStatusChanged(Handler h);
180
181     void registerForCallStateChanged(Handler h, int what, Object obj);
182     void unregisterForCallStateChanged(Handler h);
183     void registerForVoiceNetworkStateChanged(Handler h, int what, Object obj);
184     void unregisterForVoiceNetworkStateChanged(Handler h);
185     void registerForDataNetworkStateChanged(Handler h, int what, Object obj);
186     void unregisterForDataNetworkStateChanged(Handler h);
187
188     /** InCall voice privacy notifications */
189     void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj);
190     void unregisterForInCallVoicePrivacyOn(Handler h);
191     void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj);
192     void unregisterForInCallVoicePrivacyOff(Handler h);
193
194     /** Single Radio Voice Call State progress notifications */
195     void registerForSrvccStateChanged(Handler h, int what, Object obj);
196     void unregisterForSrvccStateChanged(Handler h);
197
198     /**
199      * Handlers for subscription status change indications.
200      *
201      * @param h Handler for subscription status change messages.
202      * @param what User-defined message code.
203      * @param obj User object.
204      */
205     void registerForSubscriptionStatusChanged(Handler h, int what, Object obj);
206     void unregisterForSubscriptionStatusChanged(Handler h);
207
208     /**
209      * fires on any change in hardware configuration.
210      */
211     void registerForHardwareConfigChanged(Handler h, int what, Object obj);
212     void unregisterForHardwareConfigChanged(Handler h);
213
214     /**
215      * unlike the register* methods, there's only one new 3GPP format SMS handler.
216      * if you need to unregister, you should also tell the radio to stop
217      * sending SMS's to you (via AT+CNMI)
218      *
219      * AsyncResult.result is a String containing the SMS PDU
220      */
221     void setOnNewGsmSms(Handler h, int what, Object obj);
222     void unSetOnNewGsmSms(Handler h);
223
224     /**
225      * unlike the register* methods, there's only one new 3GPP2 format SMS handler.
226      * if you need to unregister, you should also tell the radio to stop
227      * sending SMS's to you (via AT+CNMI)
228      *
229      * AsyncResult.result is a String containing the SMS PDU
230      */
231     void setOnNewCdmaSms(Handler h, int what, Object obj);
232     void unSetOnNewCdmaSms(Handler h);
233
234     /**
235      * Set the handler for SMS Cell Broadcast messages.
236      *
237      * AsyncResult.result is a byte array containing the SMS-CB PDU
238      */
239     void setOnNewGsmBroadcastSms(Handler h, int what, Object obj);
240     void unSetOnNewGsmBroadcastSms(Handler h);
241
242     /**
243      * Register for NEW_SMS_ON_SIM unsolicited message
244      *
245      * AsyncResult.result is an int array containing the index of new SMS
246      */
247     void setOnSmsOnSim(Handler h, int what, Object obj);
248     void unSetOnSmsOnSim(Handler h);
249
250     /**
251      * Register for NEW_SMS_STATUS_REPORT unsolicited message
252      *
253      * AsyncResult.result is a String containing the status report PDU
254      */
255     void setOnSmsStatus(Handler h, int what, Object obj);
256     void unSetOnSmsStatus(Handler h);
257
258     /**
259      * unlike the register* methods, there's only one NITZ time handler
260      *
261      * AsyncResult.result is an Object[]
262      * ((Object[])AsyncResult.result)[0] is a String containing the NITZ time string
263      * ((Object[])AsyncResult.result)[1] is a Long containing the milliseconds since boot as
264      *                                   returned by elapsedRealtime() when this NITZ time
265      *                                   was posted.
266      *
267      * Please note that the delivery of this message may be delayed several
268      * seconds on system startup
269      */
270     void setOnNITZTime(Handler h, int what, Object obj);
271     void unSetOnNITZTime(Handler h);
272
273     /**
274      * unlike the register* methods, there's only one USSD notify handler
275      *
276      * Represents the arrival of a USSD "notify" message, which may
277      * or may not have been triggered by a previous USSD send
278      *
279      * AsyncResult.result is a String[]
280      * ((String[])(AsyncResult.result))[0] contains status code
281      *      "0"   USSD-Notify -- text in ((const char **)data)[1]
282      *      "1"   USSD-Request -- text in ((const char **)data)[1]
283      *      "2"   Session terminated by network
284      *      "3"   other local client (eg, SIM Toolkit) has responded
285      *      "4"   Operation not supported
286      *      "5"   Network timeout
287      *
288      * ((String[])(AsyncResult.result))[1] contains the USSD message
289      * The numeric representations of these are in USSD_MODE_*
290      */
291
292     void setOnUSSD(Handler h, int what, Object obj);
293     void unSetOnUSSD(Handler h);
294
295     /**
296      * unlike the register* methods, there's only one signal strength handler
297      * AsyncResult.result is an int[2]
298      * response.obj.result[0] is received signal strength (0-31, 99)
299      * response.obj.result[1] is  bit error rate (0-7, 99)
300      * as defined in TS 27.007 8.5
301      */
302
303     void setOnSignalStrengthUpdate(Handler h, int what, Object obj);
304     void unSetOnSignalStrengthUpdate(Handler h);
305
306     /**
307      * Sets the handler for SIM/RUIM SMS storage full unsolicited message.
308      * Unlike the register* methods, there's only one notification handler
309      *
310      * @param h Handler for notification message.
311      * @param what User-defined message code.
312      * @param obj User object.
313      */
314     void setOnIccSmsFull(Handler h, int what, Object obj);
315     void unSetOnIccSmsFull(Handler h);
316
317     /**
318      * Sets the handler for SIM Refresh notifications.
319      *
320      * @param h Handler for notification message.
321      * @param what User-defined message code.
322      * @param obj User object.
323      */
324     void registerForIccRefresh(Handler h, int what, Object obj);
325     void unregisterForIccRefresh(Handler h);
326
327     void setOnIccRefresh(Handler h, int what, Object obj);
328     void unsetOnIccRefresh(Handler h);
329
330     /**
331      * Sets the handler for RING notifications.
332      * Unlike the register* methods, there's only one notification handler
333      *
334      * @param h Handler for notification message.
335      * @param what User-defined message code.
336      * @param obj User object.
337      */
338     void setOnCallRing(Handler h, int what, Object obj);
339     void unSetOnCallRing(Handler h);
340
341     /**
342      * Sets the handler for RESTRICTED_STATE changed notification,
343      * eg, for Domain Specific Access Control
344      * unlike the register* methods, there's only one signal strength handler
345      *
346      * AsyncResult.result is an int[1]
347      * response.obj.result[0] is a bitmask of RIL_RESTRICTED_STATE_* values
348      */
349
350     void setOnRestrictedStateChanged(Handler h, int what, Object obj);
351     void unSetOnRestrictedStateChanged(Handler h);
352
353     /**
354      * Sets the handler for Supplementary Service Notifications.
355      * Unlike the register* methods, there's only one notification handler
356      *
357      * @param h Handler for notification message.
358      * @param what User-defined message code.
359      * @param obj User object.
360      */
361     void setOnSuppServiceNotification(Handler h, int what, Object obj);
362     void unSetOnSuppServiceNotification(Handler h);
363
364     /**
365      * Sets the handler for Session End Notifications for CAT.
366      * Unlike the register* methods, there's only one notification handler
367      *
368      * @param h Handler for notification message.
369      * @param what User-defined message code.
370      * @param obj User object.
371      */
372     void setOnCatSessionEnd(Handler h, int what, Object obj);
373     void unSetOnCatSessionEnd(Handler h);
374
375     /**
376      * Sets the handler for Proactive Commands for CAT.
377      * Unlike the register* methods, there's only one notification handler
378      *
379      * @param h Handler for notification message.
380      * @param what User-defined message code.
381      * @param obj User object.
382      */
383     void setOnCatProactiveCmd(Handler h, int what, Object obj);
384     void unSetOnCatProactiveCmd(Handler h);
385
386     /**
387      * Sets the handler for Event Notifications for CAT.
388      * Unlike the register* methods, there's only one notification handler
389      *
390      * @param h Handler for notification message.
391      * @param what User-defined message code.
392      * @param obj User object.
393      */
394     void setOnCatEvent(Handler h, int what, Object obj);
395     void unSetOnCatEvent(Handler h);
396
397     /**
398      * Sets the handler for Call Set Up Notifications for CAT.
399      * Unlike the register* methods, there's only one notification handler
400      *
401      * @param h Handler for notification message.
402      * @param what User-defined message code.
403      * @param obj User object.
404      */
405     void setOnCatCallSetUp(Handler h, int what, Object obj);
406     void unSetOnCatCallSetUp(Handler h);
407
408     /**
409      * Enables/disbables supplementary service related notifications from
410      * the network.
411      *
412      * @param enable true to enable notifications, false to disable.
413      * @param result Message to be posted when command completes.
414      */
415     void setSuppServiceNotifications(boolean enable, Message result);
416     //void unSetSuppServiceNotifications(Handler h);
417
418     /**
419      * Sets the handler for Event Notifications for CDMA Display Info.
420      * Unlike the register* methods, there's only one notification handler
421      *
422      * @param h Handler for notification message.
423      * @param what User-defined message code.
424      * @param obj User object.
425      */
426     void registerForDisplayInfo(Handler h, int what, Object obj);
427     void unregisterForDisplayInfo(Handler h);
428
429     /**
430      * Sets the handler for Event Notifications for CallWaiting Info.
431      * Unlike the register* methods, there's only one notification handler
432      *
433      * @param h Handler for notification message.
434      * @param what User-defined message code.
435      * @param obj User object.
436      */
437     void registerForCallWaitingInfo(Handler h, int what, Object obj);
438     void unregisterForCallWaitingInfo(Handler h);
439
440     /**
441      * Sets the handler for Event Notifications for Signal Info.
442      * Unlike the register* methods, there's only one notification handler
443      *
444      * @param h Handler for notification message.
445      * @param what User-defined message code.
446      * @param obj User object.
447      */
448     void registerForSignalInfo(Handler h, int what, Object obj);
449     void unregisterForSignalInfo(Handler h);
450
451     /**
452      * Registers the handler for CDMA number information record
453      * Unlike the register* methods, there's only one notification handler
454      *
455      * @param h Handler for notification message.
456      * @param what User-defined message code.
457      * @param obj User object.
458      */
459     void registerForNumberInfo(Handler h, int what, Object obj);
460     void unregisterForNumberInfo(Handler h);
461
462     /**
463      * Registers the handler for CDMA redirected number Information record
464      * Unlike the register* methods, there's only one notification handler
465      *
466      * @param h Handler for notification message.
467      * @param what User-defined message code.
468      * @param obj User object.
469      */
470     void registerForRedirectedNumberInfo(Handler h, int what, Object obj);
471     void unregisterForRedirectedNumberInfo(Handler h);
472
473     /**
474      * Registers the handler for CDMA line control information record
475      * Unlike the register* methods, there's only one notification handler
476      *
477      * @param h Handler for notification message.
478      * @param what User-defined message code.
479      * @param obj User object.
480      */
481     void registerForLineControlInfo(Handler h, int what, Object obj);
482     void unregisterForLineControlInfo(Handler h);
483
484     /**
485      * Registers the handler for CDMA T53 CLIR information record
486      * Unlike the register* methods, there's only one notification handler
487      *
488      * @param h Handler for notification message.
489      * @param what User-defined message code.
490      * @param obj User object.
491      */
492     void registerFoT53ClirlInfo(Handler h, int what, Object obj);
493     void unregisterForT53ClirInfo(Handler h);
494
495     /**
496      * Registers the handler for CDMA T53 audio control information record
497      * Unlike the register* methods, there's only one notification handler
498      *
499      * @param h Handler for notification message.
500      * @param what User-defined message code.
501      * @param obj User object.
502      */
503     void registerForT53AudioControlInfo(Handler h, int what, Object obj);
504     void unregisterForT53AudioControlInfo(Handler h);
505
506     /**
507      * Fires on if Modem enters Emergency Callback mode
508      */
509     void setEmergencyCallbackMode(Handler h, int what, Object obj);
510
511      /**
512       * Fires on any CDMA OTA provision status change
513       */
514      void registerForCdmaOtaProvision(Handler h,int what, Object obj);
515      void unregisterForCdmaOtaProvision(Handler h);
516
517      /**
518       * Registers the handler when out-band ringback tone is needed.<p>
519       *
520       *  Messages received from this:
521       *  Message.obj will be an AsyncResult
522       *  AsyncResult.userObj = obj
523       *  AsyncResult.result = boolean. <p>
524       */
525      void registerForRingbackTone(Handler h, int what, Object obj);
526      void unregisterForRingbackTone(Handler h);
527
528      /**
529       * Registers the handler when mute/unmute need to be resent to get
530       * uplink audio during a call.<p>
531       *
532       * @param h Handler for notification message.
533       * @param what User-defined message code.
534       * @param obj User object.
535       *
536       */
537      void registerForResendIncallMute(Handler h, int what, Object obj);
538      void unregisterForResendIncallMute(Handler h);
539
540      /**
541       * Registers the handler for when Cdma subscription changed events
542       *
543       * @param h Handler for notification message.
544       * @param what User-defined message code.
545       * @param obj User object.
546       *
547       */
548      void registerForCdmaSubscriptionChanged(Handler h, int what, Object obj);
549      void unregisterForCdmaSubscriptionChanged(Handler h);
550
551      /**
552       * Registers the handler for when Cdma prl changed events
553       *
554       * @param h Handler for notification message.
555       * @param what User-defined message code.
556       * @param obj User object.
557       *
558       */
559      void registerForCdmaPrlChanged(Handler h, int what, Object obj);
560      void unregisterForCdmaPrlChanged(Handler h);
561
562      /**
563       * Registers the handler for when Cdma prl changed events
564       *
565       * @param h Handler for notification message.
566       * @param what User-defined message code.
567       * @param obj User object.
568       *
569       */
570      void registerForExitEmergencyCallbackMode(Handler h, int what, Object obj);
571      void unregisterForExitEmergencyCallbackMode(Handler h);
572
573      /**
574       * Registers the handler for RIL_UNSOL_RIL_CONNECT events.
575       *
576       * When ril connects or disconnects a message is sent to the registrant
577       * which contains an AsyncResult, ar, in msg.obj. The ar.result is an
578       * Integer which is the version of the ril or -1 if the ril disconnected.
579       *
580       * @param h Handler for notification message.
581       * @param what User-defined message code.
582       * @param obj User object.
583       */
584      void registerForRilConnected(Handler h, int what, Object obj);
585      void unregisterForRilConnected(Handler h);
586
587     /**
588      * Supply the ICC PIN to the ICC card
589      *
590      *  returned message
591      *  retMsg.obj = AsyncResult ar
592      *  ar.exception carries exception on failure
593      *  This exception is CommandException with an error of PASSWORD_INCORRECT
594      *  if the password is incorrect
595      *
596      *  ar.result is an optional array of integers where the first entry
597      *  is the number of attempts remaining before the ICC will be PUK locked.
598      *
599      * ar.exception and ar.result are null on success
600      */
601
602     void supplyIccPin(String pin, Message result);
603
604     /**
605      * Supply the PIN for the app with this AID on the ICC card
606      *
607      *  AID (Application ID), See ETSI 102.221 8.1 and 101.220 4
608      *
609      *  returned message
610      *  retMsg.obj = AsyncResult ar
611      *  ar.exception carries exception on failure
612      *  This exception is CommandException with an error of PASSWORD_INCORRECT
613      *  if the password is incorrect
614      *
615      *  ar.result is an optional array of integers where the first entry
616      *  is the number of attempts remaining before the ICC will be PUK locked.
617      *
618      * ar.exception and ar.result are null on success
619      */
620
621     void supplyIccPinForApp(String pin, String aid, Message result);
622
623     /**
624      * Supply the ICC PUK and newPin to the ICC card
625      *
626      *  returned message
627      *  retMsg.obj = AsyncResult ar
628      *  ar.exception carries exception on failure
629      *  This exception is CommandException with an error of PASSWORD_INCORRECT
630      *  if the password is incorrect
631      *
632      *  ar.result is an optional array of integers where the first entry
633      *  is the number of attempts remaining before the ICC is permanently disabled.
634      *
635      * ar.exception and ar.result are null on success
636      */
637
638     void supplyIccPuk(String puk, String newPin, Message result);
639
640     /**
641      * Supply the PUK, new pin for the app with this AID on the ICC card
642      *
643      *  AID (Application ID), See ETSI 102.221 8.1 and 101.220 4
644      *
645      *  retMsg.obj = AsyncResult ar
646      *  ar.exception carries exception on failure
647      *  This exception is CommandException with an error of PASSWORD_INCORRECT
648      *  if the password is incorrect
649      *
650      *  ar.result is an optional array of integers where the first entry
651      *  is the number of attempts remaining before the ICC is permanently disabled.
652      *
653      * ar.exception and ar.result are null on success
654      */
655
656     void supplyIccPukForApp(String puk, String newPin, String aid, Message result);
657
658     /**
659      * Supply the ICC PIN2 to the ICC card
660      * Only called following operation where ICC_PIN2 was
661      * returned as a a failure from a previous operation
662      *
663      *  returned message
664      *  retMsg.obj = AsyncResult ar
665      *  ar.exception carries exception on failure
666      *  This exception is CommandException with an error of PASSWORD_INCORRECT
667      *  if the password is incorrect
668      *
669      *  ar.result is an optional array of integers where the first entry
670      *  is the number of attempts remaining before the ICC will be PUK locked.
671      *
672      * ar.exception and ar.result are null on success
673      */
674
675     void supplyIccPin2(String pin2, Message result);
676
677     /**
678      * Supply the PIN2 for the app with this AID on the ICC card
679      * Only called following operation where ICC_PIN2 was
680      * returned as a a failure from a previous operation
681      *
682      *  AID (Application ID), See ETSI 102.221 8.1 and 101.220 4
683      *
684      *  returned message
685      *  retMsg.obj = AsyncResult ar
686      *  ar.exception carries exception on failure
687      *  This exception is CommandException with an error of PASSWORD_INCORRECT
688      *  if the password is incorrect
689      *
690      *  ar.result is an optional array of integers where the first entry
691      *  is the number of attempts remaining before the ICC will be PUK locked.
692      *
693      * ar.exception and ar.result are null on success
694      */
695
696     void supplyIccPin2ForApp(String pin2, String aid, Message result);
697
698     /**
699      * Supply the SIM PUK2 to the SIM card
700      * Only called following operation where SIM_PUK2 was
701      * returned as a a failure from a previous operation
702      *
703      *  returned message
704      *  retMsg.obj = AsyncResult ar
705      *  ar.exception carries exception on failure
706      *  This exception is CommandException with an error of PASSWORD_INCORRECT
707      *  if the password is incorrect
708      *
709      *  ar.result is an optional array of integers where the first entry
710      *  is the number of attempts remaining before the ICC is permanently disabled.
711      *
712      * ar.exception and ar.result are null on success
713      */
714
715     void supplyIccPuk2(String puk2, String newPin2, Message result);
716
717     /**
718      * Supply the PUK2, newPin2 for the app with this AID on the ICC card
719      * Only called following operation where SIM_PUK2 was
720      * returned as a a failure from a previous operation
721      *
722      *  AID (Application ID), See ETSI 102.221 8.1 and 101.220 4
723      *
724      *  returned message
725      *  retMsg.obj = AsyncResult ar
726      *  ar.exception carries exception on failure
727      *  This exception is CommandException with an error of PASSWORD_INCORRECT
728      *  if the password is incorrect
729      *
730      *  ar.result is an optional array of integers where the first entry
731      *  is the number of attempts remaining before the ICC is permanently disabled.
732      *
733      * ar.exception and ar.result are null on success
734      */
735
736     void supplyIccPuk2ForApp(String puk2, String newPin2, String aid, Message result);
737
738     // TODO: Add java doc and indicate that msg.arg1 contains the number of attempts remaining.
739     void changeIccPin(String oldPin, String newPin, Message result);
740     void changeIccPinForApp(String oldPin, String newPin, String aidPtr, Message result);
741     void changeIccPin2(String oldPin2, String newPin2, Message result);
742     void changeIccPin2ForApp(String oldPin2, String newPin2, String aidPtr, Message result);
743
744     void changeBarringPassword(String facility, String oldPwd, String newPwd, Message result);
745
746     void supplyNetworkDepersonalization(String netpin, Message result);
747
748     /**
749      *  returned message
750      *  retMsg.obj = AsyncResult ar
751      *  ar.exception carries exception on failure
752      *  ar.userObject contains the orignal value of result.obj
753      *  ar.result contains a List of DriverCall
754      *      The ar.result List is sorted by DriverCall.index
755      */
756     void getCurrentCalls (Message result);
757
758     /**
759      *  returned message
760      *  retMsg.obj = AsyncResult ar
761      *  ar.exception carries exception on failure
762      *  ar.userObject contains the orignal value of result.obj
763      *  ar.result contains a List of DataCallResponse
764      *  @deprecated Do not use.
765      */
766     @Deprecated
767     void getPDPContextList(Message result);
768
769     /**
770      *  returned message
771      *  retMsg.obj = AsyncResult ar
772      *  ar.exception carries exception on failure
773      *  ar.userObject contains the orignal value of result.obj
774      *  ar.result contains a List of DataCallResponse
775      */
776     void getDataCallList(Message result);
777
778     /**
779      *  returned message
780      *  retMsg.obj = AsyncResult ar
781      *  ar.exception carries exception on failure
782      *  ar.userObject contains the orignal value of result.obj
783      *  ar.result is null on success and failure
784      *
785      * CLIR_DEFAULT     == on "use subscription default value"
786      * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation)
787      * CLIR_INVOCATION  == on "CLIR invocation" (restrict CLI presentation)
788      */
789     void dial (String address, int clirMode, Message result);
790
791     /**
792      *  returned message
793      *  retMsg.obj = AsyncResult ar
794      *  ar.exception carries exception on failure
795      *  ar.userObject contains the orignal value of result.obj
796      *  ar.result is null on success and failure
797      *
798      * CLIR_DEFAULT     == on "use subscription default value"
799      * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation)
800      * CLIR_INVOCATION  == on "CLIR invocation" (restrict CLI presentation)
801      */
802     void dial(String address, int clirMode, UUSInfo uusInfo, Message result);
803
804     /**
805      *  returned message
806      *  retMsg.obj = AsyncResult ar
807      *  ar.exception carries exception on failure
808      *  ar.userObject contains the orignal value of result.obj
809      *  ar.result is String containing IMSI on success
810      */
811     void getIMSI(Message result);
812
813     /**
814      *  returned message
815      *  retMsg.obj = AsyncResult ar
816      *  ar.exception carries exception on failure
817      *  ar.userObject contains the orignal value of result.obj
818      *  ar.result is String containing IMSI on success
819      */
820     void getIMSIForApp(String aid, Message result);
821
822     /**
823      *  returned message
824      *  retMsg.obj = AsyncResult ar
825      *  ar.exception carries exception on failure
826      *  ar.userObject contains the orignal value of result.obj
827      *  ar.result is String containing IMEI on success
828      */
829     void getIMEI(Message result);
830
831     /**
832      *  returned message
833      *  retMsg.obj = AsyncResult ar
834      *  ar.exception carries exception on failure
835      *  ar.userObject contains the orignal value of result.obj
836      *  ar.result is String containing IMEISV on success
837      */
838     void getIMEISV(Message result);
839
840     /**
841      * Hang up one individual connection.
842      *  returned message
843      *  retMsg.obj = AsyncResult ar
844      *  ar.exception carries exception on failure
845      *  ar.userObject contains the orignal value of result.obj
846      *  ar.result is null on success and failure
847      *
848      *  3GPP 22.030 6.5.5
849      *  "Releases a specific active call X"
850      */
851     void hangupConnection (int gsmIndex, Message result);
852
853     /**
854      * 3GPP 22.030 6.5.5
855      *  "Releases all held calls or sets User Determined User Busy (UDUB)
856      *   for a waiting call."
857      *  ar.exception carries exception on failure
858      *  ar.userObject contains the orignal value of result.obj
859      *  ar.result is null on success and failure
860      */
861     void hangupWaitingOrBackground (Message result);
862
863     /**
864      * 3GPP 22.030 6.5.5
865      * "Releases all active calls (if any exist) and accepts
866      *  the other (held or waiting) call."
867      *
868      *  ar.exception carries exception on failure
869      *  ar.userObject contains the orignal value of result.obj
870      *  ar.result is null on success and failure
871      */
872     void hangupForegroundResumeBackground (Message result);
873
874     /**
875      * 3GPP 22.030 6.5.5
876      * "Places all active calls (if any exist) on hold and accepts
877      *  the other (held or waiting) call."
878      *
879      *  ar.exception carries exception on failure
880      *  ar.userObject contains the orignal value of result.obj
881      *  ar.result is null on success and failure
882      */
883     void switchWaitingOrHoldingAndActive (Message result);
884
885     /**
886      * 3GPP 22.030 6.5.5
887      * "Adds a held call to the conversation"
888      *
889      *  ar.exception carries exception on failure
890      *  ar.userObject contains the orignal value of result.obj
891      *  ar.result is null on success and failure
892      */
893     void conference (Message result);
894
895     /**
896      * Set preferred Voice Privacy (VP).
897      *
898      * @param enable true is enhanced and false is normal VP
899      * @param result is a callback message
900      */
901     void setPreferredVoicePrivacy(boolean enable, Message result);
902
903     /**
904      * Get currently set preferred Voice Privacy (VP) mode.
905      *
906      * @param result is a callback message
907      */
908     void getPreferredVoicePrivacy(Message result);
909
910     /**
911      * 3GPP 22.030 6.5.5
912      * "Places all active calls on hold except call X with which
913      *  communication shall be supported."
914      */
915     void separateConnection (int gsmIndex, Message result);
916
917     /**
918      *
919      *  ar.exception carries exception on failure
920      *  ar.userObject contains the orignal value of result.obj
921      *  ar.result is null on success and failure
922      */
923     void acceptCall (Message result);
924
925     /**
926      *  also known as UDUB
927      *  ar.exception carries exception on failure
928      *  ar.userObject contains the orignal value of result.obj
929      *  ar.result is null on success and failure
930      */
931     void rejectCall (Message result);
932
933     /**
934      * 3GPP 22.030 6.5.5
935      * "Connects the two calls and disconnects the subscriber from both calls"
936      *
937      *  ar.exception carries exception on failure
938      *  ar.userObject contains the orignal value of result.obj
939      *  ar.result is null on success and failure
940      */
941     void explicitCallTransfer (Message result);
942
943     /**
944      * cause code returned as int[0] in Message.obj.response
945      * Returns integer cause code defined in TS 24.008
946      * Annex H or closest approximation.
947      * Most significant codes:
948      * - Any defined in 22.001 F.4 (for generating busy/congestion)
949      * - Cause 68: ACM >= ACMMax
950      */
951     void getLastCallFailCause (Message result);
952
953
954     /**
955      * Reason for last PDP context deactivate or failure to activate
956      * cause code returned as int[0] in Message.obj.response
957      * returns an integer cause code defined in TS 24.008
958      * section 6.1.3.1.3 or close approximation
959      * @deprecated Do not use.
960      */
961     @Deprecated
962     void getLastPdpFailCause (Message result);
963
964     /**
965      * The preferred new alternative to getLastPdpFailCause
966      * that is also CDMA-compatible.
967      */
968     void getLastDataCallFailCause (Message result);
969
970     void setMute (boolean enableMute, Message response);
971
972     void getMute (Message response);
973
974     /**
975      * response.obj is an AsyncResult
976      * response.obj.result is an int[2]
977      * response.obj.result[0] is received signal strength (0-31, 99)
978      * response.obj.result[1] is  bit error rate (0-7, 99)
979      * as defined in TS 27.007 8.5
980      */
981     void getSignalStrength (Message response);
982
983
984     /**
985      * response.obj.result is an int[3]
986      * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2
987      * response.obj.result[1] is LAC if registered or -1 if not
988      * response.obj.result[2] is CID if registered or -1 if not
989      * valid LAC and CIDs are 0x0000 - 0xffff
990      *
991      * Please note that registration state 4 ("unknown") is treated
992      * as "out of service" above
993      */
994     void getVoiceRegistrationState (Message response);
995
996     /**
997      * response.obj.result is an int[3]
998      * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2
999      * response.obj.result[1] is LAC if registered or -1 if not
1000      * response.obj.result[2] is CID if registered or -1 if not
1001      * valid LAC and CIDs are 0x0000 - 0xffff
1002      *
1003      * Please note that registration state 4 ("unknown") is treated
1004      * as "out of service" above
1005      */
1006     void getDataRegistrationState (Message response);
1007
1008     /**
1009      * response.obj.result is a String[3]
1010      * response.obj.result[0] is long alpha or null if unregistered
1011      * response.obj.result[1] is short alpha or null if unregistered
1012      * response.obj.result[2] is numeric or null if unregistered
1013      */
1014     void getOperator(Message response);
1015
1016     /**
1017      *  ar.exception carries exception on failure
1018      *  ar.userObject contains the orignal value of result.obj
1019      *  ar.result is null on success and failure
1020      */
1021     void sendDtmf(char c, Message result);
1022
1023
1024     /**
1025      *  ar.exception carries exception on failure
1026      *  ar.userObject contains the orignal value of result.obj
1027      *  ar.result is null on success and failure
1028      */
1029     void startDtmf(char c, Message result);
1030
1031     /**
1032      *  ar.exception carries exception on failure
1033      *  ar.userObject contains the orignal value of result.obj
1034      *  ar.result is null on success and failure
1035      */
1036     void stopDtmf(Message result);
1037
1038     /**
1039      *  ar.exception carries exception on failure
1040      *  ar.userObject contains the orignal value of result.obj
1041      *  ar.result is null on success and failure
1042      */
1043     void sendBurstDtmf(String dtmfString, int on, int off, Message result);
1044
1045     /**
1046      * smscPDU is smsc address in PDU form GSM BCD format prefixed
1047      *      by a length byte (as expected by TS 27.005) or NULL for default SMSC
1048      * pdu is SMS in PDU format as an ASCII hex string
1049      *      less the SMSC address
1050      */
1051     void sendSMS (String smscPDU, String pdu, Message response);
1052
1053     /**
1054      * @param pdu is CDMA-SMS in internal pseudo-PDU format
1055      * @param response sent when operation completes
1056      */
1057     void sendCdmaSms(byte[] pdu, Message response);
1058
1059     /**
1060      * send SMS over IMS with 3GPP/GSM SMS format
1061      * @param smscPDU is smsc address in PDU form GSM BCD format prefixed
1062      *      by a length byte (as expected by TS 27.005) or NULL for default SMSC
1063      * @param pdu is SMS in PDU format as an ASCII hex string
1064      *      less the SMSC address
1065      * @param retry indicates if this is a retry; 0 == not retry, nonzero = retry
1066      * @param messageRef valid field if retry is set to nonzero.
1067      *        Contains messageRef from RIL_SMS_Response corresponding to failed MO SMS
1068      * @param response sent when operation completes
1069      */
1070     void sendImsGsmSms (String smscPDU, String pdu, int retry, int messageRef,
1071             Message response);
1072
1073     /**
1074      * send SMS over IMS with 3GPP2/CDMA SMS format
1075      * @param pdu is CDMA-SMS in internal pseudo-PDU format
1076      * @param response sent when operation completes
1077      * @param retry indicates if this is a retry; 0 == not retry, nonzero = retry
1078      * @param messageRef valid field if retry is set to nonzero.
1079      *        Contains messageRef from RIL_SMS_Response corresponding to failed MO SMS
1080      * @param response sent when operation completes
1081      */
1082     void sendImsCdmaSms(byte[] pdu, int retry, int messageRef, Message response);
1083
1084     /**
1085      * Deletes the specified SMS record from SIM memory (EF_SMS).
1086      *
1087      * @param index index of the SMS record to delete
1088      * @param response sent when operation completes
1089      */
1090     void deleteSmsOnSim(int index, Message response);
1091
1092     /**
1093      * Deletes the specified SMS record from RUIM memory (EF_SMS in DF_CDMA).
1094      *
1095      * @param index index of the SMS record to delete
1096      * @param response sent when operation completes
1097      */
1098     void deleteSmsOnRuim(int index, Message response);
1099
1100     /**
1101      * Writes an SMS message to SIM memory (EF_SMS).
1102      *
1103      * @param status status of message on SIM.  One of:
1104      *                  SmsManger.STATUS_ON_ICC_READ
1105      *                  SmsManger.STATUS_ON_ICC_UNREAD
1106      *                  SmsManger.STATUS_ON_ICC_SENT
1107      *                  SmsManger.STATUS_ON_ICC_UNSENT
1108      * @param pdu message PDU, as hex string
1109      * @param response sent when operation completes.
1110      *                  response.obj will be an AsyncResult, and will indicate
1111      *                  any error that may have occurred (eg, out of memory).
1112      */
1113     void writeSmsToSim(int status, String smsc, String pdu, Message response);
1114
1115     void writeSmsToRuim(int status, String pdu, Message response);
1116
1117     void setRadioPower(boolean on, Message response);
1118
1119     void acknowledgeLastIncomingGsmSms(boolean success, int cause, Message response);
1120
1121     void acknowledgeLastIncomingCdmaSms(boolean success, int cause, Message response);
1122
1123     /**
1124      * Acknowledge successful or failed receipt of last incoming SMS,
1125      * including acknowledgement TPDU to send as the RP-User-Data element
1126      * of the RP-ACK or RP-ERROR PDU.
1127      *
1128      * @param success true to send RP-ACK, false to send RP-ERROR
1129      * @param ackPdu the acknowledgement TPDU in hexadecimal format
1130      * @param response sent when operation completes.
1131      */
1132     void acknowledgeIncomingGsmSmsWithPdu(boolean success, String ackPdu, Message response);
1133
1134     /**
1135      * parameters equivalent to 27.007 AT+CRSM command
1136      * response.obj will be an AsyncResult
1137      * response.obj.result will be an IccIoResult on success
1138      */
1139     void iccIO (int command, int fileid, String path, int p1, int p2, int p3,
1140             String data, String pin2, Message response);
1141
1142     /**
1143      * parameters equivalent to 27.007 AT+CRSM command
1144      * response.obj will be an AsyncResult
1145      * response.obj.userObj will be a IccIoResult on success
1146      */
1147     void iccIOForApp (int command, int fileid, String path, int p1, int p2, int p3,
1148             String data, String pin2, String aid, Message response);
1149
1150     /**
1151      * (AsyncResult)response.obj).result is an int[] with element [0] set to
1152      * 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned".
1153      *
1154      * @param response is callback message
1155      */
1156
1157     void queryCLIP(Message response);
1158
1159     /**
1160      * response.obj will be a an int[2]
1161      *
1162      * response.obj[0] will be TS 27.007 +CLIR parameter 'n'
1163      *  0 presentation indicator is used according to the subscription of the CLIR service
1164      *  1 CLIR invocation
1165      *  2 CLIR suppression
1166      *
1167      * response.obj[1] will be TS 27.007 +CLIR parameter 'm'
1168      *  0 CLIR not provisioned
1169      *  1 CLIR provisioned in permanent mode
1170      *  2 unknown (e.g. no network, etc.)
1171      *  3 CLIR temporary mode presentation restricted
1172      *  4 CLIR temporary mode presentation allowed
1173      */
1174
1175     void getCLIR(Message response);
1176
1177     /**
1178      * clirMode is one of the CLIR_* constants above
1179      *
1180      * response.obj is null
1181      */
1182
1183     void setCLIR(int clirMode, Message response);
1184
1185     /**
1186      * (AsyncResult)response.obj).result is an int[] with element [0] set to
1187      * 0 for disabled, 1 for enabled.
1188      *
1189      * @param serviceClass is a sum of SERVICE_CLASS_*
1190      * @param response is callback message
1191      */
1192
1193     void queryCallWaiting(int serviceClass, Message response);
1194
1195     /**
1196      * @param enable is true to enable, false to disable
1197      * @param serviceClass is a sum of SERVICE_CLASS_*
1198      * @param response is callback message
1199      */
1200
1201     void setCallWaiting(boolean enable, int serviceClass, Message response);
1202
1203     /**
1204      * @param action is one of CF_ACTION_*
1205      * @param cfReason is one of CF_REASON_*
1206      * @param serviceClass is a sum of SERVICE_CLASSS_*
1207      */
1208     void setCallForward(int action, int cfReason, int serviceClass,
1209                 String number, int timeSeconds, Message response);
1210
1211     /**
1212      * cfReason is one of CF_REASON_*
1213      *
1214      * ((AsyncResult)response.obj).result will be an array of
1215      * CallForwardInfo's
1216      *
1217      * An array of length 0 means "disabled for all codes"
1218      */
1219     void queryCallForwardStatus(int cfReason, int serviceClass,
1220             String number, Message response);
1221
1222     void setNetworkSelectionModeAutomatic(Message response);
1223
1224     void setNetworkSelectionModeManual(String operatorNumeric, Message response);
1225
1226     /**
1227      * Queries whether the current network selection mode is automatic
1228      * or manual
1229      *
1230      * ((AsyncResult)response.obj).result  is an int[] with element [0] being
1231      * a 0 for automatic selection and a 1 for manual selection
1232      */
1233
1234     void getNetworkSelectionMode(Message response);
1235
1236     /**
1237      * Queries the currently available networks
1238      *
1239      * ((AsyncResult)response.obj).result  is a List of NetworkInfo objects
1240      */
1241     void getAvailableNetworks(Message response);
1242
1243     void getBasebandVersion (Message response);
1244
1245
1246     /**
1247      * (AsyncResult)response.obj).result will be an Integer representing
1248      * the sum of enabled service classes (sum of SERVICE_CLASS_*)
1249      *
1250      * @param facility one of CB_FACILTY_*
1251      * @param password password or "" if not required
1252      * @param serviceClass is a sum of SERVICE_CLASS_*
1253      * @param response is callback message
1254      */
1255
1256     void queryFacilityLock (String facility, String password, int serviceClass,
1257         Message response);
1258
1259     /**
1260      * (AsyncResult)response.obj).result will be an Integer representing
1261      * the sum of enabled service classes (sum of SERVICE_CLASS_*) for the
1262      * application with appId.
1263      *
1264      * @param facility one of CB_FACILTY_*
1265      * @param password password or "" if not required
1266      * @param serviceClass is a sum of SERVICE_CLASS_*
1267      * @param appId is application Id or null if none
1268      * @param response is callback message
1269      */
1270
1271     void queryFacilityLockForApp(String facility, String password, int serviceClass, String appId,
1272         Message response);
1273
1274     /**
1275      * @param facility one of CB_FACILTY_*
1276      * @param lockState true means lock, false means unlock
1277      * @param password password or "" if not required
1278      * @param serviceClass is a sum of SERVICE_CLASS_*
1279      * @param response is callback message
1280      */
1281     void setFacilityLock (String facility, boolean lockState, String password,
1282         int serviceClass, Message response);
1283
1284     /**
1285      * Set the facility lock for the app with this AID on the ICC card.
1286      *
1287      * @param facility one of CB_FACILTY_*
1288      * @param lockState true means lock, false means unlock
1289      * @param password password or "" if not required
1290      * @param serviceClass is a sum of SERVICE_CLASS_*
1291      * @param appId is application Id or null if none
1292      * @param response is callback message
1293      */
1294     void setFacilityLockForApp(String facility, boolean lockState, String password,
1295         int serviceClass, String appId, Message response);
1296
1297     void sendUSSD (String ussdString, Message response);
1298
1299     /**
1300      * Cancels a pending USSD session if one exists.
1301      * @param response callback message
1302      */
1303     void cancelPendingUssd (Message response);
1304
1305     void resetRadio(Message result);
1306
1307     /**
1308      * Assign a specified band for RF configuration.
1309      *
1310      * @param bandMode one of BM_*_BAND
1311      * @param response is callback message
1312      */
1313     void setBandMode (int bandMode, Message response);
1314
1315     /**
1316      * Query the list of band mode supported by RF.
1317      *
1318      * @param response is callback message
1319      *        ((AsyncResult)response.obj).result  is an int[] where int[0] is
1320      *        the size of the array and the rest of each element representing
1321      *        one available BM_*_BAND
1322      */
1323     void queryAvailableBandMode (Message response);
1324
1325     /**
1326      *  Requests to set the preferred network type for searching and registering
1327      * (CS/PS domain, RAT, and operation mode)
1328      * @param networkType one of  NT_*_TYPE
1329      * @param response is callback message
1330      */
1331     void setPreferredNetworkType(int networkType , Message response);
1332
1333      /**
1334      *  Query the preferred network type setting
1335      *
1336      * @param response is callback message to report one of  NT_*_TYPE
1337      */
1338     void getPreferredNetworkType(Message response);
1339
1340     /**
1341      * Query neighboring cell ids
1342      *
1343      * @param response s callback message to cell ids
1344      */
1345     void getNeighboringCids(Message response);
1346
1347     /**
1348      * Request to enable/disable network state change notifications when
1349      * location information (lac and/or cid) has changed.
1350      *
1351      * @param enable true to enable, false to disable
1352      * @param response callback message
1353      */
1354     void setLocationUpdates(boolean enable, Message response);
1355
1356     /**
1357      * Gets the default SMSC address.
1358      *
1359      * @param result Callback message contains the SMSC address.
1360      */
1361     void getSmscAddress(Message result);
1362
1363     /**
1364      * Sets the default SMSC address.
1365      *
1366      * @param address new SMSC address
1367      * @param result Callback message is empty on completion
1368      */
1369     void setSmscAddress(String address, Message result);
1370
1371     /**
1372      * Indicates whether there is storage available for new SMS messages.
1373      * @param available true if storage is available
1374      * @param result callback message
1375      */
1376     void reportSmsMemoryStatus(boolean available, Message result);
1377
1378     /**
1379      * Indicates to the vendor ril that StkService is running
1380      * and is ready to receive RIL_UNSOL_STK_XXXX commands.
1381      *
1382      * @param result callback message
1383      */
1384     void reportStkServiceIsRunning(Message result);
1385
1386     void invokeOemRilRequestRaw(byte[] data, Message response);
1387
1388     void invokeOemRilRequestStrings(String[] strings, Message response);
1389
1390
1391     /**
1392      * Send TERMINAL RESPONSE to the SIM, after processing a proactive command
1393      * sent by the SIM.
1394      *
1395      * @param contents  String containing SAT/USAT response in hexadecimal
1396      *                  format starting with first byte of response data. See
1397      *                  TS 102 223 for details.
1398      * @param response  Callback message
1399      */
1400     public void sendTerminalResponse(String contents, Message response);
1401
1402     /**
1403      * Send ENVELOPE to the SIM, after processing a proactive command sent by
1404      * the SIM.
1405      *
1406      * @param contents  String containing SAT/USAT response in hexadecimal
1407      *                  format starting with command tag. See TS 102 223 for
1408      *                  details.
1409      * @param response  Callback message
1410      */
1411     public void sendEnvelope(String contents, Message response);
1412
1413     /**
1414      * Send ENVELOPE to the SIM, such as an SMS-PP data download envelope
1415      * for a SIM data download message. This method has one difference
1416      * from {@link #sendEnvelope}: The SW1 and SW2 status bytes from the UICC response
1417      * are returned along with the response data.
1418      *
1419      * response.obj will be an AsyncResult
1420      * response.obj.result will be an IccIoResult on success
1421      *
1422      * @param contents  String containing SAT/USAT response in hexadecimal
1423      *                  format starting with command tag. See TS 102 223 for
1424      *                  details.
1425      * @param response  Callback message
1426      */
1427     public void sendEnvelopeWithStatus(String contents, Message response);
1428
1429     /**
1430      * Accept or reject the call setup request from SIM.
1431      *
1432      * @param accept   true if the call is to be accepted, false otherwise.
1433      * @param response Callback message
1434      */
1435     public void handleCallSetupRequestFromSim(boolean accept, Message response);
1436
1437     /**
1438      * Activate or deactivate cell broadcast SMS for GSM.
1439      *
1440      * @param activate
1441      *            true = activate, false = deactivate
1442      * @param result Callback message is empty on completion
1443      */
1444     public void setGsmBroadcastActivation(boolean activate, Message result);
1445
1446     /**
1447      * Configure cell broadcast SMS for GSM.
1448      *
1449      * @param response Callback message is empty on completion
1450      */
1451     public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response);
1452
1453     /**
1454      * Query the current configuration of cell broadcast SMS of GSM.
1455      *
1456      * @param response
1457      *        Callback message contains the configuration from the modem
1458      *        on completion
1459      */
1460     public void getGsmBroadcastConfig(Message response);
1461
1462     //***** new Methods for CDMA support
1463
1464     /**
1465      * Request the device ESN / MEID / IMEI / IMEISV.
1466      * "response" is const char **
1467      *   [0] is IMEI if GSM subscription is available
1468      *   [1] is IMEISV if GSM subscription is available
1469      *   [2] is ESN if CDMA subscription is available
1470      *   [3] is MEID if CDMA subscription is available
1471      */
1472     public void getDeviceIdentity(Message response);
1473
1474     /**
1475      * Request the device MDN / H_SID / H_NID / MIN.
1476      * "response" is const char **
1477      *   [0] is MDN if CDMA subscription is available
1478      *   [1] is a comma separated list of H_SID (Home SID) in decimal format
1479      *       if CDMA subscription is available
1480      *   [2] is a comma separated list of H_NID (Home NID) in decimal format
1481      *       if CDMA subscription is available
1482      *   [3] is MIN (10 digits, MIN2+MIN1) if CDMA subscription is available
1483      */
1484     public void getCDMASubscription(Message response);
1485
1486     /**
1487      * Send Flash Code.
1488      * "response" is is NULL
1489      *   [0] is a FLASH string
1490      */
1491     public void sendCDMAFeatureCode(String FeatureCode, Message response);
1492
1493     /** Set the Phone type created */
1494     void setPhoneType(int phoneType);
1495
1496     /**
1497      *  Query the CDMA roaming preference setting
1498      *
1499      * @param response is callback message to report one of  CDMA_RM_*
1500      */
1501     void queryCdmaRoamingPreference(Message response);
1502
1503     /**
1504      *  Requests to set the CDMA roaming preference
1505      * @param cdmaRoamingType one of  CDMA_RM_*
1506      * @param response is callback message
1507      */
1508     void setCdmaRoamingPreference(int cdmaRoamingType, Message response);
1509
1510     /**
1511      *  Requests to set the CDMA subscription mode
1512      * @param cdmaSubscriptionType one of  CDMA_SUBSCRIPTION_*
1513      * @param response is callback message
1514      */
1515     void setCdmaSubscriptionSource(int cdmaSubscriptionType, Message response);
1516
1517     /**
1518      *  Requests to get the CDMA subscription srouce
1519      * @param response is callback message
1520      */
1521     void getCdmaSubscriptionSource(Message response);
1522
1523     /**
1524      *  Set the TTY mode
1525      *
1526      * @param ttyMode one of the following:
1527      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
1528      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
1529      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
1530      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
1531      * @param response is callback message
1532      */
1533     void setTTYMode(int ttyMode, Message response);
1534
1535     /**
1536      *  Query the TTY mode
1537      * (AsyncResult)response.obj).result is an int[] with element [0] set to
1538      * tty mode:
1539      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
1540      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
1541      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
1542      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
1543      * @param response is callback message
1544      */
1545     void queryTTYMode(Message response);
1546
1547     /**
1548      * Setup a packet data connection On successful completion, the result
1549      * message will return a {@link com.android.internal.telephony.dataconnection.DataCallResponse}
1550      * object containing the connection information.
1551      *
1552      * @param radioTechnology
1553      *            indicates whether to setup connection on radio technology CDMA
1554      *            (0) or GSM/UMTS (1)
1555      * @param profile
1556      *            Profile Number or NULL to indicate default profile
1557      * @param apn
1558      *            the APN to connect to if radio technology is GSM/UMTS.
1559      *            Otherwise null for CDMA.
1560      * @param user
1561      *            the username for APN, or NULL
1562      * @param password
1563      *            the password for APN, or NULL
1564      * @param authType
1565      *            the PAP / CHAP auth type. Values is one of SETUP_DATA_AUTH_*
1566      * @param protocol
1567      *            one of the PDP_type values in TS 27.007 section 10.1.1.
1568      *            For example, "IP", "IPV6", "IPV4V6", or "PPP".
1569      * @param result
1570      *            Callback message
1571      */
1572     public void setupDataCall(String radioTechnology, String profile,
1573             String apn, String user, String password, String authType,
1574             String protocol, Message result);
1575
1576     /**
1577      * Deactivate packet data connection
1578      *
1579      * @param cid
1580      *            The connection ID
1581      * @param reason
1582      *            Data disconnect reason.
1583      * @param result
1584      *            Callback message is empty on completion
1585      */
1586     public void deactivateDataCall(int cid, int reason, Message result);
1587
1588     /**
1589      * Activate or deactivate cell broadcast SMS for CDMA.
1590      *
1591      * @param activate
1592      *            true = activate, false = deactivate
1593      * @param result
1594      *            Callback message is empty on completion
1595      */
1596     public void setCdmaBroadcastActivation(boolean activate, Message result);
1597
1598     /**
1599      * Configure cdma cell broadcast SMS.
1600      *
1601      * @param response
1602      *            Callback message is empty on completion
1603      */
1604     public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response);
1605
1606     /**
1607      * Query the current configuration of cdma cell broadcast SMS.
1608      *
1609      * @param result
1610      *            Callback message contains the configuration from the modem on completion
1611      */
1612     public void getCdmaBroadcastConfig(Message result);
1613
1614     /**
1615      *  Requests the radio's system selection module to exit emergency callback mode.
1616      *  This function should only be called from CDMAPHone.java.
1617      *
1618      * @param response callback message
1619      */
1620     public void exitEmergencyCallbackMode(Message response);
1621
1622     /**
1623      * Request the status of the ICC and UICC cards.
1624      *
1625      * @param result
1626      *          Callback message containing {@link IccCardStatus} structure for the card.
1627      */
1628     public void getIccCardStatus(Message result);
1629
1630     /**
1631      * Return if the current radio is LTE on CDMA. This
1632      * is a tri-state return value as for a period of time
1633      * the mode may be unknown.
1634      *
1635      * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE}
1636      * or {@link PhoneConstants#LTE_ON_CDMA_TRUE}
1637      */
1638     public int getLteOnCdmaMode();
1639
1640     /**
1641      * Request the ISIM application on the UICC to perform the AKA
1642      * challenge/response algorithm for IMS authentication. The nonce string
1643      * and challenge response are Base64 encoded Strings.
1644      *
1645      * @param nonce the nonce string to pass with the ISIM authentication request
1646      * @param response a callback message with the String response in the obj field
1647      * @deprecated
1648      * @see requestIccSimAuthentication
1649      */
1650     public void requestIsimAuthentication(String nonce, Message response);
1651
1652     /**
1653      * Request the SIM application on the UICC to perform authentication
1654      * challenge/response algorithm. The data string and challenge response are
1655      * Base64 encoded Strings.
1656      * Can support EAP-SIM, EAP-AKA with results encoded per 3GPP TS 31.102.
1657      *
1658      * @param authContext is the P2 parameter that specifies the authentication context per 3GPP TS
1659      *                    31.102 (Section 7.1.2)
1660      * @param data authentication challenge data
1661      * @param aid used to determine which application/slot to send the auth command to. See ETSI
1662      *            102.221 8.1 and 101.220 4
1663      * @param response a callback message with the String response in the obj field
1664      */
1665     public void requestIccSimAuthentication(int authContext, String data, String aid, Message response);
1666
1667     /**
1668      * Get the current Voice Radio Technology.
1669      *
1670      * AsyncResult.result is an int array with the first value
1671      * being one of the ServiceState.RIL_RADIO_TECHNOLOGY_xxx values.
1672      *
1673      * @param result is sent back to handler and result.obj is a AsyncResult
1674      */
1675     void getVoiceRadioTechnology(Message result);
1676
1677     /**
1678      * Return the current set of CellInfo records
1679      *
1680      * AsyncResult.result is a of Collection<CellInfo>
1681      *
1682      * @param result is sent back to handler and result.obj is a AsyncResult
1683      */
1684     void getCellInfoList(Message result);
1685
1686     /**
1687      * Sets the minimum time in milli-seconds between when RIL_UNSOL_CELL_INFO_LIST
1688      * should be invoked.
1689      *
1690      * The default, 0, means invoke RIL_UNSOL_CELL_INFO_LIST when any of the reported
1691      * information changes. Setting the value to INT_MAX(0x7fffffff) means never issue
1692      * A RIL_UNSOL_CELL_INFO_LIST.
1693      *
1694      *
1695
1696      * @param rateInMillis is sent back to handler and result.obj is a AsyncResult
1697      * @param response.obj is AsyncResult ar when sent to associated handler
1698      *                        ar.exception carries exception on failure or null on success
1699      *                        otherwise the error.
1700      */
1701     void setCellInfoListRate(int rateInMillis, Message response);
1702
1703     /**
1704      * Fires when RIL_UNSOL_CELL_INFO_LIST is received from the RIL.
1705      */
1706     void registerForCellInfoList(Handler h, int what, Object obj);
1707     void unregisterForCellInfoList(Handler h);
1708
1709     /**
1710      * Set Initial Attach Apn
1711      *
1712      * @param apn
1713      *            the APN to connect to if radio technology is GSM/UMTS.
1714      * @param protocol
1715      *            one of the PDP_type values in TS 27.007 section 10.1.1.
1716      *            For example, "IP", "IPV6", "IPV4V6", or "PPP".
1717      * @param authType
1718      *            authentication protocol used for this PDP context
1719      *            (None: 0, PAP: 1, CHAP: 2, PAP&CHAP: 3)
1720      * @param username
1721      *            the username for APN, or NULL
1722      * @param password
1723      *            the password for APN, or NULL
1724      * @param result
1725      *            callback message contains the information of SUCCESS/FAILURE
1726      */
1727     public void setInitialAttachApn(String apn, String protocol, int authType, String username,
1728             String password, Message result);
1729
1730     /**
1731      * Notifiy that we are testing an emergency call
1732      */
1733     public void testingEmergencyCall();
1734
1735     /**
1736      * Open a logical channel to the SIM.
1737      *
1738      * Input parameters equivalent to TS 27.007 AT+CCHO command.
1739      *
1740      * @param AID Application id. See ETSI 102.221 and 101.220.
1741      * @param response Callback message. response.obj will be an int [1] with
1742      *            element [0] set to the id of the logical channel.
1743      */
1744     public void iccOpenLogicalChannel(String AID, Message response);
1745
1746     /**
1747      * Close a previously opened logical channel to the SIM.
1748      *
1749      * Input parameters equivalent to TS 27.007 AT+CCHC command.
1750      *
1751      * @param channel Channel id. Id of the channel to be closed.
1752      * @param response Callback message.
1753      */
1754     public void iccCloseLogicalChannel(int channel, Message response);
1755
1756     /**
1757      * Exchange APDUs with the SIM on a logical channel.
1758      *
1759      * Input parameters equivalent to TS 27.007 AT+CGLA command.
1760      *
1761      * @param channel Channel id of the channel to use for communication. Has to
1762      *            be greater than zero.
1763      * @param cla Class of the APDU command.
1764      * @param instruction Instruction of the APDU command.
1765      * @param p1 P1 value of the APDU command.
1766      * @param p2 P2 value of the APDU command.
1767      * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU
1768      *            is sent to the SIM.
1769      * @param data Data to be sent with the APDU.
1770      * @param response Callback message. response.obj.userObj will be
1771      *            an IccIoResult on success.
1772      */
1773     public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction,
1774             int p1, int p2, int p3, String data, Message response);
1775
1776     /**
1777      * Exchange APDUs with the SIM on a basic channel.
1778      *
1779      * Input parameters equivalent to TS 27.007 AT+CSIM command.
1780      *
1781      * @param cla Class of the APDU command.
1782      * @param instruction Instruction of the APDU command.
1783      * @param p1 P1 value of the APDU command.
1784      * @param p2 P2 value of the APDU command.
1785      * @param p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU
1786      *            is sent to the SIM.
1787      * @param data Data to be sent with the APDU.
1788      * @param response Callback message. response.obj.userObj will be
1789      *            an IccIoResult on success.
1790      */
1791     public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2,
1792             int p3, String data, Message response);
1793
1794     /**
1795      * Read one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}.
1796      * Used for device configuration by some CDMA operators.
1797      *
1798      * @param itemID the ID of the item to read
1799      * @param response callback message with the String response in the obj field
1800      */
1801     void nvReadItem(int itemID, Message response);
1802
1803     /**
1804      * Write one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}.
1805      * Used for device configuration by some CDMA operators.
1806      *
1807      * @param itemID the ID of the item to read
1808      * @param itemValue the value to write, as a String
1809      * @param response Callback message.
1810      */
1811     void nvWriteItem(int itemID, String itemValue, Message response);
1812
1813     /**
1814      * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
1815      * Used for device configuration by some CDMA operators.
1816      *
1817      * @param preferredRoamingList byte array containing the new PRL
1818      * @param response Callback message.
1819      */
1820     void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response);
1821
1822     /**
1823      * Perform the specified type of NV config reset. The radio will be taken offline
1824      * and the device must be rebooted after erasing the NV. Used for device
1825      * configuration by some CDMA operators.
1826      *
1827      * @param resetType reset type: 1: reload NV reset, 2: erase NV reset, 3: factory NV reset
1828      * @param response Callback message.
1829      */
1830     void nvResetConfig(int resetType, Message response);
1831
1832     /**
1833      *  returned message
1834      *  retMsg.obj = AsyncResult ar
1835      *  ar.exception carries exception on failure
1836      *  ar.userObject contains the orignal value of result.obj
1837      *  ar.result contains a List of HardwareConfig
1838      */
1839     void getHardwareConfig (Message result);
1840
1841     /**
1842      * @return version of the ril.
1843      */
1844     int getRilVersion();
1845
1846    /**
1847      * Sets user selected subscription at Modem.
1848      *
1849      * @param slotId
1850      *          Slot.
1851      * @param appIndex
1852      *          Application index in the card.
1853      * @param subId
1854      *          Indicates subscription 0 or subscription 1.
1855      * @param subStatus
1856      *          Activation status, 1 = activate and 0 = deactivate.
1857      * @param result
1858      *          Callback message contains the information of SUCCESS/FAILURE.
1859      */
1860     // FIXME Update the doc and consider modifying the request to make more generic.
1861     public void setUiccSubscription(int slotId, int appIndex, int subId, int subStatus,
1862             Message result);
1863
1864     /**
1865      * Tells the modem if data is allowed or not.
1866      *
1867      * @param allowed
1868      *          true = allowed, false = not alowed
1869      * @param result
1870      *          Callback message contains the information of SUCCESS/FAILURE.
1871      */
1872     // FIXME We may need to pass AID and slotid also
1873     public void setDataAllowed(boolean allowed, Message result);
1874 }