Revert "telephony: Set roam though same named operator"
[android/platform/frameworks/opt/telephony.git] / src / java / com / android / internal / telephony / gsm / GsmServiceStateTracker.java
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
17 package com.android.internal.telephony.gsm;
18
19 import android.app.AlarmManager;
20 import android.app.Notification;
21 import android.app.NotificationManager;
22 import android.app.PendingIntent;
23 import android.content.BroadcastReceiver;
24 import android.content.ContentResolver;
25 import android.content.Context;
26 import android.content.Intent;
27 import android.content.IntentFilter;
28 import android.content.res.Resources;
29 import android.database.ContentObserver;
30 import android.os.AsyncResult;
31 import android.os.Build;
32 import android.os.Handler;
33 import android.os.Message;
34 import android.os.PowerManager;
35 import android.os.SystemClock;
36 import android.os.SystemProperties;
37 import android.os.UserHandle;
38 import android.provider.Settings;
39 import android.provider.Settings.SettingNotFoundException;
40 import android.telephony.CellIdentityGsm;
41 import android.telephony.CellIdentityLte;
42 import android.telephony.CellIdentityWcdma;
43 import android.telephony.CellInfo;
44 import android.telephony.CellInfoGsm;
45 import android.telephony.CellInfoLte;
46 import android.telephony.CellInfoWcdma;
47 import android.telephony.CellLocation;
48 import android.telephony.Rlog;
49 import android.telephony.ServiceState;
50 import android.telephony.SignalStrength;
51 import android.telephony.gsm.GsmCellLocation;
52 import android.text.TextUtils;
53 import android.util.EventLog;
54 import android.util.TimeUtils;
55
56 import com.android.internal.telephony.CommandException;
57 import com.android.internal.telephony.CommandsInterface;
58 import com.android.internal.telephony.EventLogTags;
59 import com.android.internal.telephony.MccTable;
60 import com.android.internal.telephony.Phone;
61 import com.android.internal.telephony.RILConstants;
62 import com.android.internal.telephony.RestrictedState;
63 import com.android.internal.telephony.ServiceStateTracker;
64 import com.android.internal.telephony.TelephonyIntents;
65 import com.android.internal.telephony.TelephonyProperties;
66 import com.android.internal.telephony.dataconnection.DcTrackerBase;
67 import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppState;
68 import com.android.internal.telephony.uicc.IccRecords;
69 import com.android.internal.telephony.uicc.SIMRecords;
70 import com.android.internal.telephony.uicc.UiccCardApplication;
71 import com.android.internal.telephony.uicc.UiccController;
72
73 import java.io.FileDescriptor;
74 import java.io.PrintWriter;
75 import java.util.ArrayList;
76 import java.util.Arrays;
77 import java.util.Calendar;
78 import java.util.Date;
79 import java.util.List;
80 import java.util.TimeZone;
81
82 /**
83  * {@hide}
84  */
85 final class GsmServiceStateTracker extends ServiceStateTracker {
86     private static final String LOG_TAG = "GsmSST";
87     private static final boolean VDBG = false;
88
89     GSMPhone mPhone;
90     GsmCellLocation mCellLoc;
91     GsmCellLocation mNewCellLoc;
92     int mPreferredNetworkType;
93
94     private int mMaxDataCalls = 1;
95     private int mNewMaxDataCalls = 1;
96     private int mReasonDataDenied = -1;
97     private int mNewReasonDataDenied = -1;
98
99     /**
100      * GSM roaming status solely based on TS 27.007 7.2 CREG. Only used by
101      * handlePollStateResult to store CREG roaming result.
102      */
103     private boolean mGsmRoaming = false;
104
105     /**
106      * Data roaming status solely based on TS 27.007 10.1.19 CGREG. Only used by
107      * handlePollStateResult to store CGREG roaming result.
108      */
109     private boolean mDataRoaming = false;
110
111     /**
112      * Mark when service state is in emergency call only mode
113      */
114     private boolean mEmergencyOnly = false;
115
116     /**
117      * Sometimes we get the NITZ time before we know what country we
118      * are in. Keep the time zone information from the NITZ string so
119      * we can fix the time zone once know the country.
120      */
121     private boolean mNeedFixZoneAfterNitz = false;
122     private int mZoneOffset;
123     private boolean mZoneDst;
124     private long mZoneTime;
125     private boolean mGotCountryCode = false;
126     private ContentResolver mCr;
127
128     /** Boolean is true is setTimeFromNITZString was called */
129     private boolean mNitzUpdatedTime = false;
130
131     String mSavedTimeZone;
132     long mSavedTime;
133     long mSavedAtTime;
134
135     /** Started the recheck process after finding gprs should registered but not. */
136     private boolean mStartedGprsRegCheck = false;
137
138     /** Already sent the event-log for no gprs register. */
139     private boolean mReportedGprsNoReg = false;
140
141     /**
142      * The Notification object given to the NotificationManager.
143      */
144     private Notification mNotification;
145
146     /** Wake lock used while setting time of day. */
147     private PowerManager.WakeLock mWakeLock;
148     private static final String WAKELOCK_TAG = "ServiceStateTracker";
149
150     /** Keep track of SPN display rules, so we only broadcast intent if something changes. */
151     private String mCurSpn = null;
152     private String mCurPlmn = null;
153     private boolean mCurShowPlmn = false;
154     private boolean mCurShowSpn = false;
155
156     /** Notification type. */
157     static final int PS_ENABLED = 1001;            // Access Control blocks data service
158     static final int PS_DISABLED = 1002;           // Access Control enables data service
159     static final int CS_ENABLED = 1003;            // Access Control blocks all voice/sms service
160     static final int CS_DISABLED = 1004;           // Access Control enables all voice/sms service
161     static final int CS_NORMAL_ENABLED = 1005;     // Access Control blocks normal voice/sms service
162     static final int CS_EMERGENCY_ENABLED = 1006;  // Access Control blocks emergency call service
163
164     /** Notification id. */
165     static final int PS_NOTIFICATION = 888;  // Id to update and cancel PS restricted
166     static final int CS_NOTIFICATION = 999;  // Id to update and cancel CS restricted
167
168     private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
169         @Override
170         public void onReceive(Context context, Intent intent) {
171             if (!mPhone.mIsTheCurrentActivePhone) {
172                 Rlog.e(LOG_TAG, "Received Intent " + intent +
173                         " while being destroyed. Ignoring.");
174                 return;
175             }
176
177             if (intent.getAction().equals(Intent.ACTION_LOCALE_CHANGED)) {
178                 // update emergency string whenever locale changed
179                 updateSpnDisplay();
180             }
181         }
182     };
183
184     private ContentObserver mAutoTimeObserver = new ContentObserver(new Handler()) {
185         @Override
186         public void onChange(boolean selfChange) {
187             Rlog.i("GsmServiceStateTracker", "Auto time state changed");
188             revertToNitzTime();
189         }
190     };
191
192     private ContentObserver mAutoTimeZoneObserver = new ContentObserver(new Handler()) {
193         @Override
194         public void onChange(boolean selfChange) {
195             Rlog.i("GsmServiceStateTracker", "Auto time zone state changed");
196             revertToNitzTimeZone();
197         }
198     };
199
200     public GsmServiceStateTracker(GSMPhone phone) {
201         super(phone, phone.mCi, new CellInfoGsm());
202
203         mPhone = phone;
204         mCellLoc = new GsmCellLocation();
205         mNewCellLoc = new GsmCellLocation();
206
207         PowerManager powerManager =
208                 (PowerManager)phone.getContext().getSystemService(Context.POWER_SERVICE);
209         mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG);
210
211         mCi.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null);
212         mCi.registerForRadioStateChanged(this, EVENT_RADIO_STATE_CHANGED, null);
213
214         mCi.registerForVoiceNetworkStateChanged(this, EVENT_NETWORK_STATE_CHANGED, null);
215         mCi.setOnNITZTime(this, EVENT_NITZ_TIME, null);
216         mCi.setOnRestrictedStateChanged(this, EVENT_RESTRICTED_STATE_CHANGED, null);
217
218         // system setting property AIRPLANE_MODE_ON is set in Settings.
219         int airplaneMode = Settings.Global.getInt(
220                 phone.getContext().getContentResolver(),
221                 Settings.Global.AIRPLANE_MODE_ON, 0);
222         mDesiredPowerState = ! (airplaneMode > 0);
223
224         mCr = phone.getContext().getContentResolver();
225         mCr.registerContentObserver(
226                 Settings.Global.getUriFor(Settings.Global.AUTO_TIME), true,
227                 mAutoTimeObserver);
228         mCr.registerContentObserver(
229                 Settings.Global.getUriFor(Settings.Global.AUTO_TIME_ZONE), true,
230                 mAutoTimeZoneObserver);
231
232         setSignalStrengthDefaultValues();
233
234         // Monitor locale change
235         IntentFilter filter = new IntentFilter();
236         filter.addAction(Intent.ACTION_LOCALE_CHANGED);
237         phone.getContext().registerReceiver(mIntentReceiver, filter);
238
239         // Gsm doesn't support OTASP so its not needed
240         phone.notifyOtaspChanged(OTASP_NOT_NEEDED);
241     }
242
243     @Override
244     public void dispose() {
245         checkCorrectThread();
246         log("ServiceStateTracker dispose");
247
248         // Unregister for all events.
249         mCi.unregisterForAvailable(this);
250         mCi.unregisterForRadioStateChanged(this);
251         mCi.unregisterForVoiceNetworkStateChanged(this);
252         if (mUiccApplcation != null) {mUiccApplcation.unregisterForReady(this);}
253         if (mIccRecords != null) {mIccRecords.unregisterForRecordsLoaded(this);}
254         mCi.unSetOnRestrictedStateChanged(this);
255         mCi.unSetOnNITZTime(this);
256         mCr.unregisterContentObserver(mAutoTimeObserver);
257         mCr.unregisterContentObserver(mAutoTimeZoneObserver);
258         mPhone.getContext().unregisterReceiver(mIntentReceiver);
259         super.dispose();
260     }
261
262     @Override
263     protected void finalize() {
264         if(DBG) log("finalize");
265     }
266
267     @Override
268     protected Phone getPhone() {
269         return mPhone;
270     }
271
272     @Override
273     public void handleMessage (Message msg) {
274         AsyncResult ar;
275         int[] ints;
276         String[] strings;
277         Message message;
278
279         if (!mPhone.mIsTheCurrentActivePhone) {
280             Rlog.e(LOG_TAG, "Received message " + msg +
281                     "[" + msg.what + "] while being destroyed. Ignoring.");
282             return;
283         }
284         switch (msg.what) {
285             case EVENT_RADIO_AVAILABLE:
286                 //this is unnecessary
287                 //setPowerStateToDesired();
288                 break;
289
290             case EVENT_SIM_READY:
291                 // Set the network type, in case the radio does not restore it.
292                 mCi.setCurrentPreferredNetworkType();
293
294                 boolean skipRestoringSelection = mPhone.getContext().getResources().getBoolean(
295                         com.android.internal.R.bool.skip_restoring_network_selection);
296
297                 if (!skipRestoringSelection) {
298                     // restore the previous network selection.
299                     mPhone.restoreSavedNetworkSelection(null);
300                 }
301                 pollState();
302                 // Signal strength polling stops when radio is off
303                 queueNextSignalStrengthPoll();
304                 break;
305
306             case EVENT_RADIO_STATE_CHANGED:
307                 // This will do nothing in the radio not
308                 // available case
309                 setPowerStateToDesired();
310                 pollState();
311                 break;
312
313             case EVENT_NETWORK_STATE_CHANGED:
314                 pollState();
315                 break;
316
317             case EVENT_GET_SIGNAL_STRENGTH:
318                 // This callback is called when signal strength is polled
319                 // all by itself
320
321                 if (!(mCi.getRadioState().isOn())) {
322                     // Polling will continue when radio turns back on
323                     return;
324                 }
325                 ar = (AsyncResult) msg.obj;
326                 onSignalStrengthResult(ar, true);
327                 queueNextSignalStrengthPoll();
328
329                 break;
330
331             case EVENT_GET_LOC_DONE:
332                 ar = (AsyncResult) msg.obj;
333
334                 if (ar.exception == null) {
335                     String states[] = (String[])ar.result;
336                     int lac = -1;
337                     int cid = -1;
338                     if (states.length >= 3) {
339                         try {
340                             if (states[1] != null && states[1].length() > 0) {
341                                 lac = Integer.parseInt(states[1], 16);
342                             }
343                             if (states[2] != null && states[2].length() > 0) {
344                                 cid = Integer.parseInt(states[2], 16);
345                             }
346                         } catch (NumberFormatException ex) {
347                             Rlog.w(LOG_TAG, "error parsing location: " + ex);
348                         }
349                     }
350                     mCellLoc.setLacAndCid(lac, cid);
351                     mPhone.notifyLocationChanged();
352                 }
353
354                 // Release any temporary cell lock, which could have been
355                 // acquired to allow a single-shot location update.
356                 disableSingleLocationUpdate();
357                 break;
358
359             case EVENT_POLL_STATE_REGISTRATION:
360             case EVENT_POLL_STATE_GPRS:
361             case EVENT_POLL_STATE_OPERATOR:
362             case EVENT_POLL_STATE_NETWORK_SELECTION_MODE:
363                 ar = (AsyncResult) msg.obj;
364
365                 handlePollStateResult(msg.what, ar);
366                 break;
367
368             case EVENT_POLL_SIGNAL_STRENGTH:
369                 // Just poll signal strength...not part of pollState()
370
371                 mCi.getSignalStrength(obtainMessage(EVENT_GET_SIGNAL_STRENGTH));
372                 break;
373
374             case EVENT_NITZ_TIME:
375                 ar = (AsyncResult) msg.obj;
376
377                 String nitzString = (String)((Object[])ar.result)[0];
378                 long nitzReceiveTime = ((Long)((Object[])ar.result)[1]).longValue();
379
380                 setTimeFromNITZString(nitzString, nitzReceiveTime);
381                 break;
382
383             case EVENT_SIGNAL_STRENGTH_UPDATE:
384                 // This is a notification from
385                 // CommandsInterface.setOnSignalStrengthUpdate
386
387                 ar = (AsyncResult) msg.obj;
388
389                 // The radio is telling us about signal strength changes
390                 // we don't have to ask it
391                 mDontPollSignalStrength = true;
392
393                 onSignalStrengthResult(ar, true);
394                 break;
395
396             case EVENT_SIM_RECORDS_LOADED:
397                 log("EVENT_SIM_RECORDS_LOADED: what=" + msg.what);
398
399                 updatePhoneObject();
400                 updateSpnDisplay();
401                 break;
402
403             case EVENT_LOCATION_UPDATES_ENABLED:
404                 ar = (AsyncResult) msg.obj;
405
406                 if (ar.exception == null) {
407                     mCi.getVoiceRegistrationState(obtainMessage(EVENT_GET_LOC_DONE, null));
408                 }
409                 break;
410
411             case EVENT_SET_PREFERRED_NETWORK_TYPE:
412                 ar = (AsyncResult) msg.obj;
413                 // Don't care the result, only use for dereg network (COPS=2)
414                 message = obtainMessage(EVENT_RESET_PREFERRED_NETWORK_TYPE, ar.userObj);
415                 mCi.setPreferredNetworkType(mPreferredNetworkType, message);
416                 break;
417
418             case EVENT_RESET_PREFERRED_NETWORK_TYPE:
419                 ar = (AsyncResult) msg.obj;
420                 if (ar.userObj != null) {
421                     AsyncResult.forMessage(((Message) ar.userObj)).exception
422                             = ar.exception;
423                     ((Message) ar.userObj).sendToTarget();
424                 }
425                 break;
426
427             case EVENT_GET_PREFERRED_NETWORK_TYPE:
428                 ar = (AsyncResult) msg.obj;
429
430                 if (ar.exception == null) {
431                     mPreferredNetworkType = ((int[])ar.result)[0];
432                 } else {
433                     mPreferredNetworkType = RILConstants.NETWORK_MODE_GLOBAL;
434                 }
435
436                 message = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE, ar.userObj);
437                 int toggledNetworkType = RILConstants.NETWORK_MODE_GLOBAL;
438
439                 mCi.setPreferredNetworkType(toggledNetworkType, message);
440                 break;
441
442             case EVENT_CHECK_REPORT_GPRS:
443                 if (mSS != null && !isGprsConsistent(mSS.getDataRegState(), mSS.getVoiceRegState())) {
444
445                     // Can't register data service while voice service is ok
446                     // i.e. CREG is ok while CGREG is not
447                     // possible a network or baseband side error
448                     GsmCellLocation loc = ((GsmCellLocation)mPhone.getCellLocation());
449                     EventLog.writeEvent(EventLogTags.DATA_NETWORK_REGISTRATION_FAIL,
450                             mSS.getOperatorNumeric(), loc != null ? loc.getCid() : -1);
451                     mReportedGprsNoReg = true;
452                 }
453                 mStartedGprsRegCheck = false;
454                 break;
455
456             case EVENT_RESTRICTED_STATE_CHANGED:
457                 // This is a notification from
458                 // CommandsInterface.setOnRestrictedStateChanged
459
460                 if (DBG) log("EVENT_RESTRICTED_STATE_CHANGED");
461
462                 ar = (AsyncResult) msg.obj;
463
464                 onRestrictedStateChanged(ar);
465                 break;
466
467             default:
468                 super.handleMessage(msg);
469             break;
470         }
471     }
472
473     @Override
474     protected void setPowerStateToDesired() {
475         // If we want it on and it's off, turn it on
476         if (mDesiredPowerState
477             && mCi.getRadioState() == CommandsInterface.RadioState.RADIO_OFF) {
478             mCi.setRadioPower(true, null);
479         } else if (!mDesiredPowerState && mCi.getRadioState().isOn()) {
480             // If it's on and available and we want it off gracefully
481             DcTrackerBase dcTracker = mPhone.mDcTracker;
482             powerOffRadioSafely(dcTracker);
483         } // Otherwise, we're in the desired state
484     }
485
486     @Override
487     protected void hangupAndPowerOff() {
488         // hang up all active voice calls
489         if (mPhone.isInCall()) {
490             mPhone.mCT.mRingingCall.hangupIfAlive();
491             mPhone.mCT.mBackgroundCall.hangupIfAlive();
492             mPhone.mCT.mForegroundCall.hangupIfAlive();
493         }
494
495         mCi.setRadioPower(false, null);
496     }
497
498     @Override
499     protected void updateSpnDisplay() {
500         // The values of plmn/showPlmn change in different scenarios.
501         // 1) No service but emergency call allowed -> expected
502         //    to show "Emergency call only"
503         //    EXTRA_SHOW_PLMN = true
504         //    EXTRA_PLMN = "Emergency call only"
505
506         // 2) No service at all --> expected to show "No service"
507         //    EXTRA_SHOW_PLMN = true
508         //    EXTRA_PLMN = "No service"
509
510         // 3) Normal operation in either home or roaming service
511         //    EXTRA_SHOW_PLMN = depending on IccRecords rule
512         //    EXTRA_PLMN = plmn
513
514         // 4) No service due to power off, aka airplane mode
515         //    EXTRA_SHOW_PLMN = false
516         //    EXTRA_PLMN = null
517
518         IccRecords iccRecords = mIccRecords;
519         String plmn = null;
520         boolean showPlmn = false;
521         int rule = (iccRecords != null) ? iccRecords.getDisplayRule(mSS.getOperatorNumeric()) : 0;
522         if (mSS.getVoiceRegState() == ServiceState.STATE_OUT_OF_SERVICE
523                 || mSS.getVoiceRegState() == ServiceState.STATE_EMERGENCY_ONLY) {
524             showPlmn = true;
525             if (mEmergencyOnly) {
526                 // No service but emergency call allowed
527                 plmn = Resources.getSystem().
528                         getText(com.android.internal.R.string.emergency_calls_only).toString();
529             } else {
530                 // No service at all
531                 plmn = Resources.getSystem().
532                         getText(com.android.internal.R.string.lockscreen_carrier_default).toString();
533             }
534             if (DBG) log("updateSpnDisplay: radio is on but out " +
535                     "of service, set plmn='" + plmn + "'");
536         } else if (mSS.getVoiceRegState() == ServiceState.STATE_IN_SERVICE) {
537             // In either home or roaming service
538             plmn = mSS.getOperatorAlphaLong();
539             showPlmn = !TextUtils.isEmpty(plmn) &&
540                     ((rule & SIMRecords.SPN_RULE_SHOW_PLMN)
541                             == SIMRecords.SPN_RULE_SHOW_PLMN);
542         } else {
543             // Power off state, such as airplane mode
544             if (DBG) log("updateSpnDisplay: radio is off w/ showPlmn="
545                     + showPlmn + " plmn=" + plmn);
546         }
547
548         // The value of spn/showSpn are same in different scenarios.
549         //    EXTRA_SHOW_SPN = depending on IccRecords rule
550         //    EXTRA_SPN = spn
551         String spn = (iccRecords != null) ? iccRecords.getServiceProviderName() : "";
552         boolean showSpn = !TextUtils.isEmpty(spn)
553                 && ((rule & SIMRecords.SPN_RULE_SHOW_SPN)
554                         == SIMRecords.SPN_RULE_SHOW_SPN);
555
556         // Update SPN_STRINGS_UPDATED_ACTION IFF any value changes
557         if (showPlmn != mCurShowPlmn
558                 || showSpn != mCurShowSpn
559                 || !TextUtils.equals(spn, mCurSpn)
560                 || !TextUtils.equals(plmn, mCurPlmn)) {
561             if (DBG) {
562                 log(String.format("updateSpnDisplay: changed" +
563                         " sending intent rule=" + rule +
564                         " showPlmn='%b' plmn='%s' showSpn='%b' spn='%s'",
565                         showPlmn, plmn, showSpn, spn));
566             }
567             Intent intent = new Intent(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION);
568             intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
569             intent.putExtra(TelephonyIntents.EXTRA_SHOW_SPN, showSpn);
570             intent.putExtra(TelephonyIntents.EXTRA_SPN, spn);
571             intent.putExtra(TelephonyIntents.EXTRA_SHOW_PLMN, showPlmn);
572             intent.putExtra(TelephonyIntents.EXTRA_PLMN, plmn);
573             mPhone.getContext().sendStickyBroadcastAsUser(intent, UserHandle.ALL);
574         }
575
576         mCurShowSpn = showSpn;
577         mCurShowPlmn = showPlmn;
578         mCurSpn = spn;
579         mCurPlmn = plmn;
580     }
581
582     /**
583      * Handle the result of one of the pollState()-related requests
584      */
585     @Override
586     protected void handlePollStateResult (int what, AsyncResult ar) {
587         int ints[];
588         String states[];
589
590         // Ignore stale requests from last poll
591         if (ar.userObj != mPollingContext) return;
592
593         if (ar.exception != null) {
594             CommandException.Error err=null;
595
596             if (ar.exception instanceof CommandException) {
597                 err = ((CommandException)(ar.exception)).getCommandError();
598             }
599
600             if (err == CommandException.Error.RADIO_NOT_AVAILABLE) {
601                 // Radio has crashed or turned off
602                 cancelPollState();
603                 return;
604             }
605
606             if (!mCi.getRadioState().isOn()) {
607                 // Radio has crashed or turned off
608                 cancelPollState();
609                 return;
610             }
611
612             if (err != CommandException.Error.OP_NOT_ALLOWED_BEFORE_REG_NW) {
613                 loge("RIL implementation has returned an error where it must succeed" +
614                         ar.exception);
615             }
616         } else try {
617             switch (what) {
618                 case EVENT_POLL_STATE_REGISTRATION: {
619                     states = (String[])ar.result;
620                     int lac = -1;
621                     int cid = -1;
622                     int type = ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN;
623                     int regState = ServiceState.RIL_REG_STATE_UNKNOWN;
624                     int reasonRegStateDenied = -1;
625                     int psc = -1;
626                     if (states.length > 0) {
627                         try {
628                             regState = Integer.parseInt(states[0]);
629                             if (states.length >= 3) {
630                                 if (states[1] != null && states[1].length() > 0) {
631                                     lac = Integer.parseInt(states[1], 16);
632                                 }
633                                 if (states[2] != null && states[2].length() > 0) {
634                                     cid = Integer.parseInt(states[2], 16);
635                                 }
636
637                                 // states[3] (if present) is the current radio technology
638                                 if (states.length >= 4 && states[3] != null) {
639                                     type = Integer.parseInt(states[3]);
640                                 }
641                             }
642                             if (states.length > 14) {
643                                 if (states[14] != null && states[14].length() > 0) {
644                                     psc = Integer.parseInt(states[14], 16);
645                                 }
646                             }
647                         } catch (NumberFormatException ex) {
648                             loge("error parsing RegistrationState: " + ex);
649                         }
650                     }
651
652                     mGsmRoaming = regCodeIsRoaming(regState);
653                     mNewSS.setState(regCodeToServiceState(regState));
654                     mNewSS.setRilVoiceRadioTechnology(type);
655
656                     boolean isVoiceCapable = mPhoneBase.getContext().getResources()
657                             .getBoolean(com.android.internal.R.bool.config_voice_capable);
658                     if ((regState == ServiceState.RIL_REG_STATE_DENIED_EMERGENCY_CALL_ENABLED
659                          || regState == ServiceState.RIL_REG_STATE_NOT_REG_EMERGENCY_CALL_ENABLED
660                          || regState == ServiceState.RIL_REG_STATE_SEARCHING_EMERGENCY_CALL_ENABLED
661                          || regState == ServiceState.RIL_REG_STATE_UNKNOWN_EMERGENCY_CALL_ENABLED)
662                          && isVoiceCapable) {
663                         mEmergencyOnly = true;
664                     } else {
665                         mEmergencyOnly = false;
666                     }
667
668                     // LAC and CID are -1 if not avail
669                     mNewCellLoc.setLacAndCid(lac, cid);
670                     mNewCellLoc.setPsc(psc);
671                     break;
672                 }
673
674                 case EVENT_POLL_STATE_GPRS: {
675                     states = (String[])ar.result;
676
677                     int type = 0;
678                     int regState = ServiceState.RIL_REG_STATE_UNKNOWN;
679                     mNewReasonDataDenied = -1;
680                     mNewMaxDataCalls = 1;
681                     if (states.length > 0) {
682                         try {
683                             regState = Integer.parseInt(states[0]);
684
685                             // states[3] (if present) is the current radio technology
686                             if (states.length >= 4 && states[3] != null) {
687                                 type = Integer.parseInt(states[3]);
688                             }
689                             if ((states.length >= 5 ) &&
690                                     (regState == ServiceState.RIL_REG_STATE_DENIED)) {
691                                 mNewReasonDataDenied = Integer.parseInt(states[4]);
692                             }
693                             if (states.length >= 6) {
694                                 mNewMaxDataCalls = Integer.parseInt(states[5]);
695                             }
696                         } catch (NumberFormatException ex) {
697                             loge("error parsing GprsRegistrationState: " + ex);
698                         }
699                     }
700                     int dataRegState = regCodeToServiceState(regState);
701                     mNewSS.setDataRegState(dataRegState);
702                     mDataRoaming = regCodeIsRoaming(regState);
703                     mNewSS.setRilDataRadioTechnology(type);
704                     if (DBG) {
705                         log("handlPollStateResultMessage: GsmSST setDataRegState=" + dataRegState
706                                 + " regState=" + regState
707                                 + " dataRadioTechnology=" + type);
708                     }
709                     break;
710                 }
711
712                 case EVENT_POLL_STATE_OPERATOR: {
713                     String opNames[] = (String[])ar.result;
714
715                     if (opNames != null && opNames.length >= 3) {
716                          mNewSS.setOperatorName (opNames[0], opNames[1], opNames[2]);
717                     }
718                     break;
719                 }
720
721                 case EVENT_POLL_STATE_NETWORK_SELECTION_MODE: {
722                     ints = (int[])ar.result;
723                     mNewSS.setIsManualSelection(ints[0] == 1);
724                     break;
725                 }
726             }
727
728         } catch (RuntimeException ex) {
729             loge("Exception while polling service state. Probably malformed RIL response." + ex);
730         }
731
732         mPollingContext[0]--;
733
734         if (mPollingContext[0] == 0) {
735             /**
736              * Since the roaming state of gsm service (from +CREG) and
737              * data service (from +CGREG) could be different, the new SS
738              * is set to roaming when either is true.
739              *
740              * There are exceptions for the above rule.
741              * The new SS is not set as roaming while gsm service reports
742              * roaming but indeed it is same operator.
743              * And the operator is considered non roaming.
744              *
745              * The test for the operators is to handle special roaming
746              * agreements and MVNO's.
747              */
748             boolean roaming = (mGsmRoaming || mDataRoaming);
749             if ((mGsmRoaming && isSameNamedOperators(mNewSS))
750                     || isOperatorConsideredNonRoaming(mNewSS)) {
751                 roaming = false;
752             }
753             mNewSS.setRoaming(roaming);
754             mNewSS.setEmergencyOnly(mEmergencyOnly);
755             pollStateDone();
756         }
757     }
758
759     private void setSignalStrengthDefaultValues() {
760         mSignalStrength = new SignalStrength(true);
761     }
762
763     /**
764      * A complete "service state" from our perspective is
765      * composed of a handful of separate requests to the radio.
766      *
767      * We make all of these requests at once, but then abandon them
768      * and start over again if the radio notifies us that some
769      * event has changed
770      */
771     private void pollState() {
772         mPollingContext = new int[1];
773         mPollingContext[0] = 0;
774
775         switch (mCi.getRadioState()) {
776             case RADIO_UNAVAILABLE:
777                 mNewSS.setStateOutOfService();
778                 mNewCellLoc.setStateInvalid();
779                 setSignalStrengthDefaultValues();
780                 mGotCountryCode = false;
781                 mNitzUpdatedTime = false;
782                 pollStateDone();
783             break;
784
785             case RADIO_OFF:
786                 mNewSS.setStateOff();
787                 mNewCellLoc.setStateInvalid();
788                 setSignalStrengthDefaultValues();
789                 mGotCountryCode = false;
790                 mNitzUpdatedTime = false;
791                 pollStateDone();
792             break;
793
794             default:
795                 // Issue all poll-related commands at once
796                 // then count down the responses, which
797                 // are allowed to arrive out-of-order
798
799                 mPollingContext[0]++;
800                 mCi.getOperator(
801                     obtainMessage(
802                         EVENT_POLL_STATE_OPERATOR, mPollingContext));
803
804                 mPollingContext[0]++;
805                 mCi.getDataRegistrationState(
806                     obtainMessage(
807                         EVENT_POLL_STATE_GPRS, mPollingContext));
808
809                 mPollingContext[0]++;
810                 mCi.getVoiceRegistrationState(
811                     obtainMessage(
812                         EVENT_POLL_STATE_REGISTRATION, mPollingContext));
813
814                 mPollingContext[0]++;
815                 mCi.getNetworkSelectionMode(
816                     obtainMessage(
817                         EVENT_POLL_STATE_NETWORK_SELECTION_MODE, mPollingContext));
818             break;
819         }
820     }
821
822     private void pollStateDone() {
823         if (DBG) {
824             log("Poll ServiceState done: " +
825                 " oldSS=[" + mSS + "] newSS=[" + mNewSS + "]" +
826                 " oldMaxDataCalls=" + mMaxDataCalls +
827                 " mNewMaxDataCalls=" + mNewMaxDataCalls +
828                 " oldReasonDataDenied=" + mReasonDataDenied +
829                 " mNewReasonDataDenied=" + mNewReasonDataDenied);
830         }
831
832         if (Build.IS_DEBUGGABLE && SystemProperties.getBoolean(PROP_FORCE_ROAMING, false)) {
833             mNewSS.setRoaming(true);
834         }
835
836         useDataRegStateForDataOnlyDevices();
837
838         boolean hasRegistered =
839             mSS.getVoiceRegState() != ServiceState.STATE_IN_SERVICE
840             && mNewSS.getVoiceRegState() == ServiceState.STATE_IN_SERVICE;
841
842         boolean hasDeregistered =
843             mSS.getVoiceRegState() == ServiceState.STATE_IN_SERVICE
844             && mNewSS.getVoiceRegState() != ServiceState.STATE_IN_SERVICE;
845
846         boolean hasGprsAttached =
847                 mSS.getDataRegState() != ServiceState.STATE_IN_SERVICE
848                 && mNewSS.getDataRegState() == ServiceState.STATE_IN_SERVICE;
849
850         boolean hasGprsDetached =
851                 mSS.getDataRegState() == ServiceState.STATE_IN_SERVICE
852                 && mNewSS.getDataRegState() != ServiceState.STATE_IN_SERVICE;
853
854         boolean hasDataRegStateChanged =
855                 mSS.getDataRegState() != mNewSS.getDataRegState();
856
857         boolean hasVoiceRegStateChanged =
858                 mSS.getVoiceRegState() != mNewSS.getVoiceRegState();
859
860         boolean hasRilVoiceRadioTechnologyChanged =
861                 mSS.getRilVoiceRadioTechnology() != mNewSS.getRilVoiceRadioTechnology();
862
863         boolean hasRilDataRadioTechnologyChanged =
864                 mSS.getRilDataRadioTechnology() != mNewSS.getRilDataRadioTechnology();
865
866         boolean hasChanged = !mNewSS.equals(mSS);
867
868         boolean hasRoamingOn = !mSS.getRoaming() && mNewSS.getRoaming();
869
870         boolean hasRoamingOff = mSS.getRoaming() && !mNewSS.getRoaming();
871
872         boolean hasLocationChanged = !mNewCellLoc.equals(mCellLoc);
873
874         // Add an event log when connection state changes
875         if (hasVoiceRegStateChanged || hasDataRegStateChanged) {
876             EventLog.writeEvent(EventLogTags.GSM_SERVICE_STATE_CHANGE,
877                 mSS.getVoiceRegState(), mSS.getDataRegState(),
878                 mNewSS.getVoiceRegState(), mNewSS.getDataRegState());
879         }
880
881         // Add an event log when network type switched
882         // TODO: we may add filtering to reduce the event logged,
883         // i.e. check preferred network setting, only switch to 2G, etc
884         if (hasRilVoiceRadioTechnologyChanged) {
885             int cid = -1;
886             GsmCellLocation loc = mNewCellLoc;
887             if (loc != null) cid = loc.getCid();
888             // NOTE: this code was previously located after mSS and mNewSS are swapped, so
889             // existing logs were incorrectly using the new state for "network_from"
890             // and STATE_OUT_OF_SERVICE for "network_to". To avoid confusion, use a new log tag
891             // to record the correct states.
892             EventLog.writeEvent(EventLogTags.GSM_RAT_SWITCHED_NEW, cid,
893                     mSS.getRilVoiceRadioTechnology(),
894                     mNewSS.getRilVoiceRadioTechnology());
895             if (DBG) {
896                 log("RAT switched "
897                         + ServiceState.rilRadioTechnologyToString(mSS.getRilVoiceRadioTechnology())
898                         + " -> "
899                         + ServiceState.rilRadioTechnologyToString(
900                                 mNewSS.getRilVoiceRadioTechnology()) + " at cell " + cid);
901             }
902         }
903
904         // swap mSS and mNewSS to put new state in mSS
905         ServiceState tss = mSS;
906         mSS = mNewSS;
907         mNewSS = tss;
908         // clean slate for next time
909         mNewSS.setStateOutOfService();
910
911         // swap mCellLoc and mNewCellLoc to put new state in mCellLoc
912         GsmCellLocation tcl = mCellLoc;
913         mCellLoc = mNewCellLoc;
914         mNewCellLoc = tcl;
915
916         mReasonDataDenied = mNewReasonDataDenied;
917         mMaxDataCalls = mNewMaxDataCalls;
918
919         if (hasRilVoiceRadioTechnologyChanged) {
920             updatePhoneObject();
921         }
922
923         if (hasRilDataRadioTechnologyChanged) {
924             mPhone.setSystemProperty(TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE,
925                     ServiceState.rilRadioTechnologyToString(mSS.getRilVoiceRadioTechnology()));
926         }
927
928         if (hasRegistered) {
929             mNetworkAttachedRegistrants.notifyRegistrants();
930
931             if (DBG) {
932                 log("pollStateDone: registering current mNitzUpdatedTime=" +
933                         mNitzUpdatedTime + " changing to false");
934             }
935             mNitzUpdatedTime = false;
936         }
937
938         if (hasChanged) {
939             String operatorNumeric;
940
941             updateSpnDisplay();
942
943             mPhone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ALPHA,
944                 mSS.getOperatorAlphaLong());
945
946             String prevOperatorNumeric =
947                     SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, "");
948             operatorNumeric = mSS.getOperatorNumeric();
949             mPhone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, operatorNumeric);
950
951             if (operatorNumeric == null) {
952                 if (DBG) log("operatorNumeric is null");
953                 mPhone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, "");
954                 mGotCountryCode = false;
955                 mNitzUpdatedTime = false;
956             } else {
957                 String iso = "";
958                 String mcc = "";
959                 try{
960                     mcc = operatorNumeric.substring(0, 3);
961                     iso = MccTable.countryCodeForMcc(Integer.parseInt(mcc));
962                 } catch ( NumberFormatException ex){
963                     loge("pollStateDone: countryCodeForMcc error" + ex);
964                 } catch ( StringIndexOutOfBoundsException ex) {
965                     loge("pollStateDone: countryCodeForMcc error" + ex);
966                 }
967
968                 mPhone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, iso);
969                 mGotCountryCode = true;
970
971                 TimeZone zone = null;
972
973                 if (!mNitzUpdatedTime && !mcc.equals("000") && !TextUtils.isEmpty(iso) &&
974                         getAutoTimeZone()) {
975
976                     // Test both paths if ignore nitz is true
977                     boolean testOneUniqueOffsetPath = SystemProperties.getBoolean(
978                                 TelephonyProperties.PROPERTY_IGNORE_NITZ, false) &&
979                                     ((SystemClock.uptimeMillis() & 1) == 0);
980
981                     ArrayList<TimeZone> uniqueZones = TimeUtils.getTimeZonesWithUniqueOffsets(iso);
982                     if ((uniqueZones.size() == 1) || testOneUniqueOffsetPath) {
983                         zone = uniqueZones.get(0);
984                         if (DBG) {
985                            log("pollStateDone: no nitz but one TZ for iso-cc=" + iso +
986                                    " with zone.getID=" + zone.getID() +
987                                    " testOneUniqueOffsetPath=" + testOneUniqueOffsetPath);
988                         }
989                         setAndBroadcastNetworkSetTimeZone(zone.getID());
990                     } else {
991                         if (DBG) {
992                             log("pollStateDone: there are " + uniqueZones.size() +
993                                 " unique offsets for iso-cc='" + iso +
994                                 " testOneUniqueOffsetPath=" + testOneUniqueOffsetPath +
995                                 "', do nothing");
996                         }
997                     }
998                 }
999
1000                 if (shouldFixTimeZoneNow(mPhone, operatorNumeric, prevOperatorNumeric,
1001                         mNeedFixZoneAfterNitz)) {
1002                     // If the offset is (0, false) and the timezone property
1003                     // is set, use the timezone property rather than
1004                     // GMT.
1005                     String zoneName = SystemProperties.get(TIMEZONE_PROPERTY);
1006                     if (DBG) {
1007                         log("pollStateDone: fix time zone zoneName='" + zoneName +
1008                             "' mZoneOffset=" + mZoneOffset + " mZoneDst=" + mZoneDst +
1009                             " iso-cc='" + iso +
1010                             "' iso-cc-idx=" + Arrays.binarySearch(GMT_COUNTRY_CODES, iso));
1011                     }
1012
1013                     // "(mZoneOffset == 0) && (mZoneDst == false) &&
1014                     //  (Arrays.binarySearch(GMT_COUNTRY_CODES, iso) < 0)"
1015                     // means that we received a NITZ string telling
1016                     // it is in GMT+0 w/ DST time zone
1017                     // BUT iso tells is NOT, e.g, a wrong NITZ reporting
1018                     // local time w/ 0 offset.
1019                     if ((mZoneOffset == 0) && (mZoneDst == false) &&
1020                         (zoneName != null) && (zoneName.length() > 0) &&
1021                         (Arrays.binarySearch(GMT_COUNTRY_CODES, iso) < 0)) {
1022                         zone = TimeZone.getDefault();
1023                         if (mNeedFixZoneAfterNitz) {
1024                             // For wrong NITZ reporting local time w/ 0 offset,
1025                             // need adjust time to reflect default timezone setting
1026                             long ctm = System.currentTimeMillis();
1027                             long tzOffset = zone.getOffset(ctm);
1028                             if (DBG) {
1029                                 log("pollStateDone: tzOffset=" + tzOffset + " ltod=" +
1030                                         TimeUtils.logTimeOfDay(ctm));
1031                             }
1032                             if (getAutoTime()) {
1033                                 long adj = ctm - tzOffset;
1034                                 if (DBG) log("pollStateDone: adj ltod=" +
1035                                         TimeUtils.logTimeOfDay(adj));
1036                                 setAndBroadcastNetworkSetTime(adj);
1037                             } else {
1038                                 // Adjust the saved NITZ time to account for tzOffset.
1039                                 mSavedTime = mSavedTime - tzOffset;
1040                             }
1041                         }
1042                         if (DBG) log("pollStateDone: using default TimeZone");
1043                     } else if (iso.equals("")){
1044                         // Country code not found.  This is likely a test network.
1045                         // Get a TimeZone based only on the NITZ parameters (best guess).
1046                         zone = getNitzTimeZone(mZoneOffset, mZoneDst, mZoneTime);
1047                         if (DBG) log("pollStateDone: using NITZ TimeZone");
1048                     } else {
1049                         zone = TimeUtils.getTimeZone(mZoneOffset, mZoneDst, mZoneTime, iso);
1050                         if (DBG) log("pollStateDone: using getTimeZone(off, dst, time, iso)");
1051                     }
1052
1053                     mNeedFixZoneAfterNitz = false;
1054
1055                     if (zone != null) {
1056                         log("pollStateDone: zone != null zone.getID=" + zone.getID());
1057                         if (getAutoTimeZone()) {
1058                             setAndBroadcastNetworkSetTimeZone(zone.getID());
1059                         }
1060                         saveNitzTimeZone(zone.getID());
1061                     } else {
1062                         log("pollStateDone: zone == null");
1063                     }
1064                 }
1065             }
1066
1067             mPhone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISROAMING,
1068                 mSS.getRoaming() ? "true" : "false");
1069
1070             mPhone.notifyServiceStateChanged(mSS);
1071         }
1072
1073         if (hasGprsAttached) {
1074             mAttachedRegistrants.notifyRegistrants();
1075         }
1076
1077         if (hasGprsDetached) {
1078             mDetachedRegistrants.notifyRegistrants();
1079         }
1080
1081         if (hasDataRegStateChanged || hasRilDataRadioTechnologyChanged) {
1082             notifyDataRegStateRilRadioTechnologyChanged();
1083             mPhone.notifyDataConnection(null);
1084         }
1085
1086         if (hasRoamingOn) {
1087             mRoamingOnRegistrants.notifyRegistrants();
1088         }
1089
1090         if (hasRoamingOff) {
1091             mRoamingOffRegistrants.notifyRegistrants();
1092         }
1093
1094         if (hasLocationChanged) {
1095             mPhone.notifyLocationChanged();
1096         }
1097
1098         if (! isGprsConsistent(mSS.getDataRegState(), mSS.getVoiceRegState())) {
1099             if (!mStartedGprsRegCheck && !mReportedGprsNoReg) {
1100                 mStartedGprsRegCheck = true;
1101
1102                 int check_period = Settings.Global.getInt(
1103                         mPhone.getContext().getContentResolver(),
1104                         Settings.Global.GPRS_REGISTER_CHECK_PERIOD_MS,
1105                         DEFAULT_GPRS_CHECK_PERIOD_MILLIS);
1106                 sendMessageDelayed(obtainMessage(EVENT_CHECK_REPORT_GPRS),
1107                         check_period);
1108             }
1109         } else {
1110             mReportedGprsNoReg = false;
1111         }
1112         // TODO: Add GsmCellIdenity updating, see CdmaLteServiceStateTracker.
1113     }
1114
1115     /**
1116      * Check if GPRS got registered while voice is registered.
1117      *
1118      * @param dataRegState i.e. CGREG in GSM
1119      * @param voiceRegState i.e. CREG in GSM
1120      * @return false if device only register to voice but not gprs
1121      */
1122     private boolean isGprsConsistent(int dataRegState, int voiceRegState) {
1123         return !((voiceRegState == ServiceState.STATE_IN_SERVICE) &&
1124                 (dataRegState != ServiceState.STATE_IN_SERVICE));
1125     }
1126
1127     /**
1128      * Returns a TimeZone object based only on parameters from the NITZ string.
1129      */
1130     private TimeZone getNitzTimeZone(int offset, boolean dst, long when) {
1131         TimeZone guess = findTimeZone(offset, dst, when);
1132         if (guess == null) {
1133             // Couldn't find a proper timezone.  Perhaps the DST data is wrong.
1134             guess = findTimeZone(offset, !dst, when);
1135         }
1136         if (DBG) log("getNitzTimeZone returning " + (guess == null ? guess : guess.getID()));
1137         return guess;
1138     }
1139
1140     private TimeZone findTimeZone(int offset, boolean dst, long when) {
1141         int rawOffset = offset;
1142         if (dst) {
1143             rawOffset -= 3600000;
1144         }
1145         String[] zones = TimeZone.getAvailableIDs(rawOffset);
1146         TimeZone guess = null;
1147         Date d = new Date(when);
1148         for (String zone : zones) {
1149             TimeZone tz = TimeZone.getTimeZone(zone);
1150             if (tz.getOffset(when) == offset &&
1151                 tz.inDaylightTime(d) == dst) {
1152                 guess = tz;
1153                 break;
1154             }
1155         }
1156
1157         return guess;
1158     }
1159
1160     private void queueNextSignalStrengthPoll() {
1161         if (mDontPollSignalStrength) {
1162             // The radio is telling us about signal strength changes
1163             // we don't have to ask it
1164             return;
1165         }
1166
1167         Message msg;
1168
1169         msg = obtainMessage();
1170         msg.what = EVENT_POLL_SIGNAL_STRENGTH;
1171
1172         long nextTime;
1173
1174         // TODO Don't poll signal strength if screen is off
1175         sendMessageDelayed(msg, POLL_PERIOD_MILLIS);
1176     }
1177
1178     /**
1179      * Set restricted state based on the OnRestrictedStateChanged notification
1180      * If any voice or packet restricted state changes, trigger a UI
1181      * notification and notify registrants when sim is ready.
1182      *
1183      * @param ar an int value of RIL_RESTRICTED_STATE_*
1184      */
1185     private void onRestrictedStateChanged(AsyncResult ar) {
1186         RestrictedState newRs = new RestrictedState();
1187
1188         if (DBG) log("onRestrictedStateChanged: E rs "+ mRestrictedState);
1189
1190         if (ar.exception == null) {
1191             int[] ints = (int[])ar.result;
1192             int state = ints[0];
1193
1194             newRs.setCsEmergencyRestricted(
1195                     ((state & RILConstants.RIL_RESTRICTED_STATE_CS_EMERGENCY) != 0) ||
1196                     ((state & RILConstants.RIL_RESTRICTED_STATE_CS_ALL) != 0) );
1197             //ignore the normal call and data restricted state before SIM READY
1198             if (mUiccApplcation != null && mUiccApplcation.getState() == AppState.APPSTATE_READY) {
1199                 newRs.setCsNormalRestricted(
1200                         ((state & RILConstants.RIL_RESTRICTED_STATE_CS_NORMAL) != 0) ||
1201                         ((state & RILConstants.RIL_RESTRICTED_STATE_CS_ALL) != 0) );
1202                 newRs.setPsRestricted(
1203                         (state & RILConstants.RIL_RESTRICTED_STATE_PS_ALL)!= 0);
1204             }
1205
1206             if (DBG) log("onRestrictedStateChanged: new rs "+ newRs);
1207
1208             if (!mRestrictedState.isPsRestricted() && newRs.isPsRestricted()) {
1209                 mPsRestrictEnabledRegistrants.notifyRegistrants();
1210                 setNotification(PS_ENABLED);
1211             } else if (mRestrictedState.isPsRestricted() && !newRs.isPsRestricted()) {
1212                 mPsRestrictDisabledRegistrants.notifyRegistrants();
1213                 setNotification(PS_DISABLED);
1214             }
1215
1216             /**
1217              * There are two kind of cs restriction, normal and emergency. So
1218              * there are 4 x 4 combinations in current and new restricted states
1219              * and we only need to notify when state is changed.
1220              */
1221             if (mRestrictedState.isCsRestricted()) {
1222                 if (!newRs.isCsRestricted()) {
1223                     // remove all restriction
1224                     setNotification(CS_DISABLED);
1225                 } else if (!newRs.isCsNormalRestricted()) {
1226                     // remove normal restriction
1227                     setNotification(CS_EMERGENCY_ENABLED);
1228                 } else if (!newRs.isCsEmergencyRestricted()) {
1229                     // remove emergency restriction
1230                     setNotification(CS_NORMAL_ENABLED);
1231                 }
1232             } else if (mRestrictedState.isCsEmergencyRestricted() &&
1233                     !mRestrictedState.isCsNormalRestricted()) {
1234                 if (!newRs.isCsRestricted()) {
1235                     // remove all restriction
1236                     setNotification(CS_DISABLED);
1237                 } else if (newRs.isCsRestricted()) {
1238                     // enable all restriction
1239                     setNotification(CS_ENABLED);
1240                 } else if (newRs.isCsNormalRestricted()) {
1241                     // remove emergency restriction and enable normal restriction
1242                     setNotification(CS_NORMAL_ENABLED);
1243                 }
1244             } else if (!mRestrictedState.isCsEmergencyRestricted() &&
1245                     mRestrictedState.isCsNormalRestricted()) {
1246                 if (!newRs.isCsRestricted()) {
1247                     // remove all restriction
1248                     setNotification(CS_DISABLED);
1249                 } else if (newRs.isCsRestricted()) {
1250                     // enable all restriction
1251                     setNotification(CS_ENABLED);
1252                 } else if (newRs.isCsEmergencyRestricted()) {
1253                     // remove normal restriction and enable emergency restriction
1254                     setNotification(CS_EMERGENCY_ENABLED);
1255                 }
1256             } else {
1257                 if (newRs.isCsRestricted()) {
1258                     // enable all restriction
1259                     setNotification(CS_ENABLED);
1260                 } else if (newRs.isCsEmergencyRestricted()) {
1261                     // enable emergency restriction
1262                     setNotification(CS_EMERGENCY_ENABLED);
1263                 } else if (newRs.isCsNormalRestricted()) {
1264                     // enable normal restriction
1265                     setNotification(CS_NORMAL_ENABLED);
1266                 }
1267             }
1268
1269             mRestrictedState = newRs;
1270         }
1271         log("onRestrictedStateChanged: X rs "+ mRestrictedState);
1272     }
1273
1274     /** code is registration state 0-5 from TS 27.007 7.2 */
1275     private int regCodeToServiceState(int code) {
1276         switch (code) {
1277             case 0:
1278             case 2: // 2 is "searching"
1279             case 3: // 3 is "registration denied"
1280             case 4: // 4 is "unknown" no vaild in current baseband
1281             case 10:// same as 0, but indicates that emergency call is possible.
1282             case 12:// same as 2, but indicates that emergency call is possible.
1283             case 13:// same as 3, but indicates that emergency call is possible.
1284             case 14:// same as 4, but indicates that emergency call is possible.
1285                 return ServiceState.STATE_OUT_OF_SERVICE;
1286
1287             case 1:
1288                 return ServiceState.STATE_IN_SERVICE;
1289
1290             case 5:
1291                 // in service, roam
1292                 return ServiceState.STATE_IN_SERVICE;
1293
1294             default:
1295                 loge("regCodeToServiceState: unexpected service state " + code);
1296                 return ServiceState.STATE_OUT_OF_SERVICE;
1297         }
1298     }
1299
1300
1301     /**
1302      * code is registration state 0-5 from TS 27.007 7.2
1303      * returns true if registered roam, false otherwise
1304      */
1305     private boolean regCodeIsRoaming (int code) {
1306         return ServiceState.RIL_REG_STATE_ROAMING == code;
1307     }
1308
1309     /**
1310      * Set roaming state if operator mcc is the same as sim mcc
1311      * and ons is different from spn
1312      *
1313      * @param s ServiceState hold current ons
1314      * @return true if same operator
1315      */
1316     private boolean isSameNamedOperators(ServiceState s) {
1317         String spn = SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA, "empty");
1318
1319         String onsl = s.getOperatorAlphaLong();
1320         String onss = s.getOperatorAlphaShort();
1321
1322         boolean equalsOnsl = onsl != null && spn.equals(onsl);
1323         boolean equalsOnss = onss != null && spn.equals(onss);
1324
1325         return currentMccEqualsSimMcc(s) && (equalsOnsl || equalsOnss);
1326     }
1327
1328     /**
1329      * Compare SIM MCC with Operator MCC
1330      *
1331      * @param s ServiceState hold current ons
1332      * @return true if both are same
1333      */
1334     private boolean currentMccEqualsSimMcc(ServiceState s) {
1335         String simNumeric = SystemProperties.get(
1336                 TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, "");
1337         String operatorNumeric = s.getOperatorNumeric();
1338         boolean equalsMcc = true;
1339
1340         try {
1341             equalsMcc = simNumeric.substring(0, 3).
1342                     equals(operatorNumeric.substring(0, 3));
1343         } catch (Exception e){
1344         }
1345         return equalsMcc;
1346     }
1347
1348     /**
1349      * Do not set roaming state in case of oprators considered non-roaming.
1350      *
1351      + Can use mcc or mcc+mnc as item of config_operatorConsideredNonRoaming.
1352      * For example, 302 or 21407. If mcc or mcc+mnc match with operator,
1353      * don't set roaming state.
1354      *
1355      * @param s ServiceState hold current ons
1356      * @return false for roaming state set
1357      */
1358     private boolean isOperatorConsideredNonRoaming(ServiceState s) {
1359         String operatorNumeric = s.getOperatorNumeric();
1360         String[] numericArray = mPhone.getContext().getResources().getStringArray(
1361                     com.android.internal.R.array.config_operatorConsideredNonRoaming);
1362
1363         if (numericArray.length == 0 || operatorNumeric == null)
1364             return false;
1365
1366         for (String numeric : numericArray) {
1367             if (operatorNumeric.startsWith(numeric))
1368                 return true;
1369             else
1370                 return false;
1371         }
1372         return false;
1373     }
1374
1375     /**
1376      * @return The current GPRS state. IN_SERVICE is the same as "attached"
1377      * and OUT_OF_SERVICE is the same as detached.
1378      */
1379     @Override
1380     public int getCurrentDataConnectionState() {
1381         return mSS.getDataRegState();
1382     }
1383
1384     /**
1385      * @return true if phone is camping on a technology (eg UMTS)
1386      * that could support voice and data simultaneously.
1387      */
1388     @Override
1389     public boolean isConcurrentVoiceAndDataAllowed() {
1390         return (mSS.getRilVoiceRadioTechnology() >= ServiceState.RIL_RADIO_TECHNOLOGY_UMTS);
1391     }
1392
1393     /**
1394      * @return the current cell location information. Prefer Gsm location
1395      * information if available otherwise return LTE location information
1396      */
1397     public CellLocation getCellLocation() {
1398         if ((mCellLoc.getLac() >= 0) && (mCellLoc.getCid() >= 0)) {
1399             if (DBG) log("getCellLocation(): X good mCellLoc=" + mCellLoc);
1400             return mCellLoc;
1401         } else {
1402             List<CellInfo> result = getAllCellInfo();
1403             if (result != null) {
1404                 // A hack to allow tunneling of LTE information via GsmCellLocation
1405                 // so that older Network Location Providers can return some information
1406                 // on LTE only networks, see bug 9228974.
1407                 //
1408                 // We'll search the return CellInfo array preferring GSM/WCDMA
1409                 // data, but if there is none we'll tunnel the first LTE information
1410                 // in the list.
1411                 //
1412                 // The tunnel'd LTE information is returned as follows:
1413                 //   LAC = TAC field
1414                 //   CID = CI field
1415                 //   PSC = 0.
1416                 GsmCellLocation cellLocOther = new GsmCellLocation();
1417                 for (CellInfo ci : result) {
1418                     if (ci instanceof CellInfoGsm) {
1419                         CellInfoGsm cellInfoGsm = (CellInfoGsm)ci;
1420                         CellIdentityGsm cellIdentityGsm = cellInfoGsm.getCellIdentity();
1421                         cellLocOther.setLacAndCid(cellIdentityGsm.getLac(),
1422                                 cellIdentityGsm.getCid());
1423                         cellLocOther.setPsc(cellIdentityGsm.getPsc());
1424                         if (DBG) log("getCellLocation(): X ret GSM info=" + cellLocOther);
1425                         return cellLocOther;
1426                     } else if (ci instanceof CellInfoWcdma) {
1427                         CellInfoWcdma cellInfoWcdma = (CellInfoWcdma)ci;
1428                         CellIdentityWcdma cellIdentityWcdma = cellInfoWcdma.getCellIdentity();
1429                         cellLocOther.setLacAndCid(cellIdentityWcdma.getLac(),
1430                                 cellIdentityWcdma.getCid());
1431                         cellLocOther.setPsc(cellIdentityWcdma.getPsc());
1432                         if (DBG) log("getCellLocation(): X ret WCDMA info=" + cellLocOther);
1433                         return cellLocOther;
1434                     } else if ((ci instanceof CellInfoLte) &&
1435                             ((cellLocOther.getLac() < 0) || (cellLocOther.getCid() < 0))) {
1436                         // We'll return the first good LTE info we get if there is no better answer
1437                         CellInfoLte cellInfoLte = (CellInfoLte)ci;
1438                         CellIdentityLte cellIdentityLte = cellInfoLte.getCellIdentity();
1439                         if ((cellIdentityLte.getTac() != Integer.MAX_VALUE)
1440                                 && (cellIdentityLte.getCi() != Integer.MAX_VALUE)) {
1441                             cellLocOther.setLacAndCid(cellIdentityLte.getTac(),
1442                                     cellIdentityLte.getCi());
1443                             cellLocOther.setPsc(0);
1444                             if (DBG) {
1445                                 log("getCellLocation(): possible LTE cellLocOther=" + cellLocOther);
1446                             }
1447                         }
1448                     }
1449                 }
1450                 if (DBG) {
1451                     log("getCellLocation(): X ret best answer cellLocOther=" + cellLocOther);
1452                 }
1453                 return cellLocOther;
1454             } else {
1455                 if (DBG) {
1456                     log("getCellLocation(): X empty mCellLoc and CellInfo mCellLoc=" + mCellLoc);
1457                 }
1458                 return mCellLoc;
1459             }
1460         }
1461     }
1462
1463     /**
1464      * nitzReceiveTime is time_t that the NITZ time was posted
1465      */
1466     private void setTimeFromNITZString (String nitz, long nitzReceiveTime) {
1467         // "yy/mm/dd,hh:mm:ss(+/-)tz"
1468         // tz is in number of quarter-hours
1469
1470         long start = SystemClock.elapsedRealtime();
1471         if (DBG) {log("NITZ: " + nitz + "," + nitzReceiveTime +
1472                         " start=" + start + " delay=" + (start - nitzReceiveTime));
1473         }
1474
1475         try {
1476             /* NITZ time (hour:min:sec) will be in UTC but it supplies the timezone
1477              * offset as well (which we won't worry about until later) */
1478             Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
1479
1480             c.clear();
1481             c.set(Calendar.DST_OFFSET, 0);
1482
1483             String[] nitzSubs = nitz.split("[/:,+-]");
1484
1485             int year = 2000 + Integer.parseInt(nitzSubs[0]);
1486             c.set(Calendar.YEAR, year);
1487
1488             // month is 0 based!
1489             int month = Integer.parseInt(nitzSubs[1]) - 1;
1490             c.set(Calendar.MONTH, month);
1491
1492             int date = Integer.parseInt(nitzSubs[2]);
1493             c.set(Calendar.DATE, date);
1494
1495             int hour = Integer.parseInt(nitzSubs[3]);
1496             c.set(Calendar.HOUR, hour);
1497
1498             int minute = Integer.parseInt(nitzSubs[4]);
1499             c.set(Calendar.MINUTE, minute);
1500
1501             int second = Integer.parseInt(nitzSubs[5]);
1502             c.set(Calendar.SECOND, second);
1503
1504             boolean sign = (nitz.indexOf('-') == -1);
1505
1506             int tzOffset = Integer.parseInt(nitzSubs[6]);
1507
1508             int dst = (nitzSubs.length >= 8 ) ? Integer.parseInt(nitzSubs[7])
1509                                               : 0;
1510
1511             // The zone offset received from NITZ is for current local time,
1512             // so DST correction is already applied.  Don't add it again.
1513             //
1514             // tzOffset += dst * 4;
1515             //
1516             // We could unapply it if we wanted the raw offset.
1517
1518             tzOffset = (sign ? 1 : -1) * tzOffset * 15 * 60 * 1000;
1519
1520             TimeZone    zone = null;
1521
1522             // As a special extension, the Android emulator appends the name of
1523             // the host computer's timezone to the nitz string. this is zoneinfo
1524             // timezone name of the form Area!Location or Area!Location!SubLocation
1525             // so we need to convert the ! into /
1526             if (nitzSubs.length >= 9) {
1527                 String  tzname = nitzSubs[8].replace('!','/');
1528                 zone = TimeZone.getTimeZone( tzname );
1529             }
1530
1531             String iso = SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY);
1532
1533             if (zone == null) {
1534
1535                 if (mGotCountryCode) {
1536                     if (iso != null && iso.length() > 0) {
1537                         zone = TimeUtils.getTimeZone(tzOffset, dst != 0,
1538                                 c.getTimeInMillis(),
1539                                 iso);
1540                     } else {
1541                         // We don't have a valid iso country code.  This is
1542                         // most likely because we're on a test network that's
1543                         // using a bogus MCC (eg, "001"), so get a TimeZone
1544                         // based only on the NITZ parameters.
1545                         zone = getNitzTimeZone(tzOffset, (dst != 0), c.getTimeInMillis());
1546                     }
1547                 }
1548             }
1549
1550             if ((zone == null) || (mZoneOffset != tzOffset) || (mZoneDst != (dst != 0))){
1551                 // We got the time before the country or the zone has changed
1552                 // so we don't know how to identify the DST rules yet.  Save
1553                 // the information and hope to fix it up later.
1554
1555                 mNeedFixZoneAfterNitz = true;
1556                 mZoneOffset  = tzOffset;
1557                 mZoneDst     = dst != 0;
1558                 mZoneTime    = c.getTimeInMillis();
1559             }
1560
1561             if (zone != null) {
1562                 if (getAutoTimeZone()) {
1563                     setAndBroadcastNetworkSetTimeZone(zone.getID());
1564                 }
1565                 saveNitzTimeZone(zone.getID());
1566             }
1567
1568             String ignore = SystemProperties.get("gsm.ignore-nitz");
1569             if (ignore != null && ignore.equals("yes")) {
1570                 log("NITZ: Not setting clock because gsm.ignore-nitz is set");
1571                 return;
1572             }
1573
1574             try {
1575                 mWakeLock.acquire();
1576
1577                 if (getAutoTime()) {
1578                     long millisSinceNitzReceived
1579                             = SystemClock.elapsedRealtime() - nitzReceiveTime;
1580
1581                     if (millisSinceNitzReceived < 0) {
1582                         // Sanity check: something is wrong
1583                         if (DBG) {
1584                             log("NITZ: not setting time, clock has rolled "
1585                                             + "backwards since NITZ time was received, "
1586                                             + nitz);
1587                         }
1588                         return;
1589                     }
1590
1591                     if (millisSinceNitzReceived > Integer.MAX_VALUE) {
1592                         // If the time is this far off, something is wrong > 24 days!
1593                         if (DBG) {
1594                             log("NITZ: not setting time, processing has taken "
1595                                         + (millisSinceNitzReceived / (1000 * 60 * 60 * 24))
1596                                         + " days");
1597                         }
1598                         return;
1599                     }
1600
1601                     // Note: with range checks above, cast to int is safe
1602                     c.add(Calendar.MILLISECOND, (int)millisSinceNitzReceived);
1603
1604                     if (DBG) {
1605                         log("NITZ: Setting time of day to " + c.getTime()
1606                             + " NITZ receive delay(ms): " + millisSinceNitzReceived
1607                             + " gained(ms): "
1608                             + (c.getTimeInMillis() - System.currentTimeMillis())
1609                             + " from " + nitz);
1610                     }
1611
1612                     setAndBroadcastNetworkSetTime(c.getTimeInMillis());
1613                     Rlog.i(LOG_TAG, "NITZ: after Setting time of day");
1614                 }
1615                 SystemProperties.set("gsm.nitz.time", String.valueOf(c.getTimeInMillis()));
1616                 saveNitzTime(c.getTimeInMillis());
1617                 if (VDBG) {
1618                     long end = SystemClock.elapsedRealtime();
1619                     log("NITZ: end=" + end + " dur=" + (end - start));
1620                 }
1621                 mNitzUpdatedTime = true;
1622             } finally {
1623                 mWakeLock.release();
1624             }
1625         } catch (RuntimeException ex) {
1626             loge("NITZ: Parsing NITZ time " + nitz + " ex=" + ex);
1627         }
1628     }
1629
1630     private boolean getAutoTime() {
1631         try {
1632             return Settings.Global.getInt(mPhone.getContext().getContentResolver(),
1633                     Settings.Global.AUTO_TIME) > 0;
1634         } catch (SettingNotFoundException snfe) {
1635             return true;
1636         }
1637     }
1638
1639     private boolean getAutoTimeZone() {
1640         try {
1641             return Settings.Global.getInt(mPhone.getContext().getContentResolver(),
1642                     Settings.Global.AUTO_TIME_ZONE) > 0;
1643         } catch (SettingNotFoundException snfe) {
1644             return true;
1645         }
1646     }
1647
1648     private void saveNitzTimeZone(String zoneId) {
1649         mSavedTimeZone = zoneId;
1650     }
1651
1652     private void saveNitzTime(long time) {
1653         mSavedTime = time;
1654         mSavedAtTime = SystemClock.elapsedRealtime();
1655     }
1656
1657     /**
1658      * Set the timezone and send out a sticky broadcast so the system can
1659      * determine if the timezone was set by the carrier.
1660      *
1661      * @param zoneId timezone set by carrier
1662      */
1663     private void setAndBroadcastNetworkSetTimeZone(String zoneId) {
1664         if (DBG) log("setAndBroadcastNetworkSetTimeZone: setTimeZone=" + zoneId);
1665         AlarmManager alarm =
1666             (AlarmManager) mPhone.getContext().getSystemService(Context.ALARM_SERVICE);
1667         alarm.setTimeZone(zoneId);
1668         Intent intent = new Intent(TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE);
1669         intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
1670         intent.putExtra("time-zone", zoneId);
1671         mPhone.getContext().sendStickyBroadcastAsUser(intent, UserHandle.ALL);
1672         if (DBG) {
1673             log("setAndBroadcastNetworkSetTimeZone: call alarm.setTimeZone and broadcast zoneId=" +
1674                 zoneId);
1675         }
1676     }
1677
1678     /**
1679      * Set the time and Send out a sticky broadcast so the system can determine
1680      * if the time was set by the carrier.
1681      *
1682      * @param time time set by network
1683      */
1684     private void setAndBroadcastNetworkSetTime(long time) {
1685         if (DBG) log("setAndBroadcastNetworkSetTime: time=" + time + "ms");
1686         SystemClock.setCurrentTimeMillis(time);
1687         Intent intent = new Intent(TelephonyIntents.ACTION_NETWORK_SET_TIME);
1688         intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
1689         intent.putExtra("time", time);
1690         mPhone.getContext().sendStickyBroadcastAsUser(intent, UserHandle.ALL);
1691     }
1692
1693     private void revertToNitzTime() {
1694         if (Settings.Global.getInt(mPhone.getContext().getContentResolver(),
1695                 Settings.Global.AUTO_TIME, 0) == 0) {
1696             return;
1697         }
1698         if (DBG) {
1699             log("Reverting to NITZ Time: mSavedTime=" + mSavedTime
1700                 + " mSavedAtTime=" + mSavedAtTime);
1701         }
1702         if (mSavedTime != 0 && mSavedAtTime != 0) {
1703             setAndBroadcastNetworkSetTime(mSavedTime
1704                     + (SystemClock.elapsedRealtime() - mSavedAtTime));
1705         }
1706     }
1707
1708     private void revertToNitzTimeZone() {
1709         if (Settings.Global.getInt(mPhone.getContext().getContentResolver(),
1710                 Settings.Global.AUTO_TIME_ZONE, 0) == 0) {
1711             return;
1712         }
1713         if (DBG) log("Reverting to NITZ TimeZone: tz='" + mSavedTimeZone);
1714         if (mSavedTimeZone != null) {
1715             setAndBroadcastNetworkSetTimeZone(mSavedTimeZone);
1716         }
1717     }
1718
1719     /**
1720      * Post a notification to NotificationManager for restricted state
1721      *
1722      * @param notifyType is one state of PS/CS_*_ENABLE/DISABLE
1723      */
1724     private void setNotification(int notifyType) {
1725
1726         if (DBG) log("setNotification: create notification " + notifyType);
1727         Context context = mPhone.getContext();
1728
1729         mNotification = new Notification();
1730         mNotification.when = System.currentTimeMillis();
1731         mNotification.flags = Notification.FLAG_AUTO_CANCEL;
1732         mNotification.icon = com.android.internal.R.drawable.stat_sys_warning;
1733         Intent intent = new Intent();
1734         mNotification.contentIntent = PendingIntent
1735         .getActivity(context, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT);
1736
1737         CharSequence details = "";
1738         CharSequence title = context.getText(com.android.internal.R.string.RestrictedChangedTitle);
1739         int notificationId = CS_NOTIFICATION;
1740
1741         switch (notifyType) {
1742         case PS_ENABLED:
1743             notificationId = PS_NOTIFICATION;
1744             details = context.getText(com.android.internal.R.string.RestrictedOnData);
1745             break;
1746         case PS_DISABLED:
1747             notificationId = PS_NOTIFICATION;
1748             break;
1749         case CS_ENABLED:
1750             details = context.getText(com.android.internal.R.string.RestrictedOnAllVoice);
1751             break;
1752         case CS_NORMAL_ENABLED:
1753             details = context.getText(com.android.internal.R.string.RestrictedOnNormal);
1754             break;
1755         case CS_EMERGENCY_ENABLED:
1756             details = context.getText(com.android.internal.R.string.RestrictedOnEmergency);
1757             break;
1758         case CS_DISABLED:
1759             // do nothing and cancel the notification later
1760             break;
1761         }
1762
1763         if (DBG) log("setNotification: put notification " + title + " / " +details);
1764         mNotification.tickerText = title;
1765         mNotification.setLatestEventInfo(context, title, details,
1766                 mNotification.contentIntent);
1767
1768         NotificationManager notificationManager = (NotificationManager)
1769             context.getSystemService(Context.NOTIFICATION_SERVICE);
1770
1771         if (notifyType == PS_DISABLED || notifyType == CS_DISABLED) {
1772             // cancel previous post notification
1773             notificationManager.cancel(notificationId);
1774         } else {
1775             // update restricted state notification
1776             notificationManager.notify(notificationId, mNotification);
1777         }
1778     }
1779
1780     @Override
1781     protected void onUpdateIccAvailability() {
1782         if (mUiccController == null ) {
1783             return;
1784         }
1785
1786         UiccCardApplication newUiccApplication =
1787                 mUiccController.getUiccCardApplication(UiccController.APP_FAM_3GPP);
1788
1789         if (mUiccApplcation != newUiccApplication) {
1790             if (mUiccApplcation != null) {
1791                 log("Removing stale icc objects.");
1792                 mUiccApplcation.unregisterForReady(this);
1793                 if (mIccRecords != null) {
1794                     mIccRecords.unregisterForRecordsLoaded(this);
1795                 }
1796                 mIccRecords = null;
1797                 mUiccApplcation = null;
1798             }
1799             if (newUiccApplication != null) {
1800                 log("New card found");
1801                 mUiccApplcation = newUiccApplication;
1802                 mIccRecords = mUiccApplcation.getIccRecords();
1803                 mUiccApplcation.registerForReady(this, EVENT_SIM_READY, null);
1804                 if (mIccRecords != null) {
1805                     mIccRecords.registerForRecordsLoaded(this, EVENT_SIM_RECORDS_LOADED, null);
1806                 }
1807             }
1808         }
1809     }
1810     @Override
1811     protected void log(String s) {
1812         Rlog.d(LOG_TAG, "[GsmSST] " + s);
1813     }
1814
1815     @Override
1816     protected void loge(String s) {
1817         Rlog.e(LOG_TAG, "[GsmSST] " + s);
1818     }
1819
1820     @Override
1821     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
1822         pw.println("GsmServiceStateTracker extends:");
1823         super.dump(fd, pw, args);
1824         pw.println(" mPhone=" + mPhone);
1825         pw.println(" mSS=" + mSS);
1826         pw.println(" mNewSS=" + mNewSS);
1827         pw.println(" mCellLoc=" + mCellLoc);
1828         pw.println(" mNewCellLoc=" + mNewCellLoc);
1829         pw.println(" mPreferredNetworkType=" + mPreferredNetworkType);
1830         pw.println(" mMaxDataCalls=" + mMaxDataCalls);
1831         pw.println(" mNewMaxDataCalls=" + mNewMaxDataCalls);
1832         pw.println(" mReasonDataDenied=" + mReasonDataDenied);
1833         pw.println(" mNewReasonDataDenied=" + mNewReasonDataDenied);
1834         pw.println(" mGsmRoaming=" + mGsmRoaming);
1835         pw.println(" mDataRoaming=" + mDataRoaming);
1836         pw.println(" mEmergencyOnly=" + mEmergencyOnly);
1837         pw.println(" mNeedFixZoneAfterNitz=" + mNeedFixZoneAfterNitz);
1838         pw.println(" mZoneOffset=" + mZoneOffset);
1839         pw.println(" mZoneDst=" + mZoneDst);
1840         pw.println(" mZoneTime=" + mZoneTime);
1841         pw.println(" mGotCountryCode=" + mGotCountryCode);
1842         pw.println(" mNitzUpdatedTime=" + mNitzUpdatedTime);
1843         pw.println(" mSavedTimeZone=" + mSavedTimeZone);
1844         pw.println(" mSavedTime=" + mSavedTime);
1845         pw.println(" mSavedAtTime=" + mSavedAtTime);
1846         pw.println(" mStartedGprsRegCheck=" + mStartedGprsRegCheck);
1847         pw.println(" mReportedGprsNoReg=" + mReportedGprsNoReg);
1848         pw.println(" mNotification=" + mNotification);
1849         pw.println(" mWakeLock=" + mWakeLock);
1850         pw.println(" mCurSpn=" + mCurSpn);
1851         pw.println(" mCurShowSpn=" + mCurShowSpn);
1852         pw.println(" mCurPlmn=" + mCurPlmn);
1853         pw.println(" mCurShowPlmn=" + mCurShowPlmn);
1854     }
1855 }