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