1 /* 2 * Copyright (C) 2016 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.dataconnection; 18 19 20 import static android.telephony.PhoneStateListener.LISTEN_CALL_STATE; 21 import static android.telephony.PhoneStateListener.LISTEN_NONE; 22 23 import android.annotation.IntDef; 24 import android.content.ContentResolver; 25 import android.content.Context; 26 import android.os.Handler; 27 import android.os.RegistrantList; 28 import android.os.SystemProperties; 29 import android.provider.Settings; 30 import android.sysprop.TelephonyProperties; 31 import android.telephony.Annotation.CallState; 32 import android.telephony.CarrierConfigManager; 33 import android.telephony.PhoneStateListener; 34 import android.telephony.SubscriptionInfo; 35 import android.telephony.SubscriptionManager; 36 import android.telephony.TelephonyManager; 37 import android.telephony.data.ApnSetting; 38 import android.util.LocalLog; 39 import android.util.Pair; 40 41 import com.android.internal.telephony.GlobalSettingsHelper; 42 import com.android.internal.telephony.MultiSimSettingController; 43 import com.android.internal.telephony.Phone; 44 import com.android.internal.telephony.SubscriptionController; 45 import com.android.telephony.Rlog; 46 47 import java.io.FileDescriptor; 48 import java.io.PrintWriter; 49 import java.lang.annotation.Retention; 50 import java.lang.annotation.RetentionPolicy; 51 52 /** 53 * The class to hold different data enabled/disabled settings. Also it allows clients to register 54 * for overall data enabled setting changed event. 55 * @hide 56 */ 57 public class DataEnabledSettings { 58 59 private static final String LOG_TAG = "DataEnabledSettings"; 60 61 @Retention(RetentionPolicy.SOURCE) 62 @IntDef(prefix = {"REASON_"}, 63 value = { 64 REASON_REGISTERED, 65 REASON_INTERNAL_DATA_ENABLED, 66 REASON_USER_DATA_ENABLED, 67 REASON_POLICY_DATA_ENABLED, 68 REASON_DATA_ENABLED_BY_CARRIER, 69 REASON_PROVISIONED_CHANGED, 70 REASON_PROVISIONING_DATA_ENABLED_CHANGED, 71 REASON_OVERRIDE_RULE_CHANGED, 72 REASON_OVERRIDE_CONDITION_CHANGED 73 }) 74 public @interface DataEnabledChangedReason {} 75 76 public static final int REASON_REGISTERED = 0; 77 78 public static final int REASON_INTERNAL_DATA_ENABLED = 1; 79 80 public static final int REASON_USER_DATA_ENABLED = 2; 81 82 public static final int REASON_POLICY_DATA_ENABLED = 3; 83 84 public static final int REASON_DATA_ENABLED_BY_CARRIER = 4; 85 86 public static final int REASON_PROVISIONED_CHANGED = 5; 87 88 public static final int REASON_PROVISIONING_DATA_ENABLED_CHANGED = 6; 89 90 public static final int REASON_OVERRIDE_RULE_CHANGED = 7; 91 92 public static final int REASON_OVERRIDE_CONDITION_CHANGED = 8; 93 94 /** 95 * responds to the setInternalDataEnabled call - used internally to turn off data. 96 * For example during emergency calls 97 */ 98 private boolean mInternalDataEnabled = true; 99 100 /** 101 * Flag indicating data allowed by network policy manager or not. 102 */ 103 private boolean mPolicyDataEnabled = true; 104 105 /** 106 * Indicate if metered APNs are enabled by the carrier. set false to block all the metered APNs 107 * from continuously sending requests, which causes undesired network load. 108 */ 109 private boolean mCarrierDataEnabled = true; 110 111 private boolean mIsDataEnabled = false; 112 113 private final Phone mPhone; 114 115 private int mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; 116 117 private ContentResolver mResolver = null; 118 119 private final RegistrantList mOverallDataEnabledChangedRegistrants = new RegistrantList(); 120 121 // TODO: Merge this with mOverallDataEnabledChangedRegistrants. In the future, notifying data 122 // enabled changed with APN types bitmask 123 private final RegistrantList mOverallDataEnabledOverrideChangedRegistrants = 124 new RegistrantList(); 125 126 private final LocalLog mSettingChangeLocalLog = new LocalLog(50); 127 128 private DataEnabledOverride mDataEnabledOverride; 129 130 private TelephonyManager mTelephonyManager; 131 132 // for msim, user data enabled setting depends on subId. 133 private final SubscriptionManager.OnSubscriptionsChangedListener 134 mOnSubscriptionsChangeListener = 135 new SubscriptionManager.OnSubscriptionsChangedListener() { 136 @Override 137 public void onSubscriptionsChanged() { 138 synchronized (this) { 139 if (mSubId != mPhone.getSubId()) { 140 log("onSubscriptionsChanged subId: " + mSubId + " to: " 141 + mPhone.getSubId()); 142 mSubId = mPhone.getSubId(); 143 mDataEnabledOverride = getDataEnabledOverride(); 144 updatePhoneStateListener(); 145 updateDataEnabledAndNotify(REASON_USER_DATA_ENABLED); 146 mPhone.notifyUserMobileDataStateChanged(isUserDataEnabled()); 147 } 148 } 149 } 150 }; 151 updatePhoneStateListener()152 private void updatePhoneStateListener() { 153 mTelephonyManager.listen(mPhoneStateListener, LISTEN_NONE); 154 if (SubscriptionManager.isUsableSubscriptionId(mSubId)) { 155 mTelephonyManager = mTelephonyManager.createForSubscriptionId(mSubId); 156 } 157 mTelephonyManager.listen(mPhoneStateListener, LISTEN_CALL_STATE); 158 } 159 160 private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() { 161 @Override 162 public void onCallStateChanged(@CallState int state, String phoneNumber) { 163 updateDataEnabledAndNotify(REASON_OVERRIDE_CONDITION_CHANGED); 164 } 165 }; 166 167 @Override toString()168 public String toString() { 169 return "[mInternalDataEnabled=" + mInternalDataEnabled 170 + ", isUserDataEnabled=" + isUserDataEnabled() 171 + ", isProvisioningDataEnabled=" + isProvisioningDataEnabled() 172 + ", mPolicyDataEnabled=" + mPolicyDataEnabled 173 + ", mCarrierDataEnabled=" + mCarrierDataEnabled 174 + ", mIsDataEnabled=" + mIsDataEnabled 175 + ", " + mDataEnabledOverride 176 + "]"; 177 } 178 DataEnabledSettings(Phone phone)179 public DataEnabledSettings(Phone phone) { 180 mPhone = phone; 181 mResolver = mPhone.getContext().getContentResolver(); 182 SubscriptionManager subscriptionManager = (SubscriptionManager) mPhone.getContext() 183 .getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE); 184 subscriptionManager.addOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener); 185 mTelephonyManager = (TelephonyManager) mPhone.getContext() 186 .getSystemService(Context.TELEPHONY_SERVICE); 187 mDataEnabledOverride = getDataEnabledOverride(); 188 updateDataEnabled(); 189 } 190 getDataEnabledOverride()191 private DataEnabledOverride getDataEnabledOverride() { 192 return new DataEnabledOverride(SubscriptionController.getInstance() 193 .getDataEnabledOverrideRules(mPhone.getSubId())); 194 } 195 setInternalDataEnabled(boolean enabled)196 public synchronized void setInternalDataEnabled(boolean enabled) { 197 if (mInternalDataEnabled != enabled) { 198 localLog("InternalDataEnabled", enabled); 199 mInternalDataEnabled = enabled; 200 updateDataEnabledAndNotify(REASON_INTERNAL_DATA_ENABLED); 201 } 202 } isInternalDataEnabled()203 public synchronized boolean isInternalDataEnabled() { 204 return mInternalDataEnabled; 205 } 206 setUserDataEnabled(boolean enabled)207 public synchronized void setUserDataEnabled(boolean enabled) { 208 // By default the change should propagate to the group. 209 setUserDataEnabled(enabled, true); 210 } 211 212 /** 213 * @param notifyMultiSimSettingController if setUserDataEnabled is already from propagating 214 * from MultiSimSettingController, don't notify MultiSimSettingController again. 215 * For example, if sub1 and sub2 are in the same group and user enables data for sub 216 * 1, sub 2 will also be enabled but with propagateToGroup = false. 217 */ setUserDataEnabled(boolean enabled, boolean notifyMultiSimSettingController)218 public synchronized void setUserDataEnabled(boolean enabled, 219 boolean notifyMultiSimSettingController) { 220 // Can't disable data for stand alone opportunistic subscription. 221 if (isStandAloneOpportunistic(mPhone.getSubId(), mPhone.getContext()) && !enabled) return; 222 223 boolean changed = GlobalSettingsHelper.setInt(mPhone.getContext(), 224 Settings.Global.MOBILE_DATA, mPhone.getSubId(), (enabled ? 1 : 0)); 225 if (changed) { 226 localLog("UserDataEnabled", enabled); 227 mPhone.notifyUserMobileDataStateChanged(enabled); 228 updateDataEnabledAndNotify(REASON_USER_DATA_ENABLED); 229 if (notifyMultiSimSettingController) { 230 MultiSimSettingController.getInstance().notifyUserDataEnabled( 231 mPhone.getSubId(), enabled); 232 } 233 } 234 } 235 isUserDataEnabled()236 public synchronized boolean isUserDataEnabled() { 237 // User data should always be true for opportunistic subscription. 238 if (isStandAloneOpportunistic(mPhone.getSubId(), mPhone.getContext())) return true; 239 240 boolean defaultVal = TelephonyProperties.mobile_data().orElse(true); 241 242 return GlobalSettingsHelper.getBoolean(mPhone.getContext(), 243 Settings.Global.MOBILE_DATA, mPhone.getSubId(), defaultVal); 244 } 245 246 /** 247 * Set whether always allowing MMS data connection. 248 * 249 * @param alwaysAllow {@code true} if MMS data is always allowed. 250 * 251 * @return {@code false} if the setting is changed. 252 */ setAlwaysAllowMmsData(boolean alwaysAllow)253 public synchronized boolean setAlwaysAllowMmsData(boolean alwaysAllow) { 254 localLog("setAlwaysAllowMmsData", alwaysAllow); 255 mDataEnabledOverride.setAlwaysAllowMms(alwaysAllow); 256 boolean changed = SubscriptionController.getInstance() 257 .setDataEnabledOverrideRules(mPhone.getSubId(), mDataEnabledOverride.getRules()); 258 if (changed) { 259 updateDataEnabledAndNotify(REASON_OVERRIDE_RULE_CHANGED); 260 notifyDataEnabledOverrideChanged(); 261 } 262 263 return changed; 264 } 265 266 /** 267 * Set allowing mobile data during voice call. This is used for allowing data on the non-default 268 * data SIM. When a voice call is placed on the non-default data SIM on DSDS devices, users will 269 * not be able to use mobile data. By calling this API, data will be temporarily enabled on the 270 * non-default data SIM during the life cycle of the voice call. 271 * 272 * @param allow {@code true} if allowing using data during voice call, {@code false} if 273 * disallowed 274 * 275 * @return {@code true} if operation is successful. otherwise {@code false}. 276 */ setAllowDataDuringVoiceCall(boolean allow)277 public synchronized boolean setAllowDataDuringVoiceCall(boolean allow) { 278 localLog("setAllowDataDuringVoiceCall", allow); 279 if (allow == isDataAllowedInVoiceCall()) { 280 return true; 281 } 282 mDataEnabledOverride.setDataAllowedInVoiceCall(allow); 283 284 boolean changed = SubscriptionController.getInstance() 285 .setDataEnabledOverrideRules(mPhone.getSubId(), mDataEnabledOverride.getRules()); 286 if (changed) { 287 updateDataEnabledAndNotify(REASON_OVERRIDE_RULE_CHANGED); 288 notifyDataEnabledOverrideChanged(); 289 } 290 291 return changed; 292 } 293 294 /** 295 * Check if data is allowed during voice call. 296 * 297 * @return {@code true} if data is allowed during voice call. 298 */ isDataAllowedInVoiceCall()299 public synchronized boolean isDataAllowedInVoiceCall() { 300 return mDataEnabledOverride.isDataAllowedInVoiceCall(); 301 } 302 setPolicyDataEnabled(boolean enabled)303 public synchronized void setPolicyDataEnabled(boolean enabled) { 304 if (mPolicyDataEnabled != enabled) { 305 localLog("PolicyDataEnabled", enabled); 306 mPolicyDataEnabled = enabled; 307 updateDataEnabledAndNotify(REASON_POLICY_DATA_ENABLED); 308 } 309 } 310 isPolicyDataEnabled()311 public synchronized boolean isPolicyDataEnabled() { 312 return mPolicyDataEnabled; 313 } 314 setCarrierDataEnabled(boolean enabled)315 public synchronized void setCarrierDataEnabled(boolean enabled) { 316 if (mCarrierDataEnabled != enabled) { 317 localLog("CarrierDataEnabled", enabled); 318 mCarrierDataEnabled = enabled; 319 updateDataEnabledAndNotify(REASON_DATA_ENABLED_BY_CARRIER); 320 } 321 } 322 isCarrierDataEnabled()323 public synchronized boolean isCarrierDataEnabled() { 324 return mCarrierDataEnabled; 325 } 326 updateProvisionedChanged()327 public synchronized void updateProvisionedChanged() { 328 updateDataEnabledAndNotify(REASON_PROVISIONED_CHANGED); 329 } 330 updateProvisioningDataEnabled()331 public synchronized void updateProvisioningDataEnabled() { 332 updateDataEnabledAndNotify(REASON_PROVISIONING_DATA_ENABLED_CHANGED); 333 } 334 isDataEnabled()335 public synchronized boolean isDataEnabled() { 336 return mIsDataEnabled; 337 } 338 updateDataEnabledAndNotify(int reason)339 private synchronized void updateDataEnabledAndNotify(int reason) { 340 boolean prevDataEnabled = mIsDataEnabled; 341 342 updateDataEnabled(); 343 344 if (prevDataEnabled != mIsDataEnabled) { 345 notifyDataEnabledChanged(!prevDataEnabled, reason); 346 } 347 } 348 updateDataEnabled()349 private synchronized void updateDataEnabled() { 350 if (isProvisioning()) { 351 mIsDataEnabled = isProvisioningDataEnabled(); 352 } else { 353 mIsDataEnabled = mInternalDataEnabled && (isUserDataEnabled() || mDataEnabledOverride 354 .shouldOverrideDataEnabledSettings(mPhone, ApnSetting.TYPE_ALL)) 355 && mPolicyDataEnabled && mCarrierDataEnabled; 356 } 357 } 358 isProvisioning()359 public boolean isProvisioning() { 360 return Settings.Global.getInt(mResolver, Settings.Global.DEVICE_PROVISIONED, 0) == 0; 361 } 362 /** 363 * In provisioning, we might want to have enable mobile data during provisioning. It depends 364 * on value of Settings.Global.DEVICE_PROVISIONING_MOBILE_DATA_ENABLED which is set by 365 * setupwizard. It only matters if it's in provisioning stage. 366 * @return whether we are enabling userData during provisioning stage. 367 */ isProvisioningDataEnabled()368 public boolean isProvisioningDataEnabled() { 369 final String prov_property = SystemProperties.get("ro.com.android.prov_mobiledata", 370 "false"); 371 boolean retVal = "true".equalsIgnoreCase(prov_property); 372 373 final int prov_mobile_data = Settings.Global.getInt(mResolver, 374 Settings.Global.DEVICE_PROVISIONING_MOBILE_DATA_ENABLED, 375 retVal ? 1 : 0); 376 retVal = prov_mobile_data != 0; 377 log("getDataEnabled during provisioning retVal=" + retVal + " - (" + prov_property 378 + ", " + prov_mobile_data + ")"); 379 380 return retVal; 381 } 382 setDataRoamingEnabled(boolean enabled)383 public synchronized void setDataRoamingEnabled(boolean enabled) { 384 // will trigger handleDataOnRoamingChange() through observer 385 boolean changed = GlobalSettingsHelper.setBoolean(mPhone.getContext(), 386 Settings.Global.DATA_ROAMING, mPhone.getSubId(), enabled); 387 388 if (changed) { 389 localLog("setDataRoamingEnabled", enabled); 390 MultiSimSettingController.getInstance().notifyRoamingDataEnabled(mPhone.getSubId(), 391 enabled); 392 } 393 } 394 395 /** 396 * Return current {@link android.provider.Settings.Global#DATA_ROAMING} value. 397 */ getDataRoamingEnabled()398 public synchronized boolean getDataRoamingEnabled() { 399 return GlobalSettingsHelper.getBoolean(mPhone.getContext(), 400 Settings.Global.DATA_ROAMING, mPhone.getSubId(), getDefaultDataRoamingEnabled()); 401 } 402 403 /** 404 * get default values for {@link Settings.Global#DATA_ROAMING} 405 * return {@code true} if either 406 * {@link CarrierConfigManager#KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL} or 407 * system property ro.com.android.dataroaming is set to true. otherwise return {@code false} 408 */ getDefaultDataRoamingEnabled()409 public synchronized boolean getDefaultDataRoamingEnabled() { 410 final CarrierConfigManager configMgr = (CarrierConfigManager) 411 mPhone.getContext().getSystemService(Context.CARRIER_CONFIG_SERVICE); 412 boolean isDataRoamingEnabled = "true".equalsIgnoreCase(SystemProperties.get( 413 "ro.com.android.dataroaming", "false")); 414 isDataRoamingEnabled |= configMgr.getConfigForSubId(mPhone.getSubId()).getBoolean( 415 CarrierConfigManager.KEY_CARRIER_DEFAULT_DATA_ROAMING_ENABLED_BOOL); 416 return isDataRoamingEnabled; 417 } 418 notifyDataEnabledChanged(boolean enabled, int reason)419 private void notifyDataEnabledChanged(boolean enabled, int reason) { 420 mOverallDataEnabledChangedRegistrants.notifyResult(new Pair<>(enabled, reason)); 421 } 422 registerForDataEnabledChanged(Handler h, int what, Object obj)423 public void registerForDataEnabledChanged(Handler h, int what, Object obj) { 424 mOverallDataEnabledChangedRegistrants.addUnique(h, what, obj); 425 notifyDataEnabledChanged(isDataEnabled(), REASON_REGISTERED); 426 } 427 unregisterForDataEnabledChanged(Handler h)428 public void unregisterForDataEnabledChanged(Handler h) { 429 mOverallDataEnabledChangedRegistrants.remove(h); 430 } 431 notifyDataEnabledOverrideChanged()432 private void notifyDataEnabledOverrideChanged() { 433 mOverallDataEnabledOverrideChangedRegistrants.notifyRegistrants(); 434 } 435 436 /** 437 * Register for data enabled override changed event. 438 * 439 * @param h The handler 440 * @param what The event 441 */ registerForDataEnabledOverrideChanged(Handler h, int what)442 public void registerForDataEnabledOverrideChanged(Handler h, int what) { 443 mOverallDataEnabledOverrideChangedRegistrants.addUnique(h, what, null); 444 notifyDataEnabledOverrideChanged(); 445 } 446 447 /** 448 * Unregistered for data enabled override changed event. 449 * 450 * @param h The handler 451 */ unregisterForDataEnabledOverrideChanged(Handler h)452 public void unregisterForDataEnabledOverrideChanged(Handler h) { 453 mOverallDataEnabledOverrideChangedRegistrants.remove(h); 454 } 455 isStandAloneOpportunistic(int subId, Context context)456 private static boolean isStandAloneOpportunistic(int subId, Context context) { 457 SubscriptionInfo info = SubscriptionController.getInstance().getActiveSubscriptionInfo( 458 subId, context.getOpPackageName(), null); 459 return (info != null) && info.isOpportunistic() && info.getGroupUuid() == null; 460 } 461 isDataEnabled(int apnType)462 public synchronized boolean isDataEnabled(int apnType) { 463 if (isProvisioning()) { 464 return isProvisioningDataEnabled(); 465 } else { 466 boolean userDataEnabled = isUserDataEnabled(); 467 // Check if we should temporarily enable data in certain conditions. 468 boolean isDataEnabledOverridden = mDataEnabledOverride 469 .shouldOverrideDataEnabledSettings(mPhone, apnType); 470 471 return (mInternalDataEnabled && mPolicyDataEnabled && mCarrierDataEnabled 472 && (userDataEnabled || isDataEnabledOverridden)); 473 } 474 } 475 log(String s)476 private void log(String s) { 477 Rlog.d(LOG_TAG, "[" + mPhone.getPhoneId() + "]" + s); 478 } 479 localLog(String name, boolean value)480 private void localLog(String name, boolean value) { 481 mSettingChangeLocalLog.log(name + " change to " + value); 482 } 483 dump(FileDescriptor fd, PrintWriter pw, String[] args)484 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 485 pw.println(" DataEnabledSettings="); 486 mSettingChangeLocalLog.dump(fd, pw, args); 487 } 488 } 489