1/* 2 * Copyright (C) 2015 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 */ 16package com.android.systemui.statusbar.policy; 17 18import android.content.Context; 19import android.content.Intent; 20import android.net.NetworkCapabilities; 21import android.os.Looper; 22import android.telephony.PhoneStateListener; 23import android.telephony.ServiceState; 24import android.telephony.SignalStrength; 25import android.telephony.SubscriptionInfo; 26import android.telephony.SubscriptionManager; 27import android.telephony.TelephonyManager; 28import android.text.TextUtils; 29import android.util.Log; 30import android.util.SparseArray; 31 32import com.android.internal.annotations.VisibleForTesting; 33import com.android.internal.telephony.TelephonyIntents; 34import com.android.internal.telephony.cdma.EriInfo; 35import com.android.systemui.R; 36import com.android.systemui.statusbar.policy.NetworkController.IconState; 37import com.android.systemui.statusbar.policy.NetworkController.SignalCallback; 38import com.android.systemui.statusbar.policy.NetworkControllerImpl.Config; 39import com.android.systemui.statusbar.policy.NetworkControllerImpl.SubscriptionDefaults; 40 41import java.io.PrintWriter; 42import java.util.BitSet; 43import java.util.Objects; 44 45 46public class MobileSignalController extends SignalController< 47 MobileSignalController.MobileState, MobileSignalController.MobileIconGroup> { 48 private final TelephonyManager mPhone; 49 private final SubscriptionDefaults mDefaults; 50 private final String mNetworkNameDefault; 51 private final String mNetworkNameSeparator; 52 @VisibleForTesting 53 final PhoneStateListener mPhoneStateListener; 54 // Save entire info for logging, we only use the id. 55 final SubscriptionInfo mSubscriptionInfo; 56 57 // @VisibleForDemoMode 58 final SparseArray<MobileIconGroup> mNetworkToIconLookup; 59 60 // Since some pieces of the phone state are interdependent we store it locally, 61 // this could potentially become part of MobileState for simplification/complication 62 // of code. 63 private int mDataNetType = TelephonyManager.NETWORK_TYPE_UNKNOWN; 64 private int mDataState = TelephonyManager.DATA_DISCONNECTED; 65 private ServiceState mServiceState; 66 private SignalStrength mSignalStrength; 67 private MobileIconGroup mDefaultIcons; 68 private Config mConfig; 69 70 // TODO: Reduce number of vars passed in, if we have the NetworkController, probably don't 71 // need listener lists anymore. 72 public MobileSignalController(Context context, Config config, boolean hasMobileData, 73 TelephonyManager phone, CallbackHandler callbackHandler, 74 NetworkControllerImpl networkController, SubscriptionInfo info, 75 SubscriptionDefaults defaults, Looper receiverLooper) { 76 super("MobileSignalController(" + info.getSubscriptionId() + ")", context, 77 NetworkCapabilities.TRANSPORT_CELLULAR, callbackHandler, 78 networkController); 79 mNetworkToIconLookup = new SparseArray<>(); 80 mConfig = config; 81 mPhone = phone; 82 mDefaults = defaults; 83 mSubscriptionInfo = info; 84 mPhoneStateListener = new MobilePhoneStateListener(info.getSubscriptionId(), 85 receiverLooper); 86 mNetworkNameSeparator = getStringIfExists(R.string.status_bar_network_name_separator); 87 mNetworkNameDefault = getStringIfExists( 88 com.android.internal.R.string.lockscreen_carrier_default); 89 90 mapIconSets(); 91 92 String networkName = info.getCarrierName() != null ? info.getCarrierName().toString() 93 : mNetworkNameDefault; 94 mLastState.networkName = mCurrentState.networkName = networkName; 95 mLastState.networkNameData = mCurrentState.networkNameData = networkName; 96 mLastState.enabled = mCurrentState.enabled = hasMobileData; 97 mLastState.iconGroup = mCurrentState.iconGroup = mDefaultIcons; 98 // Get initial data sim state. 99 updateDataSim(); 100 } 101 102 public void setConfiguration(Config config) { 103 mConfig = config; 104 mapIconSets(); 105 updateTelephony(); 106 } 107 108 public int getDataContentDescription() { 109 return getIcons().mDataContentDescription; 110 } 111 112 public void setAirplaneMode(boolean airplaneMode) { 113 mCurrentState.airplaneMode = airplaneMode; 114 notifyListenersIfNecessary(); 115 } 116 117 public void setUserSetupComplete(boolean userSetup) { 118 mCurrentState.userSetup = userSetup; 119 notifyListenersIfNecessary(); 120 } 121 122 @Override 123 public void updateConnectivity(BitSet connectedTransports, BitSet validatedTransports) { 124 boolean isValidated = validatedTransports.get(mTransportType); 125 mCurrentState.isDefault = connectedTransports.get(mTransportType); 126 // Only show this as not having connectivity if we are default. 127 mCurrentState.inetCondition = (isValidated || !mCurrentState.isDefault) ? 1 : 0; 128 notifyListenersIfNecessary(); 129 } 130 131 public void setCarrierNetworkChangeMode(boolean carrierNetworkChangeMode) { 132 mCurrentState.carrierNetworkChangeMode = carrierNetworkChangeMode; 133 updateTelephony(); 134 } 135 136 /** 137 * Start listening for phone state changes. 138 */ 139 public void registerListener() { 140 mPhone.listen(mPhoneStateListener, 141 PhoneStateListener.LISTEN_SERVICE_STATE 142 | PhoneStateListener.LISTEN_SIGNAL_STRENGTHS 143 | PhoneStateListener.LISTEN_CALL_STATE 144 | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE 145 | PhoneStateListener.LISTEN_DATA_ACTIVITY 146 | PhoneStateListener.LISTEN_CARRIER_NETWORK_CHANGE); 147 } 148 149 /** 150 * Stop listening for phone state changes. 151 */ 152 public void unregisterListener() { 153 mPhone.listen(mPhoneStateListener, 0); 154 } 155 156 /** 157 * Produce a mapping of data network types to icon groups for simple and quick use in 158 * updateTelephony. 159 */ 160 private void mapIconSets() { 161 mNetworkToIconLookup.clear(); 162 163 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_EVDO_0, TelephonyIcons.THREE_G); 164 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_EVDO_A, TelephonyIcons.THREE_G); 165 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_EVDO_B, TelephonyIcons.THREE_G); 166 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_EHRPD, TelephonyIcons.THREE_G); 167 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_UMTS, TelephonyIcons.THREE_G); 168 169 if (!mConfig.showAtLeast3G) { 170 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_UNKNOWN, 171 TelephonyIcons.UNKNOWN); 172 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_EDGE, TelephonyIcons.E); 173 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_CDMA, TelephonyIcons.ONE_X); 174 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_1xRTT, TelephonyIcons.ONE_X); 175 176 mDefaultIcons = TelephonyIcons.G; 177 } else { 178 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_UNKNOWN, 179 TelephonyIcons.THREE_G); 180 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_EDGE, 181 TelephonyIcons.THREE_G); 182 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_CDMA, 183 TelephonyIcons.THREE_G); 184 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_1xRTT, 185 TelephonyIcons.THREE_G); 186 mDefaultIcons = TelephonyIcons.THREE_G; 187 } 188 189 MobileIconGroup hGroup = TelephonyIcons.THREE_G; 190 if (mConfig.hspaDataDistinguishable) { 191 hGroup = TelephonyIcons.H; 192 } 193 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_HSDPA, hGroup); 194 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_HSUPA, hGroup); 195 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_HSPA, hGroup); 196 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_HSPAP, hGroup); 197 198 if (mConfig.show4gForLte) { 199 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_LTE, TelephonyIcons.FOUR_G); 200 } else { 201 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_LTE, TelephonyIcons.LTE); 202 } 203 mNetworkToIconLookup.put(TelephonyManager.NETWORK_TYPE_IWLAN, TelephonyIcons.WFC); 204 } 205 206 @Override 207 public void notifyListeners(SignalCallback callback) { 208 MobileIconGroup icons = getIcons(); 209 210 String contentDescription = getStringIfExists(getContentDescription()); 211 String dataContentDescription = getStringIfExists(icons.mDataContentDescription); 212 final boolean dataDisabled = mCurrentState.iconGroup == TelephonyIcons.DATA_DISABLED 213 && mCurrentState.userSetup; 214 215 // Show icon in QS when we are connected or need to show roaming or data is disabled. 216 boolean showDataIcon = mCurrentState.dataConnected 217 || mCurrentState.iconGroup == TelephonyIcons.ROAMING 218 || dataDisabled; 219 IconState statusIcon = new IconState(mCurrentState.enabled && !mCurrentState.airplaneMode, 220 getCurrentIconId(), contentDescription); 221 222 int qsTypeIcon = 0; 223 IconState qsIcon = null; 224 String description = null; 225 // Only send data sim callbacks to QS. 226 if (mCurrentState.dataSim) { 227 qsTypeIcon = showDataIcon ? icons.mQsDataType : 0; 228 qsIcon = new IconState(mCurrentState.enabled 229 && !mCurrentState.isEmergency, getQsCurrentIconId(), contentDescription); 230 description = mCurrentState.isEmergency ? null : mCurrentState.networkName; 231 } 232 boolean activityIn = mCurrentState.dataConnected 233 && !mCurrentState.carrierNetworkChangeMode 234 && mCurrentState.activityIn; 235 boolean activityOut = mCurrentState.dataConnected 236 && !mCurrentState.carrierNetworkChangeMode 237 && mCurrentState.activityOut; 238 showDataIcon &= mCurrentState.isDefault 239 || mCurrentState.iconGroup == TelephonyIcons.ROAMING 240 || dataDisabled; 241 int typeIcon = showDataIcon ? icons.mDataType : 0; 242 callback.setMobileDataIndicators(statusIcon, qsIcon, typeIcon, qsTypeIcon, 243 activityIn, activityOut, dataContentDescription, description, icons.mIsWide, 244 mSubscriptionInfo.getSubscriptionId()); 245 } 246 247 @Override 248 protected MobileState cleanState() { 249 return new MobileState(); 250 } 251 252 private boolean hasService() { 253 if (mServiceState != null) { 254 // Consider the device to be in service if either voice or data 255 // service is available. Some SIM cards are marketed as data-only 256 // and do not support voice service, and on these SIM cards, we 257 // want to show signal bars for data service as well as the "no 258 // service" or "emergency calls only" text that indicates that voice 259 // is not available. 260 switch (mServiceState.getVoiceRegState()) { 261 case ServiceState.STATE_POWER_OFF: 262 return false; 263 case ServiceState.STATE_OUT_OF_SERVICE: 264 case ServiceState.STATE_EMERGENCY_ONLY: 265 return mServiceState.getDataRegState() == ServiceState.STATE_IN_SERVICE; 266 default: 267 return true; 268 } 269 } else { 270 return false; 271 } 272 } 273 274 private boolean isCdma() { 275 return (mSignalStrength != null) && !mSignalStrength.isGsm(); 276 } 277 278 public boolean isEmergencyOnly() { 279 return (mServiceState != null && mServiceState.isEmergencyOnly()); 280 } 281 282 private boolean isRoaming() { 283 if (isCdma()) { 284 final int iconMode = mServiceState.getCdmaEriIconMode(); 285 return mServiceState.getCdmaEriIconIndex() != EriInfo.ROAMING_INDICATOR_OFF 286 && (iconMode == EriInfo.ROAMING_ICON_MODE_NORMAL 287 || iconMode == EriInfo.ROAMING_ICON_MODE_FLASH); 288 } else { 289 return mServiceState != null && mServiceState.getRoaming(); 290 } 291 } 292 293 private boolean isCarrierNetworkChangeActive() { 294 return mCurrentState.carrierNetworkChangeMode; 295 } 296 297 public void handleBroadcast(Intent intent) { 298 String action = intent.getAction(); 299 if (action.equals(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION)) { 300 updateNetworkName(intent.getBooleanExtra(TelephonyIntents.EXTRA_SHOW_SPN, false), 301 intent.getStringExtra(TelephonyIntents.EXTRA_SPN), 302 intent.getStringExtra(TelephonyIntents.EXTRA_DATA_SPN), 303 intent.getBooleanExtra(TelephonyIntents.EXTRA_SHOW_PLMN, false), 304 intent.getStringExtra(TelephonyIntents.EXTRA_PLMN)); 305 notifyListenersIfNecessary(); 306 } else if (action.equals(TelephonyIntents.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED)) { 307 updateDataSim(); 308 notifyListenersIfNecessary(); 309 } 310 } 311 312 private void updateDataSim() { 313 int defaultDataSub = mDefaults.getDefaultDataSubId(); 314 if (SubscriptionManager.isValidSubscriptionId(defaultDataSub)) { 315 mCurrentState.dataSim = defaultDataSub == mSubscriptionInfo.getSubscriptionId(); 316 } else { 317 // There doesn't seem to be a data sim selected, however if 318 // there isn't a MobileSignalController with dataSim set, then 319 // QS won't get any callbacks and will be blank. Instead 320 // lets just assume we are the data sim (which will basically 321 // show one at random) in QS until one is selected. The user 322 // should pick one soon after, so we shouldn't be in this state 323 // for long. 324 mCurrentState.dataSim = true; 325 } 326 } 327 328 /** 329 * Updates the network's name based on incoming spn and plmn. 330 */ 331 void updateNetworkName(boolean showSpn, String spn, String dataSpn, 332 boolean showPlmn, String plmn) { 333 if (CHATTY) { 334 Log.d("CarrierLabel", "updateNetworkName showSpn=" + showSpn 335 + " spn=" + spn + " dataSpn=" + dataSpn 336 + " showPlmn=" + showPlmn + " plmn=" + plmn); 337 } 338 StringBuilder str = new StringBuilder(); 339 StringBuilder strData = new StringBuilder(); 340 if (showPlmn && plmn != null) { 341 str.append(plmn); 342 strData.append(plmn); 343 } 344 if (showSpn && spn != null) { 345 if (str.length() != 0) { 346 str.append(mNetworkNameSeparator); 347 } 348 str.append(spn); 349 } 350 if (str.length() != 0) { 351 mCurrentState.networkName = str.toString(); 352 } else { 353 mCurrentState.networkName = mNetworkNameDefault; 354 } 355 if (showSpn && dataSpn != null) { 356 if (strData.length() != 0) { 357 strData.append(mNetworkNameSeparator); 358 } 359 strData.append(dataSpn); 360 } 361 if (strData.length() != 0) { 362 mCurrentState.networkNameData = strData.toString(); 363 } else { 364 mCurrentState.networkNameData = mNetworkNameDefault; 365 } 366 } 367 368 /** 369 * Updates the current state based on mServiceState, mSignalStrength, mDataNetType, 370 * mDataState, and mSimState. It should be called any time one of these is updated. 371 * This will call listeners if necessary. 372 */ 373 private final void updateTelephony() { 374 if (DEBUG) { 375 Log.d(mTag, "updateTelephonySignalStrength: hasService=" + hasService() 376 + " ss=" + mSignalStrength); 377 } 378 mCurrentState.connected = hasService() && mSignalStrength != null; 379 if (mCurrentState.connected) { 380 if (!mSignalStrength.isGsm() && mConfig.alwaysShowCdmaRssi) { 381 mCurrentState.level = mSignalStrength.getCdmaLevel(); 382 } else { 383 mCurrentState.level = mSignalStrength.getLevel(); 384 } 385 } 386 if (mNetworkToIconLookup.indexOfKey(mDataNetType) >= 0) { 387 mCurrentState.iconGroup = mNetworkToIconLookup.get(mDataNetType); 388 } else { 389 mCurrentState.iconGroup = mDefaultIcons; 390 } 391 mCurrentState.dataConnected = mCurrentState.connected 392 && mDataState == TelephonyManager.DATA_CONNECTED; 393 394 if (isCarrierNetworkChangeActive()) { 395 mCurrentState.iconGroup = TelephonyIcons.CARRIER_NETWORK_CHANGE; 396 } else if (isRoaming()) { 397 mCurrentState.iconGroup = TelephonyIcons.ROAMING; 398 } else if (isDataDisabled()) { 399 mCurrentState.iconGroup = TelephonyIcons.DATA_DISABLED; 400 } 401 if (isEmergencyOnly() != mCurrentState.isEmergency) { 402 mCurrentState.isEmergency = isEmergencyOnly(); 403 mNetworkController.recalculateEmergency(); 404 } 405 // Fill in the network name if we think we have it. 406 if (mCurrentState.networkName == mNetworkNameDefault && mServiceState != null 407 && !TextUtils.isEmpty(mServiceState.getOperatorAlphaShort())) { 408 mCurrentState.networkName = mServiceState.getOperatorAlphaShort(); 409 } 410 411 notifyListenersIfNecessary(); 412 } 413 414 private boolean isDataDisabled() { 415 return !mPhone.getDataEnabled(mSubscriptionInfo.getSubscriptionId()); 416 } 417 418 @VisibleForTesting 419 void setActivity(int activity) { 420 mCurrentState.activityIn = activity == TelephonyManager.DATA_ACTIVITY_INOUT 421 || activity == TelephonyManager.DATA_ACTIVITY_IN; 422 mCurrentState.activityOut = activity == TelephonyManager.DATA_ACTIVITY_INOUT 423 || activity == TelephonyManager.DATA_ACTIVITY_OUT; 424 notifyListenersIfNecessary(); 425 } 426 427 @Override 428 public void dump(PrintWriter pw) { 429 super.dump(pw); 430 pw.println(" mSubscription=" + mSubscriptionInfo + ","); 431 pw.println(" mServiceState=" + mServiceState + ","); 432 pw.println(" mSignalStrength=" + mSignalStrength + ","); 433 pw.println(" mDataState=" + mDataState + ","); 434 pw.println(" mDataNetType=" + mDataNetType + ","); 435 } 436 437 class MobilePhoneStateListener extends PhoneStateListener { 438 public MobilePhoneStateListener(int subId, Looper looper) { 439 super(subId, looper); 440 } 441 442 @Override 443 public void onSignalStrengthsChanged(SignalStrength signalStrength) { 444 if (DEBUG) { 445 Log.d(mTag, "onSignalStrengthsChanged signalStrength=" + signalStrength + 446 ((signalStrength == null) ? "" : (" level=" + signalStrength.getLevel()))); 447 } 448 mSignalStrength = signalStrength; 449 updateTelephony(); 450 } 451 452 @Override 453 public void onServiceStateChanged(ServiceState state) { 454 if (DEBUG) { 455 Log.d(mTag, "onServiceStateChanged voiceState=" + state.getVoiceRegState() 456 + " dataState=" + state.getDataRegState()); 457 } 458 mServiceState = state; 459 mDataNetType = state.getDataNetworkType(); 460 updateTelephony(); 461 } 462 463 @Override 464 public void onDataConnectionStateChanged(int state, int networkType) { 465 if (DEBUG) { 466 Log.d(mTag, "onDataConnectionStateChanged: state=" + state 467 + " type=" + networkType); 468 } 469 mDataState = state; 470 mDataNetType = networkType; 471 updateTelephony(); 472 } 473 474 @Override 475 public void onDataActivity(int direction) { 476 if (DEBUG) { 477 Log.d(mTag, "onDataActivity: direction=" + direction); 478 } 479 setActivity(direction); 480 } 481 482 @Override 483 public void onCarrierNetworkChange(boolean active) { 484 if (DEBUG) { 485 Log.d(mTag, "onCarrierNetworkChange: active=" + active); 486 } 487 mCurrentState.carrierNetworkChangeMode = active; 488 489 updateTelephony(); 490 } 491 }; 492 493 static class MobileIconGroup extends SignalController.IconGroup { 494 final int mDataContentDescription; // mContentDescriptionDataType 495 final int mDataType; 496 final boolean mIsWide; 497 final int mQsDataType; 498 499 public MobileIconGroup(String name, int[][] sbIcons, int[][] qsIcons, int[] contentDesc, 500 int sbNullState, int qsNullState, int sbDiscState, int qsDiscState, 501 int discContentDesc, int dataContentDesc, int dataType, boolean isWide, 502 int qsDataType) { 503 super(name, sbIcons, qsIcons, contentDesc, sbNullState, qsNullState, sbDiscState, 504 qsDiscState, discContentDesc); 505 mDataContentDescription = dataContentDesc; 506 mDataType = dataType; 507 mIsWide = isWide; 508 mQsDataType = qsDataType; 509 } 510 } 511 512 static class MobileState extends SignalController.State { 513 String networkName; 514 String networkNameData; 515 boolean dataSim; 516 boolean dataConnected; 517 boolean isEmergency; 518 boolean airplaneMode; 519 boolean carrierNetworkChangeMode; 520 boolean isDefault; 521 boolean userSetup; 522 523 @Override 524 public void copyFrom(State s) { 525 super.copyFrom(s); 526 MobileState state = (MobileState) s; 527 dataSim = state.dataSim; 528 networkName = state.networkName; 529 networkNameData = state.networkNameData; 530 dataConnected = state.dataConnected; 531 isDefault = state.isDefault; 532 isEmergency = state.isEmergency; 533 airplaneMode = state.airplaneMode; 534 carrierNetworkChangeMode = state.carrierNetworkChangeMode; 535 userSetup = state.userSetup; 536 } 537 538 @Override 539 protected void toString(StringBuilder builder) { 540 super.toString(builder); 541 builder.append(','); 542 builder.append("dataSim=").append(dataSim).append(','); 543 builder.append("networkName=").append(networkName).append(','); 544 builder.append("networkNameData=").append(networkNameData).append(','); 545 builder.append("dataConnected=").append(dataConnected).append(','); 546 builder.append("isDefault=").append(isDefault).append(','); 547 builder.append("isEmergency=").append(isEmergency).append(','); 548 builder.append("airplaneMode=").append(airplaneMode).append(','); 549 builder.append("carrierNetworkChangeMode=").append(carrierNetworkChangeMode) 550 .append(','); 551 builder.append("userSetup=").append(userSetup); 552 } 553 554 @Override 555 public boolean equals(Object o) { 556 return super.equals(o) 557 && Objects.equals(((MobileState) o).networkName, networkName) 558 && Objects.equals(((MobileState) o).networkNameData, networkNameData) 559 && ((MobileState) o).dataSim == dataSim 560 && ((MobileState) o).dataConnected == dataConnected 561 && ((MobileState) o).isEmergency == isEmergency 562 && ((MobileState) o).airplaneMode == airplaneMode 563 && ((MobileState) o).carrierNetworkChangeMode == carrierNetworkChangeMode 564 && ((MobileState) o).userSetup == userSetup 565 && ((MobileState) o).isDefault == isDefault; 566 } 567 } 568} 569