1 /* 2 * Copyright (C) 2012 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.cdma; 18 19 import com.android.internal.telephony.CommandException; 20 import com.android.internal.telephony.CommandsInterface; 21 import com.android.internal.telephony.DataConnectionTracker; 22 import com.android.internal.telephony.EventLogTags; 23 import com.android.internal.telephony.IccCardConstants; 24 import com.android.internal.telephony.MccTable; 25 import com.android.internal.telephony.PhoneConstants; 26 import com.android.internal.telephony.RILConstants; 27 import com.android.internal.telephony.Phone; 28 import com.android.internal.telephony.ServiceStateTracker; 29 import com.android.internal.telephony.TelephonyIntents; 30 import com.android.internal.telephony.TelephonyProperties; 31 import com.android.internal.telephony.UiccCard; 32 import com.android.internal.telephony.UiccCardApplication; 33 import com.android.internal.telephony.CommandsInterface.RadioState; 34 import com.android.internal.telephony.uicc.UiccController; 35 36 import android.app.AlarmManager; 37 import android.content.ContentResolver; 38 import android.content.Context; 39 import android.content.Intent; 40 import android.database.ContentObserver; 41 import android.os.AsyncResult; 42 import android.os.Handler; 43 import android.os.Message; 44 import android.os.PowerManager; 45 import android.os.Registrant; 46 import android.os.RegistrantList; 47 import android.os.SystemClock; 48 import android.os.SystemProperties; 49 import android.os.UserHandle; 50 import android.provider.Settings; 51 import android.provider.Settings.Secure; 52 import android.provider.Settings.SettingNotFoundException; 53 import android.telephony.CellInfo; 54 import android.telephony.CellInfoCdma; 55 import android.telephony.ServiceState; 56 import android.telephony.SignalStrength; 57 import android.telephony.cdma.CdmaCellLocation; 58 import android.text.TextUtils; 59 import android.util.EventLog; 60 import android.util.Log; 61 import android.util.TimeUtils; 62 63 import java.io.FileDescriptor; 64 import java.io.PrintWriter; 65 import java.util.Arrays; 66 import java.util.Calendar; 67 import java.util.Date; 68 import java.util.List; 69 import java.util.TimeZone; 70 71 /** 72 * {@hide} 73 */ 74 public class CdmaServiceStateTracker extends ServiceStateTracker { 75 static final String LOG_TAG = "CDMA"; 76 77 CDMAPhone phone; 78 CdmaCellLocation cellLoc; 79 CdmaCellLocation newCellLoc; 80 81 // Min values used to by getOtasp() 82 private static final String UNACTIVATED_MIN2_VALUE = "000000"; 83 private static final String UNACTIVATED_MIN_VALUE = "1111110111"; 84 85 // Current Otasp value 86 int mCurrentOtaspMode = OTASP_UNINITIALIZED; 87 88 /** if time between NITZ updates is less than mNitzUpdateSpacing the update may be ignored. */ 89 private static final int NITZ_UPDATE_SPACING_DEFAULT = 1000 * 60 * 10; 90 private int mNitzUpdateSpacing = SystemProperties.getInt("ro.nitz_update_spacing", 91 NITZ_UPDATE_SPACING_DEFAULT); 92 93 /** If mNitzUpdateSpacing hasn't been exceeded but update is > mNitzUpdate do the update */ 94 private static final int NITZ_UPDATE_DIFF_DEFAULT = 2000; 95 private int mNitzUpdateDiff = SystemProperties.getInt("ro.nitz_update_diff", 96 NITZ_UPDATE_DIFF_DEFAULT); 97 98 private boolean mCdmaRoaming = false; 99 private int mRoamingIndicator; 100 private boolean mIsInPrl; 101 private int mDefaultRoamingIndicator; 102 103 /** 104 * Initially assume no data connection. 105 */ 106 protected int mDataConnectionState = ServiceState.STATE_OUT_OF_SERVICE; 107 protected int mNewDataConnectionState = ServiceState.STATE_OUT_OF_SERVICE; 108 protected int mRegistrationState = -1; 109 protected RegistrantList cdmaForSubscriptionInfoReadyRegistrants = new RegistrantList(); 110 111 /** 112 * Sometimes we get the NITZ time before we know what country we 113 * are in. Keep the time zone information from the NITZ string so 114 * we can fix the time zone once know the country. 115 */ 116 protected boolean mNeedFixZone = false; 117 private int mZoneOffset; 118 private boolean mZoneDst; 119 private long mZoneTime; 120 protected boolean mGotCountryCode = false; 121 String mSavedTimeZone; 122 long mSavedTime; 123 long mSavedAtTime; 124 125 /** Wake lock used while setting time of day. */ 126 private PowerManager.WakeLock mWakeLock; 127 private static final String WAKELOCK_TAG = "ServiceStateTracker"; 128 129 /** Contains the name of the registered network in CDMA (either ONS or ERI text). */ 130 protected String mCurPlmn = null; 131 132 protected String mMdn; 133 protected int mHomeSystemId[] = null; 134 protected int mHomeNetworkId[] = null; 135 protected String mMin; 136 protected String mPrlVersion; 137 protected boolean mIsMinInfoReady = false; 138 139 private boolean isEriTextLoaded = false; 140 protected boolean isSubscriptionFromRuim = false; 141 private CdmaSubscriptionSourceManager mCdmaSSM; 142 143 /* Used only for debugging purposes. */ 144 private String mRegistrationDeniedReason; 145 146 private ContentResolver cr; 147 private String currentCarrier = null; 148 149 private ContentObserver mAutoTimeObserver = new ContentObserver(new Handler()) { 150 @Override 151 public void onChange(boolean selfChange) { 152 if (DBG) log("Auto time state changed"); 153 revertToNitzTime(); 154 } 155 }; 156 157 private ContentObserver mAutoTimeZoneObserver = new ContentObserver(new Handler()) { 158 @Override 159 public void onChange(boolean selfChange) { 160 if (DBG) log("Auto time zone state changed"); 161 revertToNitzTimeZone(); 162 } 163 }; 164 165 public CdmaServiceStateTracker(CDMAPhone phone) { 166 this(phone, new CellInfoCdma()); 167 } 168 169 protected CdmaServiceStateTracker(CDMAPhone phone, CellInfo cellInfo) { 170 super(phone, phone.mCM, cellInfo); 171 172 this.phone = phone; 173 cr = phone.getContext().getContentResolver(); 174 cellLoc = new CdmaCellLocation(); 175 newCellLoc = new CdmaCellLocation(); 176 177 mCdmaSSM = CdmaSubscriptionSourceManager.getInstance(phone.getContext(), cm, this, 178 EVENT_CDMA_SUBSCRIPTION_SOURCE_CHANGED, null); 179 isSubscriptionFromRuim = (mCdmaSSM.getCdmaSubscriptionSource() == 180 CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM); 181 182 PowerManager powerManager = 183 (PowerManager)phone.getContext().getSystemService(Context.POWER_SERVICE); 184 mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG); 185 186 cm.registerForRadioStateChanged(this, EVENT_RADIO_STATE_CHANGED, null); 187 188 cm.registerForVoiceNetworkStateChanged(this, EVENT_NETWORK_STATE_CHANGED_CDMA, null); 189 cm.setOnNITZTime(this, EVENT_NITZ_TIME, null); 190 191 cm.registerForCdmaPrlChanged(this, EVENT_CDMA_PRL_VERSION_CHANGED, null); 192 phone.registerForEriFileLoaded(this, EVENT_ERI_FILE_LOADED, null); 193 cm.registerForCdmaOtaProvision(this,EVENT_OTA_PROVISION_STATUS_CHANGE, null); 194 195 // System setting property AIRPLANE_MODE_ON is set in Settings. 196 int airplaneMode = Settings.System.getInt(cr, Settings.System.AIRPLANE_MODE_ON, 0); 197 mDesiredPowerState = ! (airplaneMode > 0); 198 199 cr.registerContentObserver( 200 Settings.System.getUriFor(Settings.System.AUTO_TIME), true, 201 mAutoTimeObserver); 202 cr.registerContentObserver( 203 Settings.System.getUriFor(Settings.System.AUTO_TIME_ZONE), true, 204 mAutoTimeZoneObserver); 205 setSignalStrengthDefaultValues(); 206 } 207 208 @Override 209 public void dispose() { 210 checkCorrectThread(); 211 // Unregister for all events. 212 cm.unregisterForRadioStateChanged(this); 213 cm.unregisterForVoiceNetworkStateChanged(this); 214 cm.unregisterForCdmaOtaProvision(this); 215 phone.unregisterForEriFileLoaded(this); 216 if (mUiccApplcation != null) {mUiccApplcation.unregisterForReady(this);} 217 if (mIccRecords != null) {mIccRecords.unregisterForRecordsLoaded(this);} 218 cm.unSetOnNITZTime(this); 219 cr.unregisterContentObserver(mAutoTimeObserver); 220 cr.unregisterContentObserver(mAutoTimeZoneObserver); 221 mCdmaSSM.dispose(this); 222 cm.unregisterForCdmaPrlChanged(this); 223 super.dispose(); 224 } 225 226 @Override 227 protected void finalize() { 228 if (DBG) log("CdmaServiceStateTracker finalized"); 229 } 230 231 /** 232 * Registration point for subscription info ready 233 * @param h handler to notify 234 * @param what what code of message when delivered 235 * @param obj placed in Message.obj 236 */ 237 public void registerForSubscriptionInfoReady(Handler h, int what, Object obj) { 238 Registrant r = new Registrant(h, what, obj); 239 cdmaForSubscriptionInfoReadyRegistrants.add(r); 240 241 if (isMinInfoReady()) { 242 r.notifyRegistrant(); 243 } 244 } 245 246 public void unregisterForSubscriptionInfoReady(Handler h) { 247 cdmaForSubscriptionInfoReadyRegistrants.remove(h); 248 } 249 250 /** 251 * Save current source of cdma subscription 252 * @param source - 1 for NV, 0 for RUIM 253 */ 254 private void saveCdmaSubscriptionSource(int source) { 255 log("Storing cdma subscription source: " + source); 256 Settings.Global.putInt(phone.getContext().getContentResolver(), 257 Settings.Global.CDMA_SUBSCRIPTION_MODE, 258 source ); 259 } 260 261 private void getSubscriptionInfoAndStartPollingThreads() { 262 cm.getCDMASubscription(obtainMessage(EVENT_POLL_STATE_CDMA_SUBSCRIPTION)); 263 264 // Get Registration Information 265 pollState(); 266 } 267 268 @Override 269 public void handleMessage (Message msg) { 270 AsyncResult ar; 271 int[] ints; 272 String[] strings; 273 274 if (!phone.mIsTheCurrentActivePhone) { 275 loge("Received message " + msg + "[" + msg.what + "]" + 276 " while being destroyed. Ignoring."); 277 return; 278 } 279 280 switch (msg.what) { 281 case EVENT_CDMA_SUBSCRIPTION_SOURCE_CHANGED: 282 handleCdmaSubscriptionSource(mCdmaSSM.getCdmaSubscriptionSource()); 283 break; 284 285 case EVENT_RUIM_READY: 286 // TODO: Consider calling setCurrentPreferredNetworkType as we do in GsmSST. 287 // cm.setCurrentPreferredNetworkType(); 288 289 if (phone.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE) { 290 // Subscription will be read from SIM I/O 291 if (DBG) log("Receive EVENT_RUIM_READY"); 292 pollState(); 293 } else { 294 if (DBG) log("Receive EVENT_RUIM_READY and Send Request getCDMASubscription."); 295 getSubscriptionInfoAndStartPollingThreads(); 296 } 297 phone.prepareEri(); 298 break; 299 300 case EVENT_NV_READY: 301 // For Non-RUIM phones, the subscription information is stored in 302 // Non Volatile. Here when Non-Volatile is ready, we can poll the CDMA 303 // subscription info. 304 getSubscriptionInfoAndStartPollingThreads(); 305 break; 306 307 case EVENT_RADIO_STATE_CHANGED: 308 if(cm.getRadioState() == RadioState.RADIO_ON) { 309 handleCdmaSubscriptionSource(mCdmaSSM.getCdmaSubscriptionSource()); 310 311 // Signal strength polling stops when radio is off. 312 queueNextSignalStrengthPoll(); 313 } 314 // This will do nothing in the 'radio not available' case. 315 setPowerStateToDesired(); 316 pollState(); 317 break; 318 319 case EVENT_NETWORK_STATE_CHANGED_CDMA: 320 pollState(); 321 break; 322 323 case EVENT_GET_SIGNAL_STRENGTH: 324 // This callback is called when signal strength is polled 325 // all by itself. 326 327 if (!(cm.getRadioState().isOn())) { 328 // Polling will continue when radio turns back on. 329 return; 330 } 331 ar = (AsyncResult) msg.obj; 332 onSignalStrengthResult(ar, false); 333 queueNextSignalStrengthPoll(); 334 335 break; 336 337 case EVENT_GET_LOC_DONE_CDMA: 338 ar = (AsyncResult) msg.obj; 339 340 if (ar.exception == null) { 341 String states[] = (String[])ar.result; 342 int baseStationId = -1; 343 int baseStationLatitude = CdmaCellLocation.INVALID_LAT_LONG; 344 int baseStationLongitude = CdmaCellLocation.INVALID_LAT_LONG; 345 int systemId = -1; 346 int networkId = -1; 347 348 if (states.length > 9) { 349 try { 350 if (states[4] != null) { 351 baseStationId = Integer.parseInt(states[4]); 352 } 353 if (states[5] != null) { 354 baseStationLatitude = Integer.parseInt(states[5]); 355 } 356 if (states[6] != null) { 357 baseStationLongitude = Integer.parseInt(states[6]); 358 } 359 // Some carriers only return lat-lngs of 0,0 360 if (baseStationLatitude == 0 && baseStationLongitude == 0) { 361 baseStationLatitude = CdmaCellLocation.INVALID_LAT_LONG; 362 baseStationLongitude = CdmaCellLocation.INVALID_LAT_LONG; 363 } 364 if (states[8] != null) { 365 systemId = Integer.parseInt(states[8]); 366 } 367 if (states[9] != null) { 368 networkId = Integer.parseInt(states[9]); 369 } 370 } catch (NumberFormatException ex) { 371 loge("error parsing cell location data: " + ex); 372 } 373 } 374 375 cellLoc.setCellLocationData(baseStationId, baseStationLatitude, 376 baseStationLongitude, systemId, networkId); 377 phone.notifyLocationChanged(); 378 } 379 380 // Release any temporary cell lock, which could have been 381 // acquired to allow a single-shot location update. 382 disableSingleLocationUpdate(); 383 break; 384 385 case EVENT_POLL_STATE_REGISTRATION_CDMA: 386 case EVENT_POLL_STATE_OPERATOR_CDMA: 387 ar = (AsyncResult) msg.obj; 388 handlePollStateResult(msg.what, ar); 389 break; 390 391 case EVENT_POLL_STATE_CDMA_SUBSCRIPTION: // Handle RIL_CDMA_SUBSCRIPTION 392 ar = (AsyncResult) msg.obj; 393 394 if (ar.exception == null) { 395 String cdmaSubscription[] = (String[])ar.result; 396 if (cdmaSubscription != null && cdmaSubscription.length >= 5) { 397 mMdn = cdmaSubscription[0]; 398 parseSidNid(cdmaSubscription[1], cdmaSubscription[2]); 399 400 mMin = cdmaSubscription[3]; 401 mPrlVersion = cdmaSubscription[4]; 402 if (DBG) log("GET_CDMA_SUBSCRIPTION: MDN=" + mMdn); 403 404 mIsMinInfoReady = true; 405 406 updateOtaspState(); 407 if (!isSubscriptionFromRuim && mIccRecords != null) { 408 if (DBG) { 409 log("GET_CDMA_SUBSCRIPTION set imsi in mIccRecords"); 410 } 411 mIccRecords.setImsi(getImsi()); 412 } else { 413 if (DBG) { 414 log("GET_CDMA_SUBSCRIPTION either mIccRecords is null or NV type device" + 415 " - not setting Imsi in mIccRecords"); 416 } 417 } 418 } else { 419 if (DBG) { 420 log("GET_CDMA_SUBSCRIPTION: error parsing cdmaSubscription params num=" 421 + cdmaSubscription.length); 422 } 423 } 424 } 425 break; 426 427 case EVENT_POLL_SIGNAL_STRENGTH: 428 // Just poll signal strength...not part of pollState() 429 430 cm.getSignalStrength(obtainMessage(EVENT_GET_SIGNAL_STRENGTH)); 431 break; 432 433 case EVENT_NITZ_TIME: 434 ar = (AsyncResult) msg.obj; 435 436 String nitzString = (String)((Object[])ar.result)[0]; 437 long nitzReceiveTime = ((Long)((Object[])ar.result)[1]).longValue(); 438 439 setTimeFromNITZString(nitzString, nitzReceiveTime); 440 break; 441 442 case EVENT_SIGNAL_STRENGTH_UPDATE: 443 // This is a notification from CommandsInterface.setOnSignalStrengthUpdate. 444 445 ar = (AsyncResult) msg.obj; 446 447 // The radio is telling us about signal strength changes, 448 // so we don't have to ask it. 449 dontPollSignalStrength = true; 450 451 onSignalStrengthResult(ar, false); 452 break; 453 454 case EVENT_RUIM_RECORDS_LOADED: 455 updateSpnDisplay(); 456 break; 457 458 case EVENT_LOCATION_UPDATES_ENABLED: 459 ar = (AsyncResult) msg.obj; 460 461 if (ar.exception == null) { 462 cm.getVoiceRegistrationState(obtainMessage(EVENT_GET_LOC_DONE_CDMA, null)); 463 } 464 break; 465 466 case EVENT_ERI_FILE_LOADED: 467 // Repoll the state once the ERI file has been loaded. 468 if (DBG) log("[CdmaServiceStateTracker] ERI file has been loaded, repolling."); 469 pollState(); 470 break; 471 472 case EVENT_OTA_PROVISION_STATUS_CHANGE: 473 ar = (AsyncResult)msg.obj; 474 if (ar.exception == null) { 475 ints = (int[]) ar.result; 476 int otaStatus = ints[0]; 477 if (otaStatus == Phone.CDMA_OTA_PROVISION_STATUS_COMMITTED 478 || otaStatus == Phone.CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED) { 479 if (DBG) log("EVENT_OTA_PROVISION_STATUS_CHANGE: Complete, Reload MDN"); 480 cm.getCDMASubscription( obtainMessage(EVENT_POLL_STATE_CDMA_SUBSCRIPTION)); 481 } 482 } 483 break; 484 485 case EVENT_CDMA_PRL_VERSION_CHANGED: 486 ar = (AsyncResult)msg.obj; 487 if (ar.exception == null) { 488 ints = (int[]) ar.result; 489 mPrlVersion = Integer.toString(ints[0]); 490 } 491 break; 492 493 default: 494 super.handleMessage(msg); 495 break; 496 } 497 } 498 499 //***** Private Instance Methods 500 501 private void handleCdmaSubscriptionSource(int newSubscriptionSource) { 502 log("Subscription Source : " + newSubscriptionSource); 503 isSubscriptionFromRuim = 504 (newSubscriptionSource == CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM); 505 saveCdmaSubscriptionSource(newSubscriptionSource); 506 if (!isSubscriptionFromRuim) { 507 // NV is ready when subscription source is NV 508 sendMessage(obtainMessage(EVENT_NV_READY)); 509 } 510 } 511 512 @Override 513 protected void setPowerStateToDesired() { 514 // If we want it on and it's off, turn it on 515 if (mDesiredPowerState 516 && cm.getRadioState() == CommandsInterface.RadioState.RADIO_OFF) { 517 cm.setRadioPower(true, null); 518 } else if (!mDesiredPowerState && cm.getRadioState().isOn()) { 519 DataConnectionTracker dcTracker = phone.mDataConnectionTracker; 520 521 // If it's on and available and we want it off gracefully 522 powerOffRadioSafely(dcTracker); 523 } // Otherwise, we're in the desired state 524 } 525 526 @Override 527 protected void updateSpnDisplay() { 528 // mOperatorAlphaLong contains the ERI text 529 String plmn = ss.getOperatorAlphaLong(); 530 if (!TextUtils.equals(plmn, mCurPlmn)) { 531 // Allow A blank plmn, "" to set showPlmn to true. Previously, we 532 // would set showPlmn to true only if plmn was not empty, i.e. was not 533 // null and not blank. But this would cause us to incorrectly display 534 // "No Service". Now showPlmn is set to true for any non null string. 535 boolean showPlmn = plmn != null; 536 if (DBG) { 537 log(String.format("updateSpnDisplay: changed sending intent" + 538 " showPlmn='%b' plmn='%s'", showPlmn, plmn)); 539 } 540 Intent intent = new Intent(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION); 541 intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING); 542 intent.putExtra(TelephonyIntents.EXTRA_SHOW_SPN, false); 543 intent.putExtra(TelephonyIntents.EXTRA_SPN, ""); 544 intent.putExtra(TelephonyIntents.EXTRA_SHOW_PLMN, showPlmn); 545 intent.putExtra(TelephonyIntents.EXTRA_PLMN, plmn); 546 phone.getContext().sendStickyBroadcastAsUser(intent, UserHandle.ALL); 547 } 548 549 mCurPlmn = plmn; 550 } 551 552 @Override 553 protected Phone getPhone() { 554 return phone; 555 } 556 557 /** 558 * Determine data network type based on radio technology. 559 */ 560 protected void setCdmaTechnology(int radioTech){ 561 mNewDataConnectionState = radioTechnologyToDataServiceState(radioTech); 562 newSS.setRadioTechnology(radioTech); 563 mNewRilRadioTechnology = radioTech; 564 } 565 566 /** 567 * Hanlde the PollStateResult message 568 */ 569 protected void handlePollStateResultMessage(int what, AsyncResult ar){ 570 int ints[]; 571 String states[]; 572 switch (what) { 573 case EVENT_POLL_STATE_REGISTRATION_CDMA: // Handle RIL_REQUEST_REGISTRATION_STATE. 574 states = (String[])ar.result; 575 576 int registrationState = 4; //[0] registrationState 577 int radioTechnology = -1; //[3] radioTechnology 578 int baseStationId = -1; //[4] baseStationId 579 //[5] baseStationLatitude 580 int baseStationLatitude = CdmaCellLocation.INVALID_LAT_LONG; 581 //[6] baseStationLongitude 582 int baseStationLongitude = CdmaCellLocation.INVALID_LAT_LONG; 583 int cssIndicator = 0; //[7] init with 0, because it is treated as a boolean 584 int systemId = 0; //[8] systemId 585 int networkId = 0; //[9] networkId 586 int roamingIndicator = -1; //[10] Roaming indicator 587 int systemIsInPrl = 0; //[11] Indicates if current system is in PRL 588 int defaultRoamingIndicator = 0; //[12] Is default roaming indicator from PRL 589 int reasonForDenial = 0; //[13] Denial reason if registrationState = 3 590 591 if (states.length >= 14) { 592 try { 593 if (states[0] != null) { 594 registrationState = Integer.parseInt(states[0]); 595 } 596 if (states[3] != null) { 597 radioTechnology = Integer.parseInt(states[3]); 598 } 599 if (states[4] != null) { 600 baseStationId = Integer.parseInt(states[4]); 601 } 602 if (states[5] != null) { 603 baseStationLatitude = Integer.parseInt(states[5]); 604 } 605 if (states[6] != null) { 606 baseStationLongitude = Integer.parseInt(states[6]); 607 } 608 // Some carriers only return lat-lngs of 0,0 609 if (baseStationLatitude == 0 && baseStationLongitude == 0) { 610 baseStationLatitude = CdmaCellLocation.INVALID_LAT_LONG; 611 baseStationLongitude = CdmaCellLocation.INVALID_LAT_LONG; 612 } 613 if (states[7] != null) { 614 cssIndicator = Integer.parseInt(states[7]); 615 } 616 if (states[8] != null) { 617 systemId = Integer.parseInt(states[8]); 618 } 619 if (states[9] != null) { 620 networkId = Integer.parseInt(states[9]); 621 } 622 if (states[10] != null) { 623 roamingIndicator = Integer.parseInt(states[10]); 624 } 625 if (states[11] != null) { 626 systemIsInPrl = Integer.parseInt(states[11]); 627 } 628 if (states[12] != null) { 629 defaultRoamingIndicator = Integer.parseInt(states[12]); 630 } 631 if (states[13] != null) { 632 reasonForDenial = Integer.parseInt(states[13]); 633 } 634 } catch (NumberFormatException ex) { 635 loge("EVENT_POLL_STATE_REGISTRATION_CDMA: error parsing: " + ex); 636 } 637 } else { 638 throw new RuntimeException("Warning! Wrong number of parameters returned from " 639 + "RIL_REQUEST_REGISTRATION_STATE: expected 14 or more " 640 + "strings and got " + states.length + " strings"); 641 } 642 643 mRegistrationState = registrationState; 644 // When registration state is roaming and TSB58 645 // roaming indicator is not in the carrier-specified 646 // list of ERIs for home system, mCdmaRoaming is true. 647 mCdmaRoaming = 648 regCodeIsRoaming(registrationState) && !isRoamIndForHomeSystem(states[10]); 649 newSS.setState (regCodeToServiceState(registrationState)); 650 651 setCdmaTechnology(radioTechnology); 652 653 newSS.setCssIndicator(cssIndicator); 654 newSS.setSystemAndNetworkId(systemId, networkId); 655 mRoamingIndicator = roamingIndicator; 656 mIsInPrl = (systemIsInPrl == 0) ? false : true; 657 mDefaultRoamingIndicator = defaultRoamingIndicator; 658 659 660 // Values are -1 if not available. 661 newCellLoc.setCellLocationData(baseStationId, baseStationLatitude, 662 baseStationLongitude, systemId, networkId); 663 664 if (reasonForDenial == 0) { 665 mRegistrationDeniedReason = ServiceStateTracker.REGISTRATION_DENIED_GEN; 666 } else if (reasonForDenial == 1) { 667 mRegistrationDeniedReason = ServiceStateTracker.REGISTRATION_DENIED_AUTH; 668 } else { 669 mRegistrationDeniedReason = ""; 670 } 671 672 if (mRegistrationState == 3) { 673 if (DBG) log("Registration denied, " + mRegistrationDeniedReason); 674 } 675 break; 676 677 case EVENT_POLL_STATE_OPERATOR_CDMA: // Handle RIL_REQUEST_OPERATOR 678 String opNames[] = (String[])ar.result; 679 680 if (opNames != null && opNames.length >= 3) { 681 // If the NUMERIC field isn't valid use PROPERTY_CDMA_HOME_OPERATOR_NUMERIC 682 if ((opNames[2] == null) || (opNames[2].length() < 5) 683 || ("00000".equals(opNames[2]))) { 684 opNames[2] = SystemProperties.get( 685 CDMAPhone.PROPERTY_CDMA_HOME_OPERATOR_NUMERIC, "00000"); 686 if (DBG) { 687 log("RIL_REQUEST_OPERATOR.response[2], the numeric, " + 688 " is bad. Using SystemProperties '" + 689 CDMAPhone.PROPERTY_CDMA_HOME_OPERATOR_NUMERIC + 690 "'= " + opNames[2]); 691 } 692 } 693 694 if (!isSubscriptionFromRuim) { 695 // In CDMA in case on NV, the ss.mOperatorAlphaLong is set later with the 696 // ERI text, so here it is ignored what is coming from the modem. 697 newSS.setOperatorName(null, opNames[1], opNames[2]); 698 } else { 699 newSS.setOperatorName(opNames[0], opNames[1], opNames[2]); 700 } 701 } else { 702 if (DBG) log("EVENT_POLL_STATE_OPERATOR_CDMA: error parsing opNames"); 703 } 704 break; 705 default: 706 loge("handlePollStateResultMessage: RIL response handle in wrong phone!" 707 + " Expected CDMA RIL request and get GSM RIL request."); 708 break; 709 } 710 } 711 712 /** 713 * Handle the result of one of the pollState() - related requests 714 */ 715 @Override 716 protected void handlePollStateResult(int what, AsyncResult ar) { 717 // Ignore stale requests from last poll. 718 if (ar.userObj != pollingContext) return; 719 720 if (ar.exception != null) { 721 CommandException.Error err=null; 722 723 if (ar.exception instanceof CommandException) { 724 err = ((CommandException)(ar.exception)).getCommandError(); 725 } 726 727 if (err == CommandException.Error.RADIO_NOT_AVAILABLE) { 728 // Radio has crashed or turned off. 729 cancelPollState(); 730 return; 731 } 732 733 if (!cm.getRadioState().isOn()) { 734 // Radio has crashed or turned off. 735 cancelPollState(); 736 return; 737 } 738 739 if (err != CommandException.Error.OP_NOT_ALLOWED_BEFORE_REG_NW) { 740 loge("handlePollStateResult: RIL returned an error where it must succeed" 741 + ar.exception); 742 } 743 } else try { 744 handlePollStateResultMessage(what, ar); 745 } catch (RuntimeException ex) { 746 loge("handlePollStateResult: Exception while polling service state. " 747 + "Probably malformed RIL response." + ex); 748 } 749 750 pollingContext[0]--; 751 752 if (pollingContext[0] == 0) { 753 boolean namMatch = false; 754 if (!isSidsAllZeros() && isHomeSid(newSS.getSystemId())) { 755 namMatch = true; 756 } 757 758 // Setting SS Roaming (general) 759 if (isSubscriptionFromRuim) { 760 newSS.setRoaming(isRoamingBetweenOperators(mCdmaRoaming, newSS)); 761 } else { 762 newSS.setRoaming(mCdmaRoaming); 763 } 764 765 // Setting SS CdmaRoamingIndicator and CdmaDefaultRoamingIndicator 766 newSS.setCdmaDefaultRoamingIndicator(mDefaultRoamingIndicator); 767 newSS.setCdmaRoamingIndicator(mRoamingIndicator); 768 boolean isPrlLoaded = true; 769 if (TextUtils.isEmpty(mPrlVersion)) { 770 isPrlLoaded = false; 771 } 772 if (!isPrlLoaded) { 773 newSS.setCdmaRoamingIndicator(EriInfo.ROAMING_INDICATOR_OFF); 774 } else if (!isSidsAllZeros()) { 775 if (!namMatch && !mIsInPrl) { 776 // Use default 777 newSS.setCdmaRoamingIndicator(mDefaultRoamingIndicator); 778 } else if (namMatch && !mIsInPrl) { 779 newSS.setCdmaRoamingIndicator(EriInfo.ROAMING_INDICATOR_FLASH); 780 } else if (!namMatch && mIsInPrl) { 781 // Use the one from PRL/ERI 782 newSS.setCdmaRoamingIndicator(mRoamingIndicator); 783 } else { 784 // It means namMatch && mIsInPrl 785 if ((mRoamingIndicator <= 2)) { 786 newSS.setCdmaRoamingIndicator(EriInfo.ROAMING_INDICATOR_OFF); 787 } else { 788 // Use the one from PRL/ERI 789 newSS.setCdmaRoamingIndicator(mRoamingIndicator); 790 } 791 } 792 } 793 794 int roamingIndicator = newSS.getCdmaRoamingIndicator(); 795 newSS.setCdmaEriIconIndex(phone.mEriManager.getCdmaEriIconIndex(roamingIndicator, 796 mDefaultRoamingIndicator)); 797 newSS.setCdmaEriIconMode(phone.mEriManager.getCdmaEriIconMode(roamingIndicator, 798 mDefaultRoamingIndicator)); 799 800 // NOTE: Some operator may require overriding mCdmaRoaming 801 // (set by the modem), depending on the mRoamingIndicator. 802 803 if (DBG) { 804 log("Set CDMA Roaming Indicator to: " + newSS.getCdmaRoamingIndicator() 805 + ". mCdmaRoaming = " + mCdmaRoaming + ", isPrlLoaded = " + isPrlLoaded 806 + ". namMatch = " + namMatch + " , mIsInPrl = " + mIsInPrl 807 + ", mRoamingIndicator = " + mRoamingIndicator 808 + ", mDefaultRoamingIndicator= " + mDefaultRoamingIndicator); 809 } 810 pollStateDone(); 811 } 812 813 } 814 815 protected void setSignalStrengthDefaultValues() { 816 mSignalStrength = new SignalStrength( false); 817 } 818 819 /** 820 * A complete "service state" from our perspective is 821 * composed of a handful of separate requests to the radio. 822 * 823 * We make all of these requests at once, but then abandon them 824 * and start over again if the radio notifies us that some 825 * event has changed 826 */ 827 protected void 828 pollState() { 829 pollingContext = new int[1]; 830 pollingContext[0] = 0; 831 832 switch (cm.getRadioState()) { 833 case RADIO_UNAVAILABLE: 834 newSS.setStateOutOfService(); 835 newCellLoc.setStateInvalid(); 836 setSignalStrengthDefaultValues(); 837 mGotCountryCode = false; 838 839 pollStateDone(); 840 break; 841 842 case RADIO_OFF: 843 newSS.setStateOff(); 844 newCellLoc.setStateInvalid(); 845 setSignalStrengthDefaultValues(); 846 mGotCountryCode = false; 847 848 pollStateDone(); 849 break; 850 851 default: 852 // Issue all poll-related commands at once, then count 853 // down the responses which are allowed to arrive 854 // out-of-order. 855 856 pollingContext[0]++; 857 // RIL_REQUEST_OPERATOR is necessary for CDMA 858 cm.getOperator( 859 obtainMessage(EVENT_POLL_STATE_OPERATOR_CDMA, pollingContext)); 860 861 pollingContext[0]++; 862 // RIL_REQUEST_VOICE_REGISTRATION_STATE is necessary for CDMA 863 cm.getVoiceRegistrationState( 864 obtainMessage(EVENT_POLL_STATE_REGISTRATION_CDMA, pollingContext)); 865 866 break; 867 } 868 } 869 870 protected void fixTimeZone(String isoCountryCode) { 871 TimeZone zone = null; 872 // If the offset is (0, false) and the time zone property 873 // is set, use the time zone property rather than GMT. 874 String zoneName = SystemProperties.get(TIMEZONE_PROPERTY); 875 if (DBG) { 876 log("fixTimeZone zoneName='" + zoneName + 877 "' mZoneOffset=" + mZoneOffset + " mZoneDst=" + mZoneDst + 878 " iso-cc='" + isoCountryCode + 879 "' iso-cc-idx=" + Arrays.binarySearch(GMT_COUNTRY_CODES, isoCountryCode)); 880 } 881 if ((mZoneOffset == 0) && (mZoneDst == false) && (zoneName != null) 882 && (zoneName.length() > 0) 883 && (Arrays.binarySearch(GMT_COUNTRY_CODES, isoCountryCode) < 0)) { 884 // For NITZ string without time zone, 885 // need adjust time to reflect default time zone setting 886 zone = TimeZone.getDefault(); 887 if (mNeedFixZone) { 888 long ctm = System.currentTimeMillis(); 889 long tzOffset = zone.getOffset(ctm); 890 if (DBG) { 891 log("fixTimeZone: tzOffset=" + tzOffset + 892 " ltod=" + TimeUtils.logTimeOfDay(ctm)); 893 } 894 if (getAutoTime()) { 895 long adj = ctm - tzOffset; 896 if (DBG) log("fixTimeZone: adj ltod=" + TimeUtils.logTimeOfDay(adj)); 897 setAndBroadcastNetworkSetTime(adj); 898 } else { 899 // Adjust the saved NITZ time to account for tzOffset. 900 mSavedTime = mSavedTime - tzOffset; 901 if (DBG) log("fixTimeZone: adj mSavedTime=" + mSavedTime); 902 } 903 } 904 if (DBG) log("fixTimeZone: using default TimeZone"); 905 } else if (isoCountryCode.equals("")) { 906 // Country code not found. This is likely a test network. 907 // Get a TimeZone based only on the NITZ parameters (best guess). 908 zone = getNitzTimeZone(mZoneOffset, mZoneDst, mZoneTime); 909 if (DBG) log("fixTimeZone: using NITZ TimeZone"); 910 } else { 911 zone = TimeUtils.getTimeZone(mZoneOffset, mZoneDst, mZoneTime, isoCountryCode); 912 if (DBG) log("fixTimeZone: using getTimeZone(off, dst, time, iso)"); 913 } 914 915 mNeedFixZone = false; 916 917 if (zone != null) { 918 log("fixTimeZone: zone != null zone.getID=" + zone.getID()); 919 if (getAutoTimeZone()) { 920 setAndBroadcastNetworkSetTimeZone(zone.getID()); 921 } else { 922 log("fixTimeZone: skip changing zone as getAutoTimeZone was false"); 923 } 924 saveNitzTimeZone(zone.getID()); 925 } else { 926 log("fixTimeZone: zone == null, do nothing for zone"); 927 } 928 } 929 930 protected void pollStateDone() { 931 if (DBG) log("pollStateDone: oldSS=[" + ss + "] newSS=[" + newSS + "]"); 932 933 boolean hasRegistered = 934 ss.getState() != ServiceState.STATE_IN_SERVICE 935 && newSS.getState() == ServiceState.STATE_IN_SERVICE; 936 937 boolean hasDeregistered = 938 ss.getState() == ServiceState.STATE_IN_SERVICE 939 && newSS.getState() != ServiceState.STATE_IN_SERVICE; 940 941 boolean hasCdmaDataConnectionAttached = 942 mDataConnectionState != ServiceState.STATE_IN_SERVICE 943 && mNewDataConnectionState == ServiceState.STATE_IN_SERVICE; 944 945 boolean hasCdmaDataConnectionDetached = 946 mDataConnectionState == ServiceState.STATE_IN_SERVICE 947 && mNewDataConnectionState != ServiceState.STATE_IN_SERVICE; 948 949 boolean hasCdmaDataConnectionChanged = 950 mDataConnectionState != mNewDataConnectionState; 951 952 boolean hasRadioTechnologyChanged = mRilRadioTechnology != mNewRilRadioTechnology; 953 954 boolean hasChanged = !newSS.equals(ss); 955 956 boolean hasRoamingOn = !ss.getRoaming() && newSS.getRoaming(); 957 958 boolean hasRoamingOff = ss.getRoaming() && !newSS.getRoaming(); 959 960 boolean hasLocationChanged = !newCellLoc.equals(cellLoc); 961 962 // Add an event log when connection state changes 963 if (ss.getState() != newSS.getState() || 964 mDataConnectionState != mNewDataConnectionState) { 965 EventLog.writeEvent(EventLogTags.CDMA_SERVICE_STATE_CHANGE, 966 ss.getState(), mDataConnectionState, 967 newSS.getState(), mNewDataConnectionState); 968 } 969 970 ServiceState tss; 971 tss = ss; 972 ss = newSS; 973 newSS = tss; 974 // clean slate for next time 975 newSS.setStateOutOfService(); 976 977 CdmaCellLocation tcl = cellLoc; 978 cellLoc = newCellLoc; 979 newCellLoc = tcl; 980 981 mDataConnectionState = mNewDataConnectionState; 982 mRilRadioTechnology = mNewRilRadioTechnology; 983 // this new state has been applied - forget it until we get a new new state 984 mNewRilRadioTechnology = 0; 985 986 newSS.setStateOutOfService(); // clean slate for next time 987 988 if (hasRadioTechnologyChanged) { 989 phone.setSystemProperty(TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, 990 ServiceState.rilRadioTechnologyToString(mRilRadioTechnology)); 991 } 992 993 if (hasRegistered) { 994 mNetworkAttachedRegistrants.notifyRegistrants(); 995 } 996 997 if (hasChanged) { 998 if ((cm.getRadioState().isOn()) && (!isSubscriptionFromRuim)) { 999 String eriText; 1000 // Now the CDMAPhone sees the new ServiceState so it can get the new ERI text 1001 if (ss.getState() == ServiceState.STATE_IN_SERVICE) { 1002 eriText = phone.getCdmaEriText(); 1003 } else { 1004 // Note that ServiceState.STATE_OUT_OF_SERVICE is valid used for 1005 // mRegistrationState 0,2,3 and 4 1006 eriText = phone.getContext().getText( 1007 com.android.internal.R.string.roamingTextSearching).toString(); 1008 } 1009 ss.setOperatorAlphaLong(eriText); 1010 } 1011 1012 String operatorNumeric; 1013 1014 phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ALPHA, 1015 ss.getOperatorAlphaLong()); 1016 1017 String prevOperatorNumeric = 1018 SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, ""); 1019 operatorNumeric = ss.getOperatorNumeric(); 1020 phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, operatorNumeric); 1021 1022 if (operatorNumeric == null) { 1023 if (DBG) log("operatorNumeric is null"); 1024 phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, ""); 1025 mGotCountryCode = false; 1026 } else { 1027 String isoCountryCode = ""; 1028 String mcc = operatorNumeric.substring(0, 3); 1029 try{ 1030 isoCountryCode = MccTable.countryCodeForMcc(Integer.parseInt( 1031 operatorNumeric.substring(0,3))); 1032 } catch ( NumberFormatException ex){ 1033 loge("pollStateDone: countryCodeForMcc error" + ex); 1034 } catch ( StringIndexOutOfBoundsException ex) { 1035 loge("pollStateDone: countryCodeForMcc error" + ex); 1036 } 1037 1038 phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, 1039 isoCountryCode); 1040 mGotCountryCode = true; 1041 1042 if (shouldFixTimeZoneNow(phone, operatorNumeric, prevOperatorNumeric, 1043 mNeedFixZone)) { 1044 fixTimeZone(isoCountryCode); 1045 } 1046 } 1047 1048 phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISROAMING, 1049 ss.getRoaming() ? "true" : "false"); 1050 1051 updateSpnDisplay(); 1052 phone.notifyServiceStateChanged(ss); 1053 } 1054 1055 if (hasCdmaDataConnectionAttached) { 1056 mAttachedRegistrants.notifyRegistrants(); 1057 } 1058 1059 if (hasCdmaDataConnectionDetached) { 1060 mDetachedRegistrants.notifyRegistrants(); 1061 } 1062 1063 if (hasCdmaDataConnectionChanged || hasRadioTechnologyChanged) { 1064 phone.notifyDataConnection(null); 1065 } 1066 1067 if (hasRoamingOn) { 1068 mRoamingOnRegistrants.notifyRegistrants(); 1069 } 1070 1071 if (hasRoamingOff) { 1072 mRoamingOffRegistrants.notifyRegistrants(); 1073 } 1074 1075 if (hasLocationChanged) { 1076 phone.notifyLocationChanged(); 1077 } 1078 // TODO: Add CdmaCellIdenity updating, see CdmaLteServiceStateTracker. 1079 } 1080 1081 /** 1082 * Returns a TimeZone object based only on parameters from the NITZ string. 1083 */ 1084 private TimeZone getNitzTimeZone(int offset, boolean dst, long when) { 1085 TimeZone guess = findTimeZone(offset, dst, when); 1086 if (guess == null) { 1087 // Couldn't find a proper timezone. Perhaps the DST data is wrong. 1088 guess = findTimeZone(offset, !dst, when); 1089 } 1090 if (DBG) log("getNitzTimeZone returning " + (guess == null ? guess : guess.getID())); 1091 return guess; 1092 } 1093 1094 private TimeZone findTimeZone(int offset, boolean dst, long when) { 1095 int rawOffset = offset; 1096 if (dst) { 1097 rawOffset -= 3600000; 1098 } 1099 String[] zones = TimeZone.getAvailableIDs(rawOffset); 1100 TimeZone guess = null; 1101 Date d = new Date(when); 1102 for (String zone : zones) { 1103 TimeZone tz = TimeZone.getTimeZone(zone); 1104 if (tz.getOffset(when) == offset && 1105 tz.inDaylightTime(d) == dst) { 1106 guess = tz; 1107 break; 1108 } 1109 } 1110 1111 return guess; 1112 } 1113 1114 /** 1115 * TODO: This code is exactly the same as in GsmServiceStateTracker 1116 * and has a TODO to not poll signal strength if screen is off. 1117 * This code should probably be hoisted to the base class so 1118 * the fix, when added, works for both. 1119 */ 1120 private void 1121 queueNextSignalStrengthPoll() { 1122 if (dontPollSignalStrength) { 1123 // The radio is telling us about signal strength changes 1124 // we don't have to ask it 1125 return; 1126 } 1127 1128 Message msg; 1129 1130 msg = obtainMessage(); 1131 msg.what = EVENT_POLL_SIGNAL_STRENGTH; 1132 1133 // TODO Don't poll signal strength if screen is off 1134 sendMessageDelayed(msg, POLL_PERIOD_MILLIS); 1135 } 1136 1137 protected int radioTechnologyToDataServiceState(int code) { 1138 int retVal = ServiceState.STATE_OUT_OF_SERVICE; 1139 switch(code) { 1140 case 0: 1141 case 1: 1142 case 2: 1143 case 3: 1144 case 4: 1145 case 5: 1146 break; 1147 case 6: // RADIO_TECHNOLOGY_1xRTT 1148 case 7: // RADIO_TECHNOLOGY_EVDO_0 1149 case 8: // RADIO_TECHNOLOGY_EVDO_A 1150 case 12: // RADIO_TECHNOLOGY_EVDO_B 1151 case 13: // RADIO_TECHNOLOGY_EHRPD 1152 retVal = ServiceState.STATE_IN_SERVICE; 1153 break; 1154 default: 1155 loge("radioTechnologyToDataServiceState: Wrong radioTechnology code."); 1156 break; 1157 } 1158 return(retVal); 1159 } 1160 1161 /** code is registration state 0-5 from TS 27.007 7.2 */ 1162 protected int 1163 regCodeToServiceState(int code) { 1164 switch (code) { 1165 case 0: // Not searching and not registered 1166 return ServiceState.STATE_OUT_OF_SERVICE; 1167 case 1: 1168 return ServiceState.STATE_IN_SERVICE; 1169 case 2: // 2 is "searching", fall through 1170 case 3: // 3 is "registration denied", fall through 1171 case 4: // 4 is "unknown", not valid in current baseband 1172 return ServiceState.STATE_OUT_OF_SERVICE; 1173 case 5:// 5 is "Registered, roaming" 1174 return ServiceState.STATE_IN_SERVICE; 1175 1176 default: 1177 loge("regCodeToServiceState: unexpected service state " + code); 1178 return ServiceState.STATE_OUT_OF_SERVICE; 1179 } 1180 } 1181 1182 public int getCurrentDataConnectionState() { 1183 return mDataConnectionState; 1184 } 1185 1186 /** 1187 * code is registration state 0-5 from TS 27.007 7.2 1188 * returns true if registered roam, false otherwise 1189 */ 1190 private boolean 1191 regCodeIsRoaming (int code) { 1192 // 5 is "in service -- roam" 1193 return 5 == code; 1194 } 1195 1196 /** 1197 * Determine whether a roaming indicator is in the carrier-specified list of ERIs for 1198 * home system 1199 * 1200 * @param roamInd roaming indicator in String 1201 * @return true if the roamInd is in the carrier-specified list of ERIs for home network 1202 */ 1203 private boolean isRoamIndForHomeSystem(String roamInd) { 1204 // retrieve the carrier-specified list of ERIs for home system 1205 String homeRoamIndicators = SystemProperties.get("ro.cdma.homesystem"); 1206 1207 if (!TextUtils.isEmpty(homeRoamIndicators)) { 1208 // searches through the comma-separated list for a match, 1209 // return true if one is found. 1210 for (String homeRoamInd : homeRoamIndicators.split(",")) { 1211 if (homeRoamInd.equals(roamInd)) { 1212 return true; 1213 } 1214 } 1215 // no matches found against the list! 1216 return false; 1217 } 1218 1219 // no system property found for the roaming indicators for home system 1220 return false; 1221 } 1222 1223 /** 1224 * Set roaming state when cdmaRoaming is true and ons is different from spn 1225 * @param cdmaRoaming TS 27.007 7.2 CREG registered roaming 1226 * @param s ServiceState hold current ons 1227 * @return true for roaming state set 1228 */ 1229 private 1230 boolean isRoamingBetweenOperators(boolean cdmaRoaming, ServiceState s) { 1231 String spn = SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA, "empty"); 1232 1233 // NOTE: in case of RUIM we should completely ignore the ERI data file and 1234 // mOperatorAlphaLong is set from RIL_REQUEST_OPERATOR response 0 (alpha ONS) 1235 String onsl = s.getOperatorAlphaLong(); 1236 String onss = s.getOperatorAlphaShort(); 1237 1238 boolean equalsOnsl = onsl != null && spn.equals(onsl); 1239 boolean equalsOnss = onss != null && spn.equals(onss); 1240 1241 return cdmaRoaming && !(equalsOnsl || equalsOnss); 1242 } 1243 1244 1245 /** 1246 * nitzReceiveTime is time_t that the NITZ time was posted 1247 */ 1248 1249 private 1250 void setTimeFromNITZString (String nitz, long nitzReceiveTime) 1251 { 1252 // "yy/mm/dd,hh:mm:ss(+/-)tz" 1253 // tz is in number of quarter-hours 1254 1255 long start = SystemClock.elapsedRealtime(); 1256 if (DBG) { 1257 log("NITZ: " + nitz + "," + nitzReceiveTime + 1258 " start=" + start + " delay=" + (start - nitzReceiveTime)); 1259 } 1260 1261 try { 1262 /* NITZ time (hour:min:sec) will be in UTC but it supplies the timezone 1263 * offset as well (which we won't worry about until later) */ 1264 Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT")); 1265 1266 c.clear(); 1267 c.set(Calendar.DST_OFFSET, 0); 1268 1269 String[] nitzSubs = nitz.split("[/:,+-]"); 1270 1271 int year = 2000 + Integer.parseInt(nitzSubs[0]); 1272 c.set(Calendar.YEAR, year); 1273 1274 // month is 0 based! 1275 int month = Integer.parseInt(nitzSubs[1]) - 1; 1276 c.set(Calendar.MONTH, month); 1277 1278 int date = Integer.parseInt(nitzSubs[2]); 1279 c.set(Calendar.DATE, date); 1280 1281 int hour = Integer.parseInt(nitzSubs[3]); 1282 c.set(Calendar.HOUR, hour); 1283 1284 int minute = Integer.parseInt(nitzSubs[4]); 1285 c.set(Calendar.MINUTE, minute); 1286 1287 int second = Integer.parseInt(nitzSubs[5]); 1288 c.set(Calendar.SECOND, second); 1289 1290 boolean sign = (nitz.indexOf('-') == -1); 1291 1292 int tzOffset = Integer.parseInt(nitzSubs[6]); 1293 1294 int dst = (nitzSubs.length >= 8 ) ? Integer.parseInt(nitzSubs[7]) 1295 : 0; 1296 1297 // The zone offset received from NITZ is for current local time, 1298 // so DST correction is already applied. Don't add it again. 1299 // 1300 // tzOffset += dst * 4; 1301 // 1302 // We could unapply it if we wanted the raw offset. 1303 1304 tzOffset = (sign ? 1 : -1) * tzOffset * 15 * 60 * 1000; 1305 1306 TimeZone zone = null; 1307 1308 // As a special extension, the Android emulator appends the name of 1309 // the host computer's timezone to the nitz string. this is zoneinfo 1310 // timezone name of the form Area!Location or Area!Location!SubLocation 1311 // so we need to convert the ! into / 1312 if (nitzSubs.length >= 9) { 1313 String tzname = nitzSubs[8].replace('!','/'); 1314 zone = TimeZone.getTimeZone( tzname ); 1315 } 1316 1317 String iso = SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY); 1318 1319 if (zone == null) { 1320 if (mGotCountryCode) { 1321 if (iso != null && iso.length() > 0) { 1322 zone = TimeUtils.getTimeZone(tzOffset, dst != 0, 1323 c.getTimeInMillis(), 1324 iso); 1325 } else { 1326 // We don't have a valid iso country code. This is 1327 // most likely because we're on a test network that's 1328 // using a bogus MCC (eg, "001"), so get a TimeZone 1329 // based only on the NITZ parameters. 1330 zone = getNitzTimeZone(tzOffset, (dst != 0), c.getTimeInMillis()); 1331 } 1332 } 1333 } 1334 1335 if ((zone == null) || (mZoneOffset != tzOffset) || (mZoneDst != (dst != 0))){ 1336 // We got the time before the country or the zone has changed 1337 // so we don't know how to identify the DST rules yet. Save 1338 // the information and hope to fix it up later. 1339 1340 mNeedFixZone = true; 1341 mZoneOffset = tzOffset; 1342 mZoneDst = dst != 0; 1343 mZoneTime = c.getTimeInMillis(); 1344 } 1345 if (DBG) { 1346 log("NITZ: tzOffset=" + tzOffset + " dst=" + dst + " zone=" + 1347 (zone!=null ? zone.getID() : "NULL") + 1348 " iso=" + iso + " mGotCountryCode=" + mGotCountryCode + 1349 " mNeedFixZone=" + mNeedFixZone); 1350 } 1351 1352 if (zone != null) { 1353 if (getAutoTimeZone()) { 1354 setAndBroadcastNetworkSetTimeZone(zone.getID()); 1355 } 1356 saveNitzTimeZone(zone.getID()); 1357 } 1358 1359 String ignore = SystemProperties.get("gsm.ignore-nitz"); 1360 if (ignore != null && ignore.equals("yes")) { 1361 if (DBG) log("NITZ: Not setting clock because gsm.ignore-nitz is set"); 1362 return; 1363 } 1364 1365 try { 1366 mWakeLock.acquire(); 1367 1368 /** 1369 * Correct the NITZ time by how long its taken to get here. 1370 */ 1371 long millisSinceNitzReceived 1372 = SystemClock.elapsedRealtime() - nitzReceiveTime; 1373 1374 if (millisSinceNitzReceived < 0) { 1375 // Sanity check: something is wrong 1376 if (DBG) { 1377 log("NITZ: not setting time, clock has rolled " 1378 + "backwards since NITZ time was received, " 1379 + nitz); 1380 } 1381 return; 1382 } 1383 1384 if (millisSinceNitzReceived > Integer.MAX_VALUE) { 1385 // If the time is this far off, something is wrong > 24 days! 1386 if (DBG) { 1387 log("NITZ: not setting time, processing has taken " 1388 + (millisSinceNitzReceived / (1000 * 60 * 60 * 24)) 1389 + " days"); 1390 } 1391 return; 1392 } 1393 1394 // Note: with range checks above, cast to int is safe 1395 c.add(Calendar.MILLISECOND, (int)millisSinceNitzReceived); 1396 1397 if (getAutoTime()) { 1398 /** 1399 * Update system time automatically 1400 */ 1401 long gained = c.getTimeInMillis() - System.currentTimeMillis(); 1402 long timeSinceLastUpdate = SystemClock.elapsedRealtime() - mSavedAtTime; 1403 int nitzUpdateSpacing = Settings.Global.getInt(cr, 1404 Settings.Global.NITZ_UPDATE_SPACING, mNitzUpdateSpacing); 1405 int nitzUpdateDiff = Settings.Global.getInt(cr, 1406 Settings.Global.NITZ_UPDATE_DIFF, mNitzUpdateDiff); 1407 1408 if ((mSavedAtTime == 0) || (timeSinceLastUpdate > nitzUpdateSpacing) 1409 || (Math.abs(gained) > nitzUpdateDiff)) { 1410 if (DBG) { 1411 log("NITZ: Auto updating time of day to " + c.getTime() 1412 + " NITZ receive delay=" + millisSinceNitzReceived 1413 + "ms gained=" + gained + "ms from " + nitz); 1414 } 1415 1416 setAndBroadcastNetworkSetTime(c.getTimeInMillis()); 1417 } else { 1418 if (DBG) { 1419 log("NITZ: ignore, a previous update was " 1420 + timeSinceLastUpdate + "ms ago and gained=" + gained + "ms"); 1421 } 1422 return; 1423 } 1424 } 1425 1426 /** 1427 * Update properties and save the time we did the update 1428 */ 1429 if (DBG) log("NITZ: update nitz time property"); 1430 SystemProperties.set("gsm.nitz.time", String.valueOf(c.getTimeInMillis())); 1431 mSavedTime = c.getTimeInMillis(); 1432 mSavedAtTime = SystemClock.elapsedRealtime(); 1433 } finally { 1434 long end = SystemClock.elapsedRealtime(); 1435 if (DBG) log("NITZ: end=" + end + " dur=" + (end - start)); 1436 mWakeLock.release(); 1437 } 1438 } catch (RuntimeException ex) { 1439 loge("NITZ: Parsing NITZ time " + nitz + " ex=" + ex); 1440 } 1441 } 1442 1443 private boolean getAutoTime() { 1444 try { 1445 return Settings.System.getInt(cr, Settings.System.AUTO_TIME) > 0; 1446 } catch (SettingNotFoundException snfe) { 1447 return true; 1448 } 1449 } 1450 1451 private boolean getAutoTimeZone() { 1452 try { 1453 return Settings.System.getInt(cr, Settings.System.AUTO_TIME_ZONE) > 0; 1454 } catch (SettingNotFoundException snfe) { 1455 return true; 1456 } 1457 } 1458 1459 private void saveNitzTimeZone(String zoneId) { 1460 mSavedTimeZone = zoneId; 1461 } 1462 1463 /** 1464 * Set the timezone and send out a sticky broadcast so the system can 1465 * determine if the timezone was set by the carrier. 1466 * 1467 * @param zoneId timezone set by carrier 1468 */ 1469 private void setAndBroadcastNetworkSetTimeZone(String zoneId) { 1470 if (DBG) log("setAndBroadcastNetworkSetTimeZone: setTimeZone=" + zoneId); 1471 AlarmManager alarm = 1472 (AlarmManager) phone.getContext().getSystemService(Context.ALARM_SERVICE); 1473 alarm.setTimeZone(zoneId); 1474 Intent intent = new Intent(TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE); 1475 intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING); 1476 intent.putExtra("time-zone", zoneId); 1477 phone.getContext().sendStickyBroadcastAsUser(intent, UserHandle.ALL); 1478 } 1479 1480 /** 1481 * Set the time and Send out a sticky broadcast so the system can determine 1482 * if the time was set by the carrier. 1483 * 1484 * @param time time set by network 1485 */ 1486 private void setAndBroadcastNetworkSetTime(long time) { 1487 if (DBG) log("setAndBroadcastNetworkSetTime: time=" + time + "ms"); 1488 SystemClock.setCurrentTimeMillis(time); 1489 Intent intent = new Intent(TelephonyIntents.ACTION_NETWORK_SET_TIME); 1490 intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING); 1491 intent.putExtra("time", time); 1492 phone.getContext().sendStickyBroadcastAsUser(intent, UserHandle.ALL); 1493 } 1494 1495 private void revertToNitzTime() { 1496 if (Settings.System.getInt(cr, Settings.System.AUTO_TIME, 0) == 0) { 1497 return; 1498 } 1499 if (DBG) { 1500 log("revertToNitzTime: mSavedTime=" + mSavedTime + " mSavedAtTime=" + mSavedAtTime); 1501 } 1502 if (mSavedTime != 0 && mSavedAtTime != 0) { 1503 setAndBroadcastNetworkSetTime(mSavedTime 1504 + (SystemClock.elapsedRealtime() - mSavedAtTime)); 1505 } 1506 } 1507 1508 private void revertToNitzTimeZone() { 1509 if (Settings.System.getInt(phone.getContext().getContentResolver(), 1510 Settings.System.AUTO_TIME_ZONE, 0) == 0) { 1511 return; 1512 } 1513 if (DBG) log("revertToNitzTimeZone: tz='" + mSavedTimeZone); 1514 if (mSavedTimeZone != null) { 1515 setAndBroadcastNetworkSetTimeZone(mSavedTimeZone); 1516 } 1517 } 1518 1519 protected boolean isSidsAllZeros() { 1520 if (mHomeSystemId != null) { 1521 for (int i=0; i < mHomeSystemId.length; i++) { 1522 if (mHomeSystemId[i] != 0) { 1523 return false; 1524 } 1525 } 1526 } 1527 return true; 1528 } 1529 1530 /** 1531 * Check whether a specified system ID that matches one of the home system IDs. 1532 */ 1533 private boolean isHomeSid(int sid) { 1534 if (mHomeSystemId != null) { 1535 for (int i=0; i < mHomeSystemId.length; i++) { 1536 if (sid == mHomeSystemId[i]) { 1537 return true; 1538 } 1539 } 1540 } 1541 return false; 1542 } 1543 1544 /** 1545 * @return true if phone is camping on a technology 1546 * that could support voice and data simultaneously. 1547 */ 1548 public boolean isConcurrentVoiceAndDataAllowed() { 1549 // Note: it needs to be confirmed which CDMA network types 1550 // can support voice and data calls concurrently. 1551 // For the time-being, the return value will be false. 1552 return false; 1553 } 1554 1555 public String getMdnNumber() { 1556 return mMdn; 1557 } 1558 1559 public String getCdmaMin() { 1560 return mMin; 1561 } 1562 1563 /** Returns null if NV is not yet ready */ 1564 public String getPrlVersion() { 1565 return mPrlVersion; 1566 } 1567 1568 /** 1569 * Returns IMSI as MCC + MNC + MIN 1570 */ 1571 String getImsi() { 1572 // TODO: When RUIM is enabled, IMSI will come from RUIM not build-time props. 1573 String operatorNumeric = SystemProperties.get( 1574 TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, ""); 1575 1576 if (!TextUtils.isEmpty(operatorNumeric) && getCdmaMin() != null) { 1577 return (operatorNumeric + getCdmaMin()); 1578 } else { 1579 return null; 1580 } 1581 } 1582 1583 /** 1584 * Check if subscription data has been assigned to mMin 1585 * 1586 * return true if MIN info is ready; false otherwise. 1587 */ 1588 public boolean isMinInfoReady() { 1589 return mIsMinInfoReady; 1590 } 1591 1592 /** 1593 * Returns OTASP_UNKNOWN, OTASP_NEEDED or OTASP_NOT_NEEDED 1594 */ 1595 int getOtasp() { 1596 int provisioningState; 1597 if (mMin == null || (mMin.length() < 6)) { 1598 if (DBG) log("getOtasp: bad mMin='" + mMin + "'"); 1599 provisioningState = OTASP_UNKNOWN; 1600 } else { 1601 if ((mMin.equals(UNACTIVATED_MIN_VALUE) 1602 || mMin.substring(0,6).equals(UNACTIVATED_MIN2_VALUE)) 1603 || SystemProperties.getBoolean("test_cdma_setup", false)) { 1604 provisioningState = OTASP_NEEDED; 1605 } else { 1606 provisioningState = OTASP_NOT_NEEDED; 1607 } 1608 } 1609 if (DBG) log("getOtasp: state=" + provisioningState); 1610 return provisioningState; 1611 } 1612 1613 @Override 1614 protected void hangupAndPowerOff() { 1615 // hang up all active voice calls 1616 phone.mCT.ringingCall.hangupIfAlive(); 1617 phone.mCT.backgroundCall.hangupIfAlive(); 1618 phone.mCT.foregroundCall.hangupIfAlive(); 1619 cm.setRadioPower(false, null); 1620 } 1621 1622 protected void parseSidNid (String sidStr, String nidStr) { 1623 if (sidStr != null) { 1624 String[] sid = sidStr.split(","); 1625 mHomeSystemId = new int[sid.length]; 1626 for (int i = 0; i < sid.length; i++) { 1627 try { 1628 mHomeSystemId[i] = Integer.parseInt(sid[i]); 1629 } catch (NumberFormatException ex) { 1630 loge("error parsing system id: " + ex); 1631 } 1632 } 1633 } 1634 if (DBG) log("CDMA_SUBSCRIPTION: SID=" + sidStr); 1635 1636 if (nidStr != null) { 1637 String[] nid = nidStr.split(","); 1638 mHomeNetworkId = new int[nid.length]; 1639 for (int i = 0; i < nid.length; i++) { 1640 try { 1641 mHomeNetworkId[i] = Integer.parseInt(nid[i]); 1642 } catch (NumberFormatException ex) { 1643 loge("CDMA_SUBSCRIPTION: error parsing network id: " + ex); 1644 } 1645 } 1646 } 1647 if (DBG) log("CDMA_SUBSCRIPTION: NID=" + nidStr); 1648 } 1649 1650 protected void updateOtaspState() { 1651 int otaspMode = getOtasp(); 1652 int oldOtaspMode = mCurrentOtaspMode; 1653 mCurrentOtaspMode = otaspMode; 1654 1655 // Notify apps subscription info is ready 1656 if (cdmaForSubscriptionInfoReadyRegistrants != null) { 1657 if (DBG) log("CDMA_SUBSCRIPTION: call notifyRegistrants()"); 1658 cdmaForSubscriptionInfoReadyRegistrants.notifyRegistrants(); 1659 } 1660 if (oldOtaspMode != mCurrentOtaspMode) { 1661 if (DBG) { 1662 log("CDMA_SUBSCRIPTION: call notifyOtaspChanged old otaspMode=" + 1663 oldOtaspMode + " new otaspMode=" + mCurrentOtaspMode); 1664 } 1665 phone.notifyOtaspChanged(mCurrentOtaspMode); 1666 } 1667 } 1668 1669 @Override 1670 protected void onUpdateIccAvailability() { 1671 if (mUiccController == null ) { 1672 return; 1673 } 1674 1675 UiccCardApplication newUiccApplication = 1676 mUiccController.getUiccCardApplication(UiccController.APP_FAM_3GPP2); 1677 1678 if (mUiccApplcation != newUiccApplication) { 1679 if (mUiccApplcation != null) { 1680 log("Removing stale icc objects."); 1681 mUiccApplcation.unregisterForReady(this); 1682 if (mIccRecords != null) { 1683 mIccRecords.unregisterForRecordsLoaded(this); 1684 } 1685 mIccRecords = null; 1686 mUiccApplcation = null; 1687 } 1688 if (newUiccApplication != null) { 1689 log("New card found"); 1690 mUiccApplcation = newUiccApplication; 1691 mIccRecords = mUiccApplcation.getIccRecords(); 1692 if (isSubscriptionFromRuim) { 1693 mUiccApplcation.registerForReady(this, EVENT_RUIM_READY, null); 1694 if (mIccRecords != null) { 1695 mIccRecords.registerForRecordsLoaded(this, EVENT_RUIM_RECORDS_LOADED, null); 1696 } 1697 } 1698 } 1699 } 1700 } 1701 1702 /** 1703 * @return all available cell information or null if none. 1704 */ 1705 @Override 1706 public List<CellInfo> getAllCellInfo() { 1707 return null; 1708 } 1709 1710 @Override 1711 protected void log(String s) { 1712 Log.d(LOG_TAG, "[CdmaSST] " + s); 1713 } 1714 1715 @Override 1716 protected void loge(String s) { 1717 Log.e(LOG_TAG, "[CdmaSST] " + s); 1718 } 1719 1720 @Override 1721 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 1722 pw.println("CdmaServiceStateTracker extends:"); 1723 super.dump(fd, pw, args); 1724 pw.println(" phone=" + phone); 1725 pw.println(" cellLoc=" + cellLoc); 1726 pw.println(" newCellLoc=" + newCellLoc); 1727 pw.println(" mCurrentOtaspMode=" + mCurrentOtaspMode); 1728 pw.println(" mCdmaRoaming=" + mCdmaRoaming); 1729 pw.println(" mRoamingIndicator=" + mRoamingIndicator); 1730 pw.println(" mIsInPrl=" + mIsInPrl); 1731 pw.println(" mDefaultRoamingIndicator=" + mDefaultRoamingIndicator); 1732 pw.println(" mDataConnectionState=" + mDataConnectionState); 1733 pw.println(" mNewDataConnectionState=" + mNewDataConnectionState); 1734 pw.println(" mRegistrationState=" + mRegistrationState); 1735 pw.println(" mNeedFixZone=" + mNeedFixZone); 1736 pw.println(" mZoneOffset=" + mZoneOffset); 1737 pw.println(" mZoneDst=" + mZoneDst); 1738 pw.println(" mZoneTime=" + mZoneTime); 1739 pw.println(" mGotCountryCode=" + mGotCountryCode); 1740 pw.println(" mSavedTimeZone=" + mSavedTimeZone); 1741 pw.println(" mSavedTime=" + mSavedTime); 1742 pw.println(" mSavedAtTime=" + mSavedAtTime); 1743 pw.println(" mWakeLock=" + mWakeLock); 1744 pw.println(" mCurPlmn=" + mCurPlmn); 1745 pw.println(" mMdn=" + mMdn); 1746 pw.println(" mHomeSystemId=" + mHomeSystemId); 1747 pw.println(" mHomeNetworkId=" + mHomeNetworkId); 1748 pw.println(" mMin=" + mMin); 1749 pw.println(" mPrlVersion=" + mPrlVersion); 1750 pw.println(" mIsMinInfoReady=" + mIsMinInfoReady); 1751 pw.println(" isEriTextLoaded=" + isEriTextLoaded); 1752 pw.println(" isSubscriptionFromRuim=" + isSubscriptionFromRuim); 1753 pw.println(" mCdmaSSM=" + mCdmaSSM); 1754 pw.println(" mRegistrationDeniedReason=" + mRegistrationDeniedReason); 1755 pw.println(" currentCarrier=" + currentCarrier); 1756 } 1757 } 1758