ServiceState.java revision 599a90c2a02645a5f2d189b9065b863397a4076e 
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 android.telephony;
18
19import android.os.Bundle;
20import android.os.Parcel;
21import android.os.Parcelable;
22import android.telephony.Rlog;
23
24/**
25 * Contains phone state and service related information.
26 *
27 * The following phone information is included in returned ServiceState:
28 *
29 * <ul>
30 *   <li>Service state: IN_SERVICE, OUT_OF_SERVICE, EMERGENCY_ONLY, POWER_OFF
31 *   <li>Roaming indicator
32 *   <li>Operator name, short name and numeric id
33 *   <li>Network selection mode
34 * </ul>
35 */
36public class ServiceState implements Parcelable {
37
38    static final String LOG_TAG = "PHONE";
39    static final boolean DBG = true;
40
41    /**
42     * Normal operation condition, the phone is registered
43     * with an operator either in home network or in roaming.
44     */
45    public static final int STATE_IN_SERVICE = 0;
46
47    /**
48     * Phone is not registered with any operator, the phone
49     * can be currently searching a new operator to register to, or not
50     * searching to registration at all, or registration is denied, or radio
51     * signal is not available.
52     */
53    public static final int STATE_OUT_OF_SERVICE = 1;
54
55    /**
56     * The phone is registered and locked.  Only emergency numbers are allowed. {@more}
57     */
58    public static final int STATE_EMERGENCY_ONLY = 2;
59
60    /**
61     * Radio of telephony is explicitly powered off.
62     */
63    public static final int STATE_POWER_OFF = 3;
64
65    /**
66     * RIL level registration state values from ril.h
67     * ((const char **)response)[0] is registration state 0-6,
68     *              0 - Not registered, MT is not currently searching
69     *                  a new operator to register
70     *              1 - Registered, home network
71     *              2 - Not registered, but MT is currently searching
72     *                  a new operator to register
73     *              3 - Registration denied
74     *              4 - Unknown
75     *              5 - Registered, roaming
76     *             10 - Same as 0, but indicates that emergency calls
77     *                  are enabled.
78     *             12 - Same as 2, but indicates that emergency calls
79     *                  are enabled.
80     *             13 - Same as 3, but indicates that emergency calls
81     *                  are enabled.
82     *             14 - Same as 4, but indicates that emergency calls
83     *                  are enabled.
84     * @hide
85     */
86    public static final int RIL_REG_STATE_NOT_REG = 0;
87    /** @hide */
88    public static final int RIL_REG_STATE_HOME = 1;
89    /** @hide */
90    public static final int RIL_REG_STATE_SEARCHING = 2;
91    /** @hide */
92    public static final int RIL_REG_STATE_DENIED = 3;
93    /** @hide */
94    public static final int RIL_REG_STATE_UNKNOWN = 4;
95    /** @hide */
96    public static final int RIL_REG_STATE_ROAMING = 5;
97    /** @hide */
98    public static final int RIL_REG_STATE_NOT_REG_EMERGENCY_CALL_ENABLED = 10;
99    /** @hide */
100    public static final int RIL_REG_STATE_SEARCHING_EMERGENCY_CALL_ENABLED = 12;
101    /** @hide */
102    public static final int RIL_REG_STATE_DENIED_EMERGENCY_CALL_ENABLED = 13;
103    /** @hide */
104    public static final int RIL_REG_STATE_UNKNOWN_EMERGENCY_CALL_ENABLED = 14;
105
106    /**
107     * Available radio technologies for GSM, UMTS and CDMA.
108     * Duplicates the constants from hardware/radio/include/ril.h
109     * This should only be used by agents working with the ril.  Others
110     * should use the equivalent TelephonyManager.NETWORK_TYPE_*
111     */
112    /** @hide */
113    public static final int RIL_RADIO_TECHNOLOGY_UNKNOWN = 0;
114    /** @hide */
115    public static final int RIL_RADIO_TECHNOLOGY_GPRS = 1;
116    /** @hide */
117    public static final int RIL_RADIO_TECHNOLOGY_EDGE = 2;
118    /** @hide */
119    public static final int RIL_RADIO_TECHNOLOGY_UMTS = 3;
120    /** @hide */
121    public static final int RIL_RADIO_TECHNOLOGY_IS95A = 4;
122    /** @hide */
123    public static final int RIL_RADIO_TECHNOLOGY_IS95B = 5;
124    /** @hide */
125    public static final int RIL_RADIO_TECHNOLOGY_1xRTT = 6;
126    /** @hide */
127    public static final int RIL_RADIO_TECHNOLOGY_EVDO_0 = 7;
128    /** @hide */
129    public static final int RIL_RADIO_TECHNOLOGY_EVDO_A = 8;
130    /** @hide */
131    public static final int RIL_RADIO_TECHNOLOGY_HSDPA = 9;
132    /** @hide */
133    public static final int RIL_RADIO_TECHNOLOGY_HSUPA = 10;
134    /** @hide */
135    public static final int RIL_RADIO_TECHNOLOGY_HSPA = 11;
136    /** @hide */
137    public static final int RIL_RADIO_TECHNOLOGY_EVDO_B = 12;
138    /** @hide */
139    public static final int RIL_RADIO_TECHNOLOGY_EHRPD = 13;
140    /** @hide */
141    public static final int RIL_RADIO_TECHNOLOGY_LTE = 14;
142    /** @hide */
143    public static final int RIL_RADIO_TECHNOLOGY_HSPAP = 15;
144    /**
145     * GSM radio technology only supports voice. It does not support data.
146     * @hide
147     */
148    public static final int RIL_RADIO_TECHNOLOGY_GSM = 16;
149
150    /**
151     * Available registration states for GSM, UMTS and CDMA.
152     */
153    /** @hide */
154    public static final int REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING = 0;
155    /** @hide */
156    public static final int REGISTRATION_STATE_HOME_NETWORK = 1;
157    /** @hide */
158    public static final int REGISTRATION_STATE_NOT_REGISTERED_AND_SEARCHING = 2;
159    /** @hide */
160    public static final int REGISTRATION_STATE_REGISTRATION_DENIED = 3;
161    /** @hide */
162    public static final int REGISTRATION_STATE_UNKNOWN = 4;
163    /** @hide */
164    public static final int REGISTRATION_STATE_ROAMING = 5;
165
166    private int mVoiceRegState = STATE_OUT_OF_SERVICE;
167    private int mDataRegState = STATE_OUT_OF_SERVICE;
168    private boolean mRoaming;
169    private String mOperatorAlphaLong;
170    private String mOperatorAlphaShort;
171    private String mOperatorNumeric;
172    private boolean mIsManualNetworkSelection;
173
174    private boolean mIsEmergencyOnly;
175
176    private int mRilVoiceRadioTechnology;
177    private int mRilDataRadioTechnology;
178
179    private boolean mCssIndicator;
180    private int mNetworkId;
181    private int mSystemId;
182    private int mCdmaRoamingIndicator;
183    private int mCdmaDefaultRoamingIndicator;
184    private int mCdmaEriIconIndex;
185    private int mCdmaEriIconMode;
186
187    /**
188     * Create a new ServiceState from a intent notifier Bundle
189     *
190     * This method is used by PhoneStateIntentReceiver and maybe by
191     * external applications.
192     *
193     * @param m Bundle from intent notifier
194     * @return newly created ServiceState
195     * @hide
196     */
197    public static ServiceState newFromBundle(Bundle m) {
198        ServiceState ret;
199        ret = new ServiceState();
200        ret.setFromNotifierBundle(m);
201        return ret;
202    }
203
204    /**
205     * Empty constructor
206     */
207    public ServiceState() {
208    }
209
210    /**
211     * Copy constructors
212     *
213     * @param s Source service state
214     */
215    public ServiceState(ServiceState s) {
216        copyFrom(s);
217    }
218
219    protected void copyFrom(ServiceState s) {
220        mVoiceRegState = s.mVoiceRegState;
221        mDataRegState = s.mDataRegState;
222        mRoaming = s.mRoaming;
223        mOperatorAlphaLong = s.mOperatorAlphaLong;
224        mOperatorAlphaShort = s.mOperatorAlphaShort;
225        mOperatorNumeric = s.mOperatorNumeric;
226        mIsManualNetworkSelection = s.mIsManualNetworkSelection;
227        mRilVoiceRadioTechnology = s.mRilVoiceRadioTechnology;
228        mRilDataRadioTechnology = s.mRilDataRadioTechnology;
229        mCssIndicator = s.mCssIndicator;
230        mNetworkId = s.mNetworkId;
231        mSystemId = s.mSystemId;
232        mCdmaRoamingIndicator = s.mCdmaRoamingIndicator;
233        mCdmaDefaultRoamingIndicator = s.mCdmaDefaultRoamingIndicator;
234        mCdmaEriIconIndex = s.mCdmaEriIconIndex;
235        mCdmaEriIconMode = s.mCdmaEriIconMode;
236        mIsEmergencyOnly = s.mIsEmergencyOnly;
237    }
238
239    /**
240     * Construct a ServiceState object from the given parcel.
241     */
242    public ServiceState(Parcel in) {
243        mVoiceRegState = in.readInt();
244        mDataRegState = in.readInt();
245        mRoaming = in.readInt() != 0;
246        mOperatorAlphaLong = in.readString();
247        mOperatorAlphaShort = in.readString();
248        mOperatorNumeric = in.readString();
249        mIsManualNetworkSelection = in.readInt() != 0;
250        mRilVoiceRadioTechnology = in.readInt();
251        mRilDataRadioTechnology = in.readInt();
252        mCssIndicator = (in.readInt() != 0);
253        mNetworkId = in.readInt();
254        mSystemId = in.readInt();
255        mCdmaRoamingIndicator = in.readInt();
256        mCdmaDefaultRoamingIndicator = in.readInt();
257        mCdmaEriIconIndex = in.readInt();
258        mCdmaEriIconMode = in.readInt();
259        mIsEmergencyOnly = in.readInt() != 0;
260    }
261
262    public void writeToParcel(Parcel out, int flags) {
263        out.writeInt(mVoiceRegState);
264        out.writeInt(mDataRegState);
265        out.writeInt(mRoaming ? 1 : 0);
266        out.writeString(mOperatorAlphaLong);
267        out.writeString(mOperatorAlphaShort);
268        out.writeString(mOperatorNumeric);
269        out.writeInt(mIsManualNetworkSelection ? 1 : 0);
270        out.writeInt(mRilVoiceRadioTechnology);
271        out.writeInt(mRilDataRadioTechnology);
272        out.writeInt(mCssIndicator ? 1 : 0);
273        out.writeInt(mNetworkId);
274        out.writeInt(mSystemId);
275        out.writeInt(mCdmaRoamingIndicator);
276        out.writeInt(mCdmaDefaultRoamingIndicator);
277        out.writeInt(mCdmaEriIconIndex);
278        out.writeInt(mCdmaEriIconMode);
279        out.writeInt(mIsEmergencyOnly ? 1 : 0);
280    }
281
282    public int describeContents() {
283        return 0;
284    }
285
286    public static final Parcelable.Creator<ServiceState> CREATOR =
287            new Parcelable.Creator<ServiceState>() {
288        public ServiceState createFromParcel(Parcel in) {
289            return new ServiceState(in);
290        }
291
292        public ServiceState[] newArray(int size) {
293            return new ServiceState[size];
294        }
295    };
296
297    /**
298     * Get current voice service state
299     */
300    public int getState() {
301        return getVoiceRegState();
302    }
303
304    /**
305     * Get current voice service state
306     *
307     * @see #STATE_IN_SERVICE
308     * @see #STATE_OUT_OF_SERVICE
309     * @see #STATE_EMERGENCY_ONLY
310     * @see #STATE_POWER_OFF
311     *
312     * @hide
313     */
314    public int getVoiceRegState() {
315        return mVoiceRegState;
316    }
317
318    /**
319     * Get current data service state
320     *
321     * @see #STATE_IN_SERVICE
322     * @see #STATE_OUT_OF_SERVICE
323     * @see #STATE_EMERGENCY_ONLY
324     * @see #STATE_POWER_OFF
325     *
326     * @hide
327     */
328    public int getDataRegState() {
329        return mDataRegState;
330    }
331
332    /**
333     * Get current roaming indicator of phone
334     * (note: not just decoding from TS 27.007 7.2)
335     *
336     * @return true if TS 27.007 7.2 roaming is true
337     *              and ONS is different from SPN
338     *
339     */
340    public boolean getRoaming() {
341        return mRoaming;
342    }
343
344    /**
345     * @hide
346     */
347    public boolean isEmergencyOnly() {
348        return mIsEmergencyOnly;
349    }
350
351    /**
352     * @hide
353     */
354    public int getCdmaRoamingIndicator(){
355        return this.mCdmaRoamingIndicator;
356    }
357
358    /**
359     * @hide
360     */
361    public int getCdmaDefaultRoamingIndicator(){
362        return this.mCdmaDefaultRoamingIndicator;
363    }
364
365    /**
366     * @hide
367     */
368    public int getCdmaEriIconIndex() {
369        return this.mCdmaEriIconIndex;
370    }
371
372    /**
373     * @hide
374     */
375    public int getCdmaEriIconMode() {
376        return this.mCdmaEriIconMode;
377    }
378
379    /**
380     * Get current registered operator name in long alphanumeric format.
381     *
382     * In GSM/UMTS, long format can be up to 16 characters long.
383     * In CDMA, returns the ERI text, if set. Otherwise, returns the ONS.
384     *
385     * @return long name of operator, null if unregistered or unknown
386     */
387    public String getOperatorAlphaLong() {
388        return mOperatorAlphaLong;
389    }
390
391    /**
392     * Get current registered operator name in short alphanumeric format.
393     *
394     * In GSM/UMTS, short format can be up to 8 characters long.
395     *
396     * @return short name of operator, null if unregistered or unknown
397     */
398    public String getOperatorAlphaShort() {
399        return mOperatorAlphaShort;
400    }
401
402    /**
403     * Get current registered operator numeric id.
404     *
405     * In GSM/UMTS, numeric format is 3 digit country code plus 2 or 3 digit
406     * network code.
407     *
408     * @return numeric format of operator, null if unregistered or unknown
409     */
410    /*
411     * The country code can be decoded using
412     * {@link com.android.internal.telephony.MccTable#countryCodeForMcc(int)}.
413     */
414    public String getOperatorNumeric() {
415        return mOperatorNumeric;
416    }
417
418    /**
419     * Get current network selection mode.
420     *
421     * @return true if manual mode, false if automatic mode
422     */
423    public boolean getIsManualSelection() {
424        return mIsManualNetworkSelection;
425    }
426
427    @Override
428    public int hashCode() {
429        return ((mVoiceRegState * 31)
430                + (mDataRegState * 37)
431                + (mRoaming ? 1 : 0)
432                + (mIsManualNetworkSelection ? 1 : 0)
433                + ((null == mOperatorAlphaLong) ? 0 : mOperatorAlphaLong.hashCode())
434                + ((null == mOperatorAlphaShort) ? 0 : mOperatorAlphaShort.hashCode())
435                + ((null == mOperatorNumeric) ? 0 : mOperatorNumeric.hashCode())
436                + mCdmaRoamingIndicator
437                + mCdmaDefaultRoamingIndicator
438                + (mIsEmergencyOnly ? 1 : 0));
439    }
440
441    @Override
442    public boolean equals (Object o) {
443        ServiceState s;
444
445        try {
446            s = (ServiceState) o;
447        } catch (ClassCastException ex) {
448            return false;
449        }
450
451        if (o == null) {
452            return false;
453        }
454
455        return (mVoiceRegState == s.mVoiceRegState
456                && mDataRegState == s.mDataRegState
457                && mRoaming == s.mRoaming
458                && mIsManualNetworkSelection == s.mIsManualNetworkSelection
459                && equalsHandlesNulls(mOperatorAlphaLong, s.mOperatorAlphaLong)
460                && equalsHandlesNulls(mOperatorAlphaShort, s.mOperatorAlphaShort)
461                && equalsHandlesNulls(mOperatorNumeric, s.mOperatorNumeric)
462                && equalsHandlesNulls(mRilVoiceRadioTechnology, s.mRilVoiceRadioTechnology)
463                && equalsHandlesNulls(mRilDataRadioTechnology, s.mRilDataRadioTechnology)
464                && equalsHandlesNulls(mCssIndicator, s.mCssIndicator)
465                && equalsHandlesNulls(mNetworkId, s.mNetworkId)
466                && equalsHandlesNulls(mSystemId, s.mSystemId)
467                && equalsHandlesNulls(mCdmaRoamingIndicator, s.mCdmaRoamingIndicator)
468                && equalsHandlesNulls(mCdmaDefaultRoamingIndicator,
469                        s.mCdmaDefaultRoamingIndicator)
470                && mIsEmergencyOnly == s.mIsEmergencyOnly);
471    }
472
473    /**
474     * Convert radio technology to String
475     *
476     * @param radioTechnology
477     * @return String representation of the RAT
478     *
479     * @hide
480     */
481    public static String rilRadioTechnologyToString(int rt) {
482        String rtString;
483
484        switch(rt) {
485            case RIL_RADIO_TECHNOLOGY_UNKNOWN:
486                rtString = "Unknown";
487                break;
488            case RIL_RADIO_TECHNOLOGY_GPRS:
489                rtString = "GPRS";
490                break;
491            case RIL_RADIO_TECHNOLOGY_EDGE:
492                rtString = "EDGE";
493                break;
494            case RIL_RADIO_TECHNOLOGY_UMTS:
495                rtString = "UMTS";
496                break;
497            case RIL_RADIO_TECHNOLOGY_IS95A:
498                rtString = "CDMA-IS95A";
499                break;
500            case RIL_RADIO_TECHNOLOGY_IS95B:
501                rtString = "CDMA-IS95B";
502                break;
503            case RIL_RADIO_TECHNOLOGY_1xRTT:
504                rtString = "1xRTT";
505                break;
506            case RIL_RADIO_TECHNOLOGY_EVDO_0:
507                rtString = "EvDo-rev.0";
508                break;
509            case RIL_RADIO_TECHNOLOGY_EVDO_A:
510                rtString = "EvDo-rev.A";
511                break;
512            case RIL_RADIO_TECHNOLOGY_HSDPA:
513                rtString = "HSDPA";
514                break;
515            case RIL_RADIO_TECHNOLOGY_HSUPA:
516                rtString = "HSUPA";
517                break;
518            case RIL_RADIO_TECHNOLOGY_HSPA:
519                rtString = "HSPA";
520                break;
521            case RIL_RADIO_TECHNOLOGY_EVDO_B:
522                rtString = "EvDo-rev.B";
523                break;
524            case RIL_RADIO_TECHNOLOGY_EHRPD:
525                rtString = "eHRPD";
526                break;
527            case RIL_RADIO_TECHNOLOGY_LTE:
528                rtString = "LTE";
529                break;
530            case RIL_RADIO_TECHNOLOGY_HSPAP:
531                rtString = "HSPAP";
532                break;
533            case RIL_RADIO_TECHNOLOGY_GSM:
534                rtString = "GSM";
535                break;
536            default:
537                rtString = "Unexpected";
538                Rlog.w(LOG_TAG, "Unexpected radioTechnology=" + rt);
539                break;
540        }
541        return rtString;
542    }
543
544    @Override
545    public String toString() {
546        String radioTechnology = rilRadioTechnologyToString(mRilVoiceRadioTechnology);
547        String dataRadioTechnology = rilRadioTechnologyToString(mRilDataRadioTechnology);
548
549        return (mVoiceRegState + " " + mDataRegState + " " + (mRoaming ? "roaming" : "home")
550                + " " + mOperatorAlphaLong
551                + " " + mOperatorAlphaShort
552                + " " + mOperatorNumeric
553                + " " + (mIsManualNetworkSelection ? "(manual)" : "")
554                + " " + radioTechnology
555                + " " + dataRadioTechnology
556                + " " + (mCssIndicator ? "CSS supported" : "CSS not supported")
557                + " " + mNetworkId
558                + " " + mSystemId
559                + " RoamInd=" + mCdmaRoamingIndicator
560                + " DefRoamInd=" + mCdmaDefaultRoamingIndicator
561                + " EmergOnly=" + mIsEmergencyOnly);
562    }
563
564    private void setNullState(int state) {
565        if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setNullState=" + state);
566        mVoiceRegState = state;
567        mDataRegState = state;
568        mRoaming = false;
569        mOperatorAlphaLong = null;
570        mOperatorAlphaShort = null;
571        mOperatorNumeric = null;
572        mIsManualNetworkSelection = false;
573        mRilVoiceRadioTechnology = 0;
574        mRilDataRadioTechnology = 0;
575        mCssIndicator = false;
576        mNetworkId = -1;
577        mSystemId = -1;
578        mCdmaRoamingIndicator = -1;
579        mCdmaDefaultRoamingIndicator = -1;
580        mCdmaEriIconIndex = -1;
581        mCdmaEriIconMode = -1;
582        mIsEmergencyOnly = false;
583    }
584
585    public void setStateOutOfService() {
586        setNullState(STATE_OUT_OF_SERVICE);
587    }
588
589    public void setStateOff() {
590        setNullState(STATE_POWER_OFF);
591    }
592
593    public void setState(int state) {
594        setVoiceRegState(state);
595        if (DBG) Rlog.e(LOG_TAG, "[ServiceState] setState deprecated use setVoiceRegState()");
596    }
597
598    /** @hide */
599    public void setVoiceRegState(int state) {
600        mVoiceRegState = state;
601        if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setVoiceRegState=" + mVoiceRegState);
602    }
603
604    /** @hide */
605    public void setDataRegState(int state) {
606        mDataRegState = state;
607        if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setDataRegState=" + mDataRegState);
608    }
609
610    public void setRoaming(boolean roaming) {
611        mRoaming = roaming;
612    }
613
614
615    /**
616     * @hide
617     */
618    public void setEmergencyOnly(boolean emergencyOnly) {
619        mIsEmergencyOnly = emergencyOnly;
620    }
621
622    /**
623     * @hide
624     */
625    public void setCdmaRoamingIndicator(int roaming) {
626        this.mCdmaRoamingIndicator = roaming;
627    }
628
629    /**
630     * @hide
631     */
632    public void setCdmaDefaultRoamingIndicator (int roaming) {
633        this.mCdmaDefaultRoamingIndicator = roaming;
634    }
635
636    /**
637     * @hide
638     */
639    public void setCdmaEriIconIndex(int index) {
640        this.mCdmaEriIconIndex = index;
641    }
642
643    /**
644     * @hide
645     */
646    public void setCdmaEriIconMode(int mode) {
647        this.mCdmaEriIconMode = mode;
648    }
649
650    public void setOperatorName(String longName, String shortName, String numeric) {
651        mOperatorAlphaLong = longName;
652        mOperatorAlphaShort = shortName;
653        mOperatorNumeric = numeric;
654    }
655
656    /**
657     * In CDMA, mOperatorAlphaLong can be set from the ERI text.
658     * This is done from the CDMAPhone and not from the CdmaServiceStateTracker.
659     *
660     * @hide
661     */
662    public void setOperatorAlphaLong(String longName) {
663        mOperatorAlphaLong = longName;
664    }
665
666    public void setIsManualSelection(boolean isManual) {
667        mIsManualNetworkSelection = isManual;
668    }
669
670    /**
671     * Test whether two objects hold the same data values or both are null.
672     *
673     * @param a first obj
674     * @param b second obj
675     * @return true if two objects equal or both are null
676     */
677    private static boolean equalsHandlesNulls (Object a, Object b) {
678        return (a == null) ? (b == null) : a.equals (b);
679    }
680
681    /**
682     * Set ServiceState based on intent notifier map.
683     *
684     * @param m intent notifier map
685     * @hide
686     */
687    private void setFromNotifierBundle(Bundle m) {
688        mVoiceRegState = m.getInt("voiceRegState");
689        mDataRegState = m.getInt("dataRegState");
690        mRoaming = m.getBoolean("roaming");
691        mOperatorAlphaLong = m.getString("operator-alpha-long");
692        mOperatorAlphaShort = m.getString("operator-alpha-short");
693        mOperatorNumeric = m.getString("operator-numeric");
694        mIsManualNetworkSelection = m.getBoolean("manual");
695        mRilVoiceRadioTechnology = m.getInt("radioTechnology");
696        mRilVoiceRadioTechnology = m.getInt("dataRadioTechnology");
697        mCssIndicator = m.getBoolean("cssIndicator");
698        mNetworkId = m.getInt("networkId");
699        mSystemId = m.getInt("systemId");
700        mCdmaRoamingIndicator = m.getInt("cdmaRoamingIndicator");
701        mCdmaDefaultRoamingIndicator = m.getInt("cdmaDefaultRoamingIndicator");
702        mIsEmergencyOnly = m.getBoolean("emergencyOnly");
703    }
704
705    /**
706     * Set intent notifier Bundle based on service state.
707     *
708     * @param m intent notifier Bundle
709     * @hide
710     */
711    public void fillInNotifierBundle(Bundle m) {
712        m.putInt("voiceRegState", mVoiceRegState);
713        m.putInt("dataRegState", mDataRegState);
714        m.putBoolean("roaming", Boolean.valueOf(mRoaming));
715        m.putString("operator-alpha-long", mOperatorAlphaLong);
716        m.putString("operator-alpha-short", mOperatorAlphaShort);
717        m.putString("operator-numeric", mOperatorNumeric);
718        m.putBoolean("manual", Boolean.valueOf(mIsManualNetworkSelection));
719        m.putInt("radioTechnology", mRilVoiceRadioTechnology);
720        m.putInt("dataRadioTechnology", mRilDataRadioTechnology);
721        m.putBoolean("cssIndicator", mCssIndicator);
722        m.putInt("networkId", mNetworkId);
723        m.putInt("systemId", mSystemId);
724        m.putInt("cdmaRoamingIndicator", mCdmaRoamingIndicator);
725        m.putInt("cdmaDefaultRoamingIndicator", mCdmaDefaultRoamingIndicator);
726        m.putBoolean("emergencyOnly", Boolean.valueOf(mIsEmergencyOnly));
727    }
728
729    /** @hide */
730    public void setRilVoiceRadioTechnology(int rt) {
731        this.mRilVoiceRadioTechnology = rt;
732    }
733
734    /** @hide */
735    public void setRilDataRadioTechnology(int rt) {
736        this.mRilDataRadioTechnology = rt;
737        if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setDataRadioTechnology=" + mRilDataRadioTechnology);
738    }
739
740    /** @hide */
741    public void setCssIndicator(int css) {
742        this.mCssIndicator = (css != 0);
743    }
744
745    /** @hide */
746    public void setSystemAndNetworkId(int systemId, int networkId) {
747        this.mSystemId = systemId;
748        this.mNetworkId = networkId;
749    }
750
751    /** @hide */
752    public int getRilVoiceRadioTechnology() {
753        return this.mRilVoiceRadioTechnology;
754    }
755    /** @hide */
756    public int getRilDataRadioTechnology() {
757        return this.mRilDataRadioTechnology;
758    }
759    /**
760     * @hide
761     * @Deprecated to be removed Q3 2013 use {@link #getRilDataRadioTechnology} or
762     * {@link #getRilVoiceRadioTechnology}
763     */
764    public int getRadioTechnology() {
765        Rlog.e(LOG_TAG, "ServiceState.getRadioTechnology() DEPRECATED will be removed *******");
766        return getRilDataRadioTechnology();
767    }
768
769    private int rilRadioTechnologyToNetworkType(int rt) {
770        switch(rt) {
771        case ServiceState.RIL_RADIO_TECHNOLOGY_GPRS:
772            return TelephonyManager.NETWORK_TYPE_GPRS;
773        case ServiceState.RIL_RADIO_TECHNOLOGY_EDGE:
774            return TelephonyManager.NETWORK_TYPE_EDGE;
775        case ServiceState.RIL_RADIO_TECHNOLOGY_UMTS:
776            return TelephonyManager.NETWORK_TYPE_UMTS;
777        case ServiceState.RIL_RADIO_TECHNOLOGY_HSDPA:
778            return TelephonyManager.NETWORK_TYPE_HSDPA;
779        case ServiceState.RIL_RADIO_TECHNOLOGY_HSUPA:
780            return TelephonyManager.NETWORK_TYPE_HSUPA;
781        case ServiceState.RIL_RADIO_TECHNOLOGY_HSPA:
782            return TelephonyManager.NETWORK_TYPE_HSPA;
783        case ServiceState.RIL_RADIO_TECHNOLOGY_IS95A:
784        case ServiceState.RIL_RADIO_TECHNOLOGY_IS95B:
785            return TelephonyManager.NETWORK_TYPE_CDMA;
786        case ServiceState.RIL_RADIO_TECHNOLOGY_1xRTT:
787            return TelephonyManager.NETWORK_TYPE_1xRTT;
788        case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_0:
789            return TelephonyManager.NETWORK_TYPE_EVDO_0;
790        case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_A:
791            return TelephonyManager.NETWORK_TYPE_EVDO_A;
792        case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_B:
793            return TelephonyManager.NETWORK_TYPE_EVDO_B;
794        case ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD:
795            return TelephonyManager.NETWORK_TYPE_EHRPD;
796        case ServiceState.RIL_RADIO_TECHNOLOGY_LTE:
797            return TelephonyManager.NETWORK_TYPE_LTE;
798        case ServiceState.RIL_RADIO_TECHNOLOGY_HSPAP:
799            return TelephonyManager.NETWORK_TYPE_HSPAP;
800        default:
801            return TelephonyManager.NETWORK_TYPE_UNKNOWN;
802        }
803    }
804
805    /**
806     * @Deprecated to be removed Q3 2013 use {@link #getVoiceNetworkType}
807     * @hide
808     */
809    public int getNetworkType() {
810        Rlog.e(LOG_TAG, "ServiceState.getNetworkType() DEPRECATED will be removed *******");
811        return rilRadioTechnologyToNetworkType(mRilVoiceRadioTechnology);
812    }
813
814    /** @hide */
815    public int getDataNetworkType() {
816        return rilRadioTechnologyToNetworkType(mRilDataRadioTechnology);
817    }
818
819    /** @hide */
820    public int getVoiceNetworkType() {
821        return rilRadioTechnologyToNetworkType(mRilVoiceRadioTechnology);
822    }
823
824    /** @hide */
825    public int getCssIndicator() {
826        return this.mCssIndicator ? 1 : 0;
827    }
828
829    /** @hide */
830    public int getNetworkId() {
831        return this.mNetworkId;
832    }
833
834    /** @hide */
835    public int getSystemId() {
836        return this.mSystemId;
837    }
838
839    /** @hide */
840    public static boolean isGsm(int radioTechnology) {
841        return radioTechnology == RIL_RADIO_TECHNOLOGY_GPRS
842                || radioTechnology == RIL_RADIO_TECHNOLOGY_EDGE
843                || radioTechnology == RIL_RADIO_TECHNOLOGY_UMTS
844                || radioTechnology == RIL_RADIO_TECHNOLOGY_HSDPA
845                || radioTechnology == RIL_RADIO_TECHNOLOGY_HSUPA
846                || radioTechnology == RIL_RADIO_TECHNOLOGY_HSPA
847                || radioTechnology == RIL_RADIO_TECHNOLOGY_LTE
848                || radioTechnology == RIL_RADIO_TECHNOLOGY_HSPAP
849                || radioTechnology == RIL_RADIO_TECHNOLOGY_GSM;
850    }
851
852    /** @hide */
853    public static boolean isCdma(int radioTechnology) {
854        return radioTechnology == RIL_RADIO_TECHNOLOGY_IS95A
855                || radioTechnology == RIL_RADIO_TECHNOLOGY_IS95B
856                || radioTechnology == RIL_RADIO_TECHNOLOGY_1xRTT
857                || radioTechnology == RIL_RADIO_TECHNOLOGY_EVDO_0
858                || radioTechnology == RIL_RADIO_TECHNOLOGY_EVDO_A
859                || radioTechnology == RIL_RADIO_TECHNOLOGY_EVDO_B
860                || radioTechnology == RIL_RADIO_TECHNOLOGY_EHRPD;
861    }
862}
863