RIL changes for supporting generic SIM communication.
[android/platform/frameworks/opt/telephony.git] / src / java / com / android / internal / telephony / test / SimulatedCommands.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.test;
19
20 import android.os.AsyncResult;
21 import android.os.HandlerThread;
22 import android.os.Looper;
23 import android.os.Message;
24 import android.telephony.Rlog;
25
26 import com.android.internal.telephony.BaseCommands;
27 import com.android.internal.telephony.CommandException;
28 import com.android.internal.telephony.CommandsInterface;
29 import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
30 import com.android.internal.telephony.dataconnection.DataCallResponse;
31 import com.android.internal.telephony.Phone;
32 import com.android.internal.telephony.UUSInfo;
33 import com.android.internal.telephony.gsm.CallFailCause;
34 import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
35 import com.android.internal.telephony.gsm.SuppServiceNotification;
36
37 import java.util.ArrayList;
38
39 public final class SimulatedCommands extends BaseCommands
40         implements CommandsInterface, SimulatedRadioControl {
41     private final static String LOG_TAG = "SimulatedCommands";
42
43     private enum SimLockState {
44         NONE,
45         REQUIRE_PIN,
46         REQUIRE_PUK,
47         SIM_PERM_LOCKED
48     }
49
50     private enum SimFdnState {
51         NONE,
52         REQUIRE_PIN2,
53         REQUIRE_PUK2,
54         SIM_PERM_LOCKED
55     }
56
57     private final static SimLockState INITIAL_LOCK_STATE = SimLockState.NONE;
58     private final static String DEFAULT_SIM_PIN_CODE = "1234";
59     private final static String SIM_PUK_CODE = "12345678";
60     private final static SimFdnState INITIAL_FDN_STATE = SimFdnState.NONE;
61     private final static String DEFAULT_SIM_PIN2_CODE = "5678";
62     private final static String SIM_PUK2_CODE = "87654321";
63
64     //***** Instance Variables
65
66     SimulatedGsmCallState simulatedCallState;
67     HandlerThread mHandlerThread;
68     SimLockState mSimLockedState;
69     boolean mSimLockEnabled;
70     int mPinUnlockAttempts;
71     int mPukUnlockAttempts;
72     String mPinCode;
73     SimFdnState mSimFdnEnabledState;
74     boolean mSimFdnEnabled;
75     int mPin2UnlockAttempts;
76     int mPuk2UnlockAttempts;
77     int mNetworkType;
78     String mPin2Code;
79     boolean mSsnNotifyOn = false;
80
81     int mPausedResponseCount;
82     ArrayList<Message> mPausedResponses = new ArrayList<Message>();
83
84     int mNextCallFailCause = CallFailCause.NORMAL_CLEARING;
85
86     //***** Constructor
87
88     public
89     SimulatedCommands() {
90         super(null);  // Don't log statistics
91         mHandlerThread = new HandlerThread("SimulatedCommands");
92         mHandlerThread.start();
93         Looper looper = mHandlerThread.getLooper();
94
95         simulatedCallState = new SimulatedGsmCallState(looper);
96
97         setRadioState(RadioState.RADIO_OFF);
98         mSimLockedState = INITIAL_LOCK_STATE;
99         mSimLockEnabled = (mSimLockedState != SimLockState.NONE);
100         mPinCode = DEFAULT_SIM_PIN_CODE;
101         mSimFdnEnabledState = INITIAL_FDN_STATE;
102         mSimFdnEnabled = (mSimFdnEnabledState != SimFdnState.NONE);
103         mPin2Code = DEFAULT_SIM_PIN2_CODE;
104     }
105
106     //***** CommandsInterface implementation
107
108     @Override
109     public void getIccCardStatus(Message result) {
110         unimplemented(result);
111     }
112
113     @Override
114     public void supplyIccPin(String pin, Message result)  {
115         if (mSimLockedState != SimLockState.REQUIRE_PIN) {
116             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: wrong state, state=" +
117                     mSimLockedState);
118             CommandException ex = new CommandException(
119                     CommandException.Error.PASSWORD_INCORRECT);
120             AsyncResult.forMessage(result, null, ex);
121             result.sendToTarget();
122             return;
123         }
124
125         if (pin != null && pin.equals(mPinCode)) {
126             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: success!");
127             mPinUnlockAttempts = 0;
128             mSimLockedState = SimLockState.NONE;
129             mIccStatusChangedRegistrants.notifyRegistrants();
130
131             if (result != null) {
132                 AsyncResult.forMessage(result, null, null);
133                 result.sendToTarget();
134             }
135
136             return;
137         }
138
139         if (result != null) {
140             mPinUnlockAttempts ++;
141
142             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: failed! attempt=" +
143                     mPinUnlockAttempts);
144             if (mPinUnlockAttempts >= 3) {
145                 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: set state to REQUIRE_PUK");
146                 mSimLockedState = SimLockState.REQUIRE_PUK;
147             }
148
149             CommandException ex = new CommandException(
150                     CommandException.Error.PASSWORD_INCORRECT);
151             AsyncResult.forMessage(result, null, ex);
152             result.sendToTarget();
153         }
154     }
155
156     @Override
157     public void supplyIccPuk(String puk, String newPin, Message result)  {
158         if (mSimLockedState != SimLockState.REQUIRE_PUK) {
159             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: wrong state, state=" +
160                     mSimLockedState);
161             CommandException ex = new CommandException(
162                     CommandException.Error.PASSWORD_INCORRECT);
163             AsyncResult.forMessage(result, null, ex);
164             result.sendToTarget();
165             return;
166         }
167
168         if (puk != null && puk.equals(SIM_PUK_CODE)) {
169             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: success!");
170             mSimLockedState = SimLockState.NONE;
171             mPukUnlockAttempts = 0;
172             mIccStatusChangedRegistrants.notifyRegistrants();
173
174             if (result != null) {
175                 AsyncResult.forMessage(result, null, null);
176                 result.sendToTarget();
177             }
178
179             return;
180         }
181
182         if (result != null) {
183             mPukUnlockAttempts ++;
184
185             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: failed! attempt=" +
186                     mPukUnlockAttempts);
187             if (mPukUnlockAttempts >= 10) {
188                 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: set state to SIM_PERM_LOCKED");
189                 mSimLockedState = SimLockState.SIM_PERM_LOCKED;
190             }
191
192             CommandException ex = new CommandException(
193                     CommandException.Error.PASSWORD_INCORRECT);
194             AsyncResult.forMessage(result, null, ex);
195             result.sendToTarget();
196         }
197     }
198
199     @Override
200     public void supplyIccPin2(String pin2, Message result)  {
201         if (mSimFdnEnabledState != SimFdnState.REQUIRE_PIN2) {
202             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: wrong state, state=" +
203                     mSimFdnEnabledState);
204             CommandException ex = new CommandException(
205                     CommandException.Error.PASSWORD_INCORRECT);
206             AsyncResult.forMessage(result, null, ex);
207             result.sendToTarget();
208             return;
209         }
210
211         if (pin2 != null && pin2.equals(mPin2Code)) {
212             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: success!");
213             mPin2UnlockAttempts = 0;
214             mSimFdnEnabledState = SimFdnState.NONE;
215
216             if (result != null) {
217                 AsyncResult.forMessage(result, null, null);
218                 result.sendToTarget();
219             }
220
221             return;
222         }
223
224         if (result != null) {
225             mPin2UnlockAttempts ++;
226
227             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: failed! attempt=" +
228                     mPin2UnlockAttempts);
229             if (mPin2UnlockAttempts >= 3) {
230                 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: set state to REQUIRE_PUK2");
231                 mSimFdnEnabledState = SimFdnState.REQUIRE_PUK2;
232             }
233
234             CommandException ex = new CommandException(
235                     CommandException.Error.PASSWORD_INCORRECT);
236             AsyncResult.forMessage(result, null, ex);
237             result.sendToTarget();
238         }
239     }
240
241     @Override
242     public void supplyIccPuk2(String puk2, String newPin2, Message result)  {
243         if (mSimFdnEnabledState != SimFdnState.REQUIRE_PUK2) {
244             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: wrong state, state=" +
245                     mSimLockedState);
246             CommandException ex = new CommandException(
247                     CommandException.Error.PASSWORD_INCORRECT);
248             AsyncResult.forMessage(result, null, ex);
249             result.sendToTarget();
250             return;
251         }
252
253         if (puk2 != null && puk2.equals(SIM_PUK2_CODE)) {
254             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: success!");
255             mSimFdnEnabledState = SimFdnState.NONE;
256             mPuk2UnlockAttempts = 0;
257
258             if (result != null) {
259                 AsyncResult.forMessage(result, null, null);
260                 result.sendToTarget();
261             }
262
263             return;
264         }
265
266         if (result != null) {
267             mPuk2UnlockAttempts ++;
268
269             Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: failed! attempt=" +
270                     mPuk2UnlockAttempts);
271             if (mPuk2UnlockAttempts >= 10) {
272                 Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: set state to SIM_PERM_LOCKED");
273                 mSimFdnEnabledState = SimFdnState.SIM_PERM_LOCKED;
274             }
275
276             CommandException ex = new CommandException(
277                     CommandException.Error.PASSWORD_INCORRECT);
278             AsyncResult.forMessage(result, null, ex);
279             result.sendToTarget();
280         }
281     }
282
283     @Override
284     public void changeIccPin(String oldPin, String newPin, Message result)  {
285         if (oldPin != null && oldPin.equals(mPinCode)) {
286             mPinCode = newPin;
287             if (result != null) {
288                 AsyncResult.forMessage(result, null, null);
289                 result.sendToTarget();
290             }
291
292             return;
293         }
294
295         if (result != null) {
296             Rlog.i(LOG_TAG, "[SimCmd] changeIccPin: pin failed!");
297
298             CommandException ex = new CommandException(
299                     CommandException.Error.PASSWORD_INCORRECT);
300             AsyncResult.forMessage(result, null, ex);
301             result.sendToTarget();
302         }
303     }
304
305     @Override
306     public void changeIccPin2(String oldPin2, String newPin2, Message result)  {
307         if (oldPin2 != null && oldPin2.equals(mPin2Code)) {
308             mPin2Code = newPin2;
309             if (result != null) {
310                 AsyncResult.forMessage(result, null, null);
311                 result.sendToTarget();
312             }
313
314             return;
315         }
316
317         if (result != null) {
318             Rlog.i(LOG_TAG, "[SimCmd] changeIccPin2: pin2 failed!");
319
320             CommandException ex = new CommandException(
321                     CommandException.Error.PASSWORD_INCORRECT);
322             AsyncResult.forMessage(result, null, ex);
323             result.sendToTarget();
324         }
325     }
326
327     @Override
328     public void
329     changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) {
330         unimplemented(result);
331     }
332
333     @Override
334     public void
335     setSuppServiceNotifications(boolean enable, Message result) {
336         resultSuccess(result, null);
337
338         if (enable && mSsnNotifyOn) {
339             Rlog.w(LOG_TAG, "Supp Service Notifications already enabled!");
340         }
341
342         mSsnNotifyOn = enable;
343     }
344
345     @Override
346     public void queryFacilityLock(String facility, String pin,
347                                    int serviceClass, Message result) {
348         queryFacilityLockForApp(facility, pin, serviceClass, null, result);
349     }
350
351     @Override
352     public void queryFacilityLockForApp(String facility, String pin, int serviceClass,
353             String appId, Message result) {
354         if (facility != null && facility.equals(CommandsInterface.CB_FACILITY_BA_SIM)) {
355             if (result != null) {
356                 int[] r = new int[1];
357                 r[0] = (mSimLockEnabled ? 1 : 0);
358                 Rlog.i(LOG_TAG, "[SimCmd] queryFacilityLock: SIM is "
359                         + (r[0] == 0 ? "unlocked" : "locked"));
360                 AsyncResult.forMessage(result, r, null);
361                 result.sendToTarget();
362             }
363             return;
364         } else if (facility != null && facility.equals(CommandsInterface.CB_FACILITY_BA_FD)) {
365             if (result != null) {
366                 int[] r = new int[1];
367                 r[0] = (mSimFdnEnabled ? 1 : 0);
368                 Rlog.i(LOG_TAG, "[SimCmd] queryFacilityLock: FDN is "
369                         + (r[0] == 0 ? "disabled" : "enabled"));
370                 AsyncResult.forMessage(result, r, null);
371                 result.sendToTarget();
372             }
373             return;
374         }
375
376         unimplemented(result);
377     }
378
379     @Override
380     public void setFacilityLock(String facility, boolean lockEnabled, String pin, int serviceClass,
381             Message result) {
382         setFacilityLockForApp(facility, lockEnabled, pin, serviceClass, null, result);
383     }
384
385     @Override
386     public void setFacilityLockForApp(String facility, boolean lockEnabled,
387                                  String pin, int serviceClass, String appId,
388                                  Message result) {
389         if (facility != null &&
390                 facility.equals(CommandsInterface.CB_FACILITY_BA_SIM)) {
391             if (pin != null && pin.equals(mPinCode)) {
392                 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin is valid");
393                 mSimLockEnabled = lockEnabled;
394
395                 if (result != null) {
396                     AsyncResult.forMessage(result, null, null);
397                     result.sendToTarget();
398                 }
399
400                 return;
401             }
402
403             if (result != null) {
404                 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin failed!");
405
406                 CommandException ex = new CommandException(
407                         CommandException.Error.GENERIC_FAILURE);
408                 AsyncResult.forMessage(result, null, ex);
409                 result.sendToTarget();
410             }
411
412             return;
413         }  else if (facility != null &&
414                 facility.equals(CommandsInterface.CB_FACILITY_BA_FD)) {
415             if (pin != null && pin.equals(mPin2Code)) {
416                 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin2 is valid");
417                 mSimFdnEnabled = lockEnabled;
418
419                 if (result != null) {
420                     AsyncResult.forMessage(result, null, null);
421                     result.sendToTarget();
422                 }
423
424                 return;
425             }
426
427             if (result != null) {
428                 Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin2 failed!");
429
430                 CommandException ex = new CommandException(
431                         CommandException.Error.GENERIC_FAILURE);
432                 AsyncResult.forMessage(result, null, ex);
433                 result.sendToTarget();
434             }
435
436             return;
437         }
438
439         unimplemented(result);
440     }
441
442     @Override
443     public void supplyNetworkDepersonalization(String netpin, Message result)  {
444         unimplemented(result);
445     }
446
447     /**
448      *  returned message
449      *  retMsg.obj = AsyncResult ar
450      *  ar.exception carries exception on failure
451      *  ar.userObject contains the original value of result.obj
452      *  ar.result contains a List of DriverCall
453      *      The ar.result List is sorted by DriverCall.index
454      */
455     @Override
456     public void getCurrentCalls (Message result) {
457         if ((mState == RadioState.RADIO_ON) && !isSimLocked()) {
458             //Rlog.i("GSM", "[SimCmds] getCurrentCalls");
459             resultSuccess(result, simulatedCallState.getDriverCalls());
460         } else {
461             //Rlog.i("GSM", "[SimCmds] getCurrentCalls: RADIO_OFF or SIM not ready!");
462             resultFail(result,
463                 new CommandException(
464                     CommandException.Error.RADIO_NOT_AVAILABLE));
465         }
466     }
467
468     /**
469      *  @deprecated
470      */
471     @Deprecated
472     @Override
473     public void getPDPContextList(Message result) {
474         getDataCallList(result);
475     }
476
477     /**
478      *  returned message
479      *  retMsg.obj = AsyncResult ar
480      *  ar.exception carries exception on failure
481      *  ar.userObject contains the original value of result.obj
482      *  ar.result contains a List of DataCallResponse
483      */
484     @Override
485     public void getDataCallList(Message result) {
486         resultSuccess(result, new ArrayList<DataCallResponse>(0));
487     }
488
489     /**
490      *  returned message
491      *  retMsg.obj = AsyncResult ar
492      *  ar.exception carries exception on failure
493      *  ar.userObject contains the original value of result.obj
494      *  ar.result is null on success and failure
495      *
496      * CLIR_DEFAULT     == on "use subscription default value"
497      * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation)
498      * CLIR_INVOCATION  == on "CLIR invocation" (restrict CLI presentation)
499      */
500     @Override
501     public void dial (String address, int clirMode, Message result) {
502         simulatedCallState.onDial(address);
503
504         resultSuccess(result, null);
505     }
506
507     /**
508      *  returned message
509      *  retMsg.obj = AsyncResult ar
510      *  ar.exception carries exception on failure
511      *  ar.userObject contains the original value of result.obj
512      *  ar.result is null on success and failure
513      *
514      * CLIR_DEFAULT     == on "use subscription default value"
515      * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation)
516      * CLIR_INVOCATION  == on "CLIR invocation" (restrict CLI presentation)
517      */
518     @Override
519     public void dial(String address, int clirMode, UUSInfo uusInfo, Message result) {
520         simulatedCallState.onDial(address);
521
522         resultSuccess(result, null);
523     }
524
525     @Override
526     public void getIMSI(Message result) {
527         getIMSIForApp(null, result);
528     }
529     /**
530      *  returned message
531      *  retMsg.obj = AsyncResult ar
532      *  ar.exception carries exception on failure
533      *  ar.userObject contains the original value of result.obj
534      *  ar.result is String containing IMSI on success
535      */
536     @Override
537     public void getIMSIForApp(String aid, Message result) {
538         resultSuccess(result, "012345678901234");
539     }
540
541     /**
542      *  returned message
543      *  retMsg.obj = AsyncResult ar
544      *  ar.exception carries exception on failure
545      *  ar.userObject contains the original value of result.obj
546      *  ar.result is String containing IMEI on success
547      */
548     @Override
549     public void getIMEI(Message result) {
550         resultSuccess(result, "012345678901234");
551     }
552
553     /**
554      *  returned message
555      *  retMsg.obj = AsyncResult ar
556      *  ar.exception carries exception on failure
557      *  ar.userObject contains the original value of result.obj
558      *  ar.result is String containing IMEISV on success
559      */
560     @Override
561     public void getIMEISV(Message result) {
562         resultSuccess(result, "99");
563     }
564
565     /**
566      * Hang up one individual connection.
567      *  returned message
568      *  retMsg.obj = AsyncResult ar
569      *  ar.exception carries exception on failure
570      *  ar.userObject contains the original value of result.obj
571      *  ar.result is null on success and failure
572      *
573      *  3GPP 22.030 6.5.5
574      *  "Releases a specific active call X"
575      */
576     @Override
577     public void hangupConnection (int gsmIndex, Message result) {
578         boolean success;
579
580         success = simulatedCallState.onChld('1', (char)('0'+gsmIndex));
581
582         if (!success){
583             Rlog.i("GSM", "[SimCmd] hangupConnection: resultFail");
584             resultFail(result, new RuntimeException("Hangup Error"));
585         } else {
586             Rlog.i("GSM", "[SimCmd] hangupConnection: resultSuccess");
587             resultSuccess(result, null);
588         }
589     }
590
591     /**
592      * 3GPP 22.030 6.5.5
593      *  "Releases all held calls or sets User Determined User Busy (UDUB)
594      *   for a waiting call."
595      *  ar.exception carries exception on failure
596      *  ar.userObject contains the original value of result.obj
597      *  ar.result is null on success and failure
598      */
599     @Override
600     public void hangupWaitingOrBackground (Message result) {
601         boolean success;
602
603         success = simulatedCallState.onChld('0', '\0');
604
605         if (!success){
606             resultFail(result, new RuntimeException("Hangup Error"));
607         } else {
608             resultSuccess(result, null);
609         }
610     }
611
612     /**
613      * 3GPP 22.030 6.5.5
614      * "Releases all active calls (if any exist) and accepts
615      *  the other (held or waiting) call."
616      *
617      *  ar.exception carries exception on failure
618      *  ar.userObject contains the original value of result.obj
619      *  ar.result is null on success and failure
620      */
621     @Override
622     public void hangupForegroundResumeBackground (Message result) {
623         boolean success;
624
625         success = simulatedCallState.onChld('1', '\0');
626
627         if (!success){
628             resultFail(result, new RuntimeException("Hangup Error"));
629         } else {
630             resultSuccess(result, null);
631         }
632     }
633
634     /**
635      * 3GPP 22.030 6.5.5
636      * "Places all active calls (if any exist) on hold and accepts
637      *  the other (held or waiting) call."
638      *
639      *  ar.exception carries exception on failure
640      *  ar.userObject contains the original value of result.obj
641      *  ar.result is null on success and failure
642      */
643     @Override
644     public void switchWaitingOrHoldingAndActive (Message result) {
645         boolean success;
646
647         success = simulatedCallState.onChld('2', '\0');
648
649         if (!success){
650             resultFail(result, new RuntimeException("Hangup Error"));
651         } else {
652             resultSuccess(result, null);
653         }
654     }
655
656     /**
657      * 3GPP 22.030 6.5.5
658      * "Adds a held call to the conversation"
659      *
660      *  ar.exception carries exception on failure
661      *  ar.userObject contains the original value of result.obj
662      *  ar.result is null on success and failure
663      */
664     @Override
665     public void conference (Message result) {
666         boolean success;
667
668         success = simulatedCallState.onChld('3', '\0');
669
670         if (!success){
671             resultFail(result, new RuntimeException("Hangup Error"));
672         } else {
673             resultSuccess(result, null);
674         }
675     }
676
677     /**
678      * 3GPP 22.030 6.5.5
679      * "Connects the two calls and disconnects the subscriber from both calls"
680      *
681      *  ar.exception carries exception on failure
682      *  ar.userObject contains the original value of result.obj
683      *  ar.result is null on success and failure
684      */
685     @Override
686     public void explicitCallTransfer (Message result) {
687         boolean success;
688
689         success = simulatedCallState.onChld('4', '\0');
690
691         if (!success){
692             resultFail(result, new RuntimeException("Hangup Error"));
693         } else {
694             resultSuccess(result, null);
695         }
696     }
697
698     /**
699      * 3GPP 22.030 6.5.5
700      * "Places all active calls on hold except call X with which
701      *  communication shall be supported."
702      */
703     @Override
704     public void separateConnection (int gsmIndex, Message result) {
705         boolean success;
706
707         char ch = (char)(gsmIndex + '0');
708         success = simulatedCallState.onChld('2', ch);
709
710         if (!success){
711             resultFail(result, new RuntimeException("Hangup Error"));
712         } else {
713             resultSuccess(result, null);
714         }
715     }
716
717     /**
718      *
719      *  ar.exception carries exception on failure
720      *  ar.userObject contains the original value of result.obj
721      *  ar.result is null on success and failure
722      */
723     @Override
724     public void acceptCall (Message result) {
725         boolean success;
726
727         success = simulatedCallState.onAnswer();
728
729         if (!success){
730             resultFail(result, new RuntimeException("Hangup Error"));
731         } else {
732             resultSuccess(result, null);
733         }
734     }
735
736     /**
737      *  also known as UDUB
738      *  ar.exception carries exception on failure
739      *  ar.userObject contains the original value of result.obj
740      *  ar.result is null on success and failure
741      */
742     @Override
743     public void rejectCall (Message result) {
744         boolean success;
745
746         success = simulatedCallState.onChld('0', '\0');
747
748         if (!success){
749             resultFail(result, new RuntimeException("Hangup Error"));
750         } else {
751             resultSuccess(result, null);
752         }
753     }
754
755     /**
756      * cause code returned as Integer in Message.obj.response
757      * Returns integer cause code defined in TS 24.008
758      * Annex H or closest approximation.
759      * Most significant codes:
760      * - Any defined in 22.001 F.4 (for generating busy/congestion)
761      * - Cause 68: ACM >= ACMMax
762      */
763     @Override
764     public void getLastCallFailCause (Message result) {
765         int[] ret = new int[1];
766
767         ret[0] = mNextCallFailCause;
768         resultSuccess(result, ret);
769     }
770
771     /**
772      * @deprecated
773      */
774     @Deprecated
775     @Override
776     public void getLastPdpFailCause (Message result) {
777         unimplemented(result);
778     }
779
780     @Override
781     public void getLastDataCallFailCause(Message result) {
782         //
783         unimplemented(result);
784     }
785
786     @Override
787     public void setMute (boolean enableMute, Message result) {unimplemented(result);}
788
789     @Override
790     public void getMute (Message result) {unimplemented(result);}
791
792     /**
793      * response.obj is an AsyncResult
794      * response.obj.result is an int[2]
795      * response.obj.result[0] is received signal strength (0-31, 99)
796      * response.obj.result[1] is  bit error rate (0-7, 99)
797      * as defined in TS 27.007 8.5
798      */
799     @Override
800     public void getSignalStrength (Message result) {
801         int ret[] = new int[2];
802
803         ret[0] = 23;
804         ret[1] = 0;
805
806         resultSuccess(result, ret);
807     }
808
809      /**
810      * Assign a specified band for RF configuration.
811      *
812      * @param bandMode one of BM_*_BAND
813      * @param result is callback message
814      */
815     @Override
816     public void setBandMode (int bandMode, Message result) {
817         resultSuccess(result, null);
818     }
819
820     /**
821      * Query the list of band mode supported by RF.
822      *
823      * @param result is callback message
824      *        ((AsyncResult)response.obj).result  is an int[] with every
825      *        element representing one available BM_*_BAND
826      */
827     @Override
828     public void queryAvailableBandMode (Message result) {
829         int ret[] = new int [4];
830
831         ret[0] = 4;
832         ret[1] = Phone.BM_US_BAND;
833         ret[2] = Phone.BM_JPN_BAND;
834         ret[3] = Phone.BM_AUS_BAND;
835
836         resultSuccess(result, ret);
837     }
838
839     /**
840      * {@inheritDoc}
841      */
842     @Override
843     public void sendTerminalResponse(String contents, Message response) {
844         resultSuccess(response, null);
845     }
846
847     /**
848      * {@inheritDoc}
849      */
850     @Override
851     public void sendEnvelope(String contents, Message response) {
852         resultSuccess(response, null);
853     }
854
855     /**
856      * {@inheritDoc}
857      */
858     @Override
859     public void sendEnvelopeWithStatus(String contents, Message response) {
860         resultSuccess(response, null);
861     }
862
863     /**
864      * {@inheritDoc}
865      */
866     @Override
867     public void handleCallSetupRequestFromSim(
868             boolean accept, Message response) {
869         resultSuccess(response, null);
870     }
871
872     /**
873      * response.obj.result is an String[14]
874      * See ril.h for details
875      *
876      * Please note that registration state 4 ("unknown") is treated
877      * as "out of service" above
878      */
879     @Override
880     public void getVoiceRegistrationState (Message result) {
881         String ret[] = new String[14];
882
883         ret[0] = "5"; // registered roam
884         ret[1] = null;
885         ret[2] = null;
886         ret[3] = null;
887         ret[4] = null;
888         ret[5] = null;
889         ret[6] = null;
890         ret[7] = null;
891         ret[8] = null;
892         ret[9] = null;
893         ret[10] = null;
894         ret[11] = null;
895         ret[12] = null;
896         ret[13] = null;
897
898         resultSuccess(result, ret);
899     }
900
901     /**
902      * response.obj.result is an String[4]
903      * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2
904      * response.obj.result[1] is LAC if registered or NULL if not
905      * response.obj.result[2] is CID if registered or NULL if not
906      * response.obj.result[3] indicates the available radio technology, where:
907      *      0 == unknown
908      *      1 == GPRS only
909      *      2 == EDGE
910      *      3 == UMTS
911      *
912      * valid LAC are 0x0000 - 0xffff
913      * valid CID are 0x00000000 - 0xffffffff
914      *
915      * Please note that registration state 4 ("unknown") is treated
916      * as "out of service" in the Android telephony system
917      */
918     @Override
919     public void getDataRegistrationState (Message result) {
920         String ret[] = new String[4];
921
922         ret[0] = "5"; // registered roam
923         ret[1] = null;
924         ret[2] = null;
925         ret[3] = "2";
926
927         resultSuccess(result, ret);
928     }
929
930     /**
931      * response.obj.result is a String[3]
932      * response.obj.result[0] is long alpha or null if unregistered
933      * response.obj.result[1] is short alpha or null if unregistered
934      * response.obj.result[2] is numeric or null if unregistered
935      */
936     @Override
937     public void getOperator(Message result) {
938         String[] ret = new String[3];
939
940         ret[0] = "El Telco Loco";
941         ret[1] = "Telco Loco";
942         ret[2] = "001001";
943
944         resultSuccess(result, ret);
945     }
946
947     /**
948      *  ar.exception carries exception on failure
949      *  ar.userObject contains the original value of result.obj
950      *  ar.result is null on success and failure
951      */
952     @Override
953     public void sendDtmf(char c, Message result) {
954         resultSuccess(result, null);
955     }
956
957     /**
958      *  ar.exception carries exception on failure
959      *  ar.userObject contains the original value of result.obj
960      *  ar.result is null on success and failure
961      */
962     @Override
963     public void startDtmf(char c, Message result) {
964         resultSuccess(result, null);
965     }
966
967     /**
968      *  ar.exception carries exception on failure
969      *  ar.userObject contains the original value of result.obj
970      *  ar.result is null on success and failure
971      */
972     @Override
973     public void stopDtmf(Message result) {
974         resultSuccess(result, null);
975     }
976
977     /**
978      *  ar.exception carries exception on failure
979      *  ar.userObject contains the original value of result.obj
980      *  ar.result is null on success and failure
981      */
982     @Override
983     public void sendBurstDtmf(String dtmfString, int on, int off, Message result) {
984         resultSuccess(result, null);
985     }
986
987     /**
988      * smscPDU is smsc address in PDU form GSM BCD format prefixed
989      *      by a length byte (as expected by TS 27.005) or NULL for default SMSC
990      * pdu is SMS in PDU format as an ASCII hex string
991      *      less the SMSC address
992      */
993     @Override
994     public void sendSMS (String smscPDU, String pdu, Message result) {unimplemented(result);}
995
996     @Override
997     public void deleteSmsOnSim(int index, Message response) {
998         Rlog.d(LOG_TAG, "Delete message at index " + index);
999         unimplemented(response);
1000     }
1001
1002     @Override
1003     public void deleteSmsOnRuim(int index, Message response) {
1004         Rlog.d(LOG_TAG, "Delete RUIM message at index " + index);
1005         unimplemented(response);
1006     }
1007
1008     @Override
1009     public void writeSmsToSim(int status, String smsc, String pdu, Message response) {
1010         Rlog.d(LOG_TAG, "Write SMS to SIM with status " + status);
1011         unimplemented(response);
1012     }
1013
1014     @Override
1015     public void writeSmsToRuim(int status, String pdu, Message response) {
1016         Rlog.d(LOG_TAG, "Write SMS to RUIM with status " + status);
1017         unimplemented(response);
1018     }
1019
1020     @Override
1021     public void setupDataCall(String radioTechnology, String profile,
1022             String apn, String user, String password, String authType,
1023             String protocol, Message result) {
1024         unimplemented(result);
1025     }
1026
1027     @Override
1028     public void deactivateDataCall(int cid, int reason, Message result) {unimplemented(result);}
1029
1030     @Override
1031     public void setPreferredNetworkType(int networkType , Message result) {
1032         mNetworkType = networkType;
1033         resultSuccess(result, null);
1034     }
1035
1036     @Override
1037     public void getPreferredNetworkType(Message result) {
1038         int ret[] = new int[1];
1039
1040         ret[0] = mNetworkType;
1041         resultSuccess(result, ret);
1042     }
1043
1044     @Override
1045     public void getNeighboringCids(Message result) {
1046         int ret[] = new int[7];
1047
1048         ret[0] = 6;
1049         for (int i = 1; i<7; i++) {
1050             ret[i] = i;
1051         }
1052         resultSuccess(result, ret);
1053     }
1054
1055     @Override
1056     public void setLocationUpdates(boolean enable, Message response) {
1057         unimplemented(response);
1058     }
1059
1060     @Override
1061     public void getSmscAddress(Message result) {
1062         unimplemented(result);
1063     }
1064
1065     @Override
1066     public void setSmscAddress(String address, Message result) {
1067         unimplemented(result);
1068     }
1069
1070     @Override
1071     public void reportSmsMemoryStatus(boolean available, Message result) {
1072         unimplemented(result);
1073     }
1074
1075     @Override
1076     public void reportStkServiceIsRunning(Message result) {
1077         resultSuccess(result, null);
1078     }
1079
1080     @Override
1081     public void getCdmaSubscriptionSource(Message result) {
1082         unimplemented(result);
1083     }
1084
1085     private boolean isSimLocked() {
1086         if (mSimLockedState != SimLockState.NONE) {
1087             return true;
1088         }
1089         return false;
1090     }
1091
1092     @Override
1093     public void setRadioPower(boolean on, Message result) {
1094         if(on) {
1095             setRadioState(RadioState.RADIO_ON);
1096         } else {
1097             setRadioState(RadioState.RADIO_OFF);
1098         }
1099     }
1100
1101
1102     @Override
1103     public void acknowledgeLastIncomingGsmSms(boolean success, int cause, Message result) {
1104         unimplemented(result);
1105     }
1106
1107     @Override
1108     public void acknowledgeLastIncomingCdmaSms(boolean success, int cause, Message result) {
1109         unimplemented(result);
1110     }
1111
1112     @Override
1113     public void acknowledgeIncomingGsmSmsWithPdu(boolean success, String ackPdu,
1114             Message result) {
1115         unimplemented(result);
1116     }
1117
1118     @Override
1119     public void iccIO(int command, int fileid, String path, int p1, int p2, int p3, String data,
1120             String pin2, Message response) {
1121         iccIOForApp(command, fileid, path, p1, p2, p3, data,pin2, null, response);
1122     }
1123
1124     /**
1125      * parameters equivalent to 27.007 AT+CRSM command
1126      * response.obj will be an AsyncResult
1127      * response.obj.userObj will be a SimIoResult on success
1128      */
1129     @Override
1130     public void iccIOForApp (int command, int fileid, String path, int p1, int p2,
1131                        int p3, String data, String pin2, String aid, Message result) {
1132         unimplemented(result);
1133     }
1134
1135     /**
1136      * (AsyncResult)response.obj).result is an int[] with element [0] set to
1137      * 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned".
1138      *
1139      * @param response is callback message
1140      */
1141     @Override
1142     public void queryCLIP(Message response) { unimplemented(response); }
1143
1144
1145     /**
1146      * response.obj will be a an int[2]
1147      *
1148      * response.obj[0] will be TS 27.007 +CLIR parameter 'n'
1149      *  0 presentation indicator is used according to the subscription of the CLIR service
1150      *  1 CLIR invocation
1151      *  2 CLIR suppression
1152      *
1153      * response.obj[1] will be TS 27.007 +CLIR parameter 'm'
1154      *  0 CLIR not provisioned
1155      *  1 CLIR provisioned in permanent mode
1156      *  2 unknown (e.g. no network, etc.)
1157      *  3 CLIR temporary mode presentation restricted
1158      *  4 CLIR temporary mode presentation allowed
1159      */
1160
1161     @Override
1162     public void getCLIR(Message result) {unimplemented(result);}
1163
1164     /**
1165      * clirMode is one of the CLIR_* constants above
1166      *
1167      * response.obj is null
1168      */
1169
1170     @Override
1171     public void setCLIR(int clirMode, Message result) {unimplemented(result);}
1172
1173     /**
1174      * (AsyncResult)response.obj).result is an int[] with element [0] set to
1175      * 0 for disabled, 1 for enabled.
1176      *
1177      * @param serviceClass is a sum of SERVICE_CLASS_*
1178      * @param response is callback message
1179      */
1180
1181     @Override
1182     public void queryCallWaiting(int serviceClass, Message response) {
1183         unimplemented(response);
1184     }
1185
1186     /**
1187      * @param enable is true to enable, false to disable
1188      * @param serviceClass is a sum of SERVICE_CLASS_*
1189      * @param response is callback message
1190      */
1191
1192     @Override
1193     public void setCallWaiting(boolean enable, int serviceClass,
1194             Message response) {
1195         unimplemented(response);
1196     }
1197
1198     /**
1199      * @param action is one of CF_ACTION_*
1200      * @param cfReason is one of CF_REASON_*
1201      * @param serviceClass is a sum of SERVICE_CLASSS_*
1202      */
1203     @Override
1204     public void setCallForward(int action, int cfReason, int serviceClass,
1205             String number, int timeSeconds, Message result) {unimplemented(result);}
1206
1207     /**
1208      * cfReason is one of CF_REASON_*
1209      *
1210      * ((AsyncResult)response.obj).result will be an array of
1211      * CallForwardInfo's
1212      *
1213      * An array of length 0 means "disabled for all codes"
1214      */
1215     @Override
1216     public void queryCallForwardStatus(int cfReason, int serviceClass,
1217             String number, Message result) {unimplemented(result);}
1218
1219     @Override
1220     public void setNetworkSelectionModeAutomatic(Message result) {unimplemented(result);}
1221     @Override
1222     public void exitEmergencyCallbackMode(Message result) {unimplemented(result);}
1223     @Override
1224     public void setNetworkSelectionModeManual(
1225             String operatorNumeric, Message result) {unimplemented(result);}
1226
1227     /**
1228      * Queries whether the current network selection mode is automatic
1229      * or manual
1230      *
1231      * ((AsyncResult)response.obj).result  is an int[] with element [0] being
1232      * a 0 for automatic selection and a 1 for manual selection
1233      */
1234
1235     @Override
1236     public void getNetworkSelectionMode(Message result) {
1237         int ret[] = new int[1];
1238
1239         ret[0] = 0;
1240         resultSuccess(result, ret);
1241     }
1242
1243     /**
1244      * Queries the currently available networks
1245      *
1246      * ((AsyncResult)response.obj).result  is a List of NetworkInfo objects
1247      */
1248     @Override
1249     public void getAvailableNetworks(Message result) {unimplemented(result);}
1250
1251     @Override
1252     public void getBasebandVersion (Message result) {
1253         resultSuccess(result, "SimulatedCommands");
1254     }
1255
1256     /**
1257      * Simulates an incoming USSD message
1258      * @param statusCode  Status code string. See <code>setOnUSSD</code>
1259      * in CommandsInterface.java
1260      * @param message Message text to send or null if none
1261      */
1262     @Override
1263     public void triggerIncomingUssd(String statusCode, String message) {
1264         if (mUSSDRegistrant != null) {
1265             String[] result = {statusCode, message};
1266             mUSSDRegistrant.notifyResult(result);
1267         }
1268     }
1269
1270
1271     @Override
1272     public void sendUSSD (String ussdString, Message result) {
1273
1274         // We simulate this particular sequence
1275         if (ussdString.equals("#646#")) {
1276             resultSuccess(result, null);
1277
1278             // 0 == USSD-Notify
1279             triggerIncomingUssd("0", "You have NNN minutes remaining.");
1280         } else {
1281             resultSuccess(result, null);
1282
1283             triggerIncomingUssd("0", "All Done");
1284         }
1285     }
1286
1287     // inherited javadoc suffices
1288     @Override
1289     public void cancelPendingUssd (Message response) {
1290         resultSuccess(response, null);
1291     }
1292
1293
1294     @Override
1295     public void resetRadio(Message result) {
1296         unimplemented(result);
1297     }
1298
1299     @Override
1300     public void invokeOemRilRequestRaw(byte[] data, Message response) {
1301         // Just echo back data
1302         if (response != null) {
1303             AsyncResult.forMessage(response).result = data;
1304             response.sendToTarget();
1305         }
1306     }
1307
1308     @Override
1309     public void invokeOemRilRequestStrings(String[] strings, Message response) {
1310         // Just echo back data
1311         if (response != null) {
1312             AsyncResult.forMessage(response).result = strings;
1313             response.sendToTarget();
1314         }
1315     }
1316
1317     //***** SimulatedRadioControl
1318
1319
1320     /** Start the simulated phone ringing */
1321     @Override
1322     public void
1323     triggerRing(String number) {
1324         simulatedCallState.triggerRing(number);
1325         mCallStateRegistrants.notifyRegistrants();
1326     }
1327
1328     @Override
1329     public void
1330     progressConnectingCallState() {
1331         simulatedCallState.progressConnectingCallState();
1332         mCallStateRegistrants.notifyRegistrants();
1333     }
1334
1335     /** If a call is DIALING or ALERTING, progress it all the way to ACTIVE */
1336     @Override
1337     public void
1338     progressConnectingToActive() {
1339         simulatedCallState.progressConnectingToActive();
1340         mCallStateRegistrants.notifyRegistrants();
1341     }
1342
1343     /** automatically progress mobile originated calls to ACTIVE.
1344      *  default to true
1345      */
1346     @Override
1347     public void
1348     setAutoProgressConnectingCall(boolean b) {
1349         simulatedCallState.setAutoProgressConnectingCall(b);
1350     }
1351
1352     @Override
1353     public void
1354     setNextDialFailImmediately(boolean b) {
1355         simulatedCallState.setNextDialFailImmediately(b);
1356     }
1357
1358     @Override
1359     public void
1360     setNextCallFailCause(int gsmCause) {
1361         mNextCallFailCause = gsmCause;
1362     }
1363
1364     @Override
1365     public void
1366     triggerHangupForeground() {
1367         simulatedCallState.triggerHangupForeground();
1368         mCallStateRegistrants.notifyRegistrants();
1369     }
1370
1371     /** hangup holding calls */
1372     @Override
1373     public void
1374     triggerHangupBackground() {
1375         simulatedCallState.triggerHangupBackground();
1376         mCallStateRegistrants.notifyRegistrants();
1377     }
1378
1379     @Override
1380     public void triggerSsn(int type, int code) {
1381         SuppServiceNotification not = new SuppServiceNotification();
1382         not.notificationType = type;
1383         not.code = code;
1384         mSsnRegistrant.notifyRegistrant(new AsyncResult(null, not, null));
1385     }
1386
1387     @Override
1388     public void
1389     shutdown() {
1390         setRadioState(RadioState.RADIO_UNAVAILABLE);
1391         Looper looper = mHandlerThread.getLooper();
1392         if (looper != null) {
1393             looper.quit();
1394         }
1395     }
1396
1397     /** hangup all */
1398
1399     @Override
1400     public void
1401     triggerHangupAll() {
1402         simulatedCallState.triggerHangupAll();
1403         mCallStateRegistrants.notifyRegistrants();
1404     }
1405
1406     @Override
1407     public void
1408     triggerIncomingSMS(String message) {
1409         //TODO
1410     }
1411
1412     @Override
1413     public void
1414     pauseResponses() {
1415         mPausedResponseCount++;
1416     }
1417
1418     @Override
1419     public void
1420     resumeResponses() {
1421         mPausedResponseCount--;
1422
1423         if (mPausedResponseCount == 0) {
1424             for (int i = 0, s = mPausedResponses.size(); i < s ; i++) {
1425                 mPausedResponses.get(i).sendToTarget();
1426             }
1427             mPausedResponses.clear();
1428         } else {
1429             Rlog.e("GSM", "SimulatedCommands.resumeResponses < 0");
1430         }
1431     }
1432
1433     //***** Private Methods
1434
1435     private void unimplemented(Message result) {
1436         if (result != null) {
1437             AsyncResult.forMessage(result).exception
1438                 = new RuntimeException("Unimplemented");
1439
1440             if (mPausedResponseCount > 0) {
1441                 mPausedResponses.add(result);
1442             } else {
1443                 result.sendToTarget();
1444             }
1445         }
1446     }
1447
1448     private void resultSuccess(Message result, Object ret) {
1449         if (result != null) {
1450             AsyncResult.forMessage(result).result = ret;
1451             if (mPausedResponseCount > 0) {
1452                 mPausedResponses.add(result);
1453             } else {
1454                 result.sendToTarget();
1455             }
1456         }
1457     }
1458
1459     private void resultFail(Message result, Throwable tr) {
1460         if (result != null) {
1461             AsyncResult.forMessage(result).exception = tr;
1462             if (mPausedResponseCount > 0) {
1463                 mPausedResponses.add(result);
1464             } else {
1465                 result.sendToTarget();
1466             }
1467         }
1468     }
1469
1470     // ***** Methods for CDMA support
1471     @Override
1472     public void
1473     getDeviceIdentity(Message response) {
1474         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1475         unimplemented(response);
1476     }
1477
1478     @Override
1479     public void
1480     getCDMASubscription(Message response) {
1481         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1482         unimplemented(response);
1483     }
1484
1485     @Override
1486     public void
1487     setCdmaSubscriptionSource(int cdmaSubscriptionType, Message response) {
1488         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1489         unimplemented(response);
1490     }
1491
1492     @Override
1493     public void queryCdmaRoamingPreference(Message response) {
1494         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1495         unimplemented(response);
1496     }
1497
1498     @Override
1499     public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) {
1500         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1501         unimplemented(response);
1502     }
1503
1504     @Override
1505     public void
1506     setPhoneType(int phoneType) {
1507         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1508     }
1509
1510     @Override
1511     public void getPreferredVoicePrivacy(Message result) {
1512         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1513         unimplemented(result);
1514     }
1515
1516     @Override
1517     public void setPreferredVoicePrivacy(boolean enable, Message result) {
1518         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1519         unimplemented(result);
1520     }
1521
1522     /**
1523      *  Set the TTY mode
1524      *
1525      * @param ttyMode is one of the following:
1526      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
1527      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
1528      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
1529      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
1530      * @param response is callback message
1531      */
1532     @Override
1533     public void setTTYMode(int ttyMode, Message response) {
1534         Rlog.w(LOG_TAG, "Not implemented in SimulatedCommands");
1535         unimplemented(response);
1536     }
1537
1538     /**
1539      *  Query the TTY mode
1540      * (AsyncResult)response.obj).result is an int[] with element [0] set to
1541      * tty mode:
1542      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
1543      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
1544      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
1545      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
1546      * @param response is callback message
1547      */
1548     @Override
1549     public void queryTTYMode(Message response) {
1550         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1551         unimplemented(response);
1552     }
1553
1554     /**
1555      * {@inheritDoc}
1556      */
1557     @Override
1558     public void sendCDMAFeatureCode(String FeatureCode, Message response) {
1559         Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1560         unimplemented(response);
1561     }
1562
1563     /**
1564      * {@inheritDoc}
1565      */
1566     @Override
1567     public void sendCdmaSms(byte[] pdu, Message response){
1568        Rlog.w(LOG_TAG, "CDMA not implemented in SimulatedCommands");
1569     }
1570
1571     @Override
1572     public void setCdmaBroadcastActivation(boolean activate, Message response) {
1573         unimplemented(response);
1574
1575     }
1576
1577     @Override
1578     public void getCdmaBroadcastConfig(Message response) {
1579         unimplemented(response);
1580
1581     }
1582
1583     @Override
1584     public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) {
1585         unimplemented(response);
1586     }
1587
1588     public void forceDataDormancy(Message response) {
1589         unimplemented(response);
1590     }
1591
1592
1593     @Override
1594     public void setGsmBroadcastActivation(boolean activate, Message response) {
1595         unimplemented(response);
1596     }
1597
1598
1599     @Override
1600     public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) {
1601         unimplemented(response);
1602     }
1603
1604     @Override
1605     public void getGsmBroadcastConfig(Message response) {
1606         unimplemented(response);
1607     }
1608
1609     @Override
1610     public void supplyIccPinForApp(String pin, String aid, Message response) {
1611         unimplemented(response);
1612     }
1613
1614     @Override
1615     public void supplyIccPukForApp(String puk, String newPin, String aid, Message response) {
1616         unimplemented(response);
1617     }
1618
1619     @Override
1620     public void supplyIccPin2ForApp(String pin2, String aid, Message response) {
1621         unimplemented(response);
1622     }
1623
1624     @Override
1625     public void supplyIccPuk2ForApp(String puk2, String newPin2, String aid, Message response) {
1626         unimplemented(response);
1627     }
1628
1629     @Override
1630     public void changeIccPinForApp(String oldPin, String newPin, String aidPtr, Message response) {
1631         unimplemented(response);
1632     }
1633
1634     @Override
1635     public void changeIccPin2ForApp(String oldPin2, String newPin2, String aidPtr,
1636             Message response) {
1637         unimplemented(response);
1638     }
1639
1640     @Override
1641     public void requestIsimAuthentication(String nonce, Message response) {
1642         unimplemented(response);
1643     }
1644
1645     @Override
1646     public void getVoiceRadioTechnology(Message response) {
1647         unimplemented(response);
1648     }
1649
1650     @Override
1651     public void getCellInfoList(Message response) {
1652         unimplemented(response);
1653     }
1654
1655     @Override
1656     public void setCellInfoListRate(int rateInMillis, Message response) {
1657         unimplemented(response);
1658     }
1659
1660     @Override
1661     public void setInitialAttachApn(String apn, String protocol, int authType, String username,
1662             String password, Message result) {
1663     }
1664
1665     @Override
1666     public void getImsRegistrationState(Message response) {
1667         unimplemented(response);
1668     }
1669
1670     @Override
1671     public void sendImsCdmaSms(byte[] pdu, int retry, int messageRef,
1672             Message response){
1673         unimplemented(response);
1674     }
1675
1676     @Override
1677     public void sendImsGsmSms(String smscPDU, String pdu,
1678             int retry, int messageRef, Message response){
1679         unimplemented(response);
1680     }
1681
1682     @Override
1683     public void iccOpenLogicalChannel(String AID, Message response) {
1684         unimplemented(response);
1685     }
1686
1687     @Override
1688     public void iccCloseLogicalChannel(int channel, Message response) {
1689         unimplemented(response);
1690     }
1691
1692     @Override
1693     public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction,
1694             int p1, int p2, int p3, String data, Message response) {
1695         unimplemented(response);
1696     }
1697
1698     @Override
1699     public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2,
1700             int p3, String data, Message response) {
1701         unimplemented(response);
1702     }
1703 }