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