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