CDMAPhone.java revision 13cf7e43f92022a7bb71950b388805c60726589f
1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.internal.telephony.cdma;
18
19import android.app.ActivityManagerNative;
20import android.content.ContentValues;
21import android.content.Context;
22import android.content.Intent;
23import android.content.SharedPreferences;
24import android.database.SQLException;
25import android.net.Uri;
26import android.os.AsyncResult;
27import android.os.Handler;
28import android.os.Message;
29import android.os.PowerManager;
30import android.os.PowerManager.WakeLock;
31import android.os.Registrant;
32import android.os.RegistrantList;
33import android.os.SystemProperties;
34import android.os.UserHandle;
35import android.preference.PreferenceManager;
36import android.provider.Telephony;
37import android.telephony.CellLocation;
38import android.telephony.PhoneNumberUtils;
39import android.telephony.ServiceState;
40import android.telephony.SignalStrength;
41import android.text.TextUtils;
42import android.telephony.Rlog;
43
44import com.android.internal.telephony.Call;
45import com.android.internal.telephony.CallStateException;
46import com.android.internal.telephony.CallTracker;
47import com.android.internal.telephony.CommandException;
48import com.android.internal.telephony.CommandsInterface;
49import com.android.internal.telephony.Connection;
50import com.android.internal.telephony.IccCard;
51import com.android.internal.telephony.IccException;
52import com.android.internal.telephony.IccFileHandler;
53import com.android.internal.telephony.IccPhoneBookInterfaceManager;
54import com.android.internal.telephony.IccRecords;
55import com.android.internal.telephony.IccSmsInterfaceManager;
56import com.android.internal.telephony.MccTable;
57import com.android.internal.telephony.MmiCode;
58import com.android.internal.telephony.OperatorInfo;
59import com.android.internal.telephony.Phone;
60import com.android.internal.telephony.PhoneBase;
61import com.android.internal.telephony.PhoneConstants;
62import com.android.internal.telephony.PhoneNotifier;
63import com.android.internal.telephony.PhoneProxy;
64import com.android.internal.telephony.PhoneSubInfo;
65import com.android.internal.telephony.ServiceStateTracker;
66import com.android.internal.telephony.TelephonyIntents;
67import com.android.internal.telephony.TelephonyProperties;
68import com.android.internal.telephony.UiccCard;
69import com.android.internal.telephony.UiccCardApplication;
70import com.android.internal.telephony.UUSInfo;
71import com.android.internal.telephony.IccCardApplicationStatus.AppState;
72import com.android.internal.telephony.cat.CatService;
73import com.android.internal.telephony.gsm.GsmDataConnectionTracker;
74import com.android.internal.telephony.uicc.UiccController;
75
76import java.io.FileDescriptor;
77import java.io.PrintWriter;
78import java.util.ArrayList;
79import java.util.List;
80import java.util.regex.Matcher;
81import java.util.regex.Pattern;
82
83import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA;
84import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY;
85import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC;
86
87/**
88 * {@hide}
89 */
90public class CDMAPhone extends PhoneBase {
91    static final String LOG_TAG = "CDMA";
92    private static final boolean DBG = true;
93    private static final boolean VDBG = false; /* STOP SHIP if true */
94
95    // Default Emergency Callback Mode exit timer
96    private static final int DEFAULT_ECM_EXIT_TIMER_VALUE = 300000;
97
98    static final String VM_COUNT_CDMA = "vm_count_key_cdma";
99    private static final String VM_NUMBER_CDMA = "vm_number_key_cdma";
100    private String mVmNumber = null;
101
102    static final int RESTART_ECM_TIMER = 0; // restart Ecm timer
103    static final int CANCEL_ECM_TIMER = 1; // cancel Ecm timer
104
105    // Instance Variables
106    CdmaCallTracker mCT;
107    CdmaServiceStateTracker mSST;
108    CdmaSubscriptionSourceManager mCdmaSSM;
109    ArrayList <CdmaMmiCode> mPendingMmis = new ArrayList<CdmaMmiCode>();
110    RuimPhoneBookInterfaceManager mRuimPhoneBookInterfaceManager;
111    RuimSmsInterfaceManager mRuimSmsInterfaceManager;
112    int mCdmaSubscriptionSource = CdmaSubscriptionSourceManager.SUBSCRIPTION_SOURCE_UNKNOWN;
113    PhoneSubInfo mSubInfo;
114    EriManager mEriManager;
115    WakeLock mWakeLock;
116
117    // mEriFileLoadedRegistrants are informed after the ERI text has been loaded
118    private final RegistrantList mEriFileLoadedRegistrants = new RegistrantList();
119
120    // mEcmTimerResetRegistrants are informed after Ecm timer is canceled or re-started
121    private final RegistrantList mEcmTimerResetRegistrants = new RegistrantList();
122
123    // mEcmExitRespRegistrant is informed after the phone has been exited
124    //the emergency callback mode
125    //keep track of if phone is in emergency callback mode
126    private boolean mIsPhoneInEcmState;
127    private Registrant mEcmExitRespRegistrant;
128    protected String mImei;
129    protected String mImeiSv;
130    private String mEsn;
131    private String mMeid;
132    // string to define how the carrier specifies its own ota sp number
133    private String mCarrierOtaSpNumSchema;
134
135    // A runnable which is used to automatically exit from Ecm after a period of time.
136    private Runnable mExitEcmRunnable = new Runnable() {
137        @Override
138        public void run() {
139            exitEmergencyCallbackMode();
140        }
141    };
142
143    Registrant mPostDialHandler;
144
145    static String PROPERTY_CDMA_HOME_OPERATOR_NUMERIC = "ro.cdma.home.operator.numeric";
146
147    // Constructors
148    public CDMAPhone(Context context, CommandsInterface ci, PhoneNotifier notifier) {
149        super(notifier, context, ci, false);
150        initSstIcc();
151        init(context, notifier);
152    }
153
154    public CDMAPhone(Context context, CommandsInterface ci, PhoneNotifier notifier,
155            boolean unitTestMode) {
156        super(notifier, context, ci, unitTestMode);
157        initSstIcc();
158        init(context, notifier);
159    }
160
161    protected void initSstIcc() {
162        mSST = new CdmaServiceStateTracker(this);
163    }
164
165    protected void init(Context context, PhoneNotifier notifier) {
166        mCM.setPhoneType(PhoneConstants.PHONE_TYPE_CDMA);
167        mCT = new CdmaCallTracker(this);
168        mCdmaSSM = CdmaSubscriptionSourceManager.getInstance(context, mCM, this,
169                EVENT_CDMA_SUBSCRIPTION_SOURCE_CHANGED, null);
170        mSMS = new CdmaSMSDispatcher(this, mSmsStorageMonitor, mSmsUsageMonitor);
171        mDataConnectionTracker = new GsmDataConnectionTracker (this);
172        mRuimPhoneBookInterfaceManager = new RuimPhoneBookInterfaceManager(this);
173        mRuimSmsInterfaceManager = new RuimSmsInterfaceManager(this, mSMS);
174        mSubInfo = new PhoneSubInfo(this);
175        mEriManager = new EriManager(this, context, EriManager.ERI_FROM_XML);
176
177        mCM.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null);
178        mCM.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null);
179        mCM.registerForOn(this, EVENT_RADIO_ON, null);
180        mCM.setOnSuppServiceNotification(this, EVENT_SSN, null);
181        mSST.registerForNetworkAttached(this, EVENT_REGISTERED_TO_NETWORK, null);
182        mCM.setEmergencyCallbackMode(this, EVENT_EMERGENCY_CALLBACK_MODE_ENTER, null);
183
184        PowerManager pm
185            = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
186        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,LOG_TAG);
187
188        //Change the system setting
189        SystemProperties.set(TelephonyProperties.CURRENT_ACTIVE_PHONE,
190                Integer.toString(PhoneConstants.PHONE_TYPE_CDMA));
191
192        // This is needed to handle phone process crashes
193        String inEcm=SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE, "false");
194        mIsPhoneInEcmState = inEcm.equals("true");
195        if (mIsPhoneInEcmState) {
196            // Send a message which will invoke handleExitEmergencyCallbackMode
197            mCM.exitEmergencyCallbackMode(obtainMessage(EVENT_EXIT_EMERGENCY_CALLBACK_RESPONSE));
198        }
199
200        // get the string that specifies the carrier OTA Sp number
201        mCarrierOtaSpNumSchema = SystemProperties.get(
202                TelephonyProperties.PROPERTY_OTASP_NUM_SCHEMA,"");
203
204        // Sets operator alpha property by retrieving from build-time system property
205        String operatorAlpha = SystemProperties.get("ro.cdma.home.operator.alpha");
206        setSystemProperty(PROPERTY_ICC_OPERATOR_ALPHA, operatorAlpha);
207
208        // Sets operator numeric property by retrieving from build-time system property
209        String operatorNumeric = SystemProperties.get(PROPERTY_CDMA_HOME_OPERATOR_NUMERIC);
210        log("CDMAPhone: init set 'gsm.sim.operator.numeric' to operator='" +
211                operatorNumeric + "'");
212        setSystemProperty(PROPERTY_ICC_OPERATOR_NUMERIC, operatorNumeric);
213
214        // Sets iso country property by retrieving from build-time system property
215        setIsoCountryProperty(operatorNumeric);
216
217        // Sets current entry in the telephony carrier table
218        updateCurrentCarrierInProvider(operatorNumeric);
219
220        // Notify voicemails.
221        notifier.notifyMessageWaitingChanged(this);
222    }
223
224    @Override
225    public void dispose() {
226        synchronized(PhoneProxy.lockForRadioTechnologyChange) {
227            super.dispose();
228            log("dispose");
229
230            //Unregister from all former registered events
231            unregisterForRuimRecordEvents();
232            mCM.unregisterForAvailable(this); //EVENT_RADIO_AVAILABLE
233            mCM.unregisterForOffOrNotAvailable(this); //EVENT_RADIO_OFF_OR_NOT_AVAILABLE
234            mCM.unregisterForOn(this); //EVENT_RADIO_ON
235            mSST.unregisterForNetworkAttached(this); //EVENT_REGISTERED_TO_NETWORK
236            mCM.unSetOnSuppServiceNotification(this);
237            removeCallbacks(mExitEcmRunnable);
238
239            mPendingMmis.clear();
240
241            //Force all referenced classes to unregister their former registered events
242            mCT.dispose();
243            mDataConnectionTracker.dispose();
244            mSST.dispose();
245            mCdmaSSM.dispose(this);
246            mSMS.dispose();
247            mRuimPhoneBookInterfaceManager.dispose();
248            mRuimSmsInterfaceManager.dispose();
249            mSubInfo.dispose();
250            mEriManager.dispose();
251        }
252    }
253
254    @Override
255    public void removeReferences() {
256        log("removeReferences");
257        mRuimPhoneBookInterfaceManager = null;
258        mRuimSmsInterfaceManager = null;
259        mSubInfo = null;
260        mCT = null;
261        mSST = null;
262        mEriManager = null;
263        mExitEcmRunnable = null;
264        super.removeReferences();
265    }
266
267    @Override
268    protected void finalize() {
269        if(DBG) Rlog.d(LOG_TAG, "CDMAPhone finalized");
270        if (mWakeLock.isHeld()) {
271            Rlog.e(LOG_TAG, "UNEXPECTED; mWakeLock is held when finalizing.");
272            mWakeLock.release();
273        }
274    }
275
276    public ServiceState getServiceState() {
277        return mSST.ss;
278    }
279
280    public CallTracker getCallTracker() {
281        return mCT;
282    }
283
284    public PhoneConstants.State getState() {
285        return mCT.state;
286    }
287
288    public ServiceStateTracker getServiceStateTracker() {
289        return mSST;
290    }
291
292    public String getPhoneName() {
293        return "CDMA";
294    }
295
296    public int getPhoneType() {
297        return PhoneConstants.PHONE_TYPE_CDMA;
298    }
299
300    public boolean canTransfer() {
301        Rlog.e(LOG_TAG, "canTransfer: not possible in CDMA");
302        return false;
303    }
304
305    public CdmaCall getRingingCall() {
306        return mCT.ringingCall;
307    }
308
309    public void setMute(boolean muted) {
310        mCT.setMute(muted);
311    }
312
313    public boolean getMute() {
314        return mCT.getMute();
315    }
316
317    public void conference() throws CallStateException {
318        // three way calls in CDMA will be handled by feature codes
319        Rlog.e(LOG_TAG, "conference: not possible in CDMA");
320    }
321
322    public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) {
323        this.mCM.setPreferredVoicePrivacy(enable, onComplete);
324    }
325
326    public void getEnhancedVoicePrivacy(Message onComplete) {
327        this.mCM.getPreferredVoicePrivacy(onComplete);
328    }
329
330    public void clearDisconnected() {
331        mCT.clearDisconnected();
332    }
333
334    public DataActivityState getDataActivityState() {
335        DataActivityState ret = DataActivityState.NONE;
336
337        if (mSST.getCurrentDataConnectionState() == ServiceState.STATE_IN_SERVICE) {
338
339            switch (mDataConnectionTracker.getActivity()) {
340                case DATAIN:
341                    ret = DataActivityState.DATAIN;
342                break;
343
344                case DATAOUT:
345                    ret = DataActivityState.DATAOUT;
346                break;
347
348                case DATAINANDOUT:
349                    ret = DataActivityState.DATAINANDOUT;
350                break;
351
352                case DORMANT:
353                    ret = DataActivityState.DORMANT;
354                break;
355            }
356        }
357        return ret;
358    }
359
360    public Connection
361    dial (String dialString) throws CallStateException {
362        // Need to make sure dialString gets parsed properly
363        String newDialString = PhoneNumberUtils.stripSeparators(dialString);
364        return mCT.dial(newDialString);
365    }
366
367    public Connection dial(String dialString, UUSInfo uusInfo) throws CallStateException {
368        throw new CallStateException("Sending UUS information NOT supported in CDMA!");
369    }
370
371    public boolean
372    getMessageWaitingIndicator() {
373        return (getVoiceMessageCount() > 0);
374    }
375
376    public List<? extends MmiCode>
377    getPendingMmiCodes() {
378        return mPendingMmis;
379    }
380
381    public void registerForSuppServiceNotification(
382            Handler h, int what, Object obj) {
383        Rlog.e(LOG_TAG, "method registerForSuppServiceNotification is NOT supported in CDMA!");
384    }
385
386    public CdmaCall getBackgroundCall() {
387        return mCT.backgroundCall;
388    }
389
390    public boolean handleInCallMmiCommands(String dialString) {
391        Rlog.e(LOG_TAG, "method handleInCallMmiCommands is NOT supported in CDMA!");
392        return false;
393    }
394
395    boolean isInCall() {
396        CdmaCall.State foregroundCallState = getForegroundCall().getState();
397        CdmaCall.State backgroundCallState = getBackgroundCall().getState();
398        CdmaCall.State ringingCallState = getRingingCall().getState();
399
400        return (foregroundCallState.isAlive() || backgroundCallState.isAlive() || ringingCallState
401                .isAlive());
402    }
403
404    public void
405    setNetworkSelectionModeAutomatic(Message response) {
406        Rlog.e(LOG_TAG, "method setNetworkSelectionModeAutomatic is NOT supported in CDMA!");
407    }
408
409    public void unregisterForSuppServiceNotification(Handler h) {
410        Rlog.e(LOG_TAG, "method unregisterForSuppServiceNotification is NOT supported in CDMA!");
411    }
412
413    public void
414    acceptCall() throws CallStateException {
415        mCT.acceptCall();
416    }
417
418    public void
419    rejectCall() throws CallStateException {
420        mCT.rejectCall();
421    }
422
423    public void
424    switchHoldingAndActive() throws CallStateException {
425        mCT.switchWaitingOrHoldingAndActive();
426    }
427
428    public String getLine1Number() {
429        return mSST.getMdnNumber();
430    }
431
432    public String getCdmaPrlVersion(){
433        return mSST.getPrlVersion();
434    }
435
436    public String getCdmaMin() {
437        return mSST.getCdmaMin();
438    }
439
440    public boolean isMinInfoReady() {
441        return mSST.isMinInfoReady();
442    }
443
444    public void getCallWaiting(Message onComplete) {
445        mCM.queryCallWaiting(CommandsInterface.SERVICE_CLASS_VOICE, onComplete);
446    }
447
448    public void
449    setRadioPower(boolean power) {
450        mSST.setRadioPower(power);
451    }
452
453    public String getEsn() {
454        return mEsn;
455    }
456
457    public String getMeid() {
458        return mMeid;
459    }
460
461    //returns MEID or ESN in CDMA
462    public String getDeviceId() {
463        String id = getMeid();
464        if ((id == null) || id.matches("^0*$")) {
465            Rlog.d(LOG_TAG, "getDeviceId(): MEID is not initialized use ESN");
466            id = getEsn();
467        }
468        return id;
469    }
470
471    public String getDeviceSvn() {
472        Rlog.d(LOG_TAG, "getDeviceSvn(): return 0");
473        return "0";
474    }
475
476    public String getSubscriberId() {
477        return mSST.getImsi();
478    }
479
480    public String getImei() {
481        Rlog.e(LOG_TAG, "IMEI is not available in CDMA");
482        return null;
483    }
484
485    public boolean canConference() {
486        Rlog.e(LOG_TAG, "canConference: not possible in CDMA");
487        return false;
488    }
489
490    public CellLocation getCellLocation() {
491        return mSST.cellLoc;
492    }
493
494    public CdmaCall getForegroundCall() {
495        return mCT.foregroundCall;
496    }
497
498    public void
499    selectNetworkManually(OperatorInfo network,
500            Message response) {
501        Rlog.e(LOG_TAG, "selectNetworkManually: not possible in CDMA");
502    }
503
504    public void setOnPostDialCharacter(Handler h, int what, Object obj) {
505        mPostDialHandler = new Registrant(h, what, obj);
506    }
507
508    public boolean handlePinMmi(String dialString) {
509        CdmaMmiCode mmi = CdmaMmiCode.newFromDialString(dialString, this);
510
511        if (mmi == null) {
512            Rlog.e(LOG_TAG, "Mmi is NULL!");
513            return false;
514        } else if (mmi.isPukCommand()) {
515            mPendingMmis.add(mmi);
516            mMmiRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null));
517            mmi.processCode();
518            return true;
519        }
520        Rlog.e(LOG_TAG, "Unrecognized mmi!");
521        return false;
522    }
523
524    /**
525     * Removes the given MMI from the pending list and notifies registrants that
526     * it is complete.
527     *
528     * @param mmi MMI that is done
529     */
530    void onMMIDone(CdmaMmiCode mmi) {
531        /*
532         * Only notify complete if it's on the pending list. Otherwise, it's
533         * already been handled (eg, previously canceled).
534         */
535        if (mPendingMmis.remove(mmi)) {
536            mMmiCompleteRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null));
537        }
538    }
539
540    public void setLine1Number(String alphaTag, String number, Message onComplete) {
541        Rlog.e(LOG_TAG, "setLine1Number: not possible in CDMA");
542    }
543
544    public void setCallWaiting(boolean enable, Message onComplete) {
545        Rlog.e(LOG_TAG, "method setCallWaiting is NOT supported in CDMA!");
546    }
547
548    public void updateServiceLocation() {
549        mSST.enableSingleLocationUpdate();
550    }
551
552    public void setDataRoamingEnabled(boolean enable) {
553        mDataConnectionTracker.setDataOnRoamingEnabled(enable);
554    }
555
556    public void registerForCdmaOtaStatusChange(Handler h, int what, Object obj) {
557        mCM.registerForCdmaOtaProvision(h, what, obj);
558    }
559
560    public void unregisterForCdmaOtaStatusChange(Handler h) {
561        mCM.unregisterForCdmaOtaProvision(h);
562    }
563
564    public void registerForSubscriptionInfoReady(Handler h, int what, Object obj) {
565        mSST.registerForSubscriptionInfoReady(h, what, obj);
566    }
567
568    public void unregisterForSubscriptionInfoReady(Handler h) {
569        mSST.unregisterForSubscriptionInfoReady(h);
570    }
571
572    public void setOnEcbModeExitResponse(Handler h, int what, Object obj) {
573        mEcmExitRespRegistrant = new Registrant (h, what, obj);
574    }
575
576    public void unsetOnEcbModeExitResponse(Handler h) {
577        mEcmExitRespRegistrant.clear();
578    }
579
580    public void registerForCallWaiting(Handler h, int what, Object obj) {
581        mCT.registerForCallWaiting(h, what, obj);
582    }
583
584    public void unregisterForCallWaiting(Handler h) {
585        mCT.unregisterForCallWaiting(h);
586    }
587
588    public void
589    getNeighboringCids(Message response) {
590        /*
591         * This is currently not implemented.  At least as of June
592         * 2009, there is no neighbor cell information available for
593         * CDMA because some party is resisting making this
594         * information readily available.  Consequently, calling this
595         * function can have no useful effect.  This situation may
596         * (and hopefully will) change in the future.
597         */
598        if (response != null) {
599            CommandException ce = new CommandException(
600                    CommandException.Error.REQUEST_NOT_SUPPORTED);
601            AsyncResult.forMessage(response).exception = ce;
602            response.sendToTarget();
603        }
604    }
605
606    public PhoneConstants.DataState getDataConnectionState(String apnType) {
607        PhoneConstants.DataState ret = PhoneConstants.DataState.DISCONNECTED;
608
609        if (mSST == null) {
610             // Radio Technology Change is ongoning, dispose() and removeReferences() have
611             // already been called
612
613             ret = PhoneConstants.DataState.DISCONNECTED;
614        } else if (mSST.getCurrentDataConnectionState() != ServiceState.STATE_IN_SERVICE) {
615            // If we're out of service, open TCP sockets may still work
616            // but no data will flow
617            ret = PhoneConstants.DataState.DISCONNECTED;
618        } else if (mDataConnectionTracker.isApnTypeEnabled(apnType) == false ||
619                mDataConnectionTracker.isApnTypeActive(apnType) == false) {
620            ret = PhoneConstants.DataState.DISCONNECTED;
621        } else {
622            switch (mDataConnectionTracker.getState(apnType)) {
623                case FAILED:
624                case IDLE:
625                    ret = PhoneConstants.DataState.DISCONNECTED;
626                break;
627
628                case CONNECTED:
629                case DISCONNECTING:
630                    if ( mCT.state != PhoneConstants.State.IDLE
631                            && !mSST.isConcurrentVoiceAndDataAllowed()) {
632                        ret = PhoneConstants.DataState.SUSPENDED;
633                    } else {
634                        ret = PhoneConstants.DataState.CONNECTED;
635                    }
636                break;
637
638                case CONNECTING:
639                case SCANNING:
640                    ret = PhoneConstants.DataState.CONNECTING;
641                break;
642            }
643        }
644
645        log("getDataConnectionState apnType=" + apnType + " ret=" + ret);
646        return ret;
647    }
648
649    public void sendUssdResponse(String ussdMessge) {
650        Rlog.e(LOG_TAG, "sendUssdResponse: not possible in CDMA");
651    }
652
653    public void sendDtmf(char c) {
654        if (!PhoneNumberUtils.is12Key(c)) {
655            Rlog.e(LOG_TAG,
656                    "sendDtmf called with invalid character '" + c + "'");
657        } else {
658            if (mCT.state ==  PhoneConstants.State.OFFHOOK) {
659                mCM.sendDtmf(c, null);
660            }
661        }
662    }
663
664    public void startDtmf(char c) {
665        if (!PhoneNumberUtils.is12Key(c)) {
666            Rlog.e(LOG_TAG,
667                    "startDtmf called with invalid character '" + c + "'");
668        } else {
669            mCM.startDtmf(c, null);
670        }
671    }
672
673    public void stopDtmf() {
674        mCM.stopDtmf(null);
675    }
676
677    public void sendBurstDtmf(String dtmfString, int on, int off, Message onComplete) {
678        boolean check = true;
679        for (int itr = 0;itr < dtmfString.length(); itr++) {
680            if (!PhoneNumberUtils.is12Key(dtmfString.charAt(itr))) {
681                Rlog.e(LOG_TAG,
682                        "sendDtmf called with invalid character '" + dtmfString.charAt(itr)+ "'");
683                check = false;
684                break;
685            }
686        }
687        if ((mCT.state ==  PhoneConstants.State.OFFHOOK)&&(check)) {
688            mCM.sendBurstDtmf(dtmfString, on, off, onComplete);
689        }
690     }
691
692    public void getAvailableNetworks(Message response) {
693        Rlog.e(LOG_TAG, "getAvailableNetworks: not possible in CDMA");
694    }
695
696    public void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, Message onComplete) {
697        Rlog.e(LOG_TAG, "setOutgoingCallerIdDisplay: not possible in CDMA");
698    }
699
700    public void enableLocationUpdates() {
701        mSST.enableLocationUpdates();
702    }
703
704    public void disableLocationUpdates() {
705        mSST.disableLocationUpdates();
706    }
707
708    public void getDataCallList(Message response) {
709        mCM.getDataCallList(response);
710    }
711
712    public boolean getDataRoamingEnabled() {
713        return mDataConnectionTracker.getDataOnRoamingEnabled();
714    }
715
716    public void setVoiceMailNumber(String alphaTag,
717                                   String voiceMailNumber,
718                                   Message onComplete) {
719        Message resp;
720        mVmNumber = voiceMailNumber;
721        resp = obtainMessage(EVENT_SET_VM_NUMBER_DONE, 0, 0, onComplete);
722        IccRecords r = mIccRecords.get();
723        if (r != null) {
724            r.setVoiceMailNumber(alphaTag, mVmNumber, resp);
725        }
726    }
727
728    public String getVoiceMailNumber() {
729        String number = null;
730        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
731        // TODO: The default value of voicemail number should be read from a system property
732
733        // Read platform settings for dynamic voicemail number
734        if (getContext().getResources().getBoolean(com.android.internal
735                .R.bool.config_telephony_use_own_number_for_voicemail)) {
736            number = sp.getString(VM_NUMBER_CDMA, getLine1Number());
737        } else {
738            number = sp.getString(VM_NUMBER_CDMA, "*86");
739        }
740        return number;
741    }
742
743    /* Returns Number of Voicemails
744     * @hide
745     */
746    public int getVoiceMessageCount() {
747        IccRecords r = mIccRecords.get();
748        int voicemailCount =  (r != null) ? r.getVoiceMessageCount() : 0;
749        // If mRuimRecords.getVoiceMessageCount returns zero, then there is possibility
750        // that phone was power cycled and would have lost the voicemail count.
751        // So get the count from preferences.
752        if (voicemailCount == 0) {
753            SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
754            voicemailCount = sp.getInt(VM_COUNT_CDMA, 0);
755        }
756        return voicemailCount;
757    }
758
759    public String getVoiceMailAlphaTag() {
760        // TODO: Where can we get this value has to be clarified with QC.
761        String ret = "";//TODO: Remove = "", if we know where to get this value.
762
763        //ret = mSIMRecords.getVoiceMailAlphaTag();
764
765        if (ret == null || ret.length() == 0) {
766            return mContext.getText(
767                com.android.internal.R.string.defaultVoiceMailAlphaTag).toString();
768        }
769
770        return ret;
771    }
772
773    public void getCallForwardingOption(int commandInterfaceCFReason, Message onComplete) {
774        Rlog.e(LOG_TAG, "getCallForwardingOption: not possible in CDMA");
775    }
776
777    public void setCallForwardingOption(int commandInterfaceCFAction,
778            int commandInterfaceCFReason,
779            String dialingNumber,
780            int timerSeconds,
781            Message onComplete) {
782        Rlog.e(LOG_TAG, "setCallForwardingOption: not possible in CDMA");
783    }
784
785    public void
786    getOutgoingCallerIdDisplay(Message onComplete) {
787        Rlog.e(LOG_TAG, "getOutgoingCallerIdDisplay: not possible in CDMA");
788    }
789
790    public boolean
791    getCallForwardingIndicator() {
792        Rlog.e(LOG_TAG, "getCallForwardingIndicator: not possible in CDMA");
793        return false;
794    }
795
796    public void explicitCallTransfer() {
797        Rlog.e(LOG_TAG, "explicitCallTransfer: not possible in CDMA");
798    }
799
800    public String getLine1AlphaTag() {
801        Rlog.e(LOG_TAG, "getLine1AlphaTag: not possible in CDMA");
802        return null;
803    }
804
805    /**
806     * Notify any interested party of a Phone state change  {@link PhoneConstants.State}
807     */
808    /*package*/ void notifyPhoneStateChanged() {
809        mNotifier.notifyPhoneState(this);
810    }
811
812    /**
813     * Notify registrants of a change in the call state. This notifies changes in {@link Call.State}
814     * Use this when changes in the precise call state are needed, else use notifyPhoneStateChanged.
815     */
816    /*package*/ void notifyPreciseCallStateChanged() {
817        /* we'd love it if this was package-scoped*/
818        super.notifyPreciseCallStateChangedP();
819    }
820
821     void notifyServiceStateChanged(ServiceState ss) {
822         super.notifyServiceStateChangedP(ss);
823     }
824
825     void notifyLocationChanged() {
826         mNotifier.notifyCellLocation(this);
827     }
828
829    /*package*/ void notifyNewRingingConnection(Connection c) {
830        /* we'd love it if this was package-scoped*/
831        super.notifyNewRingingConnectionP(c);
832    }
833
834    /*package*/ void notifyDisconnect(Connection cn) {
835        mDisconnectRegistrants.notifyResult(cn);
836    }
837
838    void notifyUnknownConnection() {
839        mUnknownConnectionRegistrants.notifyResult(this);
840    }
841
842    public boolean isInEmergencyCall() {
843        return mCT.isInEmergencyCall();
844    }
845
846    public boolean isInEcm() {
847        return mIsPhoneInEcmState;
848    }
849
850    void sendEmergencyCallbackModeChange(){
851        //Send an Intent
852        Intent intent = new Intent(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
853        intent.putExtra(PhoneConstants.PHONE_IN_ECM_STATE, mIsPhoneInEcmState);
854        ActivityManagerNative.broadcastStickyIntent(intent,null,UserHandle.USER_ALL);
855        if (DBG) Rlog.d(LOG_TAG, "sendEmergencyCallbackModeChange");
856    }
857
858    @Override
859    public void exitEmergencyCallbackMode() {
860        if (mWakeLock.isHeld()) {
861            mWakeLock.release();
862        }
863        // Send a message which will invoke handleExitEmergencyCallbackMode
864        mCM.exitEmergencyCallbackMode(obtainMessage(EVENT_EXIT_EMERGENCY_CALLBACK_RESPONSE));
865    }
866
867    private void handleEnterEmergencyCallbackMode(Message msg) {
868        if (DBG) {
869            Rlog.d(LOG_TAG, "handleEnterEmergencyCallbackMode,mIsPhoneInEcmState= "
870                    + mIsPhoneInEcmState);
871        }
872        // if phone is not in Ecm mode, and it's changed to Ecm mode
873        if (mIsPhoneInEcmState == false) {
874            mIsPhoneInEcmState = true;
875            // notify change
876            sendEmergencyCallbackModeChange();
877            setSystemProperty(TelephonyProperties.PROPERTY_INECM_MODE, "true");
878
879            // Post this runnable so we will automatically exit
880            // if no one invokes exitEmergencyCallbackMode() directly.
881            long delayInMillis = SystemProperties.getLong(
882                    TelephonyProperties.PROPERTY_ECM_EXIT_TIMER, DEFAULT_ECM_EXIT_TIMER_VALUE);
883            postDelayed(mExitEcmRunnable, delayInMillis);
884            // We don't want to go to sleep while in Ecm
885            mWakeLock.acquire();
886        }
887    }
888
889    private void handleExitEmergencyCallbackMode(Message msg) {
890        AsyncResult ar = (AsyncResult)msg.obj;
891        if (DBG) {
892            Rlog.d(LOG_TAG, "handleExitEmergencyCallbackMode,ar.exception , mIsPhoneInEcmState "
893                    + ar.exception + mIsPhoneInEcmState);
894        }
895        // Remove pending exit Ecm runnable, if any
896        removeCallbacks(mExitEcmRunnable);
897
898        if (mEcmExitRespRegistrant != null) {
899            mEcmExitRespRegistrant.notifyRegistrant(ar);
900        }
901        // if exiting ecm success
902        if (ar.exception == null) {
903            if (mIsPhoneInEcmState) {
904                mIsPhoneInEcmState = false;
905                setSystemProperty(TelephonyProperties.PROPERTY_INECM_MODE, "false");
906            }
907            // send an Intent
908            sendEmergencyCallbackModeChange();
909            // Re-initiate data connection
910            mDataConnectionTracker.setInternalDataEnabled(true);
911        }
912    }
913
914    /**
915     * Handle to cancel or restart Ecm timer in emergency call back mode
916     * if action is CANCEL_ECM_TIMER, cancel Ecm timer and notify apps the timer is canceled;
917     * otherwise, restart Ecm timer and notify apps the timer is restarted.
918     */
919    void handleTimerInEmergencyCallbackMode(int action) {
920        switch(action) {
921        case CANCEL_ECM_TIMER:
922            removeCallbacks(mExitEcmRunnable);
923            mEcmTimerResetRegistrants.notifyResult(Boolean.TRUE);
924            break;
925        case RESTART_ECM_TIMER:
926            long delayInMillis = SystemProperties.getLong(
927                    TelephonyProperties.PROPERTY_ECM_EXIT_TIMER, DEFAULT_ECM_EXIT_TIMER_VALUE);
928            postDelayed(mExitEcmRunnable, delayInMillis);
929            mEcmTimerResetRegistrants.notifyResult(Boolean.FALSE);
930            break;
931        default:
932            Rlog.e(LOG_TAG, "handleTimerInEmergencyCallbackMode, unsupported action " + action);
933        }
934    }
935
936    /**
937     * Registration point for Ecm timer reset
938     * @param h handler to notify
939     * @param what User-defined message code
940     * @param obj placed in Message.obj
941     */
942    public void registerForEcmTimerReset(Handler h, int what, Object obj) {
943        mEcmTimerResetRegistrants.addUnique(h, what, obj);
944    }
945
946    public void unregisterForEcmTimerReset(Handler h) {
947        mEcmTimerResetRegistrants.remove(h);
948    }
949
950    @Override
951    public void handleMessage(Message msg) {
952        AsyncResult ar;
953        Message     onComplete;
954
955        switch(msg.what) {
956            case EVENT_RADIO_AVAILABLE: {
957                mCM.getBasebandVersion(obtainMessage(EVENT_GET_BASEBAND_VERSION_DONE));
958
959                mCM.getDeviceIdentity(obtainMessage(EVENT_GET_DEVICE_IDENTITY_DONE));
960            }
961            break;
962
963            case EVENT_GET_BASEBAND_VERSION_DONE:{
964                ar = (AsyncResult)msg.obj;
965
966                if (ar.exception != null) {
967                    break;
968                }
969
970                if (DBG) Rlog.d(LOG_TAG, "Baseband version: " + ar.result);
971                setSystemProperty(TelephonyProperties.PROPERTY_BASEBAND_VERSION, (String)ar.result);
972            }
973            break;
974
975            case EVENT_GET_DEVICE_IDENTITY_DONE:{
976                ar = (AsyncResult)msg.obj;
977
978                if (ar.exception != null) {
979                    break;
980                }
981                String[] respId = (String[])ar.result;
982                mImei = respId[0];
983                mImeiSv = respId[1];
984                mEsn  =  respId[2];
985                mMeid =  respId[3];
986            }
987            break;
988
989            case EVENT_EMERGENCY_CALLBACK_MODE_ENTER:{
990                handleEnterEmergencyCallbackMode(msg);
991            }
992            break;
993
994            case EVENT_ICC_RECORD_EVENTS:
995                ar = (AsyncResult)msg.obj;
996                processIccRecordEvents((Integer)ar.result);
997                break;
998
999            case  EVENT_EXIT_EMERGENCY_CALLBACK_RESPONSE:{
1000                handleExitEmergencyCallbackMode(msg);
1001            }
1002            break;
1003
1004            case EVENT_RUIM_RECORDS_LOADED:{
1005                Rlog.d(LOG_TAG, "Event EVENT_RUIM_RECORDS_LOADED Received");
1006                updateCurrentCarrierInProvider();
1007            }
1008            break;
1009
1010            case EVENT_RADIO_OFF_OR_NOT_AVAILABLE:{
1011                Rlog.d(LOG_TAG, "Event EVENT_RADIO_OFF_OR_NOT_AVAILABLE Received");
1012            }
1013            break;
1014
1015            case EVENT_RADIO_ON:{
1016                Rlog.d(LOG_TAG, "Event EVENT_RADIO_ON Received");
1017                handleCdmaSubscriptionSource(mCdmaSSM.getCdmaSubscriptionSource());
1018            }
1019            break;
1020
1021            case EVENT_CDMA_SUBSCRIPTION_SOURCE_CHANGED:{
1022                Rlog.d(LOG_TAG, "EVENT_CDMA_SUBSCRIPTION_SOURCE_CHANGED");
1023                handleCdmaSubscriptionSource(mCdmaSSM.getCdmaSubscriptionSource());
1024            }
1025            break;
1026
1027            case EVENT_SSN:{
1028                Rlog.d(LOG_TAG, "Event EVENT_SSN Received");
1029            }
1030            break;
1031
1032            case EVENT_REGISTERED_TO_NETWORK:{
1033                Rlog.d(LOG_TAG, "Event EVENT_REGISTERED_TO_NETWORK Received");
1034            }
1035            break;
1036
1037            case EVENT_NV_READY:{
1038                Rlog.d(LOG_TAG, "Event EVENT_NV_READY Received");
1039                prepareEri();
1040            }
1041            break;
1042
1043            case EVENT_SET_VM_NUMBER_DONE:{
1044                ar = (AsyncResult)msg.obj;
1045                if (IccException.class.isInstance(ar.exception)) {
1046                    storeVoiceMailNumber(mVmNumber);
1047                    ar.exception = null;
1048                }
1049                onComplete = (Message) ar.userObj;
1050                if (onComplete != null) {
1051                    AsyncResult.forMessage(onComplete, ar.result, ar.exception);
1052                    onComplete.sendToTarget();
1053                }
1054            }
1055            break;
1056
1057            default:{
1058                super.handleMessage(msg);
1059            }
1060        }
1061    }
1062
1063    @Override
1064    protected void onUpdateIccAvailability() {
1065        if (mUiccController == null ) {
1066            return;
1067        }
1068
1069        UiccCardApplication newUiccApplication =
1070                mUiccController.getUiccCardApplication(UiccController.APP_FAM_3GPP2);
1071
1072        UiccCardApplication app = mUiccApplication.get();
1073        if (app != newUiccApplication) {
1074            if (app != null) {
1075                log("Removing stale icc objects.");
1076                if (mIccRecords.get() != null) {
1077                    unregisterForRuimRecordEvents();
1078                    mRuimPhoneBookInterfaceManager.updateIccRecords(null);
1079                }
1080                mIccRecords.set(null);
1081                mUiccApplication.set(null);
1082            }
1083            if (newUiccApplication != null) {
1084                log("New Uicc application found");
1085                mUiccApplication.set(newUiccApplication);
1086                mIccRecords.set(newUiccApplication.getIccRecords());
1087                registerForRuimRecordEvents();
1088                mRuimPhoneBookInterfaceManager.updateIccRecords(mIccRecords.get());
1089            }
1090        }
1091    }
1092
1093    private void processIccRecordEvents(int eventCode) {
1094        switch (eventCode) {
1095            case RuimRecords.EVENT_MWI:
1096                notifyMessageWaitingIndicator();
1097                break;
1098
1099            default:
1100                Rlog.e(LOG_TAG,"Unknown icc records event code " + eventCode);
1101                break;
1102        }
1103    }
1104
1105    /**
1106     * Handles the call to get the subscription source
1107     *
1108     * @param newSubscriptionSource holds the new CDMA subscription source value
1109     */
1110    private void handleCdmaSubscriptionSource(int newSubscriptionSource) {
1111        if (newSubscriptionSource != mCdmaSubscriptionSource) {
1112             mCdmaSubscriptionSource = newSubscriptionSource;
1113             if (newSubscriptionSource == CDMA_SUBSCRIPTION_NV) {
1114                 // NV is ready when subscription source is NV
1115                 sendMessage(obtainMessage(EVENT_NV_READY));
1116             }
1117        }
1118    }
1119
1120    /**
1121     * Retrieves the PhoneSubInfo of the CDMAPhone
1122     */
1123    public PhoneSubInfo getPhoneSubInfo() {
1124        return mSubInfo;
1125    }
1126
1127    /**
1128     * Retrieves the IccSmsInterfaceManager of the CDMAPhone
1129     */
1130    public IccSmsInterfaceManager getIccSmsInterfaceManager() {
1131        return mRuimSmsInterfaceManager;
1132    }
1133
1134    /**
1135     * Retrieves the IccPhoneBookInterfaceManager of the CDMAPhone
1136     */
1137    public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager() {
1138        return mRuimPhoneBookInterfaceManager;
1139    }
1140
1141    public void registerForEriFileLoaded(Handler h, int what, Object obj) {
1142        Registrant r = new Registrant (h, what, obj);
1143        mEriFileLoadedRegistrants.add(r);
1144    }
1145
1146    public void unregisterForEriFileLoaded(Handler h) {
1147        mEriFileLoadedRegistrants.remove(h);
1148    }
1149
1150    // override for allowing access from other classes of this package
1151    /**
1152     * {@inheritDoc}
1153     */
1154    public final void setSystemProperty(String property, String value) {
1155        super.setSystemProperty(property, value);
1156    }
1157
1158    /**
1159     * Activate or deactivate cell broadcast SMS.
1160     *
1161     * @param activate 0 = activate, 1 = deactivate
1162     * @param response Callback message is empty on completion
1163     */
1164    public void activateCellBroadcastSms(int activate, Message response) {
1165        Rlog.e(LOG_TAG, "[CDMAPhone] activateCellBroadcastSms() is obsolete; use SmsManager");
1166        response.sendToTarget();
1167    }
1168
1169    /**
1170     * Query the current configuration of cdma cell broadcast SMS.
1171     *
1172     * @param response Callback message is empty on completion
1173     */
1174    public void getCellBroadcastSmsConfig(Message response) {
1175        Rlog.e(LOG_TAG, "[CDMAPhone] getCellBroadcastSmsConfig() is obsolete; use SmsManager");
1176        response.sendToTarget();
1177    }
1178
1179    /**
1180     * Configure cdma cell broadcast SMS.
1181     *
1182     * @param response Callback message is empty on completion
1183     */
1184    public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response) {
1185        Rlog.e(LOG_TAG, "[CDMAPhone] setCellBroadcastSmsConfig() is obsolete; use SmsManager");
1186        response.sendToTarget();
1187    }
1188
1189    /**
1190     * Returns true if OTA Service Provisioning needs to be performed.
1191     */
1192    @Override
1193    public boolean needsOtaServiceProvisioning() {
1194        return mSST.getOtasp() != ServiceStateTracker.OTASP_NOT_NEEDED;
1195    }
1196
1197    private static final String IS683A_FEATURE_CODE = "*228";
1198    private static final int IS683A_FEATURE_CODE_NUM_DIGITS = 4;
1199    private static final int IS683A_SYS_SEL_CODE_NUM_DIGITS = 2;
1200    private static final int IS683A_SYS_SEL_CODE_OFFSET = 4;
1201
1202    private static final int IS683_CONST_800MHZ_A_BAND = 0;
1203    private static final int IS683_CONST_800MHZ_B_BAND = 1;
1204    private static final int IS683_CONST_1900MHZ_A_BLOCK = 2;
1205    private static final int IS683_CONST_1900MHZ_B_BLOCK = 3;
1206    private static final int IS683_CONST_1900MHZ_C_BLOCK = 4;
1207    private static final int IS683_CONST_1900MHZ_D_BLOCK = 5;
1208    private static final int IS683_CONST_1900MHZ_E_BLOCK = 6;
1209    private static final int IS683_CONST_1900MHZ_F_BLOCK = 7;
1210    private static final int INVALID_SYSTEM_SELECTION_CODE = -1;
1211
1212    private static boolean isIs683OtaSpDialStr(String dialStr) {
1213        int sysSelCodeInt;
1214        boolean isOtaspDialString = false;
1215        int dialStrLen = dialStr.length();
1216
1217        if (dialStrLen == IS683A_FEATURE_CODE_NUM_DIGITS) {
1218            if (dialStr.equals(IS683A_FEATURE_CODE)) {
1219                isOtaspDialString = true;
1220            }
1221        } else {
1222            sysSelCodeInt = extractSelCodeFromOtaSpNum(dialStr);
1223            switch (sysSelCodeInt) {
1224                case IS683_CONST_800MHZ_A_BAND:
1225                case IS683_CONST_800MHZ_B_BAND:
1226                case IS683_CONST_1900MHZ_A_BLOCK:
1227                case IS683_CONST_1900MHZ_B_BLOCK:
1228                case IS683_CONST_1900MHZ_C_BLOCK:
1229                case IS683_CONST_1900MHZ_D_BLOCK:
1230                case IS683_CONST_1900MHZ_E_BLOCK:
1231                case IS683_CONST_1900MHZ_F_BLOCK:
1232                    isOtaspDialString = true;
1233                    break;
1234                default:
1235                    break;
1236            }
1237        }
1238        return isOtaspDialString;
1239    }
1240    /**
1241     * This function extracts the system selection code from the dial string.
1242     */
1243    private static int extractSelCodeFromOtaSpNum(String dialStr) {
1244        int dialStrLen = dialStr.length();
1245        int sysSelCodeInt = INVALID_SYSTEM_SELECTION_CODE;
1246
1247        if ((dialStr.regionMatches(0, IS683A_FEATURE_CODE,
1248                                   0, IS683A_FEATURE_CODE_NUM_DIGITS)) &&
1249            (dialStrLen >= (IS683A_FEATURE_CODE_NUM_DIGITS +
1250                            IS683A_SYS_SEL_CODE_NUM_DIGITS))) {
1251                // Since we checked the condition above, the system selection code
1252                // extracted from dialStr will not cause any exception
1253                sysSelCodeInt = Integer.parseInt (
1254                                dialStr.substring (IS683A_FEATURE_CODE_NUM_DIGITS,
1255                                IS683A_FEATURE_CODE_NUM_DIGITS + IS683A_SYS_SEL_CODE_NUM_DIGITS));
1256        }
1257        if (DBG) Rlog.d(LOG_TAG, "extractSelCodeFromOtaSpNum " + sysSelCodeInt);
1258        return sysSelCodeInt;
1259    }
1260
1261    /**
1262     * This function checks if the system selection code extracted from
1263     * the dial string "sysSelCodeInt' is the system selection code specified
1264     * in the carrier ota sp number schema "sch".
1265     */
1266    private static boolean
1267    checkOtaSpNumBasedOnSysSelCode (int sysSelCodeInt, String sch[]) {
1268        boolean isOtaSpNum = false;
1269        try {
1270            // Get how many number of system selection code ranges
1271            int selRc = Integer.parseInt((String)sch[1]);
1272            for (int i = 0; i < selRc; i++) {
1273                if (!TextUtils.isEmpty(sch[i+2]) && !TextUtils.isEmpty(sch[i+3])) {
1274                    int selMin = Integer.parseInt((String)sch[i+2]);
1275                    int selMax = Integer.parseInt((String)sch[i+3]);
1276                    // Check if the selection code extracted from the dial string falls
1277                    // within any of the range pairs specified in the schema.
1278                    if ((sysSelCodeInt >= selMin) && (sysSelCodeInt <= selMax)) {
1279                        isOtaSpNum = true;
1280                        break;
1281                    }
1282                }
1283            }
1284        } catch (NumberFormatException ex) {
1285            // If the carrier ota sp number schema is not correct, we still allow dial
1286            // and only log the error:
1287            Rlog.e(LOG_TAG, "checkOtaSpNumBasedOnSysSelCode, error", ex);
1288        }
1289        return isOtaSpNum;
1290    }
1291
1292    // Define the pattern/format for carrier specified OTASP number schema.
1293    // It separates by comma and/or whitespace.
1294    private static Pattern pOtaSpNumSchema = Pattern.compile("[,\\s]+");
1295
1296    /**
1297     * The following function checks if a dial string is a carrier specified
1298     * OTASP number or not by checking against the OTASP number schema stored
1299     * in PROPERTY_OTASP_NUM_SCHEMA.
1300     *
1301     * Currently, there are 2 schemas for carriers to specify the OTASP number:
1302     * 1) Use system selection code:
1303     *    The schema is:
1304     *    SELC,the # of code pairs,min1,max1,min2,max2,...
1305     *    e.g "SELC,3,10,20,30,40,60,70" indicates that there are 3 pairs of
1306     *    selection codes, and they are {10,20}, {30,40} and {60,70} respectively.
1307     *
1308     * 2) Use feature code:
1309     *    The schema is:
1310     *    "FC,length of feature code,feature code".
1311     *     e.g "FC,2,*2" indicates that the length of the feature code is 2,
1312     *     and the code itself is "*2".
1313     */
1314    private boolean isCarrierOtaSpNum(String dialStr) {
1315        boolean isOtaSpNum = false;
1316        int sysSelCodeInt = extractSelCodeFromOtaSpNum(dialStr);
1317        if (sysSelCodeInt == INVALID_SYSTEM_SELECTION_CODE) {
1318            return isOtaSpNum;
1319        }
1320        // mCarrierOtaSpNumSchema is retrieved from PROPERTY_OTASP_NUM_SCHEMA:
1321        if (!TextUtils.isEmpty(mCarrierOtaSpNumSchema)) {
1322            Matcher m = pOtaSpNumSchema.matcher(mCarrierOtaSpNumSchema);
1323            if (DBG) {
1324                Rlog.d(LOG_TAG, "isCarrierOtaSpNum,schema" + mCarrierOtaSpNumSchema);
1325            }
1326
1327            if (m.find()) {
1328                String sch[] = pOtaSpNumSchema.split(mCarrierOtaSpNumSchema);
1329                // If carrier uses system selection code mechanism
1330                if (!TextUtils.isEmpty(sch[0]) && sch[0].equals("SELC")) {
1331                    if (sysSelCodeInt!=INVALID_SYSTEM_SELECTION_CODE) {
1332                        isOtaSpNum=checkOtaSpNumBasedOnSysSelCode(sysSelCodeInt,sch);
1333                    } else {
1334                        if (DBG) {
1335                            Rlog.d(LOG_TAG, "isCarrierOtaSpNum,sysSelCodeInt is invalid");
1336                        }
1337                    }
1338                } else if (!TextUtils.isEmpty(sch[0]) && sch[0].equals("FC")) {
1339                    int fcLen =  Integer.parseInt((String)sch[1]);
1340                    String fc = (String)sch[2];
1341                    if (dialStr.regionMatches(0,fc,0,fcLen)) {
1342                        isOtaSpNum = true;
1343                    } else {
1344                        if (DBG) Rlog.d(LOG_TAG, "isCarrierOtaSpNum,not otasp number");
1345                    }
1346                } else {
1347                    if (DBG) {
1348                        Rlog.d(LOG_TAG, "isCarrierOtaSpNum,ota schema not supported" + sch[0]);
1349                    }
1350                }
1351            } else {
1352                if (DBG) {
1353                    Rlog.d(LOG_TAG, "isCarrierOtaSpNum,ota schema pattern not right" +
1354                          mCarrierOtaSpNumSchema);
1355                }
1356            }
1357        } else {
1358            if (DBG) Rlog.d(LOG_TAG, "isCarrierOtaSpNum,ota schema pattern empty");
1359        }
1360        return isOtaSpNum;
1361    }
1362
1363    /**
1364     * isOTASPNumber: checks a given number against the IS-683A OTASP dial string and carrier
1365     * OTASP dial string.
1366     *
1367     * @param dialStr the number to look up.
1368     * @return true if the number is in IS-683A OTASP dial string or carrier OTASP dial string
1369     */
1370    @Override
1371    public  boolean isOtaSpNumber(String dialStr){
1372        boolean isOtaSpNum = false;
1373        String dialableStr = PhoneNumberUtils.extractNetworkPortionAlt(dialStr);
1374        if (dialableStr != null) {
1375            isOtaSpNum = isIs683OtaSpDialStr(dialableStr);
1376            if (isOtaSpNum == false) {
1377                isOtaSpNum = isCarrierOtaSpNum(dialableStr);
1378            }
1379        }
1380        if (DBG) Rlog.d(LOG_TAG, "isOtaSpNumber " + isOtaSpNum);
1381        return isOtaSpNum;
1382    }
1383
1384    @Override
1385    public int getCdmaEriIconIndex() {
1386        return getServiceState().getCdmaEriIconIndex();
1387    }
1388
1389    /**
1390     * Returns the CDMA ERI icon mode,
1391     * 0 - ON
1392     * 1 - FLASHING
1393     */
1394    @Override
1395    public int getCdmaEriIconMode() {
1396        return getServiceState().getCdmaEriIconMode();
1397    }
1398
1399    /**
1400     * Returns the CDMA ERI text,
1401     */
1402    @Override
1403    public String getCdmaEriText() {
1404        int roamInd = getServiceState().getCdmaRoamingIndicator();
1405        int defRoamInd = getServiceState().getCdmaDefaultRoamingIndicator();
1406        return mEriManager.getCdmaEriText(roamInd, defRoamInd);
1407    }
1408
1409    /**
1410     * Store the voicemail number in preferences
1411     */
1412    private void storeVoiceMailNumber(String number) {
1413        // Update the preference value of voicemail number
1414        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
1415        SharedPreferences.Editor editor = sp.edit();
1416        editor.putString(VM_NUMBER_CDMA, number);
1417        editor.apply();
1418    }
1419
1420    /**
1421     * Sets PROPERTY_ICC_OPERATOR_ISO_COUNTRY property
1422     *
1423     */
1424    private void setIsoCountryProperty(String operatorNumeric) {
1425        if (TextUtils.isEmpty(operatorNumeric)) {
1426            setSystemProperty(PROPERTY_ICC_OPERATOR_ISO_COUNTRY, "");
1427        } else {
1428            String iso = "";
1429            try {
1430                iso = MccTable.countryCodeForMcc(Integer.parseInt(
1431                        operatorNumeric.substring(0,3)));
1432            } catch (NumberFormatException ex) {
1433                Rlog.w(LOG_TAG, "countryCodeForMcc error" + ex);
1434            } catch (StringIndexOutOfBoundsException ex) {
1435                Rlog.w(LOG_TAG, "countryCodeForMcc error" + ex);
1436            }
1437
1438            setSystemProperty(PROPERTY_ICC_OPERATOR_ISO_COUNTRY, iso);
1439        }
1440    }
1441
1442    /**
1443     * Sets the "current" field in the telephony provider according to the
1444     * build-time operator numeric property
1445     *
1446     * @return true for success; false otherwise.
1447     */
1448    boolean updateCurrentCarrierInProvider(String operatorNumeric) {
1449        if (!TextUtils.isEmpty(operatorNumeric)) {
1450            try {
1451                Uri uri = Uri.withAppendedPath(Telephony.Carriers.CONTENT_URI, "current");
1452                ContentValues map = new ContentValues();
1453                map.put(Telephony.Carriers.NUMERIC, operatorNumeric);
1454                log("updateCurrentCarrierInProvider from system: numeric=" + operatorNumeric);
1455                getContext().getContentResolver().insert(uri, map);
1456
1457                // Updates MCC MNC device configuration information
1458                MccTable.updateMccMncConfiguration(mContext, operatorNumeric);
1459
1460                return true;
1461            } catch (SQLException e) {
1462                Rlog.e(LOG_TAG, "Can't store current operator", e);
1463            }
1464        }
1465        return false;
1466    }
1467
1468    /**
1469     * Sets the "current" field in the telephony provider according to the SIM's operator.
1470     * Implemented in {@link CDMALTEPhone} for CDMA/LTE devices.
1471     *
1472     * @return true for success; false otherwise.
1473     */
1474    boolean updateCurrentCarrierInProvider() {
1475        return true;
1476    }
1477
1478    public void prepareEri() {
1479        mEriManager.loadEriFile();
1480        if(mEriManager.isEriFileLoaded()) {
1481            // when the ERI file is loaded
1482            log("ERI read, notify registrants");
1483            mEriFileLoadedRegistrants.notifyRegistrants();
1484        }
1485    }
1486
1487    public boolean isEriFileLoaded() {
1488        return mEriManager.isEriFileLoaded();
1489    }
1490
1491    protected void registerForRuimRecordEvents() {
1492        IccRecords r = mIccRecords.get();
1493        if (r == null) {
1494            return;
1495        }
1496        r.registerForRecordsEvents(this, EVENT_ICC_RECORD_EVENTS, null);
1497        r.registerForRecordsLoaded(this, EVENT_RUIM_RECORDS_LOADED, null);
1498    }
1499
1500    protected void unregisterForRuimRecordEvents() {
1501        IccRecords r = mIccRecords.get();
1502        if (r == null) {
1503            return;
1504        }
1505        r.unregisterForRecordsEvents(this);
1506        r.unregisterForRecordsLoaded(this);
1507    }
1508
1509    protected void log(String s) {
1510        if (DBG)
1511            Rlog.d(LOG_TAG, "[CDMAPhone] " + s);
1512    }
1513
1514    @Override
1515    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
1516        pw.println("CDMAPhone extends:");
1517        super.dump(fd, pw, args);
1518        pw.println(" mVmNumber=" + mVmNumber);
1519        pw.println(" mCT=" + mCT);
1520        pw.println(" mSST=" + mSST);
1521        pw.println(" mCdmaSSM=" + mCdmaSSM);
1522        pw.println(" mPendingMmis=" + mPendingMmis);
1523        pw.println(" mRuimPhoneBookInterfaceManager=" + mRuimPhoneBookInterfaceManager);
1524        pw.println(" mRuimSmsInterfaceManager=" + mRuimSmsInterfaceManager);
1525        pw.println(" mCdmaSubscriptionSource=" + mCdmaSubscriptionSource);
1526        pw.println(" mSubInfo=" + mSubInfo);
1527        pw.println(" mEriManager=" + mEriManager);
1528        pw.println(" mWakeLock=" + mWakeLock);
1529        pw.println(" mIsPhoneInEcmState=" + mIsPhoneInEcmState);
1530        if (VDBG) pw.println(" mImei=" + mImei);
1531        if (VDBG) pw.println(" mImeiSv=" + mImeiSv);
1532        if (VDBG) pw.println(" mEsn=" + mEsn);
1533        if (VDBG) pw.println(" mMeid=" + mMeid);
1534        pw.println(" mCarrierOtaSpNumSchema=" + mCarrierOtaSpNumSchema);
1535        pw.println(" getCdmaEriIconIndex()=" + getCdmaEriIconIndex());
1536        pw.println(" getCdmaEriIconMode()=" + getCdmaEriIconMode());
1537        pw.println(" getCdmaEriText()=" + getCdmaEriText());
1538        pw.println(" isMinInfoReady()=" + isMinInfoReady());
1539        pw.println(" isCspPlmnEnabled()=" + isCspPlmnEnabled());
1540    }
1541}
1542