1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.provider; 18 19 import android.annotation.SdkConstant; 20 import android.annotation.SdkConstant.SdkConstantType; 21 import android.annotation.SystemApi; 22 import android.app.ActivityThread; 23 import android.app.AppOpsManager; 24 import android.app.Application; 25 import android.app.SearchManager; 26 import android.app.WallpaperManager; 27 import android.content.ComponentName; 28 import android.content.ContentResolver; 29 import android.content.ContentValues; 30 import android.content.Context; 31 import android.content.IContentProvider; 32 import android.content.Intent; 33 import android.content.pm.ActivityInfo; 34 import android.content.pm.PackageManager; 35 import android.content.pm.ResolveInfo; 36 import android.content.res.Configuration; 37 import android.content.res.Resources; 38 import android.database.Cursor; 39 import android.database.SQLException; 40 import android.location.LocationManager; 41 import android.net.ConnectivityManager; 42 import android.net.Uri; 43 import android.net.wifi.WifiManager; 44 import android.os.BatteryManager; 45 import android.os.Binder; 46 import android.os.Bundle; 47 import android.os.DropBoxManager; 48 import android.os.IBinder; 49 import android.os.Process; 50 import android.os.RemoteException; 51 import android.os.ServiceManager; 52 import android.os.SystemProperties; 53 import android.os.UserHandle; 54 import android.os.Build.VERSION_CODES; 55 import android.speech.tts.TextToSpeech; 56 import android.text.TextUtils; 57 import android.util.AndroidException; 58 import android.util.ArrayMap; 59 import android.util.ArraySet; 60 import android.util.Log; 61 62 import com.android.internal.util.ArrayUtils; 63 import com.android.internal.widget.ILockSettings; 64 65 import java.net.URISyntaxException; 66 import java.text.SimpleDateFormat; 67 import java.util.HashMap; 68 import java.util.HashSet; 69 import java.util.Locale; 70 import java.util.Map; 71 import java.util.Set; 72 73 /** 74 * The Settings provider contains global system-level device preferences. 75 */ 76 public final class Settings { 77 78 // Intent actions for Settings 79 80 /** 81 * Activity Action: Show system settings. 82 * <p> 83 * Input: Nothing. 84 * <p> 85 * Output: Nothing. 86 */ 87 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 88 public static final String ACTION_SETTINGS = "android.settings.SETTINGS"; 89 90 /** 91 * Activity Action: Show settings to allow configuration of APNs. 92 * <p> 93 * Input: Nothing. 94 * <p> 95 * Output: Nothing. 96 */ 97 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 98 public static final String ACTION_APN_SETTINGS = "android.settings.APN_SETTINGS"; 99 100 /** 101 * Activity Action: Show settings to allow configuration of current location 102 * sources. 103 * <p> 104 * In some cases, a matching Activity may not exist, so ensure you 105 * safeguard against this. 106 * <p> 107 * Input: Nothing. 108 * <p> 109 * Output: Nothing. 110 */ 111 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 112 public static final String ACTION_LOCATION_SOURCE_SETTINGS = 113 "android.settings.LOCATION_SOURCE_SETTINGS"; 114 115 /** 116 * Activity Action: Show settings to allow configuration of wireless controls 117 * such as Wi-Fi, Bluetooth and Mobile networks. 118 * <p> 119 * In some cases, a matching Activity may not exist, so ensure you 120 * safeguard against this. 121 * <p> 122 * Input: Nothing. 123 * <p> 124 * Output: Nothing. 125 */ 126 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 127 public static final String ACTION_WIRELESS_SETTINGS = 128 "android.settings.WIRELESS_SETTINGS"; 129 130 /** 131 * Activity Action: Show settings to allow entering/exiting airplane mode. 132 * <p> 133 * In some cases, a matching Activity may not exist, so ensure you 134 * safeguard against this. 135 * <p> 136 * Input: Nothing. 137 * <p> 138 * Output: Nothing. 139 */ 140 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 141 public static final String ACTION_AIRPLANE_MODE_SETTINGS = 142 "android.settings.AIRPLANE_MODE_SETTINGS"; 143 144 /** 145 * Activity Action: Modify Airplane mode settings using a voice command. 146 * <p> 147 * In some cases, a matching Activity may not exist, so ensure you safeguard against this. 148 * <p> 149 * This intent MUST be started using 150 * {@link android.service.voice.VoiceInteractionSession#startVoiceActivity 151 * startVoiceActivity}. 152 * <p> 153 * Note: The activity implementing this intent MUST verify that 154 * {@link android.app.Activity#isVoiceInteraction isVoiceInteraction} returns true before 155 * modifying the setting. 156 * <p> 157 * Input: To tell which state airplane mode should be set to, add the 158 * {@link #EXTRA_AIRPLANE_MODE_ENABLED} extra to this Intent with the state specified. 159 * If the extra is not included, no changes will be made. 160 * <p> 161 * Output: Nothing. 162 */ 163 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 164 public static final String ACTION_VOICE_CONTROL_AIRPLANE_MODE = 165 "android.settings.VOICE_CONTROL_AIRPLANE_MODE"; 166 167 /** 168 * Activity Action: Show settings for accessibility modules. 169 * <p> 170 * In some cases, a matching Activity may not exist, so ensure you 171 * safeguard against this. 172 * <p> 173 * Input: Nothing. 174 * <p> 175 * Output: Nothing. 176 */ 177 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 178 public static final String ACTION_ACCESSIBILITY_SETTINGS = 179 "android.settings.ACCESSIBILITY_SETTINGS"; 180 181 /** 182 * Activity Action: Show settings to control access to usage information. 183 * <p> 184 * In some cases, a matching Activity may not exist, so ensure you 185 * safeguard against this. 186 * <p> 187 * Input: Nothing. 188 * <p> 189 * Output: Nothing. 190 */ 191 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 192 public static final String ACTION_USAGE_ACCESS_SETTINGS = 193 "android.settings.USAGE_ACCESS_SETTINGS"; 194 195 /** 196 * Activity Category: Show application settings related to usage access. 197 * <p> 198 * An activity that provides a user interface for adjusting usage access related 199 * preferences for its containing application. Optional but recommended for apps that 200 * use {@link android.Manifest.permission#PACKAGE_USAGE_STATS}. 201 * <p> 202 * The activity may define meta-data to describe what usage access is 203 * used for within their app with {@link #METADATA_USAGE_ACCESS_REASON}, which 204 * will be displayed in Settings. 205 * <p> 206 * Input: Nothing. 207 * <p> 208 * Output: Nothing. 209 */ 210 @SdkConstant(SdkConstantType.INTENT_CATEGORY) 211 public static final String INTENT_CATEGORY_USAGE_ACCESS_CONFIG = 212 "android.intent.category.USAGE_ACCESS_CONFIG"; 213 214 /** 215 * Metadata key: Reason for needing usage access. 216 * <p> 217 * A key for metadata attached to an activity that receives action 218 * {@link #INTENT_CATEGORY_USAGE_ACCESS_CONFIG}, shown to the 219 * user as description of how the app uses usage access. 220 * <p> 221 */ 222 public static final String METADATA_USAGE_ACCESS_REASON = 223 "android.settings.metadata.USAGE_ACCESS_REASON"; 224 225 /** 226 * Activity Action: Show settings to allow configuration of security and 227 * location privacy. 228 * <p> 229 * In some cases, a matching Activity may not exist, so ensure you 230 * safeguard against this. 231 * <p> 232 * Input: Nothing. 233 * <p> 234 * Output: Nothing. 235 */ 236 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 237 public static final String ACTION_SECURITY_SETTINGS = 238 "android.settings.SECURITY_SETTINGS"; 239 240 /** 241 * Activity Action: Show trusted credentials settings, opening to the user tab, 242 * to allow management of installed credentials. 243 * <p> 244 * In some cases, a matching Activity may not exist, so ensure you 245 * safeguard against this. 246 * <p> 247 * Input: Nothing. 248 * <p> 249 * Output: Nothing. 250 * @hide 251 */ 252 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 253 public static final String ACTION_TRUSTED_CREDENTIALS_USER = 254 "com.android.settings.TRUSTED_CREDENTIALS_USER"; 255 256 /** 257 * Activity Action: Show dialog explaining that an installed CA cert may enable 258 * monitoring of encrypted network traffic. 259 * <p> 260 * In some cases, a matching Activity may not exist, so ensure you 261 * safeguard against this. 262 * <p> 263 * Input: Nothing. 264 * <p> 265 * Output: Nothing. 266 * @hide 267 */ 268 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 269 public static final String ACTION_MONITORING_CERT_INFO = 270 "com.android.settings.MONITORING_CERT_INFO"; 271 272 /** 273 * Activity Action: Show settings to allow configuration of privacy options. 274 * <p> 275 * In some cases, a matching Activity may not exist, so ensure you 276 * safeguard against this. 277 * <p> 278 * Input: Nothing. 279 * <p> 280 * Output: Nothing. 281 */ 282 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 283 public static final String ACTION_PRIVACY_SETTINGS = 284 "android.settings.PRIVACY_SETTINGS"; 285 286 /** 287 * Activity Action: Show settings to allow configuration of Wi-Fi. 288 * <p> 289 * In some cases, a matching Activity may not exist, so ensure you 290 * safeguard against this. 291 * <p> 292 * Input: Nothing. 293 * <p> 294 * Output: Nothing. 295 296 */ 297 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 298 public static final String ACTION_WIFI_SETTINGS = 299 "android.settings.WIFI_SETTINGS"; 300 301 /** 302 * Activity Action: Show settings to allow configuration of a static IP 303 * address for Wi-Fi. 304 * <p> 305 * In some cases, a matching Activity may not exist, so ensure you safeguard 306 * against this. 307 * <p> 308 * Input: Nothing. 309 * <p> 310 * Output: Nothing. 311 */ 312 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 313 public static final String ACTION_WIFI_IP_SETTINGS = 314 "android.settings.WIFI_IP_SETTINGS"; 315 316 /** 317 * Activity Action: Show settings to allow configuration of Bluetooth. 318 * <p> 319 * In some cases, a matching Activity may not exist, so ensure you 320 * safeguard against this. 321 * <p> 322 * Input: Nothing. 323 * <p> 324 * Output: Nothing. 325 */ 326 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 327 public static final String ACTION_BLUETOOTH_SETTINGS = 328 "android.settings.BLUETOOTH_SETTINGS"; 329 330 /** 331 * Activity Action: Show settings to allow configuration of cast endpoints. 332 * <p> 333 * In some cases, a matching Activity may not exist, so ensure you 334 * safeguard against this. 335 * <p> 336 * Input: Nothing. 337 * <p> 338 * Output: Nothing. 339 */ 340 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 341 public static final String ACTION_CAST_SETTINGS = 342 "android.settings.CAST_SETTINGS"; 343 344 /** 345 * Activity Action: Show settings to allow configuration of date and time. 346 * <p> 347 * In some cases, a matching Activity may not exist, so ensure you 348 * safeguard against this. 349 * <p> 350 * Input: Nothing. 351 * <p> 352 * Output: Nothing. 353 */ 354 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 355 public static final String ACTION_DATE_SETTINGS = 356 "android.settings.DATE_SETTINGS"; 357 358 /** 359 * Activity Action: Show settings to allow configuration of sound and volume. 360 * <p> 361 * In some cases, a matching Activity may not exist, so ensure you 362 * safeguard against this. 363 * <p> 364 * Input: Nothing. 365 * <p> 366 * Output: Nothing. 367 */ 368 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 369 public static final String ACTION_SOUND_SETTINGS = 370 "android.settings.SOUND_SETTINGS"; 371 372 /** 373 * Activity Action: Show settings to allow configuration of display. 374 * <p> 375 * In some cases, a matching Activity may not exist, so ensure you 376 * safeguard against this. 377 * <p> 378 * Input: Nothing. 379 * <p> 380 * Output: Nothing. 381 */ 382 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 383 public static final String ACTION_DISPLAY_SETTINGS = 384 "android.settings.DISPLAY_SETTINGS"; 385 386 /** 387 * Activity Action: Show settings to allow configuration of locale. 388 * <p> 389 * In some cases, a matching Activity may not exist, so ensure you 390 * safeguard against this. 391 * <p> 392 * Input: Nothing. 393 * <p> 394 * Output: Nothing. 395 */ 396 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 397 public static final String ACTION_LOCALE_SETTINGS = 398 "android.settings.LOCALE_SETTINGS"; 399 400 /** 401 * Activity Action: Show settings to configure input methods, in particular 402 * allowing the user to enable input methods. 403 * <p> 404 * In some cases, a matching Activity may not exist, so ensure you 405 * safeguard against this. 406 * <p> 407 * Input: Nothing. 408 * <p> 409 * Output: Nothing. 410 */ 411 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 412 public static final String ACTION_VOICE_INPUT_SETTINGS = 413 "android.settings.VOICE_INPUT_SETTINGS"; 414 415 /** 416 * Activity Action: Show settings to configure input methods, in particular 417 * allowing the user to enable input methods. 418 * <p> 419 * In some cases, a matching Activity may not exist, so ensure you 420 * safeguard against this. 421 * <p> 422 * Input: Nothing. 423 * <p> 424 * Output: Nothing. 425 */ 426 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 427 public static final String ACTION_INPUT_METHOD_SETTINGS = 428 "android.settings.INPUT_METHOD_SETTINGS"; 429 430 /** 431 * Activity Action: Show settings to enable/disable input method subtypes. 432 * <p> 433 * In some cases, a matching Activity may not exist, so ensure you 434 * safeguard against this. 435 * <p> 436 * To tell which input method's subtypes are displayed in the settings, add 437 * {@link #EXTRA_INPUT_METHOD_ID} extra to this Intent with the input method id. 438 * If there is no extra in this Intent, subtypes from all installed input methods 439 * will be displayed in the settings. 440 * 441 * @see android.view.inputmethod.InputMethodInfo#getId 442 * <p> 443 * Input: Nothing. 444 * <p> 445 * Output: Nothing. 446 */ 447 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 448 public static final String ACTION_INPUT_METHOD_SUBTYPE_SETTINGS = 449 "android.settings.INPUT_METHOD_SUBTYPE_SETTINGS"; 450 451 /** 452 * Activity Action: Show a dialog to select input method. 453 * <p> 454 * In some cases, a matching Activity may not exist, so ensure you 455 * safeguard against this. 456 * <p> 457 * Input: Nothing. 458 * <p> 459 * Output: Nothing. 460 * @hide 461 */ 462 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 463 public static final String ACTION_SHOW_INPUT_METHOD_PICKER = 464 "android.settings.SHOW_INPUT_METHOD_PICKER"; 465 466 /** 467 * Activity Action: Show settings to manage the user input dictionary. 468 * <p> 469 * Starting with {@link android.os.Build.VERSION_CODES#KITKAT}, 470 * it is guaranteed there will always be an appropriate implementation for this Intent action. 471 * In prior releases of the platform this was optional, so ensure you safeguard against it. 472 * <p> 473 * Input: Nothing. 474 * <p> 475 * Output: Nothing. 476 */ 477 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 478 public static final String ACTION_USER_DICTIONARY_SETTINGS = 479 "android.settings.USER_DICTIONARY_SETTINGS"; 480 481 /** 482 * Activity Action: Adds a word to the user dictionary. 483 * <p> 484 * In some cases, a matching Activity may not exist, so ensure you 485 * safeguard against this. 486 * <p> 487 * Input: An extra with key <code>word</code> that contains the word 488 * that should be added to the dictionary. 489 * <p> 490 * Output: Nothing. 491 * 492 * @hide 493 */ 494 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 495 public static final String ACTION_USER_DICTIONARY_INSERT = 496 "com.android.settings.USER_DICTIONARY_INSERT"; 497 498 /** 499 * Activity Action: Show settings to allow configuration of application-related settings. 500 * <p> 501 * In some cases, a matching Activity may not exist, so ensure you 502 * safeguard against this. 503 * <p> 504 * Input: Nothing. 505 * <p> 506 * Output: Nothing. 507 */ 508 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 509 public static final String ACTION_APPLICATION_SETTINGS = 510 "android.settings.APPLICATION_SETTINGS"; 511 512 /** 513 * Activity Action: Show settings to allow configuration of application 514 * development-related settings. As of 515 * {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} this action is 516 * a required part of the platform. 517 * <p> 518 * Input: Nothing. 519 * <p> 520 * Output: Nothing. 521 */ 522 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 523 public static final String ACTION_APPLICATION_DEVELOPMENT_SETTINGS = 524 "android.settings.APPLICATION_DEVELOPMENT_SETTINGS"; 525 526 /** 527 * Activity Action: Show settings to allow configuration of quick launch shortcuts. 528 * <p> 529 * In some cases, a matching Activity may not exist, so ensure you 530 * safeguard against this. 531 * <p> 532 * Input: Nothing. 533 * <p> 534 * Output: Nothing. 535 */ 536 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 537 public static final String ACTION_QUICK_LAUNCH_SETTINGS = 538 "android.settings.QUICK_LAUNCH_SETTINGS"; 539 540 /** 541 * Activity Action: Show settings to manage installed applications. 542 * <p> 543 * In some cases, a matching Activity may not exist, so ensure you 544 * safeguard against this. 545 * <p> 546 * Input: Nothing. 547 * <p> 548 * Output: Nothing. 549 */ 550 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 551 public static final String ACTION_MANAGE_APPLICATIONS_SETTINGS = 552 "android.settings.MANAGE_APPLICATIONS_SETTINGS"; 553 554 /** 555 * Activity Action: Show settings to manage all applications. 556 * <p> 557 * In some cases, a matching Activity may not exist, so ensure you 558 * safeguard against this. 559 * <p> 560 * Input: Nothing. 561 * <p> 562 * Output: Nothing. 563 */ 564 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 565 public static final String ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS = 566 "android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS"; 567 568 /** 569 * Activity Action: Show screen for controlling which apps can draw on top of other apps. 570 * <p> 571 * In some cases, a matching Activity may not exist, so ensure you 572 * safeguard against this. 573 * <p> 574 * Input: Optionally, the Intent's data URI can specify the application package name to 575 * directly invoke the management GUI specific to the package name. For example 576 * "package:com.my.app". 577 * <p> 578 * Output: Nothing. 579 */ 580 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 581 public static final String ACTION_MANAGE_OVERLAY_PERMISSION = 582 "android.settings.action.MANAGE_OVERLAY_PERMISSION"; 583 584 /** 585 * Activity Action: Show screen for controlling which apps are allowed to write/modify 586 * system settings. 587 * <p> 588 * In some cases, a matching Activity may not exist, so ensure you 589 * safeguard against this. 590 * <p> 591 * Input: Optionally, the Intent's data URI can specify the application package name to 592 * directly invoke the management GUI specific to the package name. For example 593 * "package:com.my.app". 594 * <p> 595 * Output: Nothing. 596 */ 597 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 598 public static final String ACTION_MANAGE_WRITE_SETTINGS = 599 "android.settings.action.MANAGE_WRITE_SETTINGS"; 600 601 /** 602 * Activity Action: Show screen of details about a particular application. 603 * <p> 604 * In some cases, a matching Activity may not exist, so ensure you 605 * safeguard against this. 606 * <p> 607 * Input: The Intent's data URI specifies the application package name 608 * to be shown, with the "package" scheme. That is "package:com.my.app". 609 * <p> 610 * Output: Nothing. 611 */ 612 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 613 public static final String ACTION_APPLICATION_DETAILS_SETTINGS = 614 "android.settings.APPLICATION_DETAILS_SETTINGS"; 615 616 /** 617 * Activity Action: Show screen for controlling which apps can ignore battery optimizations. 618 * <p> 619 * Input: Nothing. 620 * <p> 621 * Output: Nothing. 622 * <p> 623 * You can use {@link android.os.PowerManager#isIgnoringBatteryOptimizations 624 * PowerManager.isIgnoringBatteryOptimizations()} to determine if an application is 625 * already ignoring optimizations. You can use 626 * {@link #ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS} to ask the user to put you 627 * on this list. 628 */ 629 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 630 public static final String ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS = 631 "android.settings.IGNORE_BATTERY_OPTIMIZATION_SETTINGS"; 632 633 /** 634 * Activity Action: Ask the user to allow an to ignore battery optimizations (that is, 635 * put them on the whitelist of apps shown by 636 * {@link #ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS}). For an app to use this, it also 637 * must hold the {@link android.Manifest.permission#REQUEST_IGNORE_BATTERY_OPTIMIZATIONS} 638 * permission. 639 * <p><b>Note:</b> most applications should <em>not</em> use this; there are many facilities 640 * provided by the platform for applications to operate correctly in the various power 641 * saving mode. This is only for unusual applications that need to deeply control their own 642 * execution, at the potential expense of the user's battery life. Note that these applications 643 * greatly run the risk of showing to the user has how power consumers on their device.</p> 644 * <p> 645 * Input: The Intent's data URI must specify the application package name 646 * to be shown, with the "package" scheme. That is "package:com.my.app". 647 * <p> 648 * Output: Nothing. 649 * <p> 650 * You can use {@link android.os.PowerManager#isIgnoringBatteryOptimizations 651 * PowerManager.isIgnoringBatteryOptimizations()} to determine if an application is 652 * already ignoring optimizations. 653 */ 654 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 655 public static final String ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS = 656 "android.settings.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"; 657 658 /** 659 * @hide 660 * Activity Action: Show the "app ops" settings screen. 661 * <p> 662 * Input: Nothing. 663 * <p> 664 * Output: Nothing. 665 */ 666 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 667 public static final String ACTION_APP_OPS_SETTINGS = 668 "android.settings.APP_OPS_SETTINGS"; 669 670 /** 671 * Activity Action: Show settings for system update functionality. 672 * <p> 673 * In some cases, a matching Activity may not exist, so ensure you 674 * safeguard against this. 675 * <p> 676 * Input: Nothing. 677 * <p> 678 * Output: Nothing. 679 * 680 * @hide 681 */ 682 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 683 public static final String ACTION_SYSTEM_UPDATE_SETTINGS = 684 "android.settings.SYSTEM_UPDATE_SETTINGS"; 685 686 /** 687 * Activity Action: Show settings to allow configuration of sync settings. 688 * <p> 689 * In some cases, a matching Activity may not exist, so ensure you 690 * safeguard against this. 691 * <p> 692 * The account types available to add via the add account button may be restricted by adding an 693 * {@link #EXTRA_AUTHORITIES} extra to this Intent with one or more syncable content provider's 694 * authorities. Only account types which can sync with that content provider will be offered to 695 * the user. 696 * <p> 697 * Input: Nothing. 698 * <p> 699 * Output: Nothing. 700 */ 701 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 702 public static final String ACTION_SYNC_SETTINGS = 703 "android.settings.SYNC_SETTINGS"; 704 705 /** 706 * Activity Action: Show add account screen for creating a new account. 707 * <p> 708 * In some cases, a matching Activity may not exist, so ensure you 709 * safeguard against this. 710 * <p> 711 * The account types available to add may be restricted by adding an {@link #EXTRA_AUTHORITIES} 712 * extra to the Intent with one or more syncable content provider's authorities. Only account 713 * types which can sync with that content provider will be offered to the user. 714 * <p> 715 * Account types can also be filtered by adding an {@link #EXTRA_ACCOUNT_TYPES} extra to the 716 * Intent with one or more account types. 717 * <p> 718 * Input: Nothing. 719 * <p> 720 * Output: Nothing. 721 */ 722 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 723 public static final String ACTION_ADD_ACCOUNT = 724 "android.settings.ADD_ACCOUNT_SETTINGS"; 725 726 /** 727 * Activity Action: Show settings for selecting the network operator. 728 * <p> 729 * In some cases, a matching Activity may not exist, so ensure you 730 * safeguard against this. 731 * <p> 732 * Input: Nothing. 733 * <p> 734 * Output: Nothing. 735 */ 736 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 737 public static final String ACTION_NETWORK_OPERATOR_SETTINGS = 738 "android.settings.NETWORK_OPERATOR_SETTINGS"; 739 740 /** 741 * Activity Action: Show settings for selection of 2G/3G. 742 * <p> 743 * In some cases, a matching Activity may not exist, so ensure you 744 * safeguard against this. 745 * <p> 746 * Input: Nothing. 747 * <p> 748 * Output: Nothing. 749 */ 750 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 751 public static final String ACTION_DATA_ROAMING_SETTINGS = 752 "android.settings.DATA_ROAMING_SETTINGS"; 753 754 /** 755 * Activity Action: Show settings for internal storage. 756 * <p> 757 * In some cases, a matching Activity may not exist, so ensure you 758 * safeguard against this. 759 * <p> 760 * Input: Nothing. 761 * <p> 762 * Output: Nothing. 763 */ 764 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 765 public static final String ACTION_INTERNAL_STORAGE_SETTINGS = 766 "android.settings.INTERNAL_STORAGE_SETTINGS"; 767 /** 768 * Activity Action: Show settings for memory card storage. 769 * <p> 770 * In some cases, a matching Activity may not exist, so ensure you 771 * safeguard against this. 772 * <p> 773 * Input: Nothing. 774 * <p> 775 * Output: Nothing. 776 */ 777 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 778 public static final String ACTION_MEMORY_CARD_SETTINGS = 779 "android.settings.MEMORY_CARD_SETTINGS"; 780 781 /** 782 * Activity Action: Show settings for global search. 783 * <p> 784 * In some cases, a matching Activity may not exist, so ensure you 785 * safeguard against this. 786 * <p> 787 * Input: Nothing. 788 * <p> 789 * Output: Nothing 790 */ 791 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 792 public static final String ACTION_SEARCH_SETTINGS = 793 "android.search.action.SEARCH_SETTINGS"; 794 795 /** 796 * Activity Action: Show general device information settings (serial 797 * number, software version, phone number, etc.). 798 * <p> 799 * In some cases, a matching Activity may not exist, so ensure you 800 * safeguard against this. 801 * <p> 802 * Input: Nothing. 803 * <p> 804 * Output: Nothing 805 */ 806 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 807 public static final String ACTION_DEVICE_INFO_SETTINGS = 808 "android.settings.DEVICE_INFO_SETTINGS"; 809 810 /** 811 * Activity Action: Show NFC settings. 812 * <p> 813 * This shows UI that allows NFC to be turned on or off. 814 * <p> 815 * In some cases, a matching Activity may not exist, so ensure you 816 * safeguard against this. 817 * <p> 818 * Input: Nothing. 819 * <p> 820 * Output: Nothing 821 * @see android.nfc.NfcAdapter#isEnabled() 822 */ 823 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 824 public static final String ACTION_NFC_SETTINGS = "android.settings.NFC_SETTINGS"; 825 826 /** 827 * Activity Action: Show NFC Sharing settings. 828 * <p> 829 * This shows UI that allows NDEF Push (Android Beam) to be turned on or 830 * off. 831 * <p> 832 * In some cases, a matching Activity may not exist, so ensure you 833 * safeguard against this. 834 * <p> 835 * Input: Nothing. 836 * <p> 837 * Output: Nothing 838 * @see android.nfc.NfcAdapter#isNdefPushEnabled() 839 */ 840 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 841 public static final String ACTION_NFCSHARING_SETTINGS = 842 "android.settings.NFCSHARING_SETTINGS"; 843 844 /** 845 * Activity Action: Show NFC Tap & Pay settings 846 * <p> 847 * This shows UI that allows the user to configure Tap&Pay 848 * settings. 849 * <p> 850 * In some cases, a matching Activity may not exist, so ensure you 851 * safeguard against this. 852 * <p> 853 * Input: Nothing. 854 * <p> 855 * Output: Nothing 856 */ 857 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 858 public static final String ACTION_NFC_PAYMENT_SETTINGS = 859 "android.settings.NFC_PAYMENT_SETTINGS"; 860 861 /** 862 * Activity Action: Show Daydream settings. 863 * <p> 864 * In some cases, a matching Activity may not exist, so ensure you 865 * safeguard against this. 866 * <p> 867 * Input: Nothing. 868 * <p> 869 * Output: Nothing. 870 * @see android.service.dreams.DreamService 871 */ 872 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 873 public static final String ACTION_DREAM_SETTINGS = "android.settings.DREAM_SETTINGS"; 874 875 /** 876 * Activity Action: Show Notification listener settings. 877 * <p> 878 * In some cases, a matching Activity may not exist, so ensure you 879 * safeguard against this. 880 * <p> 881 * Input: Nothing. 882 * <p> 883 * Output: Nothing. 884 * @see android.service.notification.NotificationListenerService 885 */ 886 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 887 public static final String ACTION_NOTIFICATION_LISTENER_SETTINGS 888 = "android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"; 889 890 /** 891 * Activity Action: Show Do Not Disturb access settings. 892 * <p> 893 * Users can grant and deny access to Do Not Disturb configuration from here. 894 * See {@link android.app.NotificationManager#isNotificationPolicyAccessGranted()} for more 895 * details. 896 * <p> 897 * Input: Nothing. 898 * <p> 899 * Output: Nothing. 900 */ 901 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 902 public static final String ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS 903 = "android.settings.NOTIFICATION_POLICY_ACCESS_SETTINGS"; 904 905 /** 906 * @hide 907 */ 908 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 909 public static final String ACTION_CONDITION_PROVIDER_SETTINGS 910 = "android.settings.ACTION_CONDITION_PROVIDER_SETTINGS"; 911 912 /** 913 * Activity Action: Show settings for video captioning. 914 * <p> 915 * In some cases, a matching Activity may not exist, so ensure you safeguard 916 * against this. 917 * <p> 918 * Input: Nothing. 919 * <p> 920 * Output: Nothing. 921 */ 922 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 923 public static final String ACTION_CAPTIONING_SETTINGS = "android.settings.CAPTIONING_SETTINGS"; 924 925 /** 926 * Activity Action: Show the top level print settings. 927 * <p> 928 * In some cases, a matching Activity may not exist, so ensure you 929 * safeguard against this. 930 * <p> 931 * Input: Nothing. 932 * <p> 933 * Output: Nothing. 934 */ 935 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 936 public static final String ACTION_PRINT_SETTINGS = 937 "android.settings.ACTION_PRINT_SETTINGS"; 938 939 /** 940 * Activity Action: Show Zen Mode configuration settings. 941 * 942 * @hide 943 */ 944 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 945 public static final String ACTION_ZEN_MODE_SETTINGS = "android.settings.ZEN_MODE_SETTINGS"; 946 947 /** 948 * Activity Action: Show Zen Mode priority configuration settings. 949 * 950 * @hide 951 */ 952 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 953 public static final String ACTION_ZEN_MODE_PRIORITY_SETTINGS 954 = "android.settings.ZEN_MODE_PRIORITY_SETTINGS"; 955 956 /** 957 * Activity Action: Show Zen Mode automation configuration settings. 958 * 959 * @hide 960 */ 961 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 962 public static final String ACTION_ZEN_MODE_AUTOMATION_SETTINGS 963 = "android.settings.ZEN_MODE_AUTOMATION_SETTINGS"; 964 965 /** 966 * Activity Action: Modify do not disturb mode settings. 967 * <p> 968 * In some cases, a matching Activity may not exist, so ensure you safeguard against this. 969 * <p> 970 * This intent MUST be started using 971 * {@link android.service.voice.VoiceInteractionSession#startVoiceActivity 972 * startVoiceActivity}. 973 * <p> 974 * Note: The Activity implementing this intent MUST verify that 975 * {@link android.app.Activity#isVoiceInteraction isVoiceInteraction}. 976 * returns true before modifying the setting. 977 * <p> 978 * Input: The optional {@link #EXTRA_DO_NOT_DISTURB_MODE_MINUTES} extra can be used to indicate 979 * how long the user wishes to avoid interruptions for. The optional 980 * {@link #EXTRA_DO_NOT_DISTURB_MODE_ENABLED} extra can be to indicate if the user is 981 * enabling or disabling do not disturb mode. If either extra is not included, the 982 * user maybe asked to provide the value. 983 * <p> 984 * Output: Nothing. 985 */ 986 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 987 public static final String ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE = 988 "android.settings.VOICE_CONTROL_DO_NOT_DISTURB_MODE"; 989 990 /** 991 * Activity Action: Show Zen Mode schedule rule configuration settings. 992 * 993 * @hide 994 */ 995 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 996 public static final String ACTION_ZEN_MODE_SCHEDULE_RULE_SETTINGS 997 = "android.settings.ZEN_MODE_SCHEDULE_RULE_SETTINGS"; 998 999 /** 1000 * Activity Action: Show Zen Mode event rule configuration settings. 1001 * 1002 * @hide 1003 */ 1004 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1005 public static final String ACTION_ZEN_MODE_EVENT_RULE_SETTINGS 1006 = "android.settings.ZEN_MODE_EVENT_RULE_SETTINGS"; 1007 1008 /** 1009 * Activity Action: Show Zen Mode external rule configuration settings. 1010 * 1011 * @hide 1012 */ 1013 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1014 public static final String ACTION_ZEN_MODE_EXTERNAL_RULE_SETTINGS 1015 = "android.settings.ZEN_MODE_EXTERNAL_RULE_SETTINGS"; 1016 1017 /** 1018 * Activity Action: Show the regulatory information screen for the device. 1019 * <p> 1020 * In some cases, a matching Activity may not exist, so ensure you safeguard 1021 * against this. 1022 * <p> 1023 * Input: Nothing. 1024 * <p> 1025 * Output: Nothing. 1026 */ 1027 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1028 public static final String 1029 ACTION_SHOW_REGULATORY_INFO = "android.settings.SHOW_REGULATORY_INFO"; 1030 1031 /** 1032 * Activity Action: Show Device Name Settings. 1033 * <p> 1034 * In some cases, a matching Activity may not exist, so ensure you safeguard 1035 * against this. 1036 * 1037 * @hide 1038 */ 1039 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1040 public static final String DEVICE_NAME_SETTINGS = "android.settings.DEVICE_NAME"; 1041 1042 /** 1043 * Activity Action: Show pairing settings. 1044 * <p> 1045 * In some cases, a matching Activity may not exist, so ensure you safeguard 1046 * against this. 1047 * 1048 * @hide 1049 */ 1050 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1051 public static final String ACTION_PAIRING_SETTINGS = "android.settings.PAIRING_SETTINGS"; 1052 1053 /** 1054 * Activity Action: Show battery saver settings. 1055 * <p> 1056 * In some cases, a matching Activity may not exist, so ensure you safeguard 1057 * against this. 1058 */ 1059 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1060 public static final String ACTION_BATTERY_SAVER_SETTINGS 1061 = "android.settings.BATTERY_SAVER_SETTINGS"; 1062 1063 /** 1064 * Activity Action: Modify Battery Saver mode setting using a voice command. 1065 * <p> 1066 * In some cases, a matching Activity may not exist, so ensure you safeguard against this. 1067 * <p> 1068 * This intent MUST be started using 1069 * {@link android.service.voice.VoiceInteractionSession#startVoiceActivity 1070 * startVoiceActivity}. 1071 * <p> 1072 * Note: The activity implementing this intent MUST verify that 1073 * {@link android.app.Activity#isVoiceInteraction isVoiceInteraction} returns true before 1074 * modifying the setting. 1075 * <p> 1076 * Input: To tell which state batter saver mode should be set to, add the 1077 * {@link #EXTRA_BATTERY_SAVER_MODE_ENABLED} extra to this Intent with the state specified. 1078 * If the extra is not included, no changes will be made. 1079 * <p> 1080 * Output: Nothing. 1081 */ 1082 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1083 public static final String ACTION_VOICE_CONTROL_BATTERY_SAVER_MODE = 1084 "android.settings.VOICE_CONTROL_BATTERY_SAVER_MODE"; 1085 1086 /** 1087 * Activity Action: Show Home selection settings. If there are multiple activities 1088 * that can satisfy the {@link Intent#CATEGORY_HOME} intent, this screen allows you 1089 * to pick your preferred activity. 1090 */ 1091 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1092 public static final String ACTION_HOME_SETTINGS 1093 = "android.settings.HOME_SETTINGS"; 1094 1095 /** 1096 * Activity Action: Show notification settings. 1097 * 1098 * @hide 1099 */ 1100 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1101 public static final String ACTION_NOTIFICATION_SETTINGS 1102 = "android.settings.NOTIFICATION_SETTINGS"; 1103 1104 /** 1105 * Activity Action: Show notification settings for a single app. 1106 * 1107 * @hide 1108 */ 1109 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1110 public static final String ACTION_APP_NOTIFICATION_SETTINGS 1111 = "android.settings.APP_NOTIFICATION_SETTINGS"; 1112 1113 /** 1114 * Activity Action: Show notification redaction settings. 1115 * 1116 * @hide 1117 */ 1118 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1119 public static final String ACTION_APP_NOTIFICATION_REDACTION 1120 = "android.settings.ACTION_APP_NOTIFICATION_REDACTION"; 1121 1122 /** @hide */ public static final String EXTRA_APP_UID = "app_uid"; 1123 /** @hide */ public static final String EXTRA_APP_PACKAGE = "app_package"; 1124 1125 // End of Intent actions for Settings 1126 1127 /** 1128 * @hide - Private call() method on SettingsProvider to read from 'system' table. 1129 */ 1130 public static final String CALL_METHOD_GET_SYSTEM = "GET_system"; 1131 1132 /** 1133 * @hide - Private call() method on SettingsProvider to read from 'secure' table. 1134 */ 1135 public static final String CALL_METHOD_GET_SECURE = "GET_secure"; 1136 1137 /** 1138 * @hide - Private call() method on SettingsProvider to read from 'global' table. 1139 */ 1140 public static final String CALL_METHOD_GET_GLOBAL = "GET_global"; 1141 1142 /** 1143 * @hide - User handle argument extra to the fast-path call()-based requests 1144 */ 1145 public static final String CALL_METHOD_USER_KEY = "_user"; 1146 1147 /** @hide - Private call() method to write to 'system' table */ 1148 public static final String CALL_METHOD_PUT_SYSTEM = "PUT_system"; 1149 1150 /** @hide - Private call() method to write to 'secure' table */ 1151 public static final String CALL_METHOD_PUT_SECURE = "PUT_secure"; 1152 1153 /** @hide - Private call() method to write to 'global' table */ 1154 public static final String CALL_METHOD_PUT_GLOBAL= "PUT_global"; 1155 1156 /** 1157 * Activity Extra: Limit available options in launched activity based on the given authority. 1158 * <p> 1159 * This can be passed as an extra field in an Activity Intent with one or more syncable content 1160 * provider's authorities as a String[]. This field is used by some intents to alter the 1161 * behavior of the called activity. 1162 * <p> 1163 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types available based 1164 * on the authority given. 1165 */ 1166 public static final String EXTRA_AUTHORITIES = "authorities"; 1167 1168 /** 1169 * Activity Extra: Limit available options in launched activity based on the given account 1170 * types. 1171 * <p> 1172 * This can be passed as an extra field in an Activity Intent with one or more account types 1173 * as a String[]. This field is used by some intents to alter the behavior of the called 1174 * activity. 1175 * <p> 1176 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types to the specified 1177 * list. 1178 */ 1179 public static final String EXTRA_ACCOUNT_TYPES = "account_types"; 1180 1181 public static final String EXTRA_INPUT_METHOD_ID = "input_method_id"; 1182 1183 /** 1184 * Activity Extra: The device identifier to act upon. 1185 * <p> 1186 * This can be passed as an extra field in an Activity Intent with a single 1187 * InputDeviceIdentifier. This field is used by some activities to jump straight into the 1188 * settings for the given device. 1189 * <p> 1190 * Example: The {@link #ACTION_INPUT_METHOD_SETTINGS} intent opens the keyboard layout 1191 * dialog for the given device. 1192 * @hide 1193 */ 1194 public static final String EXTRA_INPUT_DEVICE_IDENTIFIER = "input_device_identifier"; 1195 1196 /** 1197 * Activity Extra: Enable or disable Airplane Mode. 1198 * <p> 1199 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_AIRPLANE_MODE} 1200 * intent as a boolean to indicate if it should be enabled. 1201 */ 1202 public static final String EXTRA_AIRPLANE_MODE_ENABLED = "airplane_mode_enabled"; 1203 1204 /** 1205 * Activity Extra: Enable or disable Battery saver mode. 1206 * <p> 1207 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_BATTERY_SAVER_MODE} 1208 * intent as a boolean to indicate if it should be enabled. 1209 */ 1210 public static final String EXTRA_BATTERY_SAVER_MODE_ENABLED = 1211 "android.settings.extra.battery_saver_mode_enabled"; 1212 1213 /** 1214 * Activity Extra: Enable or disable Do Not Disturb mode. 1215 * <p> 1216 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE} 1217 * intent as a boolean to indicate if it should be enabled. 1218 */ 1219 public static final String EXTRA_DO_NOT_DISTURB_MODE_ENABLED = 1220 "android.settings.extra.do_not_disturb_mode_enabled"; 1221 1222 /** 1223 * Activity Extra: How many minutes to enable do not disturb mode for. 1224 * <p> 1225 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE} 1226 * intent to indicate how long do not disturb mode should be enabled for. 1227 */ 1228 public static final String EXTRA_DO_NOT_DISTURB_MODE_MINUTES = 1229 "android.settings.extra.do_not_disturb_mode_minutes"; 1230 1231 private static final String JID_RESOURCE_PREFIX = "android"; 1232 1233 public static final String AUTHORITY = "settings"; 1234 1235 private static final String TAG = "Settings"; 1236 private static final boolean LOCAL_LOGV = false; 1237 1238 // Lock ensures that when enabling/disabling the master location switch, we don't end up 1239 // with a partial enable/disable state in multi-threaded situations. 1240 private static final Object mLocationSettingsLock = new Object(); 1241 1242 public static class SettingNotFoundException extends AndroidException { SettingNotFoundException(String msg)1243 public SettingNotFoundException(String msg) { 1244 super(msg); 1245 } 1246 } 1247 1248 /** 1249 * Common base for tables of name/value settings. 1250 */ 1251 public static class NameValueTable implements BaseColumns { 1252 public static final String NAME = "name"; 1253 public static final String VALUE = "value"; 1254 putString(ContentResolver resolver, Uri uri, String name, String value)1255 protected static boolean putString(ContentResolver resolver, Uri uri, 1256 String name, String value) { 1257 // The database will take care of replacing duplicates. 1258 try { 1259 ContentValues values = new ContentValues(); 1260 values.put(NAME, name); 1261 values.put(VALUE, value); 1262 resolver.insert(uri, values); 1263 return true; 1264 } catch (SQLException e) { 1265 Log.w(TAG, "Can't set key " + name + " in " + uri, e); 1266 return false; 1267 } 1268 } 1269 getUriFor(Uri uri, String name)1270 public static Uri getUriFor(Uri uri, String name) { 1271 return Uri.withAppendedPath(uri, name); 1272 } 1273 } 1274 1275 // Thread-safe. 1276 private static class NameValueCache { 1277 private final String mVersionSystemProperty; 1278 private final Uri mUri; 1279 1280 private static final String[] SELECT_VALUE = 1281 new String[] { Settings.NameValueTable.VALUE }; 1282 private static final String NAME_EQ_PLACEHOLDER = "name=?"; 1283 1284 // Must synchronize on 'this' to access mValues and mValuesVersion. 1285 private final HashMap<String, String> mValues = new HashMap<String, String>(); 1286 private long mValuesVersion = 0; 1287 1288 // Initially null; set lazily and held forever. Synchronized on 'this'. 1289 private IContentProvider mContentProvider = null; 1290 1291 // The method we'll call (or null, to not use) on the provider 1292 // for the fast path of retrieving settings. 1293 private final String mCallGetCommand; 1294 private final String mCallSetCommand; 1295 NameValueCache(String versionSystemProperty, Uri uri, String getCommand, String setCommand)1296 public NameValueCache(String versionSystemProperty, Uri uri, 1297 String getCommand, String setCommand) { 1298 mVersionSystemProperty = versionSystemProperty; 1299 mUri = uri; 1300 mCallGetCommand = getCommand; 1301 mCallSetCommand = setCommand; 1302 } 1303 lazyGetProvider(ContentResolver cr)1304 private IContentProvider lazyGetProvider(ContentResolver cr) { 1305 IContentProvider cp = null; 1306 synchronized (this) { 1307 cp = mContentProvider; 1308 if (cp == null) { 1309 cp = mContentProvider = cr.acquireProvider(mUri.getAuthority()); 1310 } 1311 } 1312 return cp; 1313 } 1314 putStringForUser(ContentResolver cr, String name, String value, final int userHandle)1315 public boolean putStringForUser(ContentResolver cr, String name, String value, 1316 final int userHandle) { 1317 try { 1318 Bundle arg = new Bundle(); 1319 arg.putString(Settings.NameValueTable.VALUE, value); 1320 arg.putInt(CALL_METHOD_USER_KEY, userHandle); 1321 IContentProvider cp = lazyGetProvider(cr); 1322 cp.call(cr.getPackageName(), mCallSetCommand, name, arg); 1323 } catch (RemoteException e) { 1324 Log.w(TAG, "Can't set key " + name + " in " + mUri, e); 1325 return false; 1326 } 1327 return true; 1328 } 1329 getStringForUser(ContentResolver cr, String name, final int userHandle)1330 public String getStringForUser(ContentResolver cr, String name, final int userHandle) { 1331 final boolean isSelf = (userHandle == UserHandle.myUserId()); 1332 if (isSelf) { 1333 long newValuesVersion = SystemProperties.getLong(mVersionSystemProperty, 0); 1334 1335 // Our own user's settings data uses a client-side cache 1336 synchronized (this) { 1337 if (mValuesVersion != newValuesVersion) { 1338 if (LOCAL_LOGV || false) { 1339 Log.v(TAG, "invalidate [" + mUri.getLastPathSegment() + "]: current " 1340 + newValuesVersion + " != cached " + mValuesVersion); 1341 } 1342 1343 mValues.clear(); 1344 mValuesVersion = newValuesVersion; 1345 } 1346 1347 if (mValues.containsKey(name)) { 1348 return mValues.get(name); // Could be null, that's OK -- negative caching 1349 } 1350 } 1351 } else { 1352 if (LOCAL_LOGV) Log.v(TAG, "get setting for user " + userHandle 1353 + " by user " + UserHandle.myUserId() + " so skipping cache"); 1354 } 1355 1356 IContentProvider cp = lazyGetProvider(cr); 1357 1358 // Try the fast path first, not using query(). If this 1359 // fails (alternate Settings provider that doesn't support 1360 // this interface?) then we fall back to the query/table 1361 // interface. 1362 if (mCallGetCommand != null) { 1363 try { 1364 Bundle args = null; 1365 if (!isSelf) { 1366 args = new Bundle(); 1367 args.putInt(CALL_METHOD_USER_KEY, userHandle); 1368 } 1369 Bundle b = cp.call(cr.getPackageName(), mCallGetCommand, name, args); 1370 if (b != null) { 1371 String value = b.getPairValue(); 1372 // Don't update our cache for reads of other users' data 1373 if (isSelf) { 1374 synchronized (this) { 1375 mValues.put(name, value); 1376 } 1377 } else { 1378 if (LOCAL_LOGV) Log.i(TAG, "call-query of user " + userHandle 1379 + " by " + UserHandle.myUserId() 1380 + " so not updating cache"); 1381 } 1382 return value; 1383 } 1384 // If the response Bundle is null, we fall through 1385 // to the query interface below. 1386 } catch (RemoteException e) { 1387 // Not supported by the remote side? Fall through 1388 // to query(). 1389 } 1390 } 1391 1392 Cursor c = null; 1393 try { 1394 c = cp.query(cr.getPackageName(), mUri, SELECT_VALUE, NAME_EQ_PLACEHOLDER, 1395 new String[]{name}, null, null); 1396 if (c == null) { 1397 Log.w(TAG, "Can't get key " + name + " from " + mUri); 1398 return null; 1399 } 1400 1401 String value = c.moveToNext() ? c.getString(0) : null; 1402 synchronized (this) { 1403 mValues.put(name, value); 1404 } 1405 if (LOCAL_LOGV) { 1406 Log.v(TAG, "cache miss [" + mUri.getLastPathSegment() + "]: " + 1407 name + " = " + (value == null ? "(null)" : value)); 1408 } 1409 return value; 1410 } catch (RemoteException e) { 1411 Log.w(TAG, "Can't get key " + name + " from " + mUri, e); 1412 return null; // Return null, but don't cache it. 1413 } finally { 1414 if (c != null) c.close(); 1415 } 1416 } 1417 } 1418 1419 /** 1420 * An app can use this method to check if it is currently allowed to draw on top of other 1421 * apps. In order to be allowed to do so, an app must first declare the 1422 * {@link android.Manifest.permission#SYSTEM_ALERT_WINDOW} permission in its manifest. If it 1423 * is currently disallowed, it can prompt the user to grant it this capability through a 1424 * management UI by sending an Intent with action 1425 * {@link android.provider.Settings#ACTION_MANAGE_OVERLAY_PERMISSION}. 1426 * 1427 * @param context A context 1428 * @return true if the calling app can draw on top of other apps, false otherwise. 1429 */ canDrawOverlays(Context context)1430 public static boolean canDrawOverlays(Context context) { 1431 int uid = Binder.getCallingUid(); 1432 return Settings.isCallingPackageAllowedToDrawOverlays(context, uid, Settings 1433 .getPackageNameForUid(context, uid), false); 1434 } 1435 1436 /** 1437 * System settings, containing miscellaneous system preferences. This 1438 * table holds simple name/value pairs. There are convenience 1439 * functions for accessing individual settings entries. 1440 */ 1441 public static final class System extends NameValueTable { 1442 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_system_version"; 1443 1444 /** @hide */ 1445 public static interface Validator { validate(String value)1446 public boolean validate(String value); 1447 } 1448 1449 /** 1450 * The content:// style URL for this table 1451 */ 1452 public static final Uri CONTENT_URI = 1453 Uri.parse("content://" + AUTHORITY + "/system"); 1454 1455 private static final NameValueCache sNameValueCache = new NameValueCache( 1456 SYS_PROP_SETTING_VERSION, 1457 CONTENT_URI, 1458 CALL_METHOD_GET_SYSTEM, 1459 CALL_METHOD_PUT_SYSTEM); 1460 1461 private static final HashSet<String> MOVED_TO_SECURE; 1462 static { 1463 MOVED_TO_SECURE = new HashSet<String>(30); 1464 MOVED_TO_SECURE.add(Secure.ANDROID_ID); 1465 MOVED_TO_SECURE.add(Secure.HTTP_PROXY); 1466 MOVED_TO_SECURE.add(Secure.LOCATION_PROVIDERS_ALLOWED); 1467 MOVED_TO_SECURE.add(Secure.LOCK_BIOMETRIC_WEAK_FLAGS); 1468 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_ENABLED); 1469 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_VISIBLE); 1470 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 1471 MOVED_TO_SECURE.add(Secure.LOGGING_ID); 1472 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_ENABLED); 1473 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_LAST_UPDATE); 1474 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_REDIRECT_URL); 1475 MOVED_TO_SECURE.add(Secure.SETTINGS_CLASSNAME); 1476 MOVED_TO_SECURE.add(Secure.USE_GOOGLE_MAIL); 1477 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 1478 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 1479 MOVED_TO_SECURE.add(Secure.WIFI_NUM_OPEN_NETWORKS_KEPT); 1480 MOVED_TO_SECURE.add(Secure.WIFI_ON); 1481 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE); 1482 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_AP_COUNT); 1483 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS); 1484 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED); 1485 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS); 1486 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT); 1487 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_MAX_AP_CHECKS); 1488 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ON); 1489 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_COUNT); 1490 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_DELAY_MS); 1491 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS); 1492 1493 // At one time in System, then Global, but now back in Secure 1494 MOVED_TO_SECURE.add(Secure.INSTALL_NON_MARKET_APPS); 1495 } 1496 1497 private static final HashSet<String> MOVED_TO_GLOBAL; 1498 private static final HashSet<String> MOVED_TO_SECURE_THEN_GLOBAL; 1499 static { 1500 MOVED_TO_GLOBAL = new HashSet<String>(); 1501 MOVED_TO_SECURE_THEN_GLOBAL = new HashSet<String>(); 1502 1503 // these were originally in system but migrated to secure in the past, 1504 // so are duplicated in the Secure.* namespace 1505 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.ADB_ENABLED); 1506 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.BLUETOOTH_ON); 1507 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DATA_ROAMING); 1508 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DEVICE_PROVISIONED); 1509 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.USB_MASS_STORAGE_ENABLED); 1510 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.HTTP_PROXY); 1511 1512 // these are moving directly from system to global 1513 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_ON); 1514 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_RADIOS); 1515 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS); 1516 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME); 1517 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME_ZONE); 1518 MOVED_TO_GLOBAL.add(Settings.Global.CAR_DOCK_SOUND); 1519 MOVED_TO_GLOBAL.add(Settings.Global.CAR_UNDOCK_SOUND); 1520 MOVED_TO_GLOBAL.add(Settings.Global.DESK_DOCK_SOUND); 1521 MOVED_TO_GLOBAL.add(Settings.Global.DESK_UNDOCK_SOUND); 1522 MOVED_TO_GLOBAL.add(Settings.Global.DOCK_SOUNDS_ENABLED); 1523 MOVED_TO_GLOBAL.add(Settings.Global.LOCK_SOUND); 1524 MOVED_TO_GLOBAL.add(Settings.Global.UNLOCK_SOUND); 1525 MOVED_TO_GLOBAL.add(Settings.Global.LOW_BATTERY_SOUND); 1526 MOVED_TO_GLOBAL.add(Settings.Global.POWER_SOUNDS_ENABLED); 1527 MOVED_TO_GLOBAL.add(Settings.Global.STAY_ON_WHILE_PLUGGED_IN); 1528 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SLEEP_POLICY); 1529 MOVED_TO_GLOBAL.add(Settings.Global.MODE_RINGER); 1530 MOVED_TO_GLOBAL.add(Settings.Global.WINDOW_ANIMATION_SCALE); 1531 MOVED_TO_GLOBAL.add(Settings.Global.TRANSITION_ANIMATION_SCALE); 1532 MOVED_TO_GLOBAL.add(Settings.Global.ANIMATOR_DURATION_SCALE); 1533 MOVED_TO_GLOBAL.add(Settings.Global.FANCY_IME_ANIMATIONS); 1534 MOVED_TO_GLOBAL.add(Settings.Global.COMPATIBILITY_MODE); 1535 MOVED_TO_GLOBAL.add(Settings.Global.EMERGENCY_TONE); 1536 MOVED_TO_GLOBAL.add(Settings.Global.CALL_AUTO_RETRY); 1537 MOVED_TO_GLOBAL.add(Settings.Global.DEBUG_APP); 1538 MOVED_TO_GLOBAL.add(Settings.Global.WAIT_FOR_DEBUGGER); 1539 MOVED_TO_GLOBAL.add(Settings.Global.SHOW_PROCESSES); 1540 MOVED_TO_GLOBAL.add(Settings.Global.ALWAYS_FINISH_ACTIVITIES); 1541 MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_CONTENT_URL); 1542 MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_METADATA_URL); 1543 MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_CONTENT_URL); 1544 MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_METADATA_URL); 1545 MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_CONTENT_URL); 1546 MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_METADATA_URL); 1547 MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_CONTENT_URL); 1548 MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_METADATA_URL); 1549 } 1550 1551 private static final Validator sBooleanValidator = 1552 new DiscreteValueValidator(new String[] {"0", "1"}); 1553 1554 private static final Validator sNonNegativeIntegerValidator = new Validator() { 1555 @Override 1556 public boolean validate(String value) { 1557 try { 1558 return Integer.parseInt(value) >= 0; 1559 } catch (NumberFormatException e) { 1560 return false; 1561 } 1562 } 1563 }; 1564 1565 private static final Validator sUriValidator = new Validator() { 1566 @Override 1567 public boolean validate(String value) { 1568 try { 1569 Uri.decode(value); 1570 return true; 1571 } catch (IllegalArgumentException e) { 1572 return false; 1573 } 1574 } 1575 }; 1576 1577 private static final Validator sLenientIpAddressValidator = new Validator() { 1578 private static final int MAX_IPV6_LENGTH = 45; 1579 1580 @Override 1581 public boolean validate(String value) { 1582 return value.length() <= MAX_IPV6_LENGTH; 1583 } 1584 }; 1585 1586 /** @hide */ getMovedToGlobalSettings(Set<String> outKeySet)1587 public static void getMovedToGlobalSettings(Set<String> outKeySet) { 1588 outKeySet.addAll(MOVED_TO_GLOBAL); 1589 outKeySet.addAll(MOVED_TO_SECURE_THEN_GLOBAL); 1590 } 1591 1592 /** @hide */ getMovedToSecureSettings(Set<String> outKeySet)1593 public static void getMovedToSecureSettings(Set<String> outKeySet) { 1594 outKeySet.addAll(MOVED_TO_SECURE); 1595 } 1596 1597 /** @hide */ getNonLegacyMovedKeys(HashSet<String> outKeySet)1598 public static void getNonLegacyMovedKeys(HashSet<String> outKeySet) { 1599 outKeySet.addAll(MOVED_TO_GLOBAL); 1600 } 1601 1602 /** 1603 * Look up a name in the database. 1604 * @param resolver to access the database with 1605 * @param name to look up in the table 1606 * @return the corresponding value, or null if not present 1607 */ getString(ContentResolver resolver, String name)1608 public static String getString(ContentResolver resolver, String name) { 1609 return getStringForUser(resolver, name, UserHandle.myUserId()); 1610 } 1611 1612 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)1613 public static String getStringForUser(ContentResolver resolver, String name, 1614 int userHandle) { 1615 if (MOVED_TO_SECURE.contains(name)) { 1616 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1617 + " to android.provider.Settings.Secure, returning read-only value."); 1618 return Secure.getStringForUser(resolver, name, userHandle); 1619 } 1620 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1621 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1622 + " to android.provider.Settings.Global, returning read-only value."); 1623 return Global.getStringForUser(resolver, name, userHandle); 1624 } 1625 return sNameValueCache.getStringForUser(resolver, name, userHandle); 1626 } 1627 1628 /** 1629 * Store a name/value pair into the database. 1630 * @param resolver to access the database with 1631 * @param name to store 1632 * @param value to associate with the name 1633 * @return true if the value was set, false on database errors 1634 */ putString(ContentResolver resolver, String name, String value)1635 public static boolean putString(ContentResolver resolver, String name, String value) { 1636 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 1637 } 1638 1639 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)1640 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 1641 int userHandle) { 1642 if (MOVED_TO_SECURE.contains(name)) { 1643 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1644 + " to android.provider.Settings.Secure, value is unchanged."); 1645 return false; 1646 } 1647 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1648 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1649 + " to android.provider.Settings.Global, value is unchanged."); 1650 return false; 1651 } 1652 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 1653 } 1654 1655 /** 1656 * Construct the content URI for a particular name/value pair, 1657 * useful for monitoring changes with a ContentObserver. 1658 * @param name to look up in the table 1659 * @return the corresponding content URI, or null if not present 1660 */ getUriFor(String name)1661 public static Uri getUriFor(String name) { 1662 if (MOVED_TO_SECURE.contains(name)) { 1663 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1664 + " to android.provider.Settings.Secure, returning Secure URI."); 1665 return Secure.getUriFor(Secure.CONTENT_URI, name); 1666 } 1667 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1668 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1669 + " to android.provider.Settings.Global, returning read-only global URI."); 1670 return Global.getUriFor(Global.CONTENT_URI, name); 1671 } 1672 return getUriFor(CONTENT_URI, name); 1673 } 1674 1675 /** 1676 * Convenience function for retrieving a single system settings value 1677 * as an integer. Note that internally setting values are always 1678 * stored as strings; this function converts the string to an integer 1679 * for you. The default value will be returned if the setting is 1680 * not defined or not an integer. 1681 * 1682 * @param cr The ContentResolver to access. 1683 * @param name The name of the setting to retrieve. 1684 * @param def Value to return if the setting is not defined. 1685 * 1686 * @return The setting's current value, or 'def' if it is not defined 1687 * or not a valid integer. 1688 */ getInt(ContentResolver cr, String name, int def)1689 public static int getInt(ContentResolver cr, String name, int def) { 1690 return getIntForUser(cr, name, def, UserHandle.myUserId()); 1691 } 1692 1693 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)1694 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 1695 String v = getStringForUser(cr, name, userHandle); 1696 try { 1697 return v != null ? Integer.parseInt(v) : def; 1698 } catch (NumberFormatException e) { 1699 return def; 1700 } 1701 } 1702 1703 /** 1704 * Convenience function for retrieving a single system settings value 1705 * as an integer. Note that internally setting values are always 1706 * stored as strings; this function converts the string to an integer 1707 * for you. 1708 * <p> 1709 * This version does not take a default value. If the setting has not 1710 * been set, or the string value is not a number, 1711 * it throws {@link SettingNotFoundException}. 1712 * 1713 * @param cr The ContentResolver to access. 1714 * @param name The name of the setting to retrieve. 1715 * 1716 * @throws SettingNotFoundException Thrown if a setting by the given 1717 * name can't be found or the setting value is not an integer. 1718 * 1719 * @return The setting's current value. 1720 */ getInt(ContentResolver cr, String name)1721 public static int getInt(ContentResolver cr, String name) 1722 throws SettingNotFoundException { 1723 return getIntForUser(cr, name, UserHandle.myUserId()); 1724 } 1725 1726 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)1727 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 1728 throws SettingNotFoundException { 1729 String v = getStringForUser(cr, name, userHandle); 1730 try { 1731 return Integer.parseInt(v); 1732 } catch (NumberFormatException e) { 1733 throw new SettingNotFoundException(name); 1734 } 1735 } 1736 1737 /** 1738 * Convenience function for updating a single settings value as an 1739 * integer. This will either create a new entry in the table if the 1740 * given name does not exist, or modify the value of the existing row 1741 * with that name. Note that internally setting values are always 1742 * stored as strings, so this function converts the given value to a 1743 * string before storing it. 1744 * 1745 * @param cr The ContentResolver to access. 1746 * @param name The name of the setting to modify. 1747 * @param value The new value for the setting. 1748 * @return true if the value was set, false on database errors 1749 */ putInt(ContentResolver cr, String name, int value)1750 public static boolean putInt(ContentResolver cr, String name, int value) { 1751 return putIntForUser(cr, name, value, UserHandle.myUserId()); 1752 } 1753 1754 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)1755 public static boolean putIntForUser(ContentResolver cr, String name, int value, 1756 int userHandle) { 1757 return putStringForUser(cr, name, Integer.toString(value), userHandle); 1758 } 1759 1760 /** 1761 * Convenience function for retrieving a single system settings value 1762 * as a {@code long}. Note that internally setting values are always 1763 * stored as strings; this function converts the string to a {@code long} 1764 * for you. The default value will be returned if the setting is 1765 * not defined or not a {@code long}. 1766 * 1767 * @param cr The ContentResolver to access. 1768 * @param name The name of the setting to retrieve. 1769 * @param def Value to return if the setting is not defined. 1770 * 1771 * @return The setting's current value, or 'def' if it is not defined 1772 * or not a valid {@code long}. 1773 */ getLong(ContentResolver cr, String name, long def)1774 public static long getLong(ContentResolver cr, String name, long def) { 1775 return getLongForUser(cr, name, def, UserHandle.myUserId()); 1776 } 1777 1778 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)1779 public static long getLongForUser(ContentResolver cr, String name, long def, 1780 int userHandle) { 1781 String valString = getStringForUser(cr, name, userHandle); 1782 long value; 1783 try { 1784 value = valString != null ? Long.parseLong(valString) : def; 1785 } catch (NumberFormatException e) { 1786 value = def; 1787 } 1788 return value; 1789 } 1790 1791 /** 1792 * Convenience function for retrieving a single system settings value 1793 * as a {@code long}. Note that internally setting values are always 1794 * stored as strings; this function converts the string to a {@code long} 1795 * for you. 1796 * <p> 1797 * This version does not take a default value. If the setting has not 1798 * been set, or the string value is not a number, 1799 * it throws {@link SettingNotFoundException}. 1800 * 1801 * @param cr The ContentResolver to access. 1802 * @param name The name of the setting to retrieve. 1803 * 1804 * @return The setting's current value. 1805 * @throws SettingNotFoundException Thrown if a setting by the given 1806 * name can't be found or the setting value is not an integer. 1807 */ getLong(ContentResolver cr, String name)1808 public static long getLong(ContentResolver cr, String name) 1809 throws SettingNotFoundException { 1810 return getLongForUser(cr, name, UserHandle.myUserId()); 1811 } 1812 1813 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)1814 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 1815 throws SettingNotFoundException { 1816 String valString = getStringForUser(cr, name, userHandle); 1817 try { 1818 return Long.parseLong(valString); 1819 } catch (NumberFormatException e) { 1820 throw new SettingNotFoundException(name); 1821 } 1822 } 1823 1824 /** 1825 * Convenience function for updating a single settings value as a long 1826 * integer. This will either create a new entry in the table if the 1827 * given name does not exist, or modify the value of the existing row 1828 * with that name. Note that internally setting values are always 1829 * stored as strings, so this function converts the given value to a 1830 * string before storing it. 1831 * 1832 * @param cr The ContentResolver to access. 1833 * @param name The name of the setting to modify. 1834 * @param value The new value for the setting. 1835 * @return true if the value was set, false on database errors 1836 */ putLong(ContentResolver cr, String name, long value)1837 public static boolean putLong(ContentResolver cr, String name, long value) { 1838 return putLongForUser(cr, name, value, UserHandle.myUserId()); 1839 } 1840 1841 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)1842 public static boolean putLongForUser(ContentResolver cr, String name, long value, 1843 int userHandle) { 1844 return putStringForUser(cr, name, Long.toString(value), userHandle); 1845 } 1846 1847 /** 1848 * Convenience function for retrieving a single system settings value 1849 * as a floating point number. Note that internally setting values are 1850 * always stored as strings; this function converts the string to an 1851 * float for you. The default value will be returned if the setting 1852 * is not defined or not a valid float. 1853 * 1854 * @param cr The ContentResolver to access. 1855 * @param name The name of the setting to retrieve. 1856 * @param def Value to return if the setting is not defined. 1857 * 1858 * @return The setting's current value, or 'def' if it is not defined 1859 * or not a valid float. 1860 */ getFloat(ContentResolver cr, String name, float def)1861 public static float getFloat(ContentResolver cr, String name, float def) { 1862 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 1863 } 1864 1865 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)1866 public static float getFloatForUser(ContentResolver cr, String name, float def, 1867 int userHandle) { 1868 String v = getStringForUser(cr, name, userHandle); 1869 try { 1870 return v != null ? Float.parseFloat(v) : def; 1871 } catch (NumberFormatException e) { 1872 return def; 1873 } 1874 } 1875 1876 /** 1877 * Convenience function for retrieving a single system settings value 1878 * as a float. Note that internally setting values are always 1879 * stored as strings; this function converts the string to a float 1880 * for you. 1881 * <p> 1882 * This version does not take a default value. If the setting has not 1883 * been set, or the string value is not a number, 1884 * it throws {@link SettingNotFoundException}. 1885 * 1886 * @param cr The ContentResolver to access. 1887 * @param name The name of the setting to retrieve. 1888 * 1889 * @throws SettingNotFoundException Thrown if a setting by the given 1890 * name can't be found or the setting value is not a float. 1891 * 1892 * @return The setting's current value. 1893 */ getFloat(ContentResolver cr, String name)1894 public static float getFloat(ContentResolver cr, String name) 1895 throws SettingNotFoundException { 1896 return getFloatForUser(cr, name, UserHandle.myUserId()); 1897 } 1898 1899 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)1900 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 1901 throws SettingNotFoundException { 1902 String v = getStringForUser(cr, name, userHandle); 1903 if (v == null) { 1904 throw new SettingNotFoundException(name); 1905 } 1906 try { 1907 return Float.parseFloat(v); 1908 } catch (NumberFormatException e) { 1909 throw new SettingNotFoundException(name); 1910 } 1911 } 1912 1913 /** 1914 * Convenience function for updating a single settings value as a 1915 * floating point number. This will either create a new entry in the 1916 * table if the given name does not exist, or modify the value of the 1917 * existing row with that name. Note that internally setting values 1918 * are always stored as strings, so this function converts the given 1919 * value to a string before storing it. 1920 * 1921 * @param cr The ContentResolver to access. 1922 * @param name The name of the setting to modify. 1923 * @param value The new value for the setting. 1924 * @return true if the value was set, false on database errors 1925 */ putFloat(ContentResolver cr, String name, float value)1926 public static boolean putFloat(ContentResolver cr, String name, float value) { 1927 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 1928 } 1929 1930 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)1931 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 1932 int userHandle) { 1933 return putStringForUser(cr, name, Float.toString(value), userHandle); 1934 } 1935 1936 /** 1937 * Convenience function to read all of the current 1938 * configuration-related settings into a 1939 * {@link Configuration} object. 1940 * 1941 * @param cr The ContentResolver to access. 1942 * @param outConfig Where to place the configuration settings. 1943 */ getConfiguration(ContentResolver cr, Configuration outConfig)1944 public static void getConfiguration(ContentResolver cr, Configuration outConfig) { 1945 getConfigurationForUser(cr, outConfig, UserHandle.myUserId()); 1946 } 1947 1948 /** @hide */ getConfigurationForUser(ContentResolver cr, Configuration outConfig, int userHandle)1949 public static void getConfigurationForUser(ContentResolver cr, Configuration outConfig, 1950 int userHandle) { 1951 outConfig.fontScale = Settings.System.getFloatForUser( 1952 cr, FONT_SCALE, outConfig.fontScale, userHandle); 1953 if (outConfig.fontScale < 0) { 1954 outConfig.fontScale = 1; 1955 } 1956 } 1957 1958 /** 1959 * @hide Erase the fields in the Configuration that should be applied 1960 * by the settings. 1961 */ clearConfiguration(Configuration inoutConfig)1962 public static void clearConfiguration(Configuration inoutConfig) { 1963 inoutConfig.fontScale = 0; 1964 } 1965 1966 /** 1967 * Convenience function to write a batch of configuration-related 1968 * settings from a {@link Configuration} object. 1969 * 1970 * @param cr The ContentResolver to access. 1971 * @param config The settings to write. 1972 * @return true if the values were set, false on database errors 1973 */ putConfiguration(ContentResolver cr, Configuration config)1974 public static boolean putConfiguration(ContentResolver cr, Configuration config) { 1975 return putConfigurationForUser(cr, config, UserHandle.myUserId()); 1976 } 1977 1978 /** @hide */ putConfigurationForUser(ContentResolver cr, Configuration config, int userHandle)1979 public static boolean putConfigurationForUser(ContentResolver cr, Configuration config, 1980 int userHandle) { 1981 return Settings.System.putFloatForUser(cr, FONT_SCALE, config.fontScale, userHandle); 1982 } 1983 1984 /** @hide */ hasInterestingConfigurationChanges(int changes)1985 public static boolean hasInterestingConfigurationChanges(int changes) { 1986 return (changes&ActivityInfo.CONFIG_FONT_SCALE) != 0; 1987 } 1988 1989 /** @deprecated - Do not use */ 1990 @Deprecated getShowGTalkServiceStatus(ContentResolver cr)1991 public static boolean getShowGTalkServiceStatus(ContentResolver cr) { 1992 return getShowGTalkServiceStatusForUser(cr, UserHandle.myUserId()); 1993 } 1994 1995 /** 1996 * @hide 1997 * @deprecated - Do not use 1998 */ getShowGTalkServiceStatusForUser(ContentResolver cr, int userHandle)1999 public static boolean getShowGTalkServiceStatusForUser(ContentResolver cr, 2000 int userHandle) { 2001 return getIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, 0, userHandle) != 0; 2002 } 2003 2004 /** @deprecated - Do not use */ 2005 @Deprecated setShowGTalkServiceStatus(ContentResolver cr, boolean flag)2006 public static void setShowGTalkServiceStatus(ContentResolver cr, boolean flag) { 2007 setShowGTalkServiceStatusForUser(cr, flag, UserHandle.myUserId()); 2008 } 2009 2010 /** 2011 * @hide 2012 * @deprecated - Do not use 2013 */ 2014 @Deprecated setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, int userHandle)2015 public static void setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, 2016 int userHandle) { 2017 putIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, flag ? 1 : 0, userHandle); 2018 } 2019 2020 private static final class DiscreteValueValidator implements Validator { 2021 private final String[] mValues; 2022 DiscreteValueValidator(String[] values)2023 public DiscreteValueValidator(String[] values) { 2024 mValues = values; 2025 } 2026 2027 @Override validate(String value)2028 public boolean validate(String value) { 2029 return ArrayUtils.contains(mValues, value); 2030 } 2031 } 2032 2033 private static final class InclusiveIntegerRangeValidator implements Validator { 2034 private final int mMin; 2035 private final int mMax; 2036 InclusiveIntegerRangeValidator(int min, int max)2037 public InclusiveIntegerRangeValidator(int min, int max) { 2038 mMin = min; 2039 mMax = max; 2040 } 2041 2042 @Override validate(String value)2043 public boolean validate(String value) { 2044 try { 2045 final int intValue = Integer.parseInt(value); 2046 return intValue >= mMin && intValue <= mMax; 2047 } catch (NumberFormatException e) { 2048 return false; 2049 } 2050 } 2051 } 2052 2053 private static final class InclusiveFloatRangeValidator implements Validator { 2054 private final float mMin; 2055 private final float mMax; 2056 InclusiveFloatRangeValidator(float min, float max)2057 public InclusiveFloatRangeValidator(float min, float max) { 2058 mMin = min; 2059 mMax = max; 2060 } 2061 2062 @Override validate(String value)2063 public boolean validate(String value) { 2064 try { 2065 final float floatValue = Float.parseFloat(value); 2066 return floatValue >= mMin && floatValue <= mMax; 2067 } catch (NumberFormatException e) { 2068 return false; 2069 } 2070 } 2071 } 2072 2073 /** 2074 * @deprecated Use {@link android.provider.Settings.Global#STAY_ON_WHILE_PLUGGED_IN} instead 2075 */ 2076 @Deprecated 2077 public static final String STAY_ON_WHILE_PLUGGED_IN = Global.STAY_ON_WHILE_PLUGGED_IN; 2078 2079 /** 2080 * What happens when the user presses the end call button if they're not 2081 * on a call.<br/> 2082 * <b>Values:</b><br/> 2083 * 0 - The end button does nothing.<br/> 2084 * 1 - The end button goes to the home screen.<br/> 2085 * 2 - The end button puts the device to sleep and locks the keyguard.<br/> 2086 * 3 - The end button goes to the home screen. If the user is already on the 2087 * home screen, it puts the device to sleep. 2088 */ 2089 public static final String END_BUTTON_BEHAVIOR = "end_button_behavior"; 2090 2091 private static final Validator END_BUTTON_BEHAVIOR_VALIDATOR = 2092 new InclusiveIntegerRangeValidator(0, 3); 2093 2094 /** 2095 * END_BUTTON_BEHAVIOR value for "go home". 2096 * @hide 2097 */ 2098 public static final int END_BUTTON_BEHAVIOR_HOME = 0x1; 2099 2100 /** 2101 * END_BUTTON_BEHAVIOR value for "go to sleep". 2102 * @hide 2103 */ 2104 public static final int END_BUTTON_BEHAVIOR_SLEEP = 0x2; 2105 2106 /** 2107 * END_BUTTON_BEHAVIOR default value. 2108 * @hide 2109 */ 2110 public static final int END_BUTTON_BEHAVIOR_DEFAULT = END_BUTTON_BEHAVIOR_SLEEP; 2111 2112 /** 2113 * Is advanced settings mode turned on. 0 == no, 1 == yes 2114 * @hide 2115 */ 2116 public static final String ADVANCED_SETTINGS = "advanced_settings"; 2117 2118 private static final Validator ADVANCED_SETTINGS_VALIDATOR = sBooleanValidator; 2119 2120 /** 2121 * ADVANCED_SETTINGS default value. 2122 * @hide 2123 */ 2124 public static final int ADVANCED_SETTINGS_DEFAULT = 0; 2125 2126 /** 2127 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_ON} instead 2128 */ 2129 @Deprecated 2130 public static final String AIRPLANE_MODE_ON = Global.AIRPLANE_MODE_ON; 2131 2132 /** 2133 * @deprecated Use {@link android.provider.Settings.Global#RADIO_BLUETOOTH} instead 2134 */ 2135 @Deprecated 2136 public static final String RADIO_BLUETOOTH = Global.RADIO_BLUETOOTH; 2137 2138 /** 2139 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIFI} instead 2140 */ 2141 @Deprecated 2142 public static final String RADIO_WIFI = Global.RADIO_WIFI; 2143 2144 /** 2145 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIMAX} instead 2146 * {@hide} 2147 */ 2148 @Deprecated 2149 public static final String RADIO_WIMAX = Global.RADIO_WIMAX; 2150 2151 /** 2152 * @deprecated Use {@link android.provider.Settings.Global#RADIO_CELL} instead 2153 */ 2154 @Deprecated 2155 public static final String RADIO_CELL = Global.RADIO_CELL; 2156 2157 /** 2158 * @deprecated Use {@link android.provider.Settings.Global#RADIO_NFC} instead 2159 */ 2160 @Deprecated 2161 public static final String RADIO_NFC = Global.RADIO_NFC; 2162 2163 /** 2164 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_RADIOS} instead 2165 */ 2166 @Deprecated 2167 public static final String AIRPLANE_MODE_RADIOS = Global.AIRPLANE_MODE_RADIOS; 2168 2169 /** 2170 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_TOGGLEABLE_RADIOS} instead 2171 * 2172 * {@hide} 2173 */ 2174 @Deprecated 2175 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = 2176 Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS; 2177 2178 /** 2179 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY} instead 2180 */ 2181 @Deprecated 2182 public static final String WIFI_SLEEP_POLICY = Global.WIFI_SLEEP_POLICY; 2183 2184 /** 2185 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_DEFAULT} instead 2186 */ 2187 @Deprecated 2188 public static final int WIFI_SLEEP_POLICY_DEFAULT = Global.WIFI_SLEEP_POLICY_DEFAULT; 2189 2190 /** 2191 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED} instead 2192 */ 2193 @Deprecated 2194 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 2195 Global.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED; 2196 2197 /** 2198 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER} instead 2199 */ 2200 @Deprecated 2201 public static final int WIFI_SLEEP_POLICY_NEVER = Global.WIFI_SLEEP_POLICY_NEVER; 2202 2203 /** 2204 * @deprecated Use {@link android.provider.Settings.Global#MODE_RINGER} instead 2205 */ 2206 @Deprecated 2207 public static final String MODE_RINGER = Global.MODE_RINGER; 2208 2209 /** 2210 * Whether to use static IP and other static network attributes. 2211 * <p> 2212 * Set to 1 for true and 0 for false. 2213 * 2214 * @deprecated Use {@link WifiManager} instead 2215 */ 2216 @Deprecated 2217 public static final String WIFI_USE_STATIC_IP = "wifi_use_static_ip"; 2218 2219 private static final Validator WIFI_USE_STATIC_IP_VALIDATOR = sBooleanValidator; 2220 2221 /** 2222 * The static IP address. 2223 * <p> 2224 * Example: "192.168.1.51" 2225 * 2226 * @deprecated Use {@link WifiManager} instead 2227 */ 2228 @Deprecated 2229 public static final String WIFI_STATIC_IP = "wifi_static_ip"; 2230 2231 private static final Validator WIFI_STATIC_IP_VALIDATOR = sLenientIpAddressValidator; 2232 2233 /** 2234 * If using static IP, the gateway's IP address. 2235 * <p> 2236 * Example: "192.168.1.1" 2237 * 2238 * @deprecated Use {@link WifiManager} instead 2239 */ 2240 @Deprecated 2241 public static final String WIFI_STATIC_GATEWAY = "wifi_static_gateway"; 2242 2243 private static final Validator WIFI_STATIC_GATEWAY_VALIDATOR = sLenientIpAddressValidator; 2244 2245 /** 2246 * If using static IP, the net mask. 2247 * <p> 2248 * Example: "255.255.255.0" 2249 * 2250 * @deprecated Use {@link WifiManager} instead 2251 */ 2252 @Deprecated 2253 public static final String WIFI_STATIC_NETMASK = "wifi_static_netmask"; 2254 2255 private static final Validator WIFI_STATIC_NETMASK_VALIDATOR = sLenientIpAddressValidator; 2256 2257 /** 2258 * If using static IP, the primary DNS's IP address. 2259 * <p> 2260 * Example: "192.168.1.1" 2261 * 2262 * @deprecated Use {@link WifiManager} instead 2263 */ 2264 @Deprecated 2265 public static final String WIFI_STATIC_DNS1 = "wifi_static_dns1"; 2266 2267 private static final Validator WIFI_STATIC_DNS1_VALIDATOR = sLenientIpAddressValidator; 2268 2269 /** 2270 * If using static IP, the secondary DNS's IP address. 2271 * <p> 2272 * Example: "192.168.1.2" 2273 * 2274 * @deprecated Use {@link WifiManager} instead 2275 */ 2276 @Deprecated 2277 public static final String WIFI_STATIC_DNS2 = "wifi_static_dns2"; 2278 2279 private static final Validator WIFI_STATIC_DNS2_VALIDATOR = sLenientIpAddressValidator; 2280 2281 /** 2282 * Determines whether remote devices may discover and/or connect to 2283 * this device. 2284 * <P>Type: INT</P> 2285 * 2 -- discoverable and connectable 2286 * 1 -- connectable but not discoverable 2287 * 0 -- neither connectable nor discoverable 2288 */ 2289 public static final String BLUETOOTH_DISCOVERABILITY = 2290 "bluetooth_discoverability"; 2291 2292 private static final Validator BLUETOOTH_DISCOVERABILITY_VALIDATOR = 2293 new InclusiveIntegerRangeValidator(0, 2); 2294 2295 /** 2296 * Bluetooth discoverability timeout. If this value is nonzero, then 2297 * Bluetooth becomes discoverable for a certain number of seconds, 2298 * after which is becomes simply connectable. The value is in seconds. 2299 */ 2300 public static final String BLUETOOTH_DISCOVERABILITY_TIMEOUT = 2301 "bluetooth_discoverability_timeout"; 2302 2303 private static final Validator BLUETOOTH_DISCOVERABILITY_TIMEOUT_VALIDATOR = 2304 sNonNegativeIntegerValidator; 2305 2306 /** 2307 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_ENABLED} 2308 * instead 2309 */ 2310 @Deprecated 2311 public static final String LOCK_PATTERN_ENABLED = Secure.LOCK_PATTERN_ENABLED; 2312 2313 /** 2314 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_VISIBLE} 2315 * instead 2316 */ 2317 @Deprecated 2318 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 2319 2320 /** 2321 * @deprecated Use 2322 * {@link android.provider.Settings.Secure#LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED} 2323 * instead 2324 */ 2325 @Deprecated 2326 public static final String LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = 2327 "lock_pattern_tactile_feedback_enabled"; 2328 2329 /** 2330 * A formatted string of the next alarm that is set, or the empty string 2331 * if there is no alarm set. 2332 * 2333 * @deprecated Use {@link android.app.AlarmManager#getNextAlarmClock()}. 2334 */ 2335 @Deprecated 2336 public static final String NEXT_ALARM_FORMATTED = "next_alarm_formatted"; 2337 2338 private static final Validator NEXT_ALARM_FORMATTED_VALIDATOR = new Validator() { 2339 private static final int MAX_LENGTH = 1000; 2340 2341 @Override 2342 public boolean validate(String value) { 2343 // TODO: No idea what the correct format is. 2344 return value == null || value.length() < MAX_LENGTH; 2345 } 2346 }; 2347 2348 /** 2349 * Scaling factor for fonts, float. 2350 */ 2351 public static final String FONT_SCALE = "font_scale"; 2352 2353 private static final Validator FONT_SCALE_VALIDATOR = new Validator() { 2354 @Override 2355 public boolean validate(String value) { 2356 try { 2357 return Float.parseFloat(value) >= 0; 2358 } catch (NumberFormatException e) { 2359 return false; 2360 } 2361 } 2362 }; 2363 2364 /** 2365 * Name of an application package to be debugged. 2366 * 2367 * @deprecated Use {@link Global#DEBUG_APP} instead 2368 */ 2369 @Deprecated 2370 public static final String DEBUG_APP = Global.DEBUG_APP; 2371 2372 /** 2373 * If 1, when launching DEBUG_APP it will wait for the debugger before 2374 * starting user code. If 0, it will run normally. 2375 * 2376 * @deprecated Use {@link Global#WAIT_FOR_DEBUGGER} instead 2377 */ 2378 @Deprecated 2379 public static final String WAIT_FOR_DEBUGGER = Global.WAIT_FOR_DEBUGGER; 2380 2381 /** 2382 * Whether or not to dim the screen. 0=no 1=yes 2383 * @deprecated This setting is no longer used. 2384 */ 2385 @Deprecated 2386 public static final String DIM_SCREEN = "dim_screen"; 2387 2388 private static final Validator DIM_SCREEN_VALIDATOR = sBooleanValidator; 2389 2390 /** 2391 * The amount of time in milliseconds before the device goes to sleep or begins 2392 * to dream after a period of inactivity. This value is also known as the 2393 * user activity timeout period since the screen isn't necessarily turned off 2394 * when it expires. 2395 */ 2396 public static final String SCREEN_OFF_TIMEOUT = "screen_off_timeout"; 2397 2398 private static final Validator SCREEN_OFF_TIMEOUT_VALIDATOR = sNonNegativeIntegerValidator; 2399 2400 /** 2401 * The screen backlight brightness between 0 and 255. 2402 */ 2403 public static final String SCREEN_BRIGHTNESS = "screen_brightness"; 2404 2405 private static final Validator SCREEN_BRIGHTNESS_VALIDATOR = 2406 new InclusiveIntegerRangeValidator(0, 255); 2407 2408 /** 2409 * Control whether to enable automatic brightness mode. 2410 */ 2411 public static final String SCREEN_BRIGHTNESS_MODE = "screen_brightness_mode"; 2412 2413 private static final Validator SCREEN_BRIGHTNESS_MODE_VALIDATOR = sBooleanValidator; 2414 2415 /** 2416 * Adjustment to auto-brightness to make it generally more (>0.0 <1.0) 2417 * or less (<0.0 >-1.0) bright. 2418 * @hide 2419 */ 2420 public static final String SCREEN_AUTO_BRIGHTNESS_ADJ = "screen_auto_brightness_adj"; 2421 2422 private static final Validator SCREEN_AUTO_BRIGHTNESS_ADJ_VALIDATOR = 2423 new InclusiveFloatRangeValidator(-1, 1); 2424 2425 /** 2426 * SCREEN_BRIGHTNESS_MODE value for manual mode. 2427 */ 2428 public static final int SCREEN_BRIGHTNESS_MODE_MANUAL = 0; 2429 2430 /** 2431 * SCREEN_BRIGHTNESS_MODE value for automatic mode. 2432 */ 2433 public static final int SCREEN_BRIGHTNESS_MODE_AUTOMATIC = 1; 2434 2435 /** 2436 * Control whether the process CPU usage meter should be shown. 2437 * 2438 * @deprecated Use {@link Global#SHOW_PROCESSES} instead 2439 */ 2440 @Deprecated 2441 public static final String SHOW_PROCESSES = Global.SHOW_PROCESSES; 2442 2443 /** 2444 * If 1, the activity manager will aggressively finish activities and 2445 * processes as soon as they are no longer needed. If 0, the normal 2446 * extended lifetime is used. 2447 * 2448 * @deprecated Use {@link Global#ALWAYS_FINISH_ACTIVITIES} instead 2449 */ 2450 @Deprecated 2451 public static final String ALWAYS_FINISH_ACTIVITIES = Global.ALWAYS_FINISH_ACTIVITIES; 2452 2453 /** 2454 * Determines which streams are affected by ringer mode changes. The 2455 * stream type's bit should be set to 1 if it should be muted when going 2456 * into an inaudible ringer mode. 2457 */ 2458 public static final String MODE_RINGER_STREAMS_AFFECTED = "mode_ringer_streams_affected"; 2459 2460 private static final Validator MODE_RINGER_STREAMS_AFFECTED_VALIDATOR = 2461 sNonNegativeIntegerValidator; 2462 2463 /** 2464 * Determines which streams are affected by mute. The 2465 * stream type's bit should be set to 1 if it should be muted when a mute request 2466 * is received. 2467 */ 2468 public static final String MUTE_STREAMS_AFFECTED = "mute_streams_affected"; 2469 2470 private static final Validator MUTE_STREAMS_AFFECTED_VALIDATOR = 2471 sNonNegativeIntegerValidator; 2472 2473 /** 2474 * Whether vibrate is on for different events. This is used internally, 2475 * changing this value will not change the vibrate. See AudioManager. 2476 */ 2477 public static final String VIBRATE_ON = "vibrate_on"; 2478 2479 private static final Validator VIBRATE_ON_VALIDATOR = sBooleanValidator; 2480 2481 /** 2482 * If 1, redirects the system vibrator to all currently attached input devices 2483 * that support vibration. If there are no such input devices, then the system 2484 * vibrator is used instead. 2485 * If 0, does not register the system vibrator. 2486 * 2487 * This setting is mainly intended to provide a compatibility mechanism for 2488 * applications that only know about the system vibrator and do not use the 2489 * input device vibrator API. 2490 * 2491 * @hide 2492 */ 2493 public static final String VIBRATE_INPUT_DEVICES = "vibrate_input_devices"; 2494 2495 private static final Validator VIBRATE_INPUT_DEVICES_VALIDATOR = sBooleanValidator; 2496 2497 /** 2498 * Ringer volume. This is used internally, changing this value will not 2499 * change the volume. See AudioManager. 2500 * 2501 * @removed Not used by anything since API 2. 2502 */ 2503 public static final String VOLUME_RING = "volume_ring"; 2504 2505 /** 2506 * System/notifications volume. This is used internally, changing this 2507 * value will not change the volume. See AudioManager. 2508 * 2509 * @removed Not used by anything since API 2. 2510 */ 2511 public static final String VOLUME_SYSTEM = "volume_system"; 2512 2513 /** 2514 * Voice call volume. This is used internally, changing this value will 2515 * not change the volume. See AudioManager. 2516 * 2517 * @removed Not used by anything since API 2. 2518 */ 2519 public static final String VOLUME_VOICE = "volume_voice"; 2520 2521 /** 2522 * Music/media/gaming volume. This is used internally, changing this 2523 * value will not change the volume. See AudioManager. 2524 * 2525 * @removed Not used by anything since API 2. 2526 */ 2527 public static final String VOLUME_MUSIC = "volume_music"; 2528 2529 /** 2530 * Alarm volume. This is used internally, changing this 2531 * value will not change the volume. See AudioManager. 2532 * 2533 * @removed Not used by anything since API 2. 2534 */ 2535 public static final String VOLUME_ALARM = "volume_alarm"; 2536 2537 /** 2538 * Notification volume. This is used internally, changing this 2539 * value will not change the volume. See AudioManager. 2540 * 2541 * @removed Not used by anything since API 2. 2542 */ 2543 public static final String VOLUME_NOTIFICATION = "volume_notification"; 2544 2545 /** 2546 * Bluetooth Headset volume. This is used internally, changing this value will 2547 * not change the volume. See AudioManager. 2548 * 2549 * @removed Not used by anything since API 2. 2550 */ 2551 public static final String VOLUME_BLUETOOTH_SCO = "volume_bluetooth_sco"; 2552 2553 /** 2554 * Master volume (float in the range 0.0f to 1.0f). 2555 * 2556 * @hide 2557 */ 2558 public static final String VOLUME_MASTER = "volume_master"; 2559 2560 /** 2561 * Master volume mute (int 1 = mute, 0 = not muted). 2562 * 2563 * @hide 2564 */ 2565 public static final String VOLUME_MASTER_MUTE = "volume_master_mute"; 2566 2567 private static final Validator VOLUME_MASTER_MUTE_VALIDATOR = sBooleanValidator; 2568 2569 /** 2570 * Microphone mute (int 1 = mute, 0 = not muted). 2571 * 2572 * @hide 2573 */ 2574 public static final String MICROPHONE_MUTE = "microphone_mute"; 2575 2576 private static final Validator MICROPHONE_MUTE_VALIDATOR = sBooleanValidator; 2577 2578 /** 2579 * Whether the notifications should use the ring volume (value of 1) or 2580 * a separate notification volume (value of 0). In most cases, users 2581 * will have this enabled so the notification and ringer volumes will be 2582 * the same. However, power users can disable this and use the separate 2583 * notification volume control. 2584 * <p> 2585 * Note: This is a one-off setting that will be removed in the future 2586 * when there is profile support. For this reason, it is kept hidden 2587 * from the public APIs. 2588 * 2589 * @hide 2590 * @deprecated 2591 */ 2592 @Deprecated 2593 public static final String NOTIFICATIONS_USE_RING_VOLUME = 2594 "notifications_use_ring_volume"; 2595 2596 private static final Validator NOTIFICATIONS_USE_RING_VOLUME_VALIDATOR = sBooleanValidator; 2597 2598 /** 2599 * Whether silent mode should allow vibration feedback. This is used 2600 * internally in AudioService and the Sound settings activity to 2601 * coordinate decoupling of vibrate and silent modes. This setting 2602 * will likely be removed in a future release with support for 2603 * audio/vibe feedback profiles. 2604 * 2605 * Not used anymore. On devices with vibrator, the user explicitly selects 2606 * silent or vibrate mode. 2607 * Kept for use by legacy database upgrade code in DatabaseHelper. 2608 * @hide 2609 */ 2610 public static final String VIBRATE_IN_SILENT = "vibrate_in_silent"; 2611 2612 private static final Validator VIBRATE_IN_SILENT_VALIDATOR = sBooleanValidator; 2613 2614 /** 2615 * The mapping of stream type (integer) to its setting. 2616 * 2617 * @removed Not used by anything since API 2. 2618 */ 2619 public static final String[] VOLUME_SETTINGS = { 2620 VOLUME_VOICE, VOLUME_SYSTEM, VOLUME_RING, VOLUME_MUSIC, 2621 VOLUME_ALARM, VOLUME_NOTIFICATION, VOLUME_BLUETOOTH_SCO 2622 }; 2623 2624 /** 2625 * Appended to various volume related settings to record the previous 2626 * values before they the settings were affected by a silent/vibrate 2627 * ringer mode change. 2628 * 2629 * @removed Not used by anything since API 2. 2630 */ 2631 public static final String APPEND_FOR_LAST_AUDIBLE = "_last_audible"; 2632 2633 /** 2634 * Persistent store for the system-wide default ringtone URI. 2635 * <p> 2636 * If you need to play the default ringtone at any given time, it is recommended 2637 * you give {@link #DEFAULT_RINGTONE_URI} to the media player. It will resolve 2638 * to the set default ringtone at the time of playing. 2639 * 2640 * @see #DEFAULT_RINGTONE_URI 2641 */ 2642 public static final String RINGTONE = "ringtone"; 2643 2644 private static final Validator RINGTONE_VALIDATOR = sUriValidator; 2645 2646 /** 2647 * A {@link Uri} that will point to the current default ringtone at any 2648 * given time. 2649 * <p> 2650 * If the current default ringtone is in the DRM provider and the caller 2651 * does not have permission, the exception will be a 2652 * FileNotFoundException. 2653 */ 2654 public static final Uri DEFAULT_RINGTONE_URI = getUriFor(RINGTONE); 2655 2656 /** 2657 * Persistent store for the system-wide default notification sound. 2658 * 2659 * @see #RINGTONE 2660 * @see #DEFAULT_NOTIFICATION_URI 2661 */ 2662 public static final String NOTIFICATION_SOUND = "notification_sound"; 2663 2664 private static final Validator NOTIFICATION_SOUND_VALIDATOR = sUriValidator; 2665 2666 /** 2667 * A {@link Uri} that will point to the current default notification 2668 * sound at any given time. 2669 * 2670 * @see #DEFAULT_RINGTONE_URI 2671 */ 2672 public static final Uri DEFAULT_NOTIFICATION_URI = getUriFor(NOTIFICATION_SOUND); 2673 2674 /** 2675 * Persistent store for the system-wide default alarm alert. 2676 * 2677 * @see #RINGTONE 2678 * @see #DEFAULT_ALARM_ALERT_URI 2679 */ 2680 public static final String ALARM_ALERT = "alarm_alert"; 2681 2682 private static final Validator ALARM_ALERT_VALIDATOR = sUriValidator; 2683 2684 /** 2685 * A {@link Uri} that will point to the current default alarm alert at 2686 * any given time. 2687 * 2688 * @see #DEFAULT_ALARM_ALERT_URI 2689 */ 2690 public static final Uri DEFAULT_ALARM_ALERT_URI = getUriFor(ALARM_ALERT); 2691 2692 /** 2693 * Persistent store for the system default media button event receiver. 2694 * 2695 * @hide 2696 */ 2697 public static final String MEDIA_BUTTON_RECEIVER = "media_button_receiver"; 2698 2699 private static final Validator MEDIA_BUTTON_RECEIVER_VALIDATOR = new Validator() { 2700 @Override 2701 public boolean validate(String value) { 2702 try { 2703 ComponentName.unflattenFromString(value); 2704 return true; 2705 } catch (NullPointerException e) { 2706 return false; 2707 } 2708 } 2709 }; 2710 2711 /** 2712 * Setting to enable Auto Replace (AutoText) in text editors. 1 = On, 0 = Off 2713 */ 2714 public static final String TEXT_AUTO_REPLACE = "auto_replace"; 2715 2716 private static final Validator TEXT_AUTO_REPLACE_VALIDATOR = sBooleanValidator; 2717 2718 /** 2719 * Setting to enable Auto Caps in text editors. 1 = On, 0 = Off 2720 */ 2721 public static final String TEXT_AUTO_CAPS = "auto_caps"; 2722 2723 private static final Validator TEXT_AUTO_CAPS_VALIDATOR = sBooleanValidator; 2724 2725 /** 2726 * Setting to enable Auto Punctuate in text editors. 1 = On, 0 = Off. This 2727 * feature converts two spaces to a "." and space. 2728 */ 2729 public static final String TEXT_AUTO_PUNCTUATE = "auto_punctuate"; 2730 2731 private static final Validator TEXT_AUTO_PUNCTUATE_VALIDATOR = sBooleanValidator; 2732 2733 /** 2734 * Setting to showing password characters in text editors. 1 = On, 0 = Off 2735 */ 2736 public static final String TEXT_SHOW_PASSWORD = "show_password"; 2737 2738 private static final Validator TEXT_SHOW_PASSWORD_VALIDATOR = sBooleanValidator; 2739 2740 public static final String SHOW_GTALK_SERVICE_STATUS = 2741 "SHOW_GTALK_SERVICE_STATUS"; 2742 2743 private static final Validator SHOW_GTALK_SERVICE_STATUS_VALIDATOR = sBooleanValidator; 2744 2745 /** 2746 * Name of activity to use for wallpaper on the home screen. 2747 * 2748 * @deprecated Use {@link WallpaperManager} instead. 2749 */ 2750 @Deprecated 2751 public static final String WALLPAPER_ACTIVITY = "wallpaper_activity"; 2752 2753 private static final Validator WALLPAPER_ACTIVITY_VALIDATOR = new Validator() { 2754 private static final int MAX_LENGTH = 1000; 2755 2756 @Override 2757 public boolean validate(String value) { 2758 if (value != null && value.length() > MAX_LENGTH) { 2759 return false; 2760 } 2761 return ComponentName.unflattenFromString(value) != null; 2762 } 2763 }; 2764 2765 /** 2766 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME} 2767 * instead 2768 */ 2769 @Deprecated 2770 public static final String AUTO_TIME = Global.AUTO_TIME; 2771 2772 /** 2773 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME_ZONE} 2774 * instead 2775 */ 2776 @Deprecated 2777 public static final String AUTO_TIME_ZONE = Global.AUTO_TIME_ZONE; 2778 2779 /** 2780 * Display times as 12 or 24 hours 2781 * 12 2782 * 24 2783 */ 2784 public static final String TIME_12_24 = "time_12_24"; 2785 2786 /** @hide */ 2787 public static final Validator TIME_12_24_VALIDATOR = 2788 new DiscreteValueValidator(new String[] {"12", "24"}); 2789 2790 /** 2791 * Date format string 2792 * mm/dd/yyyy 2793 * dd/mm/yyyy 2794 * yyyy/mm/dd 2795 */ 2796 public static final String DATE_FORMAT = "date_format"; 2797 2798 /** @hide */ 2799 public static final Validator DATE_FORMAT_VALIDATOR = new Validator() { 2800 @Override 2801 public boolean validate(String value) { 2802 try { 2803 new SimpleDateFormat(value); 2804 return true; 2805 } catch (IllegalArgumentException e) { 2806 return false; 2807 } 2808 } 2809 }; 2810 2811 /** 2812 * Whether the setup wizard has been run before (on first boot), or if 2813 * it still needs to be run. 2814 * 2815 * nonzero = it has been run in the past 2816 * 0 = it has not been run in the past 2817 */ 2818 public static final String SETUP_WIZARD_HAS_RUN = "setup_wizard_has_run"; 2819 2820 /** @hide */ 2821 public static final Validator SETUP_WIZARD_HAS_RUN_VALIDATOR = sBooleanValidator; 2822 2823 /** 2824 * Scaling factor for normal window animations. Setting to 0 will disable window 2825 * animations. 2826 * 2827 * @deprecated Use {@link Global#WINDOW_ANIMATION_SCALE} instead 2828 */ 2829 @Deprecated 2830 public static final String WINDOW_ANIMATION_SCALE = Global.WINDOW_ANIMATION_SCALE; 2831 2832 /** 2833 * Scaling factor for activity transition animations. Setting to 0 will disable window 2834 * animations. 2835 * 2836 * @deprecated Use {@link Global#TRANSITION_ANIMATION_SCALE} instead 2837 */ 2838 @Deprecated 2839 public static final String TRANSITION_ANIMATION_SCALE = Global.TRANSITION_ANIMATION_SCALE; 2840 2841 /** 2842 * Scaling factor for Animator-based animations. This affects both the start delay and 2843 * duration of all such animations. Setting to 0 will cause animations to end immediately. 2844 * The default value is 1. 2845 * 2846 * @deprecated Use {@link Global#ANIMATOR_DURATION_SCALE} instead 2847 */ 2848 @Deprecated 2849 public static final String ANIMATOR_DURATION_SCALE = Global.ANIMATOR_DURATION_SCALE; 2850 2851 /** 2852 * Control whether the accelerometer will be used to change screen 2853 * orientation. If 0, it will not be used unless explicitly requested 2854 * by the application; if 1, it will be used by default unless explicitly 2855 * disabled by the application. 2856 */ 2857 public static final String ACCELEROMETER_ROTATION = "accelerometer_rotation"; 2858 2859 /** @hide */ 2860 public static final Validator ACCELEROMETER_ROTATION_VALIDATOR = sBooleanValidator; 2861 2862 /** 2863 * Default screen rotation when no other policy applies. 2864 * When {@link #ACCELEROMETER_ROTATION} is zero and no on-screen Activity expresses a 2865 * preference, this rotation value will be used. Must be one of the 2866 * {@link android.view.Surface#ROTATION_0 Surface rotation constants}. 2867 * 2868 * @see android.view.Display#getRotation 2869 */ 2870 public static final String USER_ROTATION = "user_rotation"; 2871 2872 /** @hide */ 2873 public static final Validator USER_ROTATION_VALIDATOR = 2874 new InclusiveIntegerRangeValidator(0, 3); 2875 2876 /** 2877 * Control whether the rotation lock toggle in the System UI should be hidden. 2878 * Typically this is done for accessibility purposes to make it harder for 2879 * the user to accidentally toggle the rotation lock while the display rotation 2880 * has been locked for accessibility. 2881 * 2882 * If 0, then rotation lock toggle is not hidden for accessibility (although it may be 2883 * unavailable for other reasons). If 1, then the rotation lock toggle is hidden. 2884 * 2885 * @hide 2886 */ 2887 public static final String HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY = 2888 "hide_rotation_lock_toggle_for_accessibility"; 2889 2890 /** @hide */ 2891 public static final Validator HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY_VALIDATOR = 2892 sBooleanValidator; 2893 2894 /** 2895 * Whether the phone vibrates when it is ringing due to an incoming call. This will 2896 * be used by Phone and Setting apps; it shouldn't affect other apps. 2897 * The value is boolean (1 or 0). 2898 * 2899 * Note: this is not same as "vibrate on ring", which had been available until ICS. 2900 * It was about AudioManager's setting and thus affected all the applications which 2901 * relied on the setting, while this is purely about the vibration setting for incoming 2902 * calls. 2903 */ 2904 public static final String VIBRATE_WHEN_RINGING = "vibrate_when_ringing"; 2905 2906 /** @hide */ 2907 public static final Validator VIBRATE_WHEN_RINGING_VALIDATOR = sBooleanValidator; 2908 2909 /** 2910 * Whether the audible DTMF tones are played by the dialer when dialing. The value is 2911 * boolean (1 or 0). 2912 */ 2913 public static final String DTMF_TONE_WHEN_DIALING = "dtmf_tone"; 2914 2915 /** @hide */ 2916 public static final Validator DTMF_TONE_WHEN_DIALING_VALIDATOR = sBooleanValidator; 2917 2918 /** 2919 * CDMA only settings 2920 * DTMF tone type played by the dialer when dialing. 2921 * 0 = Normal 2922 * 1 = Long 2923 */ 2924 public static final String DTMF_TONE_TYPE_WHEN_DIALING = "dtmf_tone_type"; 2925 2926 /** @hide */ 2927 public static final Validator DTMF_TONE_TYPE_WHEN_DIALING_VALIDATOR = sBooleanValidator; 2928 2929 /** 2930 * Whether the hearing aid is enabled. The value is 2931 * boolean (1 or 0). 2932 * @hide 2933 */ 2934 public static final String HEARING_AID = "hearing_aid"; 2935 2936 /** @hide */ 2937 public static final Validator HEARING_AID_VALIDATOR = sBooleanValidator; 2938 2939 /** 2940 * CDMA only settings 2941 * TTY Mode 2942 * 0 = OFF 2943 * 1 = FULL 2944 * 2 = VCO 2945 * 3 = HCO 2946 * @hide 2947 */ 2948 public static final String TTY_MODE = "tty_mode"; 2949 2950 /** @hide */ 2951 public static final Validator TTY_MODE_VALIDATOR = new InclusiveIntegerRangeValidator(0, 3); 2952 2953 /** 2954 * Whether the sounds effects (key clicks, lid open ...) are enabled. The value is 2955 * boolean (1 or 0). 2956 */ 2957 public static final String SOUND_EFFECTS_ENABLED = "sound_effects_enabled"; 2958 2959 /** @hide */ 2960 public static final Validator SOUND_EFFECTS_ENABLED_VALIDATOR = sBooleanValidator; 2961 2962 /** 2963 * Whether the haptic feedback (long presses, ...) are enabled. The value is 2964 * boolean (1 or 0). 2965 */ 2966 public static final String HAPTIC_FEEDBACK_ENABLED = "haptic_feedback_enabled"; 2967 2968 /** @hide */ 2969 public static final Validator HAPTIC_FEEDBACK_ENABLED_VALIDATOR = sBooleanValidator; 2970 2971 /** 2972 * @deprecated Each application that shows web suggestions should have its own 2973 * setting for this. 2974 */ 2975 @Deprecated 2976 public static final String SHOW_WEB_SUGGESTIONS = "show_web_suggestions"; 2977 2978 /** @hide */ 2979 public static final Validator SHOW_WEB_SUGGESTIONS_VALIDATOR = sBooleanValidator; 2980 2981 /** 2982 * Whether the notification LED should repeatedly flash when a notification is 2983 * pending. The value is boolean (1 or 0). 2984 * @hide 2985 */ 2986 public static final String NOTIFICATION_LIGHT_PULSE = "notification_light_pulse"; 2987 2988 /** @hide */ 2989 public static final Validator NOTIFICATION_LIGHT_PULSE_VALIDATOR = sBooleanValidator; 2990 2991 /** 2992 * Show pointer location on screen? 2993 * 0 = no 2994 * 1 = yes 2995 * @hide 2996 */ 2997 public static final String POINTER_LOCATION = "pointer_location"; 2998 2999 /** @hide */ 3000 public static final Validator POINTER_LOCATION_VALIDATOR = sBooleanValidator; 3001 3002 /** 3003 * Show touch positions on screen? 3004 * 0 = no 3005 * 1 = yes 3006 * @hide 3007 */ 3008 public static final String SHOW_TOUCHES = "show_touches"; 3009 3010 /** @hide */ 3011 public static final Validator SHOW_TOUCHES_VALIDATOR = sBooleanValidator; 3012 3013 /** 3014 * Log raw orientation data from 3015 * {@link com.android.server.policy.WindowOrientationListener} for use with the 3016 * orientationplot.py tool. 3017 * 0 = no 3018 * 1 = yes 3019 * @hide 3020 */ 3021 public static final String WINDOW_ORIENTATION_LISTENER_LOG = 3022 "window_orientation_listener_log"; 3023 3024 /** @hide */ 3025 public static final Validator WINDOW_ORIENTATION_LISTENER_LOG_VALIDATOR = sBooleanValidator; 3026 3027 /** 3028 * @deprecated Use {@link android.provider.Settings.Global#POWER_SOUNDS_ENABLED} 3029 * instead 3030 * @hide 3031 */ 3032 @Deprecated 3033 public static final String POWER_SOUNDS_ENABLED = Global.POWER_SOUNDS_ENABLED; 3034 3035 /** 3036 * @deprecated Use {@link android.provider.Settings.Global#DOCK_SOUNDS_ENABLED} 3037 * instead 3038 * @hide 3039 */ 3040 @Deprecated 3041 public static final String DOCK_SOUNDS_ENABLED = Global.DOCK_SOUNDS_ENABLED; 3042 3043 /** 3044 * Whether to play sounds when the keyguard is shown and dismissed. 3045 * @hide 3046 */ 3047 public static final String LOCKSCREEN_SOUNDS_ENABLED = "lockscreen_sounds_enabled"; 3048 3049 /** @hide */ 3050 public static final Validator LOCKSCREEN_SOUNDS_ENABLED_VALIDATOR = sBooleanValidator; 3051 3052 /** 3053 * Whether the lockscreen should be completely disabled. 3054 * @hide 3055 */ 3056 public static final String LOCKSCREEN_DISABLED = "lockscreen.disabled"; 3057 3058 /** @hide */ 3059 public static final Validator LOCKSCREEN_DISABLED_VALIDATOR = sBooleanValidator; 3060 3061 /** 3062 * @deprecated Use {@link android.provider.Settings.Global#LOW_BATTERY_SOUND} 3063 * instead 3064 * @hide 3065 */ 3066 @Deprecated 3067 public static final String LOW_BATTERY_SOUND = Global.LOW_BATTERY_SOUND; 3068 3069 /** 3070 * @deprecated Use {@link android.provider.Settings.Global#DESK_DOCK_SOUND} 3071 * instead 3072 * @hide 3073 */ 3074 @Deprecated 3075 public static final String DESK_DOCK_SOUND = Global.DESK_DOCK_SOUND; 3076 3077 /** 3078 * @deprecated Use {@link android.provider.Settings.Global#DESK_UNDOCK_SOUND} 3079 * instead 3080 * @hide 3081 */ 3082 @Deprecated 3083 public static final String DESK_UNDOCK_SOUND = Global.DESK_UNDOCK_SOUND; 3084 3085 /** 3086 * @deprecated Use {@link android.provider.Settings.Global#CAR_DOCK_SOUND} 3087 * instead 3088 * @hide 3089 */ 3090 @Deprecated 3091 public static final String CAR_DOCK_SOUND = Global.CAR_DOCK_SOUND; 3092 3093 /** 3094 * @deprecated Use {@link android.provider.Settings.Global#CAR_UNDOCK_SOUND} 3095 * instead 3096 * @hide 3097 */ 3098 @Deprecated 3099 public static final String CAR_UNDOCK_SOUND = Global.CAR_UNDOCK_SOUND; 3100 3101 /** 3102 * @deprecated Use {@link android.provider.Settings.Global#LOCK_SOUND} 3103 * instead 3104 * @hide 3105 */ 3106 @Deprecated 3107 public static final String LOCK_SOUND = Global.LOCK_SOUND; 3108 3109 /** 3110 * @deprecated Use {@link android.provider.Settings.Global#UNLOCK_SOUND} 3111 * instead 3112 * @hide 3113 */ 3114 @Deprecated 3115 public static final String UNLOCK_SOUND = Global.UNLOCK_SOUND; 3116 3117 /** 3118 * Receive incoming SIP calls? 3119 * 0 = no 3120 * 1 = yes 3121 * @hide 3122 */ 3123 public static final String SIP_RECEIVE_CALLS = "sip_receive_calls"; 3124 3125 /** @hide */ 3126 public static final Validator SIP_RECEIVE_CALLS_VALIDATOR = sBooleanValidator; 3127 3128 /** 3129 * Call Preference String. 3130 * "SIP_ALWAYS" : Always use SIP with network access 3131 * "SIP_ADDRESS_ONLY" : Only if destination is a SIP address 3132 * @hide 3133 */ 3134 public static final String SIP_CALL_OPTIONS = "sip_call_options"; 3135 3136 /** @hide */ 3137 public static final Validator SIP_CALL_OPTIONS_VALIDATOR = new DiscreteValueValidator( 3138 new String[] {"SIP_ALWAYS", "SIP_ADDRESS_ONLY"}); 3139 3140 /** 3141 * One of the sip call options: Always use SIP with network access. 3142 * @hide 3143 */ 3144 public static final String SIP_ALWAYS = "SIP_ALWAYS"; 3145 3146 /** @hide */ 3147 public static final Validator SIP_ALWAYS_VALIDATOR = sBooleanValidator; 3148 3149 /** 3150 * One of the sip call options: Only if destination is a SIP address. 3151 * @hide 3152 */ 3153 public static final String SIP_ADDRESS_ONLY = "SIP_ADDRESS_ONLY"; 3154 3155 /** @hide */ 3156 public static final Validator SIP_ADDRESS_ONLY_VALIDATOR = sBooleanValidator; 3157 3158 /** 3159 * @deprecated Use SIP_ALWAYS or SIP_ADDRESS_ONLY instead. Formerly used to indicate that 3160 * the user should be prompted each time a call is made whether it should be placed using 3161 * SIP. The {@link com.android.providers.settings.DatabaseHelper} replaces this with 3162 * SIP_ADDRESS_ONLY. 3163 * @hide 3164 */ 3165 @Deprecated 3166 public static final String SIP_ASK_ME_EACH_TIME = "SIP_ASK_ME_EACH_TIME"; 3167 3168 /** @hide */ 3169 public static final Validator SIP_ASK_ME_EACH_TIME_VALIDATOR = sBooleanValidator; 3170 3171 /** 3172 * Pointer speed setting. 3173 * This is an integer value in a range between -7 and +7, so there are 15 possible values. 3174 * -7 = slowest 3175 * 0 = default speed 3176 * +7 = fastest 3177 * @hide 3178 */ 3179 public static final String POINTER_SPEED = "pointer_speed"; 3180 3181 /** @hide */ 3182 public static final Validator POINTER_SPEED_VALIDATOR = 3183 new InclusiveFloatRangeValidator(-7, 7); 3184 3185 /** 3186 * Whether lock-to-app will be triggered by long-press on recents. 3187 * @hide 3188 */ 3189 public static final String LOCK_TO_APP_ENABLED = "lock_to_app_enabled"; 3190 3191 /** @hide */ 3192 public static final Validator LOCK_TO_APP_ENABLED_VALIDATOR = sBooleanValidator; 3193 3194 /** 3195 * I am the lolrus. 3196 * <p> 3197 * Nonzero values indicate that the user has a bukkit. 3198 * Backward-compatible with <code>PrefGetPreference(prefAllowEasterEggs)</code>. 3199 * @hide 3200 */ 3201 public static final String EGG_MODE = "egg_mode"; 3202 3203 /** @hide */ 3204 public static final Validator EGG_MODE_VALIDATOR = new Validator() { 3205 @Override 3206 public boolean validate(String value) { 3207 try { 3208 return Long.parseLong(value) >= 0; 3209 } catch (NumberFormatException e) { 3210 return false; 3211 } 3212 } 3213 }; 3214 3215 /** 3216 * IMPORTANT: If you add a new public settings you also have to add it to 3217 * PUBLIC_SETTINGS below. If the new setting is hidden you have to add 3218 * it to PRIVATE_SETTINGS below. Also add a validator that can validate 3219 * the setting value. See an example above. 3220 */ 3221 3222 /** 3223 * Settings to backup. This is here so that it's in the same place as the settings 3224 * keys and easy to update. 3225 * 3226 * NOTE: Settings are backed up and restored in the order they appear 3227 * in this array. If you have one setting depending on another, 3228 * make sure that they are ordered appropriately. 3229 * 3230 * @hide 3231 */ 3232 public static final String[] SETTINGS_TO_BACKUP = { 3233 STAY_ON_WHILE_PLUGGED_IN, // moved to global 3234 WIFI_USE_STATIC_IP, 3235 WIFI_STATIC_IP, 3236 WIFI_STATIC_GATEWAY, 3237 WIFI_STATIC_NETMASK, 3238 WIFI_STATIC_DNS1, 3239 WIFI_STATIC_DNS2, 3240 BLUETOOTH_DISCOVERABILITY, 3241 BLUETOOTH_DISCOVERABILITY_TIMEOUT, 3242 DIM_SCREEN, 3243 SCREEN_OFF_TIMEOUT, 3244 SCREEN_BRIGHTNESS, 3245 SCREEN_BRIGHTNESS_MODE, 3246 SCREEN_AUTO_BRIGHTNESS_ADJ, 3247 VIBRATE_INPUT_DEVICES, 3248 MODE_RINGER_STREAMS_AFFECTED, 3249 TEXT_AUTO_REPLACE, 3250 TEXT_AUTO_CAPS, 3251 TEXT_AUTO_PUNCTUATE, 3252 TEXT_SHOW_PASSWORD, 3253 AUTO_TIME, // moved to global 3254 AUTO_TIME_ZONE, // moved to global 3255 TIME_12_24, 3256 DATE_FORMAT, 3257 DTMF_TONE_WHEN_DIALING, 3258 DTMF_TONE_TYPE_WHEN_DIALING, 3259 HEARING_AID, 3260 TTY_MODE, 3261 SOUND_EFFECTS_ENABLED, 3262 HAPTIC_FEEDBACK_ENABLED, 3263 POWER_SOUNDS_ENABLED, // moved to global 3264 DOCK_SOUNDS_ENABLED, // moved to global 3265 LOCKSCREEN_SOUNDS_ENABLED, 3266 SHOW_WEB_SUGGESTIONS, 3267 SIP_CALL_OPTIONS, 3268 SIP_RECEIVE_CALLS, 3269 POINTER_SPEED, 3270 VIBRATE_WHEN_RINGING, 3271 RINGTONE, 3272 LOCK_TO_APP_ENABLED, 3273 NOTIFICATION_SOUND 3274 }; 3275 3276 /** 3277 * These are all public system settings 3278 * 3279 * @hide 3280 */ 3281 public static final Set<String> PUBLIC_SETTINGS = new ArraySet<>(); 3282 static { 3283 PUBLIC_SETTINGS.add(END_BUTTON_BEHAVIOR); 3284 PUBLIC_SETTINGS.add(WIFI_USE_STATIC_IP); 3285 PUBLIC_SETTINGS.add(WIFI_STATIC_IP); 3286 PUBLIC_SETTINGS.add(WIFI_STATIC_GATEWAY); 3287 PUBLIC_SETTINGS.add(WIFI_STATIC_NETMASK); 3288 PUBLIC_SETTINGS.add(WIFI_STATIC_DNS1); 3289 PUBLIC_SETTINGS.add(WIFI_STATIC_DNS2); 3290 PUBLIC_SETTINGS.add(BLUETOOTH_DISCOVERABILITY); 3291 PUBLIC_SETTINGS.add(BLUETOOTH_DISCOVERABILITY_TIMEOUT); 3292 PUBLIC_SETTINGS.add(NEXT_ALARM_FORMATTED); 3293 PUBLIC_SETTINGS.add(FONT_SCALE); 3294 PUBLIC_SETTINGS.add(DIM_SCREEN); 3295 PUBLIC_SETTINGS.add(SCREEN_OFF_TIMEOUT); 3296 PUBLIC_SETTINGS.add(SCREEN_BRIGHTNESS); 3297 PUBLIC_SETTINGS.add(SCREEN_BRIGHTNESS_MODE); 3298 PUBLIC_SETTINGS.add(MODE_RINGER_STREAMS_AFFECTED); 3299 PUBLIC_SETTINGS.add(MUTE_STREAMS_AFFECTED); 3300 PUBLIC_SETTINGS.add(VIBRATE_ON); 3301 PUBLIC_SETTINGS.add(VOLUME_RING); 3302 PUBLIC_SETTINGS.add(VOLUME_SYSTEM); 3303 PUBLIC_SETTINGS.add(VOLUME_VOICE); 3304 PUBLIC_SETTINGS.add(VOLUME_MUSIC); 3305 PUBLIC_SETTINGS.add(VOLUME_ALARM); 3306 PUBLIC_SETTINGS.add(VOLUME_NOTIFICATION); 3307 PUBLIC_SETTINGS.add(VOLUME_BLUETOOTH_SCO); 3308 PUBLIC_SETTINGS.add(RINGTONE); 3309 PUBLIC_SETTINGS.add(NOTIFICATION_SOUND); 3310 PUBLIC_SETTINGS.add(ALARM_ALERT); 3311 PUBLIC_SETTINGS.add(TEXT_AUTO_REPLACE); 3312 PUBLIC_SETTINGS.add(TEXT_AUTO_CAPS); 3313 PUBLIC_SETTINGS.add(TEXT_AUTO_PUNCTUATE); 3314 PUBLIC_SETTINGS.add(TEXT_SHOW_PASSWORD); 3315 PUBLIC_SETTINGS.add(SHOW_GTALK_SERVICE_STATUS); 3316 PUBLIC_SETTINGS.add(WALLPAPER_ACTIVITY); 3317 PUBLIC_SETTINGS.add(TIME_12_24); 3318 PUBLIC_SETTINGS.add(DATE_FORMAT); 3319 PUBLIC_SETTINGS.add(SETUP_WIZARD_HAS_RUN); 3320 PUBLIC_SETTINGS.add(ACCELEROMETER_ROTATION); 3321 PUBLIC_SETTINGS.add(USER_ROTATION); 3322 PUBLIC_SETTINGS.add(DTMF_TONE_WHEN_DIALING); 3323 PUBLIC_SETTINGS.add(SOUND_EFFECTS_ENABLED); 3324 PUBLIC_SETTINGS.add(HAPTIC_FEEDBACK_ENABLED); 3325 PUBLIC_SETTINGS.add(SHOW_WEB_SUGGESTIONS); 3326 } 3327 3328 /** 3329 * These are all hidden system settings. 3330 * 3331 * @hide 3332 */ 3333 public static final Set<String> PRIVATE_SETTINGS = new ArraySet<>(); 3334 static { 3335 PRIVATE_SETTINGS.add(WIFI_USE_STATIC_IP); 3336 PRIVATE_SETTINGS.add(END_BUTTON_BEHAVIOR); 3337 PRIVATE_SETTINGS.add(ADVANCED_SETTINGS); 3338 PRIVATE_SETTINGS.add(SCREEN_AUTO_BRIGHTNESS_ADJ); 3339 PRIVATE_SETTINGS.add(VIBRATE_INPUT_DEVICES); 3340 PRIVATE_SETTINGS.add(VOLUME_MASTER); 3341 PRIVATE_SETTINGS.add(VOLUME_MASTER_MUTE); 3342 PRIVATE_SETTINGS.add(MICROPHONE_MUTE); 3343 PRIVATE_SETTINGS.add(NOTIFICATIONS_USE_RING_VOLUME); 3344 PRIVATE_SETTINGS.add(VIBRATE_IN_SILENT); 3345 PRIVATE_SETTINGS.add(MEDIA_BUTTON_RECEIVER); 3346 PRIVATE_SETTINGS.add(HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY); 3347 PRIVATE_SETTINGS.add(VIBRATE_WHEN_RINGING); 3348 PRIVATE_SETTINGS.add(DTMF_TONE_TYPE_WHEN_DIALING); 3349 PRIVATE_SETTINGS.add(HEARING_AID); 3350 PRIVATE_SETTINGS.add(TTY_MODE); 3351 PRIVATE_SETTINGS.add(NOTIFICATION_LIGHT_PULSE); 3352 PRIVATE_SETTINGS.add(POINTER_LOCATION); 3353 PRIVATE_SETTINGS.add(SHOW_TOUCHES); 3354 PRIVATE_SETTINGS.add(WINDOW_ORIENTATION_LISTENER_LOG); 3355 PRIVATE_SETTINGS.add(POWER_SOUNDS_ENABLED); 3356 PRIVATE_SETTINGS.add(DOCK_SOUNDS_ENABLED); 3357 PRIVATE_SETTINGS.add(LOCKSCREEN_SOUNDS_ENABLED); 3358 PRIVATE_SETTINGS.add(LOCKSCREEN_DISABLED); 3359 PRIVATE_SETTINGS.add(LOW_BATTERY_SOUND); 3360 PRIVATE_SETTINGS.add(DESK_DOCK_SOUND); 3361 PRIVATE_SETTINGS.add(DESK_UNDOCK_SOUND); 3362 PRIVATE_SETTINGS.add(CAR_DOCK_SOUND); 3363 PRIVATE_SETTINGS.add(CAR_UNDOCK_SOUND); 3364 PRIVATE_SETTINGS.add(LOCK_SOUND); 3365 PRIVATE_SETTINGS.add(UNLOCK_SOUND); 3366 PRIVATE_SETTINGS.add(SIP_RECEIVE_CALLS); 3367 PRIVATE_SETTINGS.add(SIP_CALL_OPTIONS); 3368 PRIVATE_SETTINGS.add(SIP_ALWAYS); 3369 PRIVATE_SETTINGS.add(SIP_ADDRESS_ONLY); 3370 PRIVATE_SETTINGS.add(SIP_ASK_ME_EACH_TIME); 3371 PRIVATE_SETTINGS.add(POINTER_SPEED); 3372 PRIVATE_SETTINGS.add(LOCK_TO_APP_ENABLED); 3373 PRIVATE_SETTINGS.add(EGG_MODE); 3374 } 3375 3376 /** 3377 * These are all public system settings 3378 * 3379 * @hide 3380 */ 3381 public static final Map<String, Validator> VALIDATORS = new ArrayMap<>(); 3382 static { VALIDATORS.put(END_BUTTON_BEHAVIOR,END_BUTTON_BEHAVIOR_VALIDATOR)3383 VALIDATORS.put(END_BUTTON_BEHAVIOR,END_BUTTON_BEHAVIOR_VALIDATOR); VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR)3384 VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR); VALIDATORS.put(BLUETOOTH_DISCOVERABILITY, BLUETOOTH_DISCOVERABILITY_VALIDATOR)3385 VALIDATORS.put(BLUETOOTH_DISCOVERABILITY, BLUETOOTH_DISCOVERABILITY_VALIDATOR); VALIDATORS.put(BLUETOOTH_DISCOVERABILITY_TIMEOUT, BLUETOOTH_DISCOVERABILITY_TIMEOUT_VALIDATOR)3386 VALIDATORS.put(BLUETOOTH_DISCOVERABILITY_TIMEOUT, 3387 BLUETOOTH_DISCOVERABILITY_TIMEOUT_VALIDATOR); VALIDATORS.put(NEXT_ALARM_FORMATTED, NEXT_ALARM_FORMATTED_VALIDATOR)3388 VALIDATORS.put(NEXT_ALARM_FORMATTED, NEXT_ALARM_FORMATTED_VALIDATOR); VALIDATORS.put(FONT_SCALE, FONT_SCALE_VALIDATOR)3389 VALIDATORS.put(FONT_SCALE, FONT_SCALE_VALIDATOR); VALIDATORS.put(DIM_SCREEN, DIM_SCREEN_VALIDATOR)3390 VALIDATORS.put(DIM_SCREEN, DIM_SCREEN_VALIDATOR); VALIDATORS.put(SCREEN_OFF_TIMEOUT, SCREEN_OFF_TIMEOUT_VALIDATOR)3391 VALIDATORS.put(SCREEN_OFF_TIMEOUT, SCREEN_OFF_TIMEOUT_VALIDATOR); VALIDATORS.put(SCREEN_BRIGHTNESS, SCREEN_BRIGHTNESS_VALIDATOR)3392 VALIDATORS.put(SCREEN_BRIGHTNESS, SCREEN_BRIGHTNESS_VALIDATOR); VALIDATORS.put(SCREEN_BRIGHTNESS_MODE, SCREEN_BRIGHTNESS_MODE_VALIDATOR)3393 VALIDATORS.put(SCREEN_BRIGHTNESS_MODE, SCREEN_BRIGHTNESS_MODE_VALIDATOR); VALIDATORS.put(MODE_RINGER_STREAMS_AFFECTED, MODE_RINGER_STREAMS_AFFECTED_VALIDATOR)3394 VALIDATORS.put(MODE_RINGER_STREAMS_AFFECTED, MODE_RINGER_STREAMS_AFFECTED_VALIDATOR); VALIDATORS.put(MUTE_STREAMS_AFFECTED, MUTE_STREAMS_AFFECTED_VALIDATOR)3395 VALIDATORS.put(MUTE_STREAMS_AFFECTED, MUTE_STREAMS_AFFECTED_VALIDATOR); VALIDATORS.put(VIBRATE_ON, VIBRATE_ON_VALIDATOR)3396 VALIDATORS.put(VIBRATE_ON, VIBRATE_ON_VALIDATOR); VALIDATORS.put(RINGTONE, RINGTONE_VALIDATOR)3397 VALIDATORS.put(RINGTONE, RINGTONE_VALIDATOR); VALIDATORS.put(NOTIFICATION_SOUND, NOTIFICATION_SOUND_VALIDATOR)3398 VALIDATORS.put(NOTIFICATION_SOUND, NOTIFICATION_SOUND_VALIDATOR); VALIDATORS.put(ALARM_ALERT, ALARM_ALERT_VALIDATOR)3399 VALIDATORS.put(ALARM_ALERT, ALARM_ALERT_VALIDATOR); VALIDATORS.put(TEXT_AUTO_REPLACE, TEXT_AUTO_REPLACE_VALIDATOR)3400 VALIDATORS.put(TEXT_AUTO_REPLACE, TEXT_AUTO_REPLACE_VALIDATOR); VALIDATORS.put(TEXT_AUTO_CAPS, TEXT_AUTO_CAPS_VALIDATOR)3401 VALIDATORS.put(TEXT_AUTO_CAPS, TEXT_AUTO_CAPS_VALIDATOR); VALIDATORS.put(TEXT_AUTO_PUNCTUATE, TEXT_AUTO_PUNCTUATE_VALIDATOR)3402 VALIDATORS.put(TEXT_AUTO_PUNCTUATE, TEXT_AUTO_PUNCTUATE_VALIDATOR); VALIDATORS.put(TEXT_SHOW_PASSWORD, TEXT_SHOW_PASSWORD_VALIDATOR)3403 VALIDATORS.put(TEXT_SHOW_PASSWORD, TEXT_SHOW_PASSWORD_VALIDATOR); VALIDATORS.put(SHOW_GTALK_SERVICE_STATUS, SHOW_GTALK_SERVICE_STATUS_VALIDATOR)3404 VALIDATORS.put(SHOW_GTALK_SERVICE_STATUS, SHOW_GTALK_SERVICE_STATUS_VALIDATOR); VALIDATORS.put(WALLPAPER_ACTIVITY, WALLPAPER_ACTIVITY_VALIDATOR)3405 VALIDATORS.put(WALLPAPER_ACTIVITY, WALLPAPER_ACTIVITY_VALIDATOR); VALIDATORS.put(TIME_12_24, TIME_12_24_VALIDATOR)3406 VALIDATORS.put(TIME_12_24, TIME_12_24_VALIDATOR); VALIDATORS.put(DATE_FORMAT, DATE_FORMAT_VALIDATOR)3407 VALIDATORS.put(DATE_FORMAT, DATE_FORMAT_VALIDATOR); VALIDATORS.put(SETUP_WIZARD_HAS_RUN, SETUP_WIZARD_HAS_RUN_VALIDATOR)3408 VALIDATORS.put(SETUP_WIZARD_HAS_RUN, SETUP_WIZARD_HAS_RUN_VALIDATOR); VALIDATORS.put(ACCELEROMETER_ROTATION, ACCELEROMETER_ROTATION_VALIDATOR)3409 VALIDATORS.put(ACCELEROMETER_ROTATION, ACCELEROMETER_ROTATION_VALIDATOR); VALIDATORS.put(USER_ROTATION, USER_ROTATION_VALIDATOR)3410 VALIDATORS.put(USER_ROTATION, USER_ROTATION_VALIDATOR); VALIDATORS.put(DTMF_TONE_WHEN_DIALING, DTMF_TONE_WHEN_DIALING_VALIDATOR)3411 VALIDATORS.put(DTMF_TONE_WHEN_DIALING, DTMF_TONE_WHEN_DIALING_VALIDATOR); VALIDATORS.put(SOUND_EFFECTS_ENABLED, SOUND_EFFECTS_ENABLED_VALIDATOR)3412 VALIDATORS.put(SOUND_EFFECTS_ENABLED, SOUND_EFFECTS_ENABLED_VALIDATOR); VALIDATORS.put(HAPTIC_FEEDBACK_ENABLED, HAPTIC_FEEDBACK_ENABLED_VALIDATOR)3413 VALIDATORS.put(HAPTIC_FEEDBACK_ENABLED, HAPTIC_FEEDBACK_ENABLED_VALIDATOR); VALIDATORS.put(SHOW_WEB_SUGGESTIONS, SHOW_WEB_SUGGESTIONS_VALIDATOR)3414 VALIDATORS.put(SHOW_WEB_SUGGESTIONS, SHOW_WEB_SUGGESTIONS_VALIDATOR); VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR)3415 VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR); VALIDATORS.put(END_BUTTON_BEHAVIOR, END_BUTTON_BEHAVIOR_VALIDATOR)3416 VALIDATORS.put(END_BUTTON_BEHAVIOR, END_BUTTON_BEHAVIOR_VALIDATOR); VALIDATORS.put(ADVANCED_SETTINGS, ADVANCED_SETTINGS_VALIDATOR)3417 VALIDATORS.put(ADVANCED_SETTINGS, ADVANCED_SETTINGS_VALIDATOR); VALIDATORS.put(SCREEN_AUTO_BRIGHTNESS_ADJ, SCREEN_AUTO_BRIGHTNESS_ADJ_VALIDATOR)3418 VALIDATORS.put(SCREEN_AUTO_BRIGHTNESS_ADJ, SCREEN_AUTO_BRIGHTNESS_ADJ_VALIDATOR); VALIDATORS.put(VIBRATE_INPUT_DEVICES, VIBRATE_INPUT_DEVICES_VALIDATOR)3419 VALIDATORS.put(VIBRATE_INPUT_DEVICES, VIBRATE_INPUT_DEVICES_VALIDATOR); VALIDATORS.put(VOLUME_MASTER_MUTE, VOLUME_MASTER_MUTE_VALIDATOR)3420 VALIDATORS.put(VOLUME_MASTER_MUTE, VOLUME_MASTER_MUTE_VALIDATOR); VALIDATORS.put(MICROPHONE_MUTE, MICROPHONE_MUTE_VALIDATOR)3421 VALIDATORS.put(MICROPHONE_MUTE, MICROPHONE_MUTE_VALIDATOR); VALIDATORS.put(NOTIFICATIONS_USE_RING_VOLUME, NOTIFICATIONS_USE_RING_VOLUME_VALIDATOR)3422 VALIDATORS.put(NOTIFICATIONS_USE_RING_VOLUME, NOTIFICATIONS_USE_RING_VOLUME_VALIDATOR); VALIDATORS.put(VIBRATE_IN_SILENT, VIBRATE_IN_SILENT_VALIDATOR)3423 VALIDATORS.put(VIBRATE_IN_SILENT, VIBRATE_IN_SILENT_VALIDATOR); VALIDATORS.put(MEDIA_BUTTON_RECEIVER, MEDIA_BUTTON_RECEIVER_VALIDATOR)3424 VALIDATORS.put(MEDIA_BUTTON_RECEIVER, MEDIA_BUTTON_RECEIVER_VALIDATOR); VALIDATORS.put(HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY, HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY_VALIDATOR)3425 VALIDATORS.put(HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY, 3426 HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY_VALIDATOR); VALIDATORS.put(VIBRATE_WHEN_RINGING, VIBRATE_WHEN_RINGING_VALIDATOR)3427 VALIDATORS.put(VIBRATE_WHEN_RINGING, VIBRATE_WHEN_RINGING_VALIDATOR); VALIDATORS.put(DTMF_TONE_TYPE_WHEN_DIALING, DTMF_TONE_TYPE_WHEN_DIALING_VALIDATOR)3428 VALIDATORS.put(DTMF_TONE_TYPE_WHEN_DIALING, DTMF_TONE_TYPE_WHEN_DIALING_VALIDATOR); VALIDATORS.put(HEARING_AID, HEARING_AID_VALIDATOR)3429 VALIDATORS.put(HEARING_AID, HEARING_AID_VALIDATOR); VALIDATORS.put(TTY_MODE, TTY_MODE_VALIDATOR)3430 VALIDATORS.put(TTY_MODE, TTY_MODE_VALIDATOR); VALIDATORS.put(NOTIFICATION_LIGHT_PULSE, NOTIFICATION_LIGHT_PULSE_VALIDATOR)3431 VALIDATORS.put(NOTIFICATION_LIGHT_PULSE, NOTIFICATION_LIGHT_PULSE_VALIDATOR); VALIDATORS.put(POINTER_LOCATION, POINTER_LOCATION_VALIDATOR)3432 VALIDATORS.put(POINTER_LOCATION, POINTER_LOCATION_VALIDATOR); VALIDATORS.put(SHOW_TOUCHES, SHOW_TOUCHES_VALIDATOR)3433 VALIDATORS.put(SHOW_TOUCHES, SHOW_TOUCHES_VALIDATOR); VALIDATORS.put(WINDOW_ORIENTATION_LISTENER_LOG, WINDOW_ORIENTATION_LISTENER_LOG_VALIDATOR)3434 VALIDATORS.put(WINDOW_ORIENTATION_LISTENER_LOG, 3435 WINDOW_ORIENTATION_LISTENER_LOG_VALIDATOR); VALIDATORS.put(LOCKSCREEN_SOUNDS_ENABLED, LOCKSCREEN_SOUNDS_ENABLED_VALIDATOR)3436 VALIDATORS.put(LOCKSCREEN_SOUNDS_ENABLED, LOCKSCREEN_SOUNDS_ENABLED_VALIDATOR); VALIDATORS.put(LOCKSCREEN_DISABLED, LOCKSCREEN_DISABLED_VALIDATOR)3437 VALIDATORS.put(LOCKSCREEN_DISABLED, LOCKSCREEN_DISABLED_VALIDATOR); VALIDATORS.put(SIP_RECEIVE_CALLS, SIP_RECEIVE_CALLS_VALIDATOR)3438 VALIDATORS.put(SIP_RECEIVE_CALLS, SIP_RECEIVE_CALLS_VALIDATOR); VALIDATORS.put(SIP_CALL_OPTIONS, SIP_CALL_OPTIONS_VALIDATOR)3439 VALIDATORS.put(SIP_CALL_OPTIONS, SIP_CALL_OPTIONS_VALIDATOR); VALIDATORS.put(SIP_ALWAYS, SIP_ALWAYS_VALIDATOR)3440 VALIDATORS.put(SIP_ALWAYS, SIP_ALWAYS_VALIDATOR); VALIDATORS.put(SIP_ADDRESS_ONLY, SIP_ADDRESS_ONLY_VALIDATOR)3441 VALIDATORS.put(SIP_ADDRESS_ONLY, SIP_ADDRESS_ONLY_VALIDATOR); VALIDATORS.put(SIP_ASK_ME_EACH_TIME, SIP_ASK_ME_EACH_TIME_VALIDATOR)3442 VALIDATORS.put(SIP_ASK_ME_EACH_TIME, SIP_ASK_ME_EACH_TIME_VALIDATOR); VALIDATORS.put(POINTER_SPEED, POINTER_SPEED_VALIDATOR)3443 VALIDATORS.put(POINTER_SPEED, POINTER_SPEED_VALIDATOR); VALIDATORS.put(LOCK_TO_APP_ENABLED, LOCK_TO_APP_ENABLED_VALIDATOR)3444 VALIDATORS.put(LOCK_TO_APP_ENABLED, LOCK_TO_APP_ENABLED_VALIDATOR); VALIDATORS.put(EGG_MODE, EGG_MODE_VALIDATOR)3445 VALIDATORS.put(EGG_MODE, EGG_MODE_VALIDATOR); VALIDATORS.put(WIFI_STATIC_IP, WIFI_STATIC_IP_VALIDATOR)3446 VALIDATORS.put(WIFI_STATIC_IP, WIFI_STATIC_IP_VALIDATOR); VALIDATORS.put(WIFI_STATIC_GATEWAY, WIFI_STATIC_GATEWAY_VALIDATOR)3447 VALIDATORS.put(WIFI_STATIC_GATEWAY, WIFI_STATIC_GATEWAY_VALIDATOR); VALIDATORS.put(WIFI_STATIC_NETMASK, WIFI_STATIC_NETMASK_VALIDATOR)3448 VALIDATORS.put(WIFI_STATIC_NETMASK, WIFI_STATIC_NETMASK_VALIDATOR); VALIDATORS.put(WIFI_STATIC_DNS1, WIFI_STATIC_DNS1_VALIDATOR)3449 VALIDATORS.put(WIFI_STATIC_DNS1, WIFI_STATIC_DNS1_VALIDATOR); VALIDATORS.put(WIFI_STATIC_DNS2, WIFI_STATIC_DNS2_VALIDATOR)3450 VALIDATORS.put(WIFI_STATIC_DNS2, WIFI_STATIC_DNS2_VALIDATOR); 3451 } 3452 3453 /** 3454 * These entries are considered common between the personal and the managed profile, 3455 * since the managed profile doesn't get to change them. 3456 */ 3457 private static final Set<String> CLONE_TO_MANAGED_PROFILE = new ArraySet<>(); 3458 static { 3459 CLONE_TO_MANAGED_PROFILE.add(DATE_FORMAT); 3460 CLONE_TO_MANAGED_PROFILE.add(HAPTIC_FEEDBACK_ENABLED); 3461 CLONE_TO_MANAGED_PROFILE.add(SOUND_EFFECTS_ENABLED); 3462 CLONE_TO_MANAGED_PROFILE.add(TEXT_SHOW_PASSWORD); 3463 CLONE_TO_MANAGED_PROFILE.add(TIME_12_24); 3464 } 3465 3466 /** @hide */ getCloneToManagedProfileSettings(Set<String> outKeySet)3467 public static void getCloneToManagedProfileSettings(Set<String> outKeySet) { 3468 outKeySet.addAll(CLONE_TO_MANAGED_PROFILE); 3469 } 3470 3471 /** 3472 * When to use Wi-Fi calling 3473 * 3474 * @see android.telephony.TelephonyManager.WifiCallingChoices 3475 * @hide 3476 */ 3477 public static final String WHEN_TO_MAKE_WIFI_CALLS = "when_to_make_wifi_calls"; 3478 3479 // Settings moved to Settings.Secure 3480 3481 /** 3482 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} 3483 * instead 3484 */ 3485 @Deprecated 3486 public static final String ADB_ENABLED = Global.ADB_ENABLED; 3487 3488 /** 3489 * @deprecated Use {@link android.provider.Settings.Secure#ANDROID_ID} instead 3490 */ 3491 @Deprecated 3492 public static final String ANDROID_ID = Secure.ANDROID_ID; 3493 3494 /** 3495 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 3496 */ 3497 @Deprecated 3498 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 3499 3500 /** 3501 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 3502 */ 3503 @Deprecated 3504 public static final String DATA_ROAMING = Global.DATA_ROAMING; 3505 3506 /** 3507 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 3508 */ 3509 @Deprecated 3510 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 3511 3512 /** 3513 * @deprecated Use {@link android.provider.Settings.Global#HTTP_PROXY} instead 3514 */ 3515 @Deprecated 3516 public static final String HTTP_PROXY = Global.HTTP_PROXY; 3517 3518 /** 3519 * @deprecated Use {@link android.provider.Settings.Secure#INSTALL_NON_MARKET_APPS} instead 3520 */ 3521 @Deprecated 3522 public static final String INSTALL_NON_MARKET_APPS = Secure.INSTALL_NON_MARKET_APPS; 3523 3524 /** 3525 * @deprecated Use {@link android.provider.Settings.Secure#LOCATION_PROVIDERS_ALLOWED} 3526 * instead 3527 */ 3528 @Deprecated 3529 public static final String LOCATION_PROVIDERS_ALLOWED = Secure.LOCATION_PROVIDERS_ALLOWED; 3530 3531 /** 3532 * @deprecated Use {@link android.provider.Settings.Secure#LOGGING_ID} instead 3533 */ 3534 @Deprecated 3535 public static final String LOGGING_ID = Secure.LOGGING_ID; 3536 3537 /** 3538 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 3539 */ 3540 @Deprecated 3541 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 3542 3543 /** 3544 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_ENABLED} 3545 * instead 3546 */ 3547 @Deprecated 3548 public static final String PARENTAL_CONTROL_ENABLED = Secure.PARENTAL_CONTROL_ENABLED; 3549 3550 /** 3551 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_LAST_UPDATE} 3552 * instead 3553 */ 3554 @Deprecated 3555 public static final String PARENTAL_CONTROL_LAST_UPDATE = Secure.PARENTAL_CONTROL_LAST_UPDATE; 3556 3557 /** 3558 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_REDIRECT_URL} 3559 * instead 3560 */ 3561 @Deprecated 3562 public static final String PARENTAL_CONTROL_REDIRECT_URL = 3563 Secure.PARENTAL_CONTROL_REDIRECT_URL; 3564 3565 /** 3566 * @deprecated Use {@link android.provider.Settings.Secure#SETTINGS_CLASSNAME} instead 3567 */ 3568 @Deprecated 3569 public static final String SETTINGS_CLASSNAME = Secure.SETTINGS_CLASSNAME; 3570 3571 /** 3572 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 3573 */ 3574 @Deprecated 3575 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 3576 3577 /** 3578 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 3579 */ 3580 @Deprecated 3581 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 3582 3583 /** 3584 * @deprecated Use 3585 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 3586 */ 3587 @Deprecated 3588 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 3589 3590 /** 3591 * @deprecated Use 3592 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 3593 */ 3594 @Deprecated 3595 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 3596 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 3597 3598 /** 3599 * @deprecated Use 3600 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} instead 3601 */ 3602 @Deprecated 3603 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 3604 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 3605 3606 /** 3607 * @deprecated Use 3608 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} instead 3609 */ 3610 @Deprecated 3611 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 3612 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 3613 3614 /** 3615 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 3616 * instead 3617 */ 3618 @Deprecated 3619 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 3620 3621 /** 3622 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} instead 3623 */ 3624 @Deprecated 3625 public static final String WIFI_ON = Global.WIFI_ON; 3626 3627 /** 3628 * @deprecated Use 3629 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE} 3630 * instead 3631 */ 3632 @Deprecated 3633 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 3634 Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE; 3635 3636 /** 3637 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_AP_COUNT} instead 3638 */ 3639 @Deprecated 3640 public static final String WIFI_WATCHDOG_AP_COUNT = Secure.WIFI_WATCHDOG_AP_COUNT; 3641 3642 /** 3643 * @deprecated Use 3644 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS} instead 3645 */ 3646 @Deprecated 3647 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 3648 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS; 3649 3650 /** 3651 * @deprecated Use 3652 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED} instead 3653 */ 3654 @Deprecated 3655 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 3656 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED; 3657 3658 /** 3659 * @deprecated Use 3660 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS} 3661 * instead 3662 */ 3663 @Deprecated 3664 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 3665 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS; 3666 3667 /** 3668 * @deprecated Use 3669 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT} instead 3670 */ 3671 @Deprecated 3672 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 3673 Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT; 3674 3675 /** 3676 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS} 3677 * instead 3678 */ 3679 @Deprecated 3680 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = Secure.WIFI_WATCHDOG_MAX_AP_CHECKS; 3681 3682 /** 3683 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 3684 */ 3685 @Deprecated 3686 public static final String WIFI_WATCHDOG_ON = Global.WIFI_WATCHDOG_ON; 3687 3688 /** 3689 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_COUNT} instead 3690 */ 3691 @Deprecated 3692 public static final String WIFI_WATCHDOG_PING_COUNT = Secure.WIFI_WATCHDOG_PING_COUNT; 3693 3694 /** 3695 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_DELAY_MS} 3696 * instead 3697 */ 3698 @Deprecated 3699 public static final String WIFI_WATCHDOG_PING_DELAY_MS = Secure.WIFI_WATCHDOG_PING_DELAY_MS; 3700 3701 /** 3702 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_TIMEOUT_MS} 3703 * instead 3704 */ 3705 @Deprecated 3706 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = 3707 Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS; 3708 3709 /** 3710 * An app can use this method to check if it is currently allowed to write or modify system 3711 * settings. In order to gain write access to the system settings, an app must declare the 3712 * {@link android.Manifest.permission#WRITE_SETTINGS} permission in its manifest. If it is 3713 * currently disallowed, it can prompt the user to grant it this capability through a 3714 * management UI by sending an Intent with action 3715 * {@link android.provider.Settings#ACTION_MANAGE_WRITE_SETTINGS}. 3716 * 3717 * @param context A context 3718 * @return true if the calling app can write to system settings, false otherwise 3719 */ canWrite(Context context)3720 public static boolean canWrite(Context context) { 3721 int uid = Binder.getCallingUid(); 3722 return isCallingPackageAllowedToWriteSettings(context, uid, getPackageNameForUid( 3723 context, uid), false); 3724 } 3725 } 3726 3727 /** 3728 * Secure system settings, containing system preferences that applications 3729 * can read but are not allowed to write. These are for preferences that 3730 * the user must explicitly modify through the system UI or specialized 3731 * APIs for those values, not modified directly by applications. 3732 */ 3733 public static final class Secure extends NameValueTable { 3734 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_secure_version"; 3735 3736 /** 3737 * The content:// style URL for this table 3738 */ 3739 public static final Uri CONTENT_URI = 3740 Uri.parse("content://" + AUTHORITY + "/secure"); 3741 3742 // Populated lazily, guarded by class object: 3743 private static final NameValueCache sNameValueCache = new NameValueCache( 3744 SYS_PROP_SETTING_VERSION, 3745 CONTENT_URI, 3746 CALL_METHOD_GET_SECURE, 3747 CALL_METHOD_PUT_SECURE); 3748 3749 private static ILockSettings sLockSettings = null; 3750 3751 private static boolean sIsSystemProcess; 3752 private static final HashSet<String> MOVED_TO_LOCK_SETTINGS; 3753 private static final HashSet<String> MOVED_TO_GLOBAL; 3754 static { 3755 MOVED_TO_LOCK_SETTINGS = new HashSet<String>(3); 3756 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_ENABLED); 3757 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_VISIBLE); 3758 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 3759 3760 MOVED_TO_GLOBAL = new HashSet<String>(); 3761 MOVED_TO_GLOBAL.add(Settings.Global.ADB_ENABLED); 3762 MOVED_TO_GLOBAL.add(Settings.Global.ASSISTED_GPS_ENABLED); 3763 MOVED_TO_GLOBAL.add(Settings.Global.BLUETOOTH_ON); 3764 MOVED_TO_GLOBAL.add(Settings.Global.BUGREPORT_IN_POWER_MENU); 3765 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_CELL_BROADCAST_SMS); 3766 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_ROAMING_MODE); 3767 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_SUBSCRIPTION_MODE); 3768 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_MOBILE); 3769 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_WIFI); 3770 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ROAMING); 3771 MOVED_TO_GLOBAL.add(Settings.Global.DEVELOPMENT_SETTINGS_ENABLED); 3772 MOVED_TO_GLOBAL.add(Settings.Global.DEVICE_PROVISIONED); 3773 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_DENSITY_FORCED); 3774 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_SIZE_FORCED); 3775 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_MAX_BYTES_OVER_MOBILE); 3776 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE); 3777 MOVED_TO_GLOBAL.add(Settings.Global.MOBILE_DATA); 3778 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_BUCKET_DURATION); 3779 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_DELETE_AGE); 3780 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_PERSIST_BYTES); 3781 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_ROTATE_AGE); 3782 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_ENABLED); 3783 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_GLOBAL_ALERT_BYTES); 3784 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_POLL_INTERVAL); 3785 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_SAMPLE_ENABLED); 3786 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_TIME_CACHE_MAX_AGE); 3787 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_BUCKET_DURATION); 3788 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_DELETE_AGE); 3789 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_PERSIST_BYTES); 3790 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_ROTATE_AGE); 3791 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_BUCKET_DURATION); 3792 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_DELETE_AGE); 3793 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_PERSIST_BYTES); 3794 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_ROTATE_AGE); 3795 MOVED_TO_GLOBAL.add(Settings.Global.NETWORK_PREFERENCE); 3796 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_DIFF); 3797 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_SPACING); 3798 MOVED_TO_GLOBAL.add(Settings.Global.NTP_SERVER); 3799 MOVED_TO_GLOBAL.add(Settings.Global.NTP_TIMEOUT); 3800 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_ERROR_POLL_COUNT); 3801 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_LONG_POLL_INTERVAL_MS); 3802 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT); 3803 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_POLL_INTERVAL_MS); 3804 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_TRIGGER_PACKET_COUNT); 3805 MOVED_TO_GLOBAL.add(Settings.Global.SAMPLING_PROFILER_MS); 3806 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); 3807 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_REDIR_HOST); 3808 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_TARGET_URL); 3809 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_APN); 3810 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_REQUIRED); 3811 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_SUPPORTED); 3812 MOVED_TO_GLOBAL.add(Settings.Global.USB_MASS_STORAGE_ENABLED); 3813 MOVED_TO_GLOBAL.add(Settings.Global.USE_GOOGLE_MAIL); 3814 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_COUNTRY_CODE); 3815 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FRAMEWORK_SCAN_INTERVAL_MS); 3816 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FREQUENCY_BAND); 3817 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_IDLE_MS); 3818 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT); 3819 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS); 3820 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 3821 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 3822 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NUM_OPEN_NETWORKS_KEPT); 3823 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_ON); 3824 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_P2P_DEVICE_NAME); 3825 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SAVED_STATE); 3826 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUPPLICANT_SCAN_INTERVAL_MS); 3827 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED); 3828 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_ENHANCED_AUTO_JOIN); 3829 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORK_SHOW_RSSI); 3830 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_ON); 3831 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED); 3832 MOVED_TO_GLOBAL.add(Settings.Global.WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON); 3833 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_ENABLE); 3834 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_TIMEOUT); 3835 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE); 3836 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS); 3837 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS); 3838 MOVED_TO_GLOBAL.add(Settings.Global.GPRS_REGISTER_CHECK_PERIOD_MS); 3839 MOVED_TO_GLOBAL.add(Settings.Global.WTF_IS_FATAL); 3840 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD); 3841 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_THRESHOLD); 3842 MOVED_TO_GLOBAL.add(Settings.Global.SEND_ACTION_APP_ERROR); 3843 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_AGE_SECONDS); 3844 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_MAX_FILES); 3845 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_KB); 3846 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_PERCENT); 3847 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_RESERVE_PERCENT); 3848 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_TAG_PREFIX); 3849 MOVED_TO_GLOBAL.add(Settings.Global.ERROR_LOGCAT_PREFIX); 3850 MOVED_TO_GLOBAL.add(Settings.Global.SYS_FREE_STORAGE_LOG_INTERVAL); 3851 MOVED_TO_GLOBAL.add(Settings.Global.DISK_FREE_CHANGE_REPORTING_THRESHOLD); 3852 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_PERCENTAGE); 3853 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_MAX_BYTES); 3854 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_FULL_THRESHOLD_BYTES); 3855 MOVED_TO_GLOBAL.add(Settings.Global.SYNC_MAX_RETRY_DELAY_IN_SECONDS); 3856 MOVED_TO_GLOBAL.add(Settings.Global.CONNECTIVITY_CHANGE_DELAY); 3857 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_DETECTION_ENABLED); 3858 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_SERVER); 3859 MOVED_TO_GLOBAL.add(Settings.Global.NSD_ON); 3860 MOVED_TO_GLOBAL.add(Settings.Global.SET_INSTALL_LOCATION); 3861 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_INSTALL_LOCATION); 3862 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_UP_DELAY); 3863 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_DOWN_DELAY); 3864 MOVED_TO_GLOBAL.add(Settings.Global.READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT); 3865 MOVED_TO_GLOBAL.add(Settings.Global.HTTP_PROXY); 3866 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_HOST); 3867 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_PORT); 3868 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_EXCLUSION_LIST); 3869 MOVED_TO_GLOBAL.add(Settings.Global.SET_GLOBAL_HTTP_PROXY); 3870 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_DNS_SERVER); 3871 MOVED_TO_GLOBAL.add(Settings.Global.PREFERRED_NETWORK_MODE); 3872 MOVED_TO_GLOBAL.add(Settings.Global.WEBVIEW_DATA_REDUCTION_PROXY_KEY); 3873 } 3874 3875 /** @hide */ getMovedToGlobalSettings(Set<String> outKeySet)3876 public static void getMovedToGlobalSettings(Set<String> outKeySet) { 3877 outKeySet.addAll(MOVED_TO_GLOBAL); 3878 } 3879 3880 /** 3881 * Look up a name in the database. 3882 * @param resolver to access the database with 3883 * @param name to look up in the table 3884 * @return the corresponding value, or null if not present 3885 */ getString(ContentResolver resolver, String name)3886 public static String getString(ContentResolver resolver, String name) { 3887 return getStringForUser(resolver, name, UserHandle.myUserId()); 3888 } 3889 3890 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)3891 public static String getStringForUser(ContentResolver resolver, String name, 3892 int userHandle) { 3893 if (MOVED_TO_GLOBAL.contains(name)) { 3894 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 3895 + " to android.provider.Settings.Global."); 3896 return Global.getStringForUser(resolver, name, userHandle); 3897 } 3898 3899 if (MOVED_TO_LOCK_SETTINGS.contains(name)) { 3900 synchronized (Secure.class) { 3901 if (sLockSettings == null) { 3902 sLockSettings = ILockSettings.Stub.asInterface( 3903 (IBinder) ServiceManager.getService("lock_settings")); 3904 sIsSystemProcess = Process.myUid() == Process.SYSTEM_UID; 3905 } 3906 } 3907 if (sLockSettings != null && !sIsSystemProcess) { 3908 // No context; use the ActivityThread's context as an approximation for 3909 // determining the target API level. 3910 Application application = ActivityThread.currentApplication(); 3911 3912 boolean isPreMnc = application != null 3913 && application.getApplicationInfo() != null 3914 && application.getApplicationInfo().targetSdkVersion 3915 <= VERSION_CODES.LOLLIPOP_MR1; 3916 if (isPreMnc) { 3917 try { 3918 return sLockSettings.getString(name, "0", userHandle); 3919 } catch (RemoteException re) { 3920 // Fall through 3921 } 3922 } else { 3923 throw new SecurityException("Settings.Secure." + name 3924 + " is deprecated and no longer accessible." 3925 + " See API documentation for potential replacements."); 3926 } 3927 } 3928 } 3929 3930 return sNameValueCache.getStringForUser(resolver, name, userHandle); 3931 } 3932 3933 /** 3934 * Store a name/value pair into the database. 3935 * @param resolver to access the database with 3936 * @param name to store 3937 * @param value to associate with the name 3938 * @return true if the value was set, false on database errors 3939 */ putString(ContentResolver resolver, String name, String value)3940 public static boolean putString(ContentResolver resolver, String name, String value) { 3941 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 3942 } 3943 3944 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)3945 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 3946 int userHandle) { 3947 if (LOCATION_MODE.equals(name)) { 3948 // HACK ALERT: temporary hack to work around b/10491283. 3949 // TODO: once b/10491283 fixed, remove this hack 3950 return setLocationModeForUser(resolver, Integer.parseInt(value), userHandle); 3951 } 3952 if (MOVED_TO_GLOBAL.contains(name)) { 3953 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 3954 + " to android.provider.Settings.Global"); 3955 return Global.putStringForUser(resolver, name, value, userHandle); 3956 } 3957 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 3958 } 3959 3960 /** 3961 * Construct the content URI for a particular name/value pair, 3962 * useful for monitoring changes with a ContentObserver. 3963 * @param name to look up in the table 3964 * @return the corresponding content URI, or null if not present 3965 */ getUriFor(String name)3966 public static Uri getUriFor(String name) { 3967 if (MOVED_TO_GLOBAL.contains(name)) { 3968 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 3969 + " to android.provider.Settings.Global, returning global URI."); 3970 return Global.getUriFor(Global.CONTENT_URI, name); 3971 } 3972 return getUriFor(CONTENT_URI, name); 3973 } 3974 3975 /** 3976 * Convenience function for retrieving a single secure settings value 3977 * as an integer. Note that internally setting values are always 3978 * stored as strings; this function converts the string to an integer 3979 * for you. The default value will be returned if the setting is 3980 * not defined or not an integer. 3981 * 3982 * @param cr The ContentResolver to access. 3983 * @param name The name of the setting to retrieve. 3984 * @param def Value to return if the setting is not defined. 3985 * 3986 * @return The setting's current value, or 'def' if it is not defined 3987 * or not a valid integer. 3988 */ getInt(ContentResolver cr, String name, int def)3989 public static int getInt(ContentResolver cr, String name, int def) { 3990 return getIntForUser(cr, name, def, UserHandle.myUserId()); 3991 } 3992 3993 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)3994 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 3995 if (LOCATION_MODE.equals(name)) { 3996 // HACK ALERT: temporary hack to work around b/10491283. 3997 // TODO: once b/10491283 fixed, remove this hack 3998 return getLocationModeForUser(cr, userHandle); 3999 } 4000 String v = getStringForUser(cr, name, userHandle); 4001 try { 4002 return v != null ? Integer.parseInt(v) : def; 4003 } catch (NumberFormatException e) { 4004 return def; 4005 } 4006 } 4007 4008 /** 4009 * Convenience function for retrieving a single secure settings value 4010 * as an integer. Note that internally setting values are always 4011 * stored as strings; this function converts the string to an integer 4012 * for you. 4013 * <p> 4014 * This version does not take a default value. If the setting has not 4015 * been set, or the string value is not a number, 4016 * it throws {@link SettingNotFoundException}. 4017 * 4018 * @param cr The ContentResolver to access. 4019 * @param name The name of the setting to retrieve. 4020 * 4021 * @throws SettingNotFoundException Thrown if a setting by the given 4022 * name can't be found or the setting value is not an integer. 4023 * 4024 * @return The setting's current value. 4025 */ getInt(ContentResolver cr, String name)4026 public static int getInt(ContentResolver cr, String name) 4027 throws SettingNotFoundException { 4028 return getIntForUser(cr, name, UserHandle.myUserId()); 4029 } 4030 4031 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)4032 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 4033 throws SettingNotFoundException { 4034 if (LOCATION_MODE.equals(name)) { 4035 // HACK ALERT: temporary hack to work around b/10491283. 4036 // TODO: once b/10491283 fixed, remove this hack 4037 return getLocationModeForUser(cr, userHandle); 4038 } 4039 String v = getStringForUser(cr, name, userHandle); 4040 try { 4041 return Integer.parseInt(v); 4042 } catch (NumberFormatException e) { 4043 throw new SettingNotFoundException(name); 4044 } 4045 } 4046 4047 /** 4048 * Convenience function for updating a single settings value as an 4049 * integer. This will either create a new entry in the table if the 4050 * given name does not exist, or modify the value of the existing row 4051 * with that name. Note that internally setting values are always 4052 * stored as strings, so this function converts the given value to a 4053 * string before storing it. 4054 * 4055 * @param cr The ContentResolver to access. 4056 * @param name The name of the setting to modify. 4057 * @param value The new value for the setting. 4058 * @return true if the value was set, false on database errors 4059 */ putInt(ContentResolver cr, String name, int value)4060 public static boolean putInt(ContentResolver cr, String name, int value) { 4061 return putIntForUser(cr, name, value, UserHandle.myUserId()); 4062 } 4063 4064 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)4065 public static boolean putIntForUser(ContentResolver cr, String name, int value, 4066 int userHandle) { 4067 return putStringForUser(cr, name, Integer.toString(value), userHandle); 4068 } 4069 4070 /** 4071 * Convenience function for retrieving a single secure settings value 4072 * as a {@code long}. Note that internally setting values are always 4073 * stored as strings; this function converts the string to a {@code long} 4074 * for you. The default value will be returned if the setting is 4075 * not defined or not a {@code long}. 4076 * 4077 * @param cr The ContentResolver to access. 4078 * @param name The name of the setting to retrieve. 4079 * @param def Value to return if the setting is not defined. 4080 * 4081 * @return The setting's current value, or 'def' if it is not defined 4082 * or not a valid {@code long}. 4083 */ getLong(ContentResolver cr, String name, long def)4084 public static long getLong(ContentResolver cr, String name, long def) { 4085 return getLongForUser(cr, name, def, UserHandle.myUserId()); 4086 } 4087 4088 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)4089 public static long getLongForUser(ContentResolver cr, String name, long def, 4090 int userHandle) { 4091 String valString = getStringForUser(cr, name, userHandle); 4092 long value; 4093 try { 4094 value = valString != null ? Long.parseLong(valString) : def; 4095 } catch (NumberFormatException e) { 4096 value = def; 4097 } 4098 return value; 4099 } 4100 4101 /** 4102 * Convenience function for retrieving a single secure settings value 4103 * as a {@code long}. Note that internally setting values are always 4104 * stored as strings; this function converts the string to a {@code long} 4105 * for you. 4106 * <p> 4107 * This version does not take a default value. If the setting has not 4108 * been set, or the string value is not a number, 4109 * it throws {@link SettingNotFoundException}. 4110 * 4111 * @param cr The ContentResolver to access. 4112 * @param name The name of the setting to retrieve. 4113 * 4114 * @return The setting's current value. 4115 * @throws SettingNotFoundException Thrown if a setting by the given 4116 * name can't be found or the setting value is not an integer. 4117 */ getLong(ContentResolver cr, String name)4118 public static long getLong(ContentResolver cr, String name) 4119 throws SettingNotFoundException { 4120 return getLongForUser(cr, name, UserHandle.myUserId()); 4121 } 4122 4123 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)4124 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 4125 throws SettingNotFoundException { 4126 String valString = getStringForUser(cr, name, userHandle); 4127 try { 4128 return Long.parseLong(valString); 4129 } catch (NumberFormatException e) { 4130 throw new SettingNotFoundException(name); 4131 } 4132 } 4133 4134 /** 4135 * Convenience function for updating a secure settings value as a long 4136 * integer. This will either create a new entry in the table if the 4137 * given name does not exist, or modify the value of the existing row 4138 * with that name. Note that internally setting values are always 4139 * stored as strings, so this function converts the given value to a 4140 * string before storing it. 4141 * 4142 * @param cr The ContentResolver to access. 4143 * @param name The name of the setting to modify. 4144 * @param value The new value for the setting. 4145 * @return true if the value was set, false on database errors 4146 */ putLong(ContentResolver cr, String name, long value)4147 public static boolean putLong(ContentResolver cr, String name, long value) { 4148 return putLongForUser(cr, name, value, UserHandle.myUserId()); 4149 } 4150 4151 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)4152 public static boolean putLongForUser(ContentResolver cr, String name, long value, 4153 int userHandle) { 4154 return putStringForUser(cr, name, Long.toString(value), userHandle); 4155 } 4156 4157 /** 4158 * Convenience function for retrieving a single secure settings value 4159 * as a floating point number. Note that internally setting values are 4160 * always stored as strings; this function converts the string to an 4161 * float for you. The default value will be returned if the setting 4162 * is not defined or not a valid float. 4163 * 4164 * @param cr The ContentResolver to access. 4165 * @param name The name of the setting to retrieve. 4166 * @param def Value to return if the setting is not defined. 4167 * 4168 * @return The setting's current value, or 'def' if it is not defined 4169 * or not a valid float. 4170 */ getFloat(ContentResolver cr, String name, float def)4171 public static float getFloat(ContentResolver cr, String name, float def) { 4172 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 4173 } 4174 4175 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)4176 public static float getFloatForUser(ContentResolver cr, String name, float def, 4177 int userHandle) { 4178 String v = getStringForUser(cr, name, userHandle); 4179 try { 4180 return v != null ? Float.parseFloat(v) : def; 4181 } catch (NumberFormatException e) { 4182 return def; 4183 } 4184 } 4185 4186 /** 4187 * Convenience function for retrieving a single secure settings value 4188 * as a float. Note that internally setting values are always 4189 * stored as strings; this function converts the string to a float 4190 * for you. 4191 * <p> 4192 * This version does not take a default value. If the setting has not 4193 * been set, or the string value is not a number, 4194 * it throws {@link SettingNotFoundException}. 4195 * 4196 * @param cr The ContentResolver to access. 4197 * @param name The name of the setting to retrieve. 4198 * 4199 * @throws SettingNotFoundException Thrown if a setting by the given 4200 * name can't be found or the setting value is not a float. 4201 * 4202 * @return The setting's current value. 4203 */ getFloat(ContentResolver cr, String name)4204 public static float getFloat(ContentResolver cr, String name) 4205 throws SettingNotFoundException { 4206 return getFloatForUser(cr, name, UserHandle.myUserId()); 4207 } 4208 4209 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)4210 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 4211 throws SettingNotFoundException { 4212 String v = getStringForUser(cr, name, userHandle); 4213 if (v == null) { 4214 throw new SettingNotFoundException(name); 4215 } 4216 try { 4217 return Float.parseFloat(v); 4218 } catch (NumberFormatException e) { 4219 throw new SettingNotFoundException(name); 4220 } 4221 } 4222 4223 /** 4224 * Convenience function for updating a single settings value as a 4225 * floating point number. This will either create a new entry in the 4226 * table if the given name does not exist, or modify the value of the 4227 * existing row with that name. Note that internally setting values 4228 * are always stored as strings, so this function converts the given 4229 * value to a string before storing it. 4230 * 4231 * @param cr The ContentResolver to access. 4232 * @param name The name of the setting to modify. 4233 * @param value The new value for the setting. 4234 * @return true if the value was set, false on database errors 4235 */ putFloat(ContentResolver cr, String name, float value)4236 public static boolean putFloat(ContentResolver cr, String name, float value) { 4237 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 4238 } 4239 4240 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)4241 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 4242 int userHandle) { 4243 return putStringForUser(cr, name, Float.toString(value), userHandle); 4244 } 4245 4246 /** 4247 * @deprecated Use {@link android.provider.Settings.Global#DEVELOPMENT_SETTINGS_ENABLED} 4248 * instead 4249 */ 4250 @Deprecated 4251 public static final String DEVELOPMENT_SETTINGS_ENABLED = 4252 Global.DEVELOPMENT_SETTINGS_ENABLED; 4253 4254 /** 4255 * When the user has enable the option to have a "bug report" command 4256 * in the power menu. 4257 * @deprecated Use {@link android.provider.Settings.Global#BUGREPORT_IN_POWER_MENU} instead 4258 * @hide 4259 */ 4260 @Deprecated 4261 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 4262 4263 /** 4264 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} instead 4265 */ 4266 @Deprecated 4267 public static final String ADB_ENABLED = Global.ADB_ENABLED; 4268 4269 /** 4270 * Setting to allow mock locations and location provider status to be injected into the 4271 * LocationManager service for testing purposes during application development. These 4272 * locations and status values override actual location and status information generated 4273 * by network, gps, or other location providers. 4274 * 4275 * @deprecated This settings is not used anymore. 4276 */ 4277 @Deprecated 4278 public static final String ALLOW_MOCK_LOCATION = "mock_location"; 4279 4280 /** 4281 * A 64-bit number (as a hex string) that is randomly 4282 * generated when the user first sets up the device and should remain 4283 * constant for the lifetime of the user's device. The value may 4284 * change if a factory reset is performed on the device. 4285 * <p class="note"><strong>Note:</strong> When a device has <a 4286 * href="{@docRoot}about/versions/android-4.2.html#MultipleUsers">multiple users</a> 4287 * (available on certain devices running Android 4.2 or higher), each user appears as a 4288 * completely separate device, so the {@code ANDROID_ID} value is unique to each 4289 * user.</p> 4290 */ 4291 public static final String ANDROID_ID = "android_id"; 4292 4293 /** 4294 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 4295 */ 4296 @Deprecated 4297 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 4298 4299 /** 4300 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 4301 */ 4302 @Deprecated 4303 public static final String DATA_ROAMING = Global.DATA_ROAMING; 4304 4305 /** 4306 * Setting to record the input method used by default, holding the ID 4307 * of the desired method. 4308 */ 4309 public static final String DEFAULT_INPUT_METHOD = "default_input_method"; 4310 4311 /** 4312 * Setting to record the input method subtype used by default, holding the ID 4313 * of the desired method. 4314 */ 4315 public static final String SELECTED_INPUT_METHOD_SUBTYPE = 4316 "selected_input_method_subtype"; 4317 4318 /** 4319 * Setting to record the history of input method subtype, holding the pair of ID of IME 4320 * and its last used subtype. 4321 * @hide 4322 */ 4323 public static final String INPUT_METHODS_SUBTYPE_HISTORY = 4324 "input_methods_subtype_history"; 4325 4326 /** 4327 * Setting to record the visibility of input method selector 4328 */ 4329 public static final String INPUT_METHOD_SELECTOR_VISIBILITY = 4330 "input_method_selector_visibility"; 4331 4332 /** 4333 * The currently selected voice interaction service flattened ComponentName. 4334 * @hide 4335 */ 4336 public static final String VOICE_INTERACTION_SERVICE = "voice_interaction_service"; 4337 4338 /** 4339 * bluetooth HCI snoop log configuration 4340 * @hide 4341 */ 4342 public static final String BLUETOOTH_HCI_LOG = 4343 "bluetooth_hci_log"; 4344 4345 /** 4346 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 4347 */ 4348 @Deprecated 4349 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 4350 4351 /** 4352 * Whether the current user has been set up via setup wizard (0 = false, 1 = true) 4353 * @hide 4354 */ 4355 public static final String USER_SETUP_COMPLETE = "user_setup_complete"; 4356 4357 /** 4358 * List of input methods that are currently enabled. This is a string 4359 * containing the IDs of all enabled input methods, each ID separated 4360 * by ':'. 4361 */ 4362 public static final String ENABLED_INPUT_METHODS = "enabled_input_methods"; 4363 4364 /** 4365 * List of system input methods that are currently disabled. This is a string 4366 * containing the IDs of all disabled input methods, each ID separated 4367 * by ':'. 4368 * @hide 4369 */ 4370 public static final String DISABLED_SYSTEM_INPUT_METHODS = "disabled_system_input_methods"; 4371 4372 /** 4373 * Whether to show the IME when a hard keyboard is connected. This is a boolean that 4374 * determines if the IME should be shown when a hard keyboard is attached. 4375 * @hide 4376 */ 4377 public static final String SHOW_IME_WITH_HARD_KEYBOARD = "show_ime_with_hard_keyboard"; 4378 4379 /** 4380 * Host name and port for global http proxy. Uses ':' seperator for 4381 * between host and port. 4382 * 4383 * @deprecated Use {@link Global#HTTP_PROXY} 4384 */ 4385 @Deprecated 4386 public static final String HTTP_PROXY = Global.HTTP_PROXY; 4387 4388 /** 4389 * Whether applications can be installed for this user via the system's 4390 * {@link Intent#ACTION_INSTALL_PACKAGE} mechanism. 4391 * 4392 * <p>1 = permit app installation via the system package installer intent 4393 * <p>0 = do not allow use of the package installer 4394 */ 4395 public static final String INSTALL_NON_MARKET_APPS = "install_non_market_apps"; 4396 4397 /** 4398 * Comma-separated list of location providers that activities may access. Do not rely on 4399 * this value being present in settings.db or on ContentObserver notifications on the 4400 * corresponding Uri. 4401 * 4402 * @deprecated use {@link #LOCATION_MODE} and 4403 * {@link LocationManager#MODE_CHANGED_ACTION} (or 4404 * {@link LocationManager#PROVIDERS_CHANGED_ACTION}) 4405 */ 4406 @Deprecated 4407 public static final String LOCATION_PROVIDERS_ALLOWED = "location_providers_allowed"; 4408 4409 /** 4410 * The degree of location access enabled by the user. 4411 * <p> 4412 * When used with {@link #putInt(ContentResolver, String, int)}, must be one of {@link 4413 * #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, {@link 4414 * #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. When used with {@link 4415 * #getInt(ContentResolver, String)}, the caller must gracefully handle additional location 4416 * modes that might be added in the future. 4417 * <p> 4418 * Note: do not rely on this value being present in settings.db or on ContentObserver 4419 * notifications for the corresponding Uri. Use {@link LocationManager#MODE_CHANGED_ACTION} 4420 * to receive changes in this value. 4421 */ 4422 public static final String LOCATION_MODE = "location_mode"; 4423 4424 /** 4425 * Location access disabled. 4426 */ 4427 public static final int LOCATION_MODE_OFF = 0; 4428 /** 4429 * Network Location Provider disabled, but GPS and other sensors enabled. 4430 */ 4431 public static final int LOCATION_MODE_SENSORS_ONLY = 1; 4432 /** 4433 * Reduced power usage, such as limiting the number of GPS updates per hour. Requests 4434 * with {@link android.location.Criteria#POWER_HIGH} may be downgraded to 4435 * {@link android.location.Criteria#POWER_MEDIUM}. 4436 */ 4437 public static final int LOCATION_MODE_BATTERY_SAVING = 2; 4438 /** 4439 * Best-effort location computation allowed. 4440 */ 4441 public static final int LOCATION_MODE_HIGH_ACCURACY = 3; 4442 4443 /** 4444 * A flag containing settings used for biometric weak 4445 * @hide 4446 */ 4447 @Deprecated 4448 public static final String LOCK_BIOMETRIC_WEAK_FLAGS = 4449 "lock_biometric_weak_flags"; 4450 4451 /** 4452 * Whether lock-to-app will lock the keyguard when exiting. 4453 * @hide 4454 */ 4455 public static final String LOCK_TO_APP_EXIT_LOCKED = "lock_to_app_exit_locked"; 4456 4457 /** 4458 * Whether autolock is enabled (0 = false, 1 = true) 4459 * 4460 * @deprecated Use {@link android.app.KeyguardManager} to determine the state and security 4461 * level of the keyguard. Accessing this setting from an app that is targeting 4462 * {@link VERSION_CODES#M} or later throws a {@code SecurityException}. 4463 */ 4464 @Deprecated 4465 public static final String LOCK_PATTERN_ENABLED = "lock_pattern_autolock"; 4466 4467 /** 4468 * Whether lock pattern is visible as user enters (0 = false, 1 = true) 4469 * 4470 * @deprecated Accessing this setting from an app that is targeting 4471 * {@link VERSION_CODES#M} or later throws a {@code SecurityException}. 4472 */ 4473 @Deprecated 4474 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 4475 4476 /** 4477 * Whether lock pattern will vibrate as user enters (0 = false, 1 = 4478 * true) 4479 * 4480 * @deprecated Starting in {@link VERSION_CODES#JELLY_BEAN_MR1} the 4481 * lockscreen uses 4482 * {@link Settings.System#HAPTIC_FEEDBACK_ENABLED}. 4483 * Accessing this setting from an app that is targeting 4484 * {@link VERSION_CODES#M} or later throws a {@code SecurityException}. 4485 */ 4486 @Deprecated 4487 public static final String 4488 LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = "lock_pattern_tactile_feedback_enabled"; 4489 4490 /** 4491 * This preference allows the device to be locked given time after screen goes off, 4492 * subject to current DeviceAdmin policy limits. 4493 * @hide 4494 */ 4495 public static final String LOCK_SCREEN_LOCK_AFTER_TIMEOUT = "lock_screen_lock_after_timeout"; 4496 4497 4498 /** 4499 * This preference contains the string that shows for owner info on LockScreen. 4500 * @hide 4501 * @deprecated 4502 */ 4503 public static final String LOCK_SCREEN_OWNER_INFO = "lock_screen_owner_info"; 4504 4505 /** 4506 * Ids of the user-selected appwidgets on the lockscreen (comma-delimited). 4507 * @hide 4508 */ 4509 @Deprecated 4510 public static final String LOCK_SCREEN_APPWIDGET_IDS = 4511 "lock_screen_appwidget_ids"; 4512 4513 /** 4514 * Id of the appwidget shown on the lock screen when appwidgets are disabled. 4515 * @hide 4516 */ 4517 @Deprecated 4518 public static final String LOCK_SCREEN_FALLBACK_APPWIDGET_ID = 4519 "lock_screen_fallback_appwidget_id"; 4520 4521 /** 4522 * Index of the lockscreen appwidget to restore, -1 if none. 4523 * @hide 4524 */ 4525 @Deprecated 4526 public static final String LOCK_SCREEN_STICKY_APPWIDGET = 4527 "lock_screen_sticky_appwidget"; 4528 4529 /** 4530 * This preference enables showing the owner info on LockScreen. 4531 * @hide 4532 * @deprecated 4533 */ 4534 public static final String LOCK_SCREEN_OWNER_INFO_ENABLED = 4535 "lock_screen_owner_info_enabled"; 4536 4537 /** 4538 * When set by a user, allows notifications to be shown atop a securely locked screen 4539 * in their full "private" form (same as when the device is unlocked). 4540 * @hide 4541 */ 4542 public static final String LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS = 4543 "lock_screen_allow_private_notifications"; 4544 4545 /** 4546 * Set by the system to track if the user needs to see the call to action for 4547 * the lockscreen notification policy. 4548 * @hide 4549 */ 4550 public static final String SHOW_NOTE_ABOUT_NOTIFICATION_HIDING = 4551 "show_note_about_notification_hiding"; 4552 4553 /** 4554 * Set to 1 by the system after trust agents have been initialized. 4555 * @hide 4556 */ 4557 public static final String TRUST_AGENTS_INITIALIZED = 4558 "trust_agents_initialized"; 4559 4560 /** 4561 * The Logging ID (a unique 64-bit value) as a hex string. 4562 * Used as a pseudonymous identifier for logging. 4563 * @deprecated This identifier is poorly initialized and has 4564 * many collisions. It should not be used. 4565 */ 4566 @Deprecated 4567 public static final String LOGGING_ID = "logging_id"; 4568 4569 /** 4570 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 4571 */ 4572 @Deprecated 4573 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 4574 4575 /** 4576 * No longer supported. 4577 */ 4578 public static final String PARENTAL_CONTROL_ENABLED = "parental_control_enabled"; 4579 4580 /** 4581 * No longer supported. 4582 */ 4583 public static final String PARENTAL_CONTROL_LAST_UPDATE = "parental_control_last_update"; 4584 4585 /** 4586 * No longer supported. 4587 */ 4588 public static final String PARENTAL_CONTROL_REDIRECT_URL = "parental_control_redirect_url"; 4589 4590 /** 4591 * Settings classname to launch when Settings is clicked from All 4592 * Applications. Needed because of user testing between the old 4593 * and new Settings apps. 4594 */ 4595 // TODO: 881807 4596 public static final String SETTINGS_CLASSNAME = "settings_classname"; 4597 4598 /** 4599 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 4600 */ 4601 @Deprecated 4602 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 4603 4604 /** 4605 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 4606 */ 4607 @Deprecated 4608 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 4609 4610 /** 4611 * If accessibility is enabled. 4612 */ 4613 public static final String ACCESSIBILITY_ENABLED = "accessibility_enabled"; 4614 4615 /** 4616 * If touch exploration is enabled. 4617 */ 4618 public static final String TOUCH_EXPLORATION_ENABLED = "touch_exploration_enabled"; 4619 4620 /** 4621 * List of the enabled accessibility providers. 4622 */ 4623 public static final String ENABLED_ACCESSIBILITY_SERVICES = 4624 "enabled_accessibility_services"; 4625 4626 /** 4627 * List of the accessibility services to which the user has granted 4628 * permission to put the device into touch exploration mode. 4629 * 4630 * @hide 4631 */ 4632 public static final String TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES = 4633 "touch_exploration_granted_accessibility_services"; 4634 4635 /** 4636 * Whether to speak passwords while in accessibility mode. 4637 */ 4638 public static final String ACCESSIBILITY_SPEAK_PASSWORD = "speak_password"; 4639 4640 /** 4641 * Whether to draw text with high contrast while in accessibility mode. 4642 * 4643 * @hide 4644 */ 4645 public static final String ACCESSIBILITY_HIGH_TEXT_CONTRAST_ENABLED = 4646 "high_text_contrast_enabled"; 4647 4648 /** 4649 * If injection of accessibility enhancing JavaScript screen-reader 4650 * is enabled. 4651 * <p> 4652 * Note: The JavaScript based screen-reader is served by the 4653 * Google infrastructure and enable users with disabilities to 4654 * efficiently navigate in and explore web content. 4655 * </p> 4656 * <p> 4657 * This property represents a boolean value. 4658 * </p> 4659 * @hide 4660 */ 4661 public static final String ACCESSIBILITY_SCRIPT_INJECTION = 4662 "accessibility_script_injection"; 4663 4664 /** 4665 * The URL for the injected JavaScript based screen-reader used 4666 * for providing accessibility of content in WebView. 4667 * <p> 4668 * Note: The JavaScript based screen-reader is served by the 4669 * Google infrastructure and enable users with disabilities to 4670 * efficiently navigate in and explore web content. 4671 * </p> 4672 * <p> 4673 * This property represents a string value. 4674 * </p> 4675 * @hide 4676 */ 4677 public static final String ACCESSIBILITY_SCREEN_READER_URL = 4678 "accessibility_script_injection_url"; 4679 4680 /** 4681 * Key bindings for navigation in built-in accessibility support for web content. 4682 * <p> 4683 * Note: These key bindings are for the built-in accessibility navigation for 4684 * web content which is used as a fall back solution if JavaScript in a WebView 4685 * is not enabled or the user has not opted-in script injection from Google. 4686 * </p> 4687 * <p> 4688 * The bindings are separated by semi-colon. A binding is a mapping from 4689 * a key to a sequence of actions (for more details look at 4690 * android.webkit.AccessibilityInjector). A key is represented as the hexademical 4691 * string representation of an integer obtained from a meta state (optional) shifted 4692 * sixteen times left and bitwise ored with a key code. An action is represented 4693 * as a hexademical string representation of an integer where the first two digits 4694 * are navigation action index, the second, the third, and the fourth digit pairs 4695 * represent the action arguments. The separate actions in a binding are colon 4696 * separated. The key and the action sequence it maps to are separated by equals. 4697 * </p> 4698 * <p> 4699 * For example, the binding below maps the DPAD right button to traverse the 4700 * current navigation axis once without firing an accessibility event and to 4701 * perform the same traversal again but to fire an event: 4702 * <code> 4703 * 0x16=0x01000100:0x01000101; 4704 * </code> 4705 * </p> 4706 * <p> 4707 * The goal of this binding is to enable dynamic rebinding of keys to 4708 * navigation actions for web content without requiring a framework change. 4709 * </p> 4710 * <p> 4711 * This property represents a string value. 4712 * </p> 4713 * @hide 4714 */ 4715 public static final String ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS = 4716 "accessibility_web_content_key_bindings"; 4717 4718 /** 4719 * Setting that specifies whether the display magnification is enabled. 4720 * Display magnifications allows the user to zoom in the display content 4721 * and is targeted to low vision users. The current magnification scale 4722 * is controlled by {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE}. 4723 * 4724 * @hide 4725 */ 4726 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED = 4727 "accessibility_display_magnification_enabled"; 4728 4729 /** 4730 * Setting that specifies what the display magnification scale is. 4731 * Display magnifications allows the user to zoom in the display 4732 * content and is targeted to low vision users. Whether a display 4733 * magnification is performed is controlled by 4734 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 4735 * 4736 * @hide 4737 */ 4738 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE = 4739 "accessibility_display_magnification_scale"; 4740 4741 /** 4742 * Setting that specifies whether the display magnification should be 4743 * automatically updated. If this fearture is enabled the system will 4744 * exit magnification mode or pan the viewport when a context change 4745 * occurs. For example, on staring a new activity or rotating the screen, 4746 * the system may zoom out so the user can see the new context he is in. 4747 * Another example is on showing a window that is not visible in the 4748 * magnified viewport the system may pan the viewport to make the window 4749 * the has popped up so the user knows that the context has changed. 4750 * Whether a screen magnification is performed is controlled by 4751 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 4752 * 4753 * @hide 4754 */ 4755 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE = 4756 "accessibility_display_magnification_auto_update"; 4757 4758 /** 4759 * Setting that specifies whether timed text (captions) should be 4760 * displayed in video content. Text display properties are controlled by 4761 * the following settings: 4762 * <ul> 4763 * <li>{@link #ACCESSIBILITY_CAPTIONING_LOCALE} 4764 * <li>{@link #ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR} 4765 * <li>{@link #ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR} 4766 * <li>{@link #ACCESSIBILITY_CAPTIONING_EDGE_COLOR} 4767 * <li>{@link #ACCESSIBILITY_CAPTIONING_EDGE_TYPE} 4768 * <li>{@link #ACCESSIBILITY_CAPTIONING_TYPEFACE} 4769 * <li>{@link #ACCESSIBILITY_CAPTIONING_FONT_SCALE} 4770 * </ul> 4771 * 4772 * @hide 4773 */ 4774 public static final String ACCESSIBILITY_CAPTIONING_ENABLED = 4775 "accessibility_captioning_enabled"; 4776 4777 /** 4778 * Setting that specifies the language for captions as a locale string, 4779 * e.g. en_US. 4780 * 4781 * @see java.util.Locale#toString 4782 * @hide 4783 */ 4784 public static final String ACCESSIBILITY_CAPTIONING_LOCALE = 4785 "accessibility_captioning_locale"; 4786 4787 /** 4788 * Integer property that specifies the preset style for captions, one 4789 * of: 4790 * <ul> 4791 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#PRESET_CUSTOM} 4792 * <li>a valid index of {@link android.view.accessibility.CaptioningManager.CaptionStyle#PRESETS} 4793 * </ul> 4794 * 4795 * @see java.util.Locale#toString 4796 * @hide 4797 */ 4798 public static final String ACCESSIBILITY_CAPTIONING_PRESET = 4799 "accessibility_captioning_preset"; 4800 4801 /** 4802 * Integer property that specifes the background color for captions as a 4803 * packed 32-bit color. 4804 * 4805 * @see android.graphics.Color#argb 4806 * @hide 4807 */ 4808 public static final String ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR = 4809 "accessibility_captioning_background_color"; 4810 4811 /** 4812 * Integer property that specifes the foreground color for captions as a 4813 * packed 32-bit color. 4814 * 4815 * @see android.graphics.Color#argb 4816 * @hide 4817 */ 4818 public static final String ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR = 4819 "accessibility_captioning_foreground_color"; 4820 4821 /** 4822 * Integer property that specifes the edge type for captions, one of: 4823 * <ul> 4824 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_NONE} 4825 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_OUTLINE} 4826 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_DROP_SHADOW} 4827 * </ul> 4828 * 4829 * @see #ACCESSIBILITY_CAPTIONING_EDGE_COLOR 4830 * @hide 4831 */ 4832 public static final String ACCESSIBILITY_CAPTIONING_EDGE_TYPE = 4833 "accessibility_captioning_edge_type"; 4834 4835 /** 4836 * Integer property that specifes the edge color for captions as a 4837 * packed 32-bit color. 4838 * 4839 * @see #ACCESSIBILITY_CAPTIONING_EDGE_TYPE 4840 * @see android.graphics.Color#argb 4841 * @hide 4842 */ 4843 public static final String ACCESSIBILITY_CAPTIONING_EDGE_COLOR = 4844 "accessibility_captioning_edge_color"; 4845 4846 /** 4847 * Integer property that specifes the window color for captions as a 4848 * packed 32-bit color. 4849 * 4850 * @see android.graphics.Color#argb 4851 * @hide 4852 */ 4853 public static final String ACCESSIBILITY_CAPTIONING_WINDOW_COLOR = 4854 "accessibility_captioning_window_color"; 4855 4856 /** 4857 * String property that specifies the typeface for captions, one of: 4858 * <ul> 4859 * <li>DEFAULT 4860 * <li>MONOSPACE 4861 * <li>SANS_SERIF 4862 * <li>SERIF 4863 * </ul> 4864 * 4865 * @see android.graphics.Typeface 4866 * @hide 4867 */ 4868 public static final String ACCESSIBILITY_CAPTIONING_TYPEFACE = 4869 "accessibility_captioning_typeface"; 4870 4871 /** 4872 * Floating point property that specifies font scaling for captions. 4873 * 4874 * @hide 4875 */ 4876 public static final String ACCESSIBILITY_CAPTIONING_FONT_SCALE = 4877 "accessibility_captioning_font_scale"; 4878 4879 /** 4880 * Setting that specifies whether display color inversion is enabled. 4881 */ 4882 public static final String ACCESSIBILITY_DISPLAY_INVERSION_ENABLED = 4883 "accessibility_display_inversion_enabled"; 4884 4885 /** 4886 * Setting that specifies whether display color space adjustment is 4887 * enabled. 4888 * 4889 * @hide 4890 */ 4891 public static final String ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED = 4892 "accessibility_display_daltonizer_enabled"; 4893 4894 /** 4895 * Integer property that specifies the type of color space adjustment to 4896 * perform. Valid values are defined in AccessibilityManager. 4897 * 4898 * @hide 4899 */ 4900 public static final String ACCESSIBILITY_DISPLAY_DALTONIZER = 4901 "accessibility_display_daltonizer"; 4902 4903 /** 4904 * The timout for considering a press to be a long press in milliseconds. 4905 * @hide 4906 */ 4907 public static final String LONG_PRESS_TIMEOUT = "long_press_timeout"; 4908 4909 /** 4910 * List of the enabled print services. 4911 * @hide 4912 */ 4913 public static final String ENABLED_PRINT_SERVICES = 4914 "enabled_print_services"; 4915 4916 /** 4917 * List of the system print services we enabled on first boot. On 4918 * first boot we enable all system, i.e. bundled print services, 4919 * once, so they work out-of-the-box. 4920 * @hide 4921 */ 4922 public static final String ENABLED_ON_FIRST_BOOT_SYSTEM_PRINT_SERVICES = 4923 "enabled_on_first_boot_system_print_services"; 4924 4925 /** 4926 * Setting to always use the default text-to-speech settings regardless 4927 * of the application settings. 4928 * 1 = override application settings, 4929 * 0 = use application settings (if specified). 4930 * 4931 * @deprecated The value of this setting is no longer respected by 4932 * the framework text to speech APIs as of the Ice Cream Sandwich release. 4933 */ 4934 @Deprecated 4935 public static final String TTS_USE_DEFAULTS = "tts_use_defaults"; 4936 4937 /** 4938 * Default text-to-speech engine speech rate. 100 = 1x 4939 */ 4940 public static final String TTS_DEFAULT_RATE = "tts_default_rate"; 4941 4942 /** 4943 * Default text-to-speech engine pitch. 100 = 1x 4944 */ 4945 public static final String TTS_DEFAULT_PITCH = "tts_default_pitch"; 4946 4947 /** 4948 * Default text-to-speech engine. 4949 */ 4950 public static final String TTS_DEFAULT_SYNTH = "tts_default_synth"; 4951 4952 /** 4953 * Default text-to-speech language. 4954 * 4955 * @deprecated this setting is no longer in use, as of the Ice Cream 4956 * Sandwich release. Apps should never need to read this setting directly, 4957 * instead can query the TextToSpeech framework classes for the default 4958 * locale. {@link TextToSpeech#getLanguage()}. 4959 */ 4960 @Deprecated 4961 public static final String TTS_DEFAULT_LANG = "tts_default_lang"; 4962 4963 /** 4964 * Default text-to-speech country. 4965 * 4966 * @deprecated this setting is no longer in use, as of the Ice Cream 4967 * Sandwich release. Apps should never need to read this setting directly, 4968 * instead can query the TextToSpeech framework classes for the default 4969 * locale. {@link TextToSpeech#getLanguage()}. 4970 */ 4971 @Deprecated 4972 public static final String TTS_DEFAULT_COUNTRY = "tts_default_country"; 4973 4974 /** 4975 * Default text-to-speech locale variant. 4976 * 4977 * @deprecated this setting is no longer in use, as of the Ice Cream 4978 * Sandwich release. Apps should never need to read this setting directly, 4979 * instead can query the TextToSpeech framework classes for the 4980 * locale that is in use {@link TextToSpeech#getLanguage()}. 4981 */ 4982 @Deprecated 4983 public static final String TTS_DEFAULT_VARIANT = "tts_default_variant"; 4984 4985 /** 4986 * Stores the default tts locales on a per engine basis. Stored as 4987 * a comma seperated list of values, each value being of the form 4988 * {@code engine_name:locale} for example, 4989 * {@code com.foo.ttsengine:eng-USA,com.bar.ttsengine:esp-ESP}. This 4990 * supersedes {@link #TTS_DEFAULT_LANG}, {@link #TTS_DEFAULT_COUNTRY} and 4991 * {@link #TTS_DEFAULT_VARIANT}. Apps should never need to read this 4992 * setting directly, and can query the TextToSpeech framework classes 4993 * for the locale that is in use. 4994 * 4995 * @hide 4996 */ 4997 public static final String TTS_DEFAULT_LOCALE = "tts_default_locale"; 4998 4999 /** 5000 * Space delimited list of plugin packages that are enabled. 5001 */ 5002 public static final String TTS_ENABLED_PLUGINS = "tts_enabled_plugins"; 5003 5004 /** 5005 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} 5006 * instead. 5007 */ 5008 @Deprecated 5009 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 5010 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 5011 5012 /** 5013 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} 5014 * instead. 5015 */ 5016 @Deprecated 5017 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 5018 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 5019 5020 /** 5021 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 5022 * instead. 5023 */ 5024 @Deprecated 5025 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = 5026 Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 5027 5028 /** 5029 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} 5030 * instead. 5031 */ 5032 @Deprecated 5033 public static final String WIFI_ON = Global.WIFI_ON; 5034 5035 /** 5036 * The acceptable packet loss percentage (range 0 - 100) before trying 5037 * another AP on the same network. 5038 * @deprecated This setting is not used. 5039 */ 5040 @Deprecated 5041 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 5042 "wifi_watchdog_acceptable_packet_loss_percentage"; 5043 5044 /** 5045 * The number of access points required for a network in order for the 5046 * watchdog to monitor it. 5047 * @deprecated This setting is not used. 5048 */ 5049 @Deprecated 5050 public static final String WIFI_WATCHDOG_AP_COUNT = "wifi_watchdog_ap_count"; 5051 5052 /** 5053 * The delay between background checks. 5054 * @deprecated This setting is not used. 5055 */ 5056 @Deprecated 5057 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 5058 "wifi_watchdog_background_check_delay_ms"; 5059 5060 /** 5061 * Whether the Wi-Fi watchdog is enabled for background checking even 5062 * after it thinks the user has connected to a good access point. 5063 * @deprecated This setting is not used. 5064 */ 5065 @Deprecated 5066 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 5067 "wifi_watchdog_background_check_enabled"; 5068 5069 /** 5070 * The timeout for a background ping 5071 * @deprecated This setting is not used. 5072 */ 5073 @Deprecated 5074 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 5075 "wifi_watchdog_background_check_timeout_ms"; 5076 5077 /** 5078 * The number of initial pings to perform that *may* be ignored if they 5079 * fail. Again, if these fail, they will *not* be used in packet loss 5080 * calculation. For example, one network always seemed to time out for 5081 * the first couple pings, so this is set to 3 by default. 5082 * @deprecated This setting is not used. 5083 */ 5084 @Deprecated 5085 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 5086 "wifi_watchdog_initial_ignored_ping_count"; 5087 5088 /** 5089 * The maximum number of access points (per network) to attempt to test. 5090 * If this number is reached, the watchdog will no longer monitor the 5091 * initial connection state for the network. This is a safeguard for 5092 * networks containing multiple APs whose DNS does not respond to pings. 5093 * @deprecated This setting is not used. 5094 */ 5095 @Deprecated 5096 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = "wifi_watchdog_max_ap_checks"; 5097 5098 /** 5099 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 5100 */ 5101 @Deprecated 5102 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 5103 5104 /** 5105 * A comma-separated list of SSIDs for which the Wi-Fi watchdog should be enabled. 5106 * @deprecated This setting is not used. 5107 */ 5108 @Deprecated 5109 public static final String WIFI_WATCHDOG_WATCH_LIST = "wifi_watchdog_watch_list"; 5110 5111 /** 5112 * The number of pings to test if an access point is a good connection. 5113 * @deprecated This setting is not used. 5114 */ 5115 @Deprecated 5116 public static final String WIFI_WATCHDOG_PING_COUNT = "wifi_watchdog_ping_count"; 5117 5118 /** 5119 * The delay between pings. 5120 * @deprecated This setting is not used. 5121 */ 5122 @Deprecated 5123 public static final String WIFI_WATCHDOG_PING_DELAY_MS = "wifi_watchdog_ping_delay_ms"; 5124 5125 /** 5126 * The timeout per ping. 5127 * @deprecated This setting is not used. 5128 */ 5129 @Deprecated 5130 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = "wifi_watchdog_ping_timeout_ms"; 5131 5132 /** 5133 * @deprecated Use 5134 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 5135 */ 5136 @Deprecated 5137 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 5138 5139 /** 5140 * @deprecated Use 5141 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 5142 */ 5143 @Deprecated 5144 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 5145 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 5146 5147 /** 5148 * The number of milliseconds to hold on to a PendingIntent based request. This delay gives 5149 * the receivers of the PendingIntent an opportunity to make a new network request before 5150 * the Network satisfying the request is potentially removed. 5151 * 5152 * @hide 5153 */ 5154 public static final String CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS = 5155 "connectivity_release_pending_intent_delay_ms"; 5156 5157 /** 5158 * Whether background data usage is allowed. 5159 * 5160 * @deprecated As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, 5161 * availability of background data depends on several 5162 * combined factors. When background data is unavailable, 5163 * {@link ConnectivityManager#getActiveNetworkInfo()} will 5164 * now appear disconnected. 5165 */ 5166 @Deprecated 5167 public static final String BACKGROUND_DATA = "background_data"; 5168 5169 /** 5170 * Origins for which browsers should allow geolocation by default. 5171 * The value is a space-separated list of origins. 5172 */ 5173 public static final String ALLOWED_GEOLOCATION_ORIGINS 5174 = "allowed_geolocation_origins"; 5175 5176 /** 5177 * The preferred TTY mode 0 = TTy Off, CDMA default 5178 * 1 = TTY Full 5179 * 2 = TTY HCO 5180 * 3 = TTY VCO 5181 * @hide 5182 */ 5183 public static final String PREFERRED_TTY_MODE = 5184 "preferred_tty_mode"; 5185 5186 /** 5187 * Whether the enhanced voice privacy mode is enabled. 5188 * 0 = normal voice privacy 5189 * 1 = enhanced voice privacy 5190 * @hide 5191 */ 5192 public static final String ENHANCED_VOICE_PRIVACY_ENABLED = "enhanced_voice_privacy_enabled"; 5193 5194 /** 5195 * Whether the TTY mode mode is enabled. 5196 * 0 = disabled 5197 * 1 = enabled 5198 * @hide 5199 */ 5200 public static final String TTY_MODE_ENABLED = "tty_mode_enabled"; 5201 5202 /** 5203 * Controls whether settings backup is enabled. 5204 * Type: int ( 0 = disabled, 1 = enabled ) 5205 * @hide 5206 */ 5207 public static final String BACKUP_ENABLED = "backup_enabled"; 5208 5209 /** 5210 * Controls whether application data is automatically restored from backup 5211 * at install time. 5212 * Type: int ( 0 = disabled, 1 = enabled ) 5213 * @hide 5214 */ 5215 public static final String BACKUP_AUTO_RESTORE = "backup_auto_restore"; 5216 5217 /** 5218 * Indicates whether settings backup has been fully provisioned. 5219 * Type: int ( 0 = unprovisioned, 1 = fully provisioned ) 5220 * @hide 5221 */ 5222 public static final String BACKUP_PROVISIONED = "backup_provisioned"; 5223 5224 /** 5225 * Component of the transport to use for backup/restore. 5226 * @hide 5227 */ 5228 public static final String BACKUP_TRANSPORT = "backup_transport"; 5229 5230 /** 5231 * Version for which the setup wizard was last shown. Bumped for 5232 * each release when there is new setup information to show. 5233 * @hide 5234 */ 5235 public static final String LAST_SETUP_SHOWN = "last_setup_shown"; 5236 5237 /** 5238 * The interval in milliseconds after which Wi-Fi is considered idle. 5239 * When idle, it is possible for the device to be switched from Wi-Fi to 5240 * the mobile data network. 5241 * @hide 5242 * @deprecated Use {@link android.provider.Settings.Global#WIFI_IDLE_MS} 5243 * instead. 5244 */ 5245 @Deprecated 5246 public static final String WIFI_IDLE_MS = Global.WIFI_IDLE_MS; 5247 5248 /** 5249 * The global search provider chosen by the user (if multiple global 5250 * search providers are installed). This will be the provider returned 5251 * by {@link SearchManager#getGlobalSearchActivity()} if it's still 5252 * installed. This setting is stored as a flattened component name as 5253 * per {@link ComponentName#flattenToString()}. 5254 * 5255 * @hide 5256 */ 5257 public static final String SEARCH_GLOBAL_SEARCH_ACTIVITY = 5258 "search_global_search_activity"; 5259 5260 /** 5261 * The number of promoted sources in GlobalSearch. 5262 * @hide 5263 */ 5264 public static final String SEARCH_NUM_PROMOTED_SOURCES = "search_num_promoted_sources"; 5265 /** 5266 * The maximum number of suggestions returned by GlobalSearch. 5267 * @hide 5268 */ 5269 public static final String SEARCH_MAX_RESULTS_TO_DISPLAY = "search_max_results_to_display"; 5270 /** 5271 * The number of suggestions GlobalSearch will ask each non-web search source for. 5272 * @hide 5273 */ 5274 public static final String SEARCH_MAX_RESULTS_PER_SOURCE = "search_max_results_per_source"; 5275 /** 5276 * The number of suggestions the GlobalSearch will ask the web search source for. 5277 * @hide 5278 */ 5279 public static final String SEARCH_WEB_RESULTS_OVERRIDE_LIMIT = 5280 "search_web_results_override_limit"; 5281 /** 5282 * The number of milliseconds that GlobalSearch will wait for suggestions from 5283 * promoted sources before continuing with all other sources. 5284 * @hide 5285 */ 5286 public static final String SEARCH_PROMOTED_SOURCE_DEADLINE_MILLIS = 5287 "search_promoted_source_deadline_millis"; 5288 /** 5289 * The number of milliseconds before GlobalSearch aborts search suggesiton queries. 5290 * @hide 5291 */ 5292 public static final String SEARCH_SOURCE_TIMEOUT_MILLIS = "search_source_timeout_millis"; 5293 /** 5294 * The maximum number of milliseconds that GlobalSearch shows the previous results 5295 * after receiving a new query. 5296 * @hide 5297 */ 5298 public static final String SEARCH_PREFILL_MILLIS = "search_prefill_millis"; 5299 /** 5300 * The maximum age of log data used for shortcuts in GlobalSearch. 5301 * @hide 5302 */ 5303 public static final String SEARCH_MAX_STAT_AGE_MILLIS = "search_max_stat_age_millis"; 5304 /** 5305 * The maximum age of log data used for source ranking in GlobalSearch. 5306 * @hide 5307 */ 5308 public static final String SEARCH_MAX_SOURCE_EVENT_AGE_MILLIS = 5309 "search_max_source_event_age_millis"; 5310 /** 5311 * The minimum number of impressions needed to rank a source in GlobalSearch. 5312 * @hide 5313 */ 5314 public static final String SEARCH_MIN_IMPRESSIONS_FOR_SOURCE_RANKING = 5315 "search_min_impressions_for_source_ranking"; 5316 /** 5317 * The minimum number of clicks needed to rank a source in GlobalSearch. 5318 * @hide 5319 */ 5320 public static final String SEARCH_MIN_CLICKS_FOR_SOURCE_RANKING = 5321 "search_min_clicks_for_source_ranking"; 5322 /** 5323 * The maximum number of shortcuts shown by GlobalSearch. 5324 * @hide 5325 */ 5326 public static final String SEARCH_MAX_SHORTCUTS_RETURNED = "search_max_shortcuts_returned"; 5327 /** 5328 * The size of the core thread pool for suggestion queries in GlobalSearch. 5329 * @hide 5330 */ 5331 public static final String SEARCH_QUERY_THREAD_CORE_POOL_SIZE = 5332 "search_query_thread_core_pool_size"; 5333 /** 5334 * The maximum size of the thread pool for suggestion queries in GlobalSearch. 5335 * @hide 5336 */ 5337 public static final String SEARCH_QUERY_THREAD_MAX_POOL_SIZE = 5338 "search_query_thread_max_pool_size"; 5339 /** 5340 * The size of the core thread pool for shortcut refreshing in GlobalSearch. 5341 * @hide 5342 */ 5343 public static final String SEARCH_SHORTCUT_REFRESH_CORE_POOL_SIZE = 5344 "search_shortcut_refresh_core_pool_size"; 5345 /** 5346 * The maximum size of the thread pool for shortcut refreshing in GlobalSearch. 5347 * @hide 5348 */ 5349 public static final String SEARCH_SHORTCUT_REFRESH_MAX_POOL_SIZE = 5350 "search_shortcut_refresh_max_pool_size"; 5351 /** 5352 * The maximun time that excess threads in the GlobalSeach thread pools will 5353 * wait before terminating. 5354 * @hide 5355 */ 5356 public static final String SEARCH_THREAD_KEEPALIVE_SECONDS = 5357 "search_thread_keepalive_seconds"; 5358 /** 5359 * The maximum number of concurrent suggestion queries to each source. 5360 * @hide 5361 */ 5362 public static final String SEARCH_PER_SOURCE_CONCURRENT_QUERY_LIMIT = 5363 "search_per_source_concurrent_query_limit"; 5364 5365 /** 5366 * Whether or not alert sounds are played on MountService events. (0 = false, 1 = true) 5367 * @hide 5368 */ 5369 public static final String MOUNT_PLAY_NOTIFICATION_SND = "mount_play_not_snd"; 5370 5371 /** 5372 * Whether or not UMS auto-starts on UMS host detection. (0 = false, 1 = true) 5373 * @hide 5374 */ 5375 public static final String MOUNT_UMS_AUTOSTART = "mount_ums_autostart"; 5376 5377 /** 5378 * Whether or not a notification is displayed on UMS host detection. (0 = false, 1 = true) 5379 * @hide 5380 */ 5381 public static final String MOUNT_UMS_PROMPT = "mount_ums_prompt"; 5382 5383 /** 5384 * Whether or not a notification is displayed while UMS is enabled. (0 = false, 1 = true) 5385 * @hide 5386 */ 5387 public static final String MOUNT_UMS_NOTIFY_ENABLED = "mount_ums_notify_enabled"; 5388 5389 /** 5390 * If nonzero, ANRs in invisible background processes bring up a dialog. 5391 * Otherwise, the process will be silently killed. 5392 * @hide 5393 */ 5394 public static final String ANR_SHOW_BACKGROUND = "anr_show_background"; 5395 5396 /** 5397 * The {@link ComponentName} string of the service to be used as the voice recognition 5398 * service. 5399 * 5400 * @hide 5401 */ 5402 public static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service"; 5403 5404 /** 5405 * Stores whether an user has consented to have apps verified through PAM. 5406 * The value is boolean (1 or 0). 5407 * 5408 * @hide 5409 */ 5410 public static final String PACKAGE_VERIFIER_USER_CONSENT = 5411 "package_verifier_user_consent"; 5412 5413 /** 5414 * The {@link ComponentName} string of the selected spell checker service which is 5415 * one of the services managed by the text service manager. 5416 * 5417 * @hide 5418 */ 5419 public static final String SELECTED_SPELL_CHECKER = "selected_spell_checker"; 5420 5421 /** 5422 * The {@link ComponentName} string of the selected subtype of the selected spell checker 5423 * service which is one of the services managed by the text service manager. 5424 * 5425 * @hide 5426 */ 5427 public static final String SELECTED_SPELL_CHECKER_SUBTYPE = 5428 "selected_spell_checker_subtype"; 5429 5430 /** 5431 * The {@link ComponentName} string whether spell checker is enabled or not. 5432 * 5433 * @hide 5434 */ 5435 public static final String SPELL_CHECKER_ENABLED = "spell_checker_enabled"; 5436 5437 /** 5438 * What happens when the user presses the Power button while in-call 5439 * and the screen is on.<br/> 5440 * <b>Values:</b><br/> 5441 * 1 - The Power button turns off the screen and locks the device. (Default behavior)<br/> 5442 * 2 - The Power button hangs up the current call.<br/> 5443 * 5444 * @hide 5445 */ 5446 public static final String INCALL_POWER_BUTTON_BEHAVIOR = "incall_power_button_behavior"; 5447 5448 /** 5449 * INCALL_POWER_BUTTON_BEHAVIOR value for "turn off screen". 5450 * @hide 5451 */ 5452 public static final int INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF = 0x1; 5453 5454 /** 5455 * INCALL_POWER_BUTTON_BEHAVIOR value for "hang up". 5456 * @hide 5457 */ 5458 public static final int INCALL_POWER_BUTTON_BEHAVIOR_HANGUP = 0x2; 5459 5460 /** 5461 * INCALL_POWER_BUTTON_BEHAVIOR default value. 5462 * @hide 5463 */ 5464 public static final int INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT = 5465 INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF; 5466 5467 /** 5468 * Whether the device should wake when the wake gesture sensor detects motion. 5469 * @hide 5470 */ 5471 public static final String WAKE_GESTURE_ENABLED = "wake_gesture_enabled"; 5472 5473 /** 5474 * Whether the device should doze if configured. 5475 * @hide 5476 */ 5477 public static final String DOZE_ENABLED = "doze_enabled"; 5478 5479 /** 5480 * The current night mode that has been selected by the user. Owned 5481 * and controlled by UiModeManagerService. Constants are as per 5482 * UiModeManager. 5483 * @hide 5484 */ 5485 public static final String UI_NIGHT_MODE = "ui_night_mode"; 5486 5487 /** 5488 * Whether screensavers are enabled. 5489 * @hide 5490 */ 5491 public static final String SCREENSAVER_ENABLED = "screensaver_enabled"; 5492 5493 /** 5494 * The user's chosen screensaver components. 5495 * 5496 * These will be launched by the PhoneWindowManager after a timeout when not on 5497 * battery, or upon dock insertion (if SCREENSAVER_ACTIVATE_ON_DOCK is set to 1). 5498 * @hide 5499 */ 5500 public static final String SCREENSAVER_COMPONENTS = "screensaver_components"; 5501 5502 /** 5503 * If screensavers are enabled, whether the screensaver should be automatically launched 5504 * when the device is inserted into a (desk) dock. 5505 * @hide 5506 */ 5507 public static final String SCREENSAVER_ACTIVATE_ON_DOCK = "screensaver_activate_on_dock"; 5508 5509 /** 5510 * If screensavers are enabled, whether the screensaver should be automatically launched 5511 * when the screen times out when not on battery. 5512 * @hide 5513 */ 5514 public static final String SCREENSAVER_ACTIVATE_ON_SLEEP = "screensaver_activate_on_sleep"; 5515 5516 /** 5517 * If screensavers are enabled, the default screensaver component. 5518 * @hide 5519 */ 5520 public static final String SCREENSAVER_DEFAULT_COMPONENT = "screensaver_default_component"; 5521 5522 /** 5523 * The default NFC payment component 5524 * @hide 5525 */ 5526 public static final String NFC_PAYMENT_DEFAULT_COMPONENT = "nfc_payment_default_component"; 5527 5528 /** 5529 * Whether NFC payment is handled by the foreground application or a default. 5530 * @hide 5531 */ 5532 public static final String NFC_PAYMENT_FOREGROUND = "nfc_payment_foreground"; 5533 5534 /** 5535 * Specifies the package name currently configured to be the primary sms application 5536 * @hide 5537 */ 5538 public static final String SMS_DEFAULT_APPLICATION = "sms_default_application"; 5539 5540 /** 5541 * Specifies the package name currently configured to be the default dialer application 5542 * @hide 5543 */ 5544 public static final String DIALER_DEFAULT_APPLICATION = "dialer_default_application"; 5545 5546 /** 5547 * Specifies the package name currently configured to be the emergency assistance application 5548 * 5549 * @see android.telephony.TelephonyManager#ACTION_EMERGENCY_ASSISTANCE 5550 * 5551 * @hide 5552 */ 5553 public static final String EMERGENCY_ASSISTANCE_APPLICATION = "emergency_assistance_application"; 5554 5555 /** 5556 * Specifies whether the current app context on scren (assist data) will be sent to the 5557 * assist application (active voice interaction service). 5558 * 5559 * @hide 5560 */ 5561 public static final String ASSIST_STRUCTURE_ENABLED = "assist_structure_enabled"; 5562 5563 /** 5564 * Specifies whether a screenshot of the screen contents will be sent to the assist 5565 * application (active voice interaction service). 5566 * 5567 * @hide 5568 */ 5569 public static final String ASSIST_SCREENSHOT_ENABLED = "assist_screenshot_enabled"; 5570 5571 /** 5572 * Names of the service components that the current user has explicitly allowed to 5573 * see all of the user's notifications, separated by ':'. 5574 * 5575 * @hide 5576 */ 5577 public static final String ENABLED_NOTIFICATION_LISTENERS = "enabled_notification_listeners"; 5578 5579 /** 5580 * Names of the packages that the current user has explicitly allowed to 5581 * manage notification policy configuration, separated by ':'. 5582 * 5583 * @hide 5584 */ 5585 public static final String ENABLED_NOTIFICATION_POLICY_ACCESS_PACKAGES = 5586 "enabled_notification_policy_access_packages"; 5587 5588 /** 5589 * @hide 5590 */ 5591 public static final String ENABLED_CONDITION_PROVIDERS = "enabled_condition_providers"; 5592 5593 /** @hide */ 5594 public static final String BAR_SERVICE_COMPONENT = "bar_service_component"; 5595 5596 /** @hide */ 5597 public static final String VOLUME_CONTROLLER_SERVICE_COMPONENT 5598 = "volume_controller_service_component"; 5599 5600 /** @hide */ 5601 public static final String IMMERSIVE_MODE_CONFIRMATIONS = "immersive_mode_confirmations"; 5602 5603 /** 5604 * This is the query URI for finding a print service to install. 5605 * 5606 * @hide 5607 */ 5608 public static final String PRINT_SERVICE_SEARCH_URI = "print_service_search_uri"; 5609 5610 /** 5611 * This is the query URI for finding a NFC payment service to install. 5612 * 5613 * @hide 5614 */ 5615 public static final String PAYMENT_SERVICE_SEARCH_URI = "payment_service_search_uri"; 5616 5617 /** 5618 * If enabled, apps should try to skip any introductory hints on first launch. This might 5619 * apply to users that are already familiar with the environment or temporary users. 5620 * <p> 5621 * Type : int (0 to show hints, 1 to skip showing hints) 5622 */ 5623 public static final String SKIP_FIRST_USE_HINTS = "skip_first_use_hints"; 5624 5625 /** 5626 * Persisted playback time after a user confirmation of an unsafe volume level. 5627 * 5628 * @hide 5629 */ 5630 public static final String UNSAFE_VOLUME_MUSIC_ACTIVE_MS = "unsafe_volume_music_active_ms"; 5631 5632 /** 5633 * This preference enables notification display on the lockscreen. 5634 * @hide 5635 */ 5636 public static final String LOCK_SCREEN_SHOW_NOTIFICATIONS = 5637 "lock_screen_show_notifications"; 5638 5639 /** 5640 * List of TV inputs that are currently hidden. This is a string 5641 * containing the IDs of all hidden TV inputs. Each ID is encoded by 5642 * {@link android.net.Uri#encode(String)} and separated by ':'. 5643 * @hide 5644 */ 5645 public static final String TV_INPUT_HIDDEN_INPUTS = "tv_input_hidden_inputs"; 5646 5647 /** 5648 * List of custom TV input labels. This is a string containing <TV input id, custom name> 5649 * pairs. TV input id and custom name are encoded by {@link android.net.Uri#encode(String)} 5650 * and separated by ','. Each pair is separated by ':'. 5651 * @hide 5652 */ 5653 public static final String TV_INPUT_CUSTOM_LABELS = "tv_input_custom_labels"; 5654 5655 /** 5656 * Whether automatic routing of system audio to USB audio peripheral is disabled. 5657 * The value is boolean (1 or 0), where 1 means automatic routing is disabled, 5658 * and 0 means automatic routing is enabled. 5659 * 5660 * @hide 5661 */ 5662 public static final String USB_AUDIO_AUTOMATIC_ROUTING_DISABLED = 5663 "usb_audio_automatic_routing_disabled"; 5664 5665 /** 5666 * The timeout in milliseconds before the device fully goes to sleep after 5667 * a period of inactivity. This value sets an upper bound on how long the device 5668 * will stay awake or dreaming without user activity. It should generally 5669 * be longer than {@link Settings.System#SCREEN_OFF_TIMEOUT} as otherwise the device 5670 * will sleep before it ever has a chance to dream. 5671 * <p> 5672 * Use -1 to disable this timeout. 5673 * </p> 5674 * 5675 * @hide 5676 */ 5677 public static final String SLEEP_TIMEOUT = "sleep_timeout"; 5678 5679 /** 5680 * Controls whether double tap to wake is enabled. 5681 * @hide 5682 */ 5683 public static final String DOUBLE_TAP_TO_WAKE = "double_tap_to_wake"; 5684 5685 /** 5686 * The current assistant component. It could be a voice interaction service, 5687 * or an activity that handles ACTION_ASSIST, or empty which means using the default 5688 * handling. 5689 * 5690 * @hide 5691 */ 5692 public static final String ASSISTANT = "assistant"; 5693 5694 /** 5695 * Whether the camera launch gesture should be disabled. 5696 * 5697 * @hide 5698 */ 5699 public static final String CAMERA_GESTURE_DISABLED = "camera_gesture_disabled"; 5700 5701 /** 5702 * Whether the camera launch gesture to double tap the power button when the screen is off 5703 * should be disabled. 5704 * 5705 * @hide 5706 */ 5707 public static final String CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED = 5708 "camera_double_tap_power_gesture_disabled"; 5709 5710 /** 5711 * This are the settings to be backed up. 5712 * 5713 * NOTE: Settings are backed up and restored in the order they appear 5714 * in this array. If you have one setting depending on another, 5715 * make sure that they are ordered appropriately. 5716 * 5717 * @hide 5718 */ 5719 public static final String[] SETTINGS_TO_BACKUP = { 5720 BUGREPORT_IN_POWER_MENU, // moved to global 5721 ALLOW_MOCK_LOCATION, 5722 PARENTAL_CONTROL_ENABLED, 5723 PARENTAL_CONTROL_REDIRECT_URL, 5724 USB_MASS_STORAGE_ENABLED, // moved to global 5725 ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 5726 ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE, 5727 ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE, 5728 ACCESSIBILITY_SCRIPT_INJECTION, 5729 BACKUP_AUTO_RESTORE, 5730 ENABLED_ACCESSIBILITY_SERVICES, 5731 ENABLED_NOTIFICATION_LISTENERS, 5732 ENABLED_INPUT_METHODS, 5733 TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, 5734 TOUCH_EXPLORATION_ENABLED, 5735 ACCESSIBILITY_ENABLED, 5736 ACCESSIBILITY_SPEAK_PASSWORD, 5737 ACCESSIBILITY_HIGH_TEXT_CONTRAST_ENABLED, 5738 ACCESSIBILITY_CAPTIONING_ENABLED, 5739 ACCESSIBILITY_CAPTIONING_LOCALE, 5740 ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR, 5741 ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR, 5742 ACCESSIBILITY_CAPTIONING_EDGE_TYPE, 5743 ACCESSIBILITY_CAPTIONING_EDGE_COLOR, 5744 ACCESSIBILITY_CAPTIONING_TYPEFACE, 5745 ACCESSIBILITY_CAPTIONING_FONT_SCALE, 5746 TTS_USE_DEFAULTS, 5747 TTS_DEFAULT_RATE, 5748 TTS_DEFAULT_PITCH, 5749 TTS_DEFAULT_SYNTH, 5750 TTS_DEFAULT_LANG, 5751 TTS_DEFAULT_COUNTRY, 5752 TTS_ENABLED_PLUGINS, 5753 TTS_DEFAULT_LOCALE, 5754 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, // moved to global 5755 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, // moved to global 5756 WIFI_NUM_OPEN_NETWORKS_KEPT, // moved to global 5757 SELECTED_SPELL_CHECKER, 5758 SELECTED_SPELL_CHECKER_SUBTYPE, 5759 SPELL_CHECKER_ENABLED, 5760 MOUNT_PLAY_NOTIFICATION_SND, 5761 MOUNT_UMS_AUTOSTART, 5762 MOUNT_UMS_PROMPT, 5763 MOUNT_UMS_NOTIFY_ENABLED, 5764 SLEEP_TIMEOUT, 5765 DOUBLE_TAP_TO_WAKE, 5766 CAMERA_GESTURE_DISABLED, 5767 }; 5768 5769 /** 5770 * These entries are considered common between the personal and the managed profile, 5771 * since the managed profile doesn't get to change them. 5772 */ 5773 private static final Set<String> CLONE_TO_MANAGED_PROFILE = new ArraySet<>(); 5774 5775 static { 5776 CLONE_TO_MANAGED_PROFILE.add(ACCESSIBILITY_ENABLED); 5777 CLONE_TO_MANAGED_PROFILE.add(ALLOW_MOCK_LOCATION); 5778 CLONE_TO_MANAGED_PROFILE.add(ALLOWED_GEOLOCATION_ORIGINS); 5779 CLONE_TO_MANAGED_PROFILE.add(DEFAULT_INPUT_METHOD); 5780 CLONE_TO_MANAGED_PROFILE.add(ENABLED_ACCESSIBILITY_SERVICES); 5781 CLONE_TO_MANAGED_PROFILE.add(ENABLED_INPUT_METHODS); 5782 CLONE_TO_MANAGED_PROFILE.add(LOCATION_MODE); 5783 CLONE_TO_MANAGED_PROFILE.add(LOCATION_PROVIDERS_ALLOWED); 5784 CLONE_TO_MANAGED_PROFILE.add(LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS); 5785 CLONE_TO_MANAGED_PROFILE.add(SELECTED_INPUT_METHOD_SUBTYPE); 5786 CLONE_TO_MANAGED_PROFILE.add(SELECTED_SPELL_CHECKER); 5787 CLONE_TO_MANAGED_PROFILE.add(SELECTED_SPELL_CHECKER_SUBTYPE); 5788 } 5789 5790 /** @hide */ getCloneToManagedProfileSettings(Set<String> outKeySet)5791 public static void getCloneToManagedProfileSettings(Set<String> outKeySet) { 5792 outKeySet.addAll(CLONE_TO_MANAGED_PROFILE); 5793 } 5794 5795 /** 5796 * Helper method for determining if a location provider is enabled. 5797 * 5798 * @param cr the content resolver to use 5799 * @param provider the location provider to query 5800 * @return true if the provider is enabled 5801 * 5802 * @deprecated use {@link #LOCATION_MODE} or 5803 * {@link LocationManager#isProviderEnabled(String)} 5804 */ 5805 @Deprecated isLocationProviderEnabled(ContentResolver cr, String provider)5806 public static final boolean isLocationProviderEnabled(ContentResolver cr, String provider) { 5807 return isLocationProviderEnabledForUser(cr, provider, UserHandle.myUserId()); 5808 } 5809 5810 /** 5811 * Helper method for determining if a location provider is enabled. 5812 * @param cr the content resolver to use 5813 * @param provider the location provider to query 5814 * @param userId the userId to query 5815 * @return true if the provider is enabled 5816 * @deprecated use {@link #LOCATION_MODE} or 5817 * {@link LocationManager#isProviderEnabled(String)} 5818 * @hide 5819 */ 5820 @Deprecated isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId)5821 public static final boolean isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId) { 5822 String allowedProviders = Settings.Secure.getStringForUser(cr, 5823 LOCATION_PROVIDERS_ALLOWED, userId); 5824 return TextUtils.delimitedStringContains(allowedProviders, ',', provider); 5825 } 5826 5827 /** 5828 * Thread-safe method for enabling or disabling a single location provider. 5829 * @param cr the content resolver to use 5830 * @param provider the location provider to enable or disable 5831 * @param enabled true if the provider should be enabled 5832 * @deprecated use {@link #putInt(ContentResolver, String, int)} and {@link #LOCATION_MODE} 5833 */ 5834 @Deprecated setLocationProviderEnabled(ContentResolver cr, String provider, boolean enabled)5835 public static final void setLocationProviderEnabled(ContentResolver cr, 5836 String provider, boolean enabled) { 5837 setLocationProviderEnabledForUser(cr, provider, enabled, UserHandle.myUserId()); 5838 } 5839 5840 /** 5841 * Thread-safe method for enabling or disabling a single location provider. 5842 * 5843 * @param cr the content resolver to use 5844 * @param provider the location provider to enable or disable 5845 * @param enabled true if the provider should be enabled 5846 * @param userId the userId for which to enable/disable providers 5847 * @return true if the value was set, false on database errors 5848 * @deprecated use {@link #putIntForUser(ContentResolver, String, int, int)} and 5849 * {@link #LOCATION_MODE} 5850 * @hide 5851 */ 5852 @Deprecated setLocationProviderEnabledForUser(ContentResolver cr, String provider, boolean enabled, int userId)5853 public static final boolean setLocationProviderEnabledForUser(ContentResolver cr, 5854 String provider, boolean enabled, int userId) { 5855 synchronized (mLocationSettingsLock) { 5856 // to ensure thread safety, we write the provider name with a '+' or '-' 5857 // and let the SettingsProvider handle it rather than reading and modifying 5858 // the list of enabled providers. 5859 if (enabled) { 5860 provider = "+" + provider; 5861 } else { 5862 provider = "-" + provider; 5863 } 5864 return putStringForUser(cr, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, provider, 5865 userId); 5866 } 5867 } 5868 5869 /** 5870 * Thread-safe method for setting the location mode to one of 5871 * {@link #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, 5872 * {@link #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. 5873 * 5874 * @param cr the content resolver to use 5875 * @param mode such as {@link #LOCATION_MODE_HIGH_ACCURACY} 5876 * @param userId the userId for which to change mode 5877 * @return true if the value was set, false on database errors 5878 * 5879 * @throws IllegalArgumentException if mode is not one of the supported values 5880 */ setLocationModeForUser(ContentResolver cr, int mode, int userId)5881 private static final boolean setLocationModeForUser(ContentResolver cr, int mode, 5882 int userId) { 5883 synchronized (mLocationSettingsLock) { 5884 boolean gps = false; 5885 boolean network = false; 5886 switch (mode) { 5887 case LOCATION_MODE_OFF: 5888 break; 5889 case LOCATION_MODE_SENSORS_ONLY: 5890 gps = true; 5891 break; 5892 case LOCATION_MODE_BATTERY_SAVING: 5893 network = true; 5894 break; 5895 case LOCATION_MODE_HIGH_ACCURACY: 5896 gps = true; 5897 network = true; 5898 break; 5899 default: 5900 throw new IllegalArgumentException("Invalid location mode: " + mode); 5901 } 5902 // Note it's important that we set the NLP mode first. The Google implementation 5903 // of NLP clears its NLP consent setting any time it receives a 5904 // LocationManager.PROVIDERS_CHANGED_ACTION broadcast and NLP is disabled. Also, 5905 // it shows an NLP consent dialog any time it receives the broadcast, NLP is 5906 // enabled, and the NLP consent is not set. If 1) we were to enable GPS first, 5907 // 2) a setup wizard has its own NLP consent UI that sets the NLP consent setting, 5908 // and 3) the receiver happened to complete before we enabled NLP, then the Google 5909 // NLP would detect the attempt to enable NLP and show a redundant NLP consent 5910 // dialog. Then the people who wrote the setup wizard would be sad. 5911 boolean nlpSuccess = Settings.Secure.setLocationProviderEnabledForUser( 5912 cr, LocationManager.NETWORK_PROVIDER, network, userId); 5913 boolean gpsSuccess = Settings.Secure.setLocationProviderEnabledForUser( 5914 cr, LocationManager.GPS_PROVIDER, gps, userId); 5915 return gpsSuccess && nlpSuccess; 5916 } 5917 } 5918 5919 /** 5920 * Thread-safe method for reading the location mode, returns one of 5921 * {@link #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, 5922 * {@link #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. 5923 * 5924 * @param cr the content resolver to use 5925 * @param userId the userId for which to read the mode 5926 * @return the location mode 5927 */ getLocationModeForUser(ContentResolver cr, int userId)5928 private static final int getLocationModeForUser(ContentResolver cr, int userId) { 5929 synchronized (mLocationSettingsLock) { 5930 boolean gpsEnabled = Settings.Secure.isLocationProviderEnabledForUser( 5931 cr, LocationManager.GPS_PROVIDER, userId); 5932 boolean networkEnabled = Settings.Secure.isLocationProviderEnabledForUser( 5933 cr, LocationManager.NETWORK_PROVIDER, userId); 5934 if (gpsEnabled && networkEnabled) { 5935 return LOCATION_MODE_HIGH_ACCURACY; 5936 } else if (gpsEnabled) { 5937 return LOCATION_MODE_SENSORS_ONLY; 5938 } else if (networkEnabled) { 5939 return LOCATION_MODE_BATTERY_SAVING; 5940 } else { 5941 return LOCATION_MODE_OFF; 5942 } 5943 } 5944 } 5945 } 5946 5947 /** 5948 * Global system settings, containing preferences that always apply identically 5949 * to all defined users. Applications can read these but are not allowed to write; 5950 * like the "Secure" settings, these are for preferences that the user must 5951 * explicitly modify through the system UI or specialized APIs for those values. 5952 */ 5953 public static final class Global extends NameValueTable { 5954 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_global_version"; 5955 5956 /** 5957 * The content:// style URL for global secure settings items. Not public. 5958 */ 5959 public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/global"); 5960 5961 /** 5962 * Whether users are allowed to add more users or guest from lockscreen. 5963 * <p> 5964 * Type: int 5965 * @hide 5966 */ 5967 public static final String ADD_USERS_WHEN_LOCKED = "add_users_when_locked"; 5968 5969 /** 5970 * Setting whether the global gesture for enabling accessibility is enabled. 5971 * If this gesture is enabled the user will be able to perfrom it to enable 5972 * the accessibility state without visiting the settings app. 5973 * @hide 5974 */ 5975 public static final String ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED = 5976 "enable_accessibility_global_gesture_enabled"; 5977 5978 /** 5979 * Whether Airplane Mode is on. 5980 */ 5981 public static final String AIRPLANE_MODE_ON = "airplane_mode_on"; 5982 5983 /** 5984 * Whether Theater Mode is on. 5985 * {@hide} 5986 */ 5987 @SystemApi 5988 public static final String THEATER_MODE_ON = "theater_mode_on"; 5989 5990 /** 5991 * Constant for use in AIRPLANE_MODE_RADIOS to specify Bluetooth radio. 5992 */ 5993 public static final String RADIO_BLUETOOTH = "bluetooth"; 5994 5995 /** 5996 * Constant for use in AIRPLANE_MODE_RADIOS to specify Wi-Fi radio. 5997 */ 5998 public static final String RADIO_WIFI = "wifi"; 5999 6000 /** 6001 * {@hide} 6002 */ 6003 public static final String RADIO_WIMAX = "wimax"; 6004 /** 6005 * Constant for use in AIRPLANE_MODE_RADIOS to specify Cellular radio. 6006 */ 6007 public static final String RADIO_CELL = "cell"; 6008 6009 /** 6010 * Constant for use in AIRPLANE_MODE_RADIOS to specify NFC radio. 6011 */ 6012 public static final String RADIO_NFC = "nfc"; 6013 6014 /** 6015 * A comma separated list of radios that need to be disabled when airplane mode 6016 * is on. This overrides WIFI_ON and BLUETOOTH_ON, if Wi-Fi and bluetooth are 6017 * included in the comma separated list. 6018 */ 6019 public static final String AIRPLANE_MODE_RADIOS = "airplane_mode_radios"; 6020 6021 /** 6022 * A comma separated list of radios that should to be disabled when airplane mode 6023 * is on, but can be manually reenabled by the user. For example, if RADIO_WIFI is 6024 * added to both AIRPLANE_MODE_RADIOS and AIRPLANE_MODE_TOGGLEABLE_RADIOS, then Wifi 6025 * will be turned off when entering airplane mode, but the user will be able to reenable 6026 * Wifi in the Settings app. 6027 * 6028 * {@hide} 6029 */ 6030 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = "airplane_mode_toggleable_radios"; 6031 6032 /** 6033 * A semi-colon separated list of Bluetooth interoperability workarounds. 6034 * Each entry is a partial Bluetooth device address string and an integer representing 6035 * the feature to be disabled, separated by a comma. The integer must correspond 6036 * to a interoperability feature as defined in "interop.h" in /system/bt. 6037 * <p> 6038 * Example: <br/> 6039 * "00:11:22,0;01:02:03:04,2" 6040 * @hide 6041 */ 6042 public static final String BLUETOOTH_INTEROPERABILITY_LIST = "bluetooth_interoperability_list"; 6043 6044 /** 6045 * The policy for deciding when Wi-Fi should go to sleep (which will in 6046 * turn switch to using the mobile data as an Internet connection). 6047 * <p> 6048 * Set to one of {@link #WIFI_SLEEP_POLICY_DEFAULT}, 6049 * {@link #WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED}, or 6050 * {@link #WIFI_SLEEP_POLICY_NEVER}. 6051 */ 6052 public static final String WIFI_SLEEP_POLICY = "wifi_sleep_policy"; 6053 6054 /** 6055 * Value for {@link #WIFI_SLEEP_POLICY} to use the default Wi-Fi sleep 6056 * policy, which is to sleep shortly after the turning off 6057 * according to the {@link #STAY_ON_WHILE_PLUGGED_IN} setting. 6058 */ 6059 public static final int WIFI_SLEEP_POLICY_DEFAULT = 0; 6060 6061 /** 6062 * Value for {@link #WIFI_SLEEP_POLICY} to use the default policy when 6063 * the device is on battery, and never go to sleep when the device is 6064 * plugged in. 6065 */ 6066 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1; 6067 6068 /** 6069 * Value for {@link #WIFI_SLEEP_POLICY} to never go to sleep. 6070 */ 6071 public static final int WIFI_SLEEP_POLICY_NEVER = 2; 6072 6073 /** 6074 * Value to specify if the user prefers the date, time and time zone 6075 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 6076 */ 6077 public static final String AUTO_TIME = "auto_time"; 6078 6079 /** 6080 * Value to specify if the user prefers the time zone 6081 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 6082 */ 6083 public static final String AUTO_TIME_ZONE = "auto_time_zone"; 6084 6085 /** 6086 * URI for the car dock "in" event sound. 6087 * @hide 6088 */ 6089 public static final String CAR_DOCK_SOUND = "car_dock_sound"; 6090 6091 /** 6092 * URI for the car dock "out" event sound. 6093 * @hide 6094 */ 6095 public static final String CAR_UNDOCK_SOUND = "car_undock_sound"; 6096 6097 /** 6098 * URI for the desk dock "in" event sound. 6099 * @hide 6100 */ 6101 public static final String DESK_DOCK_SOUND = "desk_dock_sound"; 6102 6103 /** 6104 * URI for the desk dock "out" event sound. 6105 * @hide 6106 */ 6107 public static final String DESK_UNDOCK_SOUND = "desk_undock_sound"; 6108 6109 /** 6110 * Whether to play a sound for dock events. 6111 * @hide 6112 */ 6113 public static final String DOCK_SOUNDS_ENABLED = "dock_sounds_enabled"; 6114 6115 /** 6116 * URI for the "device locked" (keyguard shown) sound. 6117 * @hide 6118 */ 6119 public static final String LOCK_SOUND = "lock_sound"; 6120 6121 /** 6122 * URI for the "device unlocked" sound. 6123 * @hide 6124 */ 6125 public static final String UNLOCK_SOUND = "unlock_sound"; 6126 6127 /** 6128 * URI for the "device is trusted" sound, which is played when the device enters the trusted 6129 * state without unlocking. 6130 * @hide 6131 */ 6132 public static final String TRUSTED_SOUND = "trusted_sound"; 6133 6134 /** 6135 * URI for the low battery sound file. 6136 * @hide 6137 */ 6138 public static final String LOW_BATTERY_SOUND = "low_battery_sound"; 6139 6140 /** 6141 * Whether to play a sound for low-battery alerts. 6142 * @hide 6143 */ 6144 public static final String POWER_SOUNDS_ENABLED = "power_sounds_enabled"; 6145 6146 /** 6147 * URI for the "wireless charging started" sound. 6148 * @hide 6149 */ 6150 public static final String WIRELESS_CHARGING_STARTED_SOUND = 6151 "wireless_charging_started_sound"; 6152 6153 /** 6154 * Whether to play a sound for charging events. 6155 * @hide 6156 */ 6157 public static final String CHARGING_SOUNDS_ENABLED = "charging_sounds_enabled"; 6158 6159 /** 6160 * Whether we keep the device on while the device is plugged in. 6161 * Supported values are: 6162 * <ul> 6163 * <li>{@code 0} to never stay on while plugged in</li> 6164 * <li>{@link BatteryManager#BATTERY_PLUGGED_AC} to stay on for AC charger</li> 6165 * <li>{@link BatteryManager#BATTERY_PLUGGED_USB} to stay on for USB charger</li> 6166 * <li>{@link BatteryManager#BATTERY_PLUGGED_WIRELESS} to stay on for wireless charger</li> 6167 * </ul> 6168 * These values can be OR-ed together. 6169 */ 6170 public static final String STAY_ON_WHILE_PLUGGED_IN = "stay_on_while_plugged_in"; 6171 6172 /** 6173 * When the user has enable the option to have a "bug report" command 6174 * in the power menu. 6175 * @hide 6176 */ 6177 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 6178 6179 /** 6180 * Whether ADB is enabled. 6181 */ 6182 public static final String ADB_ENABLED = "adb_enabled"; 6183 6184 /** 6185 * Whether Views are allowed to save their attribute data. 6186 * @hide 6187 */ 6188 public static final String DEBUG_VIEW_ATTRIBUTES = "debug_view_attributes"; 6189 6190 /** 6191 * Whether assisted GPS should be enabled or not. 6192 * @hide 6193 */ 6194 public static final String ASSISTED_GPS_ENABLED = "assisted_gps_enabled"; 6195 6196 /** 6197 * Whether bluetooth is enabled/disabled 6198 * 0=disabled. 1=enabled. 6199 */ 6200 public static final String BLUETOOTH_ON = "bluetooth_on"; 6201 6202 /** 6203 * CDMA Cell Broadcast SMS 6204 * 0 = CDMA Cell Broadcast SMS disabled 6205 * 1 = CDMA Cell Broadcast SMS enabled 6206 * @hide 6207 */ 6208 public static final String CDMA_CELL_BROADCAST_SMS = 6209 "cdma_cell_broadcast_sms"; 6210 6211 /** 6212 * The CDMA roaming mode 0 = Home Networks, CDMA default 6213 * 1 = Roaming on Affiliated networks 6214 * 2 = Roaming on any networks 6215 * @hide 6216 */ 6217 public static final String CDMA_ROAMING_MODE = "roaming_settings"; 6218 6219 /** 6220 * The CDMA subscription mode 0 = RUIM/SIM (default) 6221 * 1 = NV 6222 * @hide 6223 */ 6224 public static final String CDMA_SUBSCRIPTION_MODE = "subscription_mode"; 6225 6226 /** Inactivity timeout to track mobile data activity. 6227 * 6228 * If set to a positive integer, it indicates the inactivity timeout value in seconds to 6229 * infer the data activity of mobile network. After a period of no activity on mobile 6230 * networks with length specified by the timeout, an {@code ACTION_DATA_ACTIVITY_CHANGE} 6231 * intent is fired to indicate a transition of network status from "active" to "idle". Any 6232 * subsequent activity on mobile networks triggers the firing of {@code 6233 * ACTION_DATA_ACTIVITY_CHANGE} intent indicating transition from "idle" to "active". 6234 * 6235 * Network activity refers to transmitting or receiving data on the network interfaces. 6236 * 6237 * Tracking is disabled if set to zero or negative value. 6238 * 6239 * @hide 6240 */ 6241 public static final String DATA_ACTIVITY_TIMEOUT_MOBILE = "data_activity_timeout_mobile"; 6242 6243 /** Timeout to tracking Wifi data activity. Same as {@code DATA_ACTIVITY_TIMEOUT_MOBILE} 6244 * but for Wifi network. 6245 * @hide 6246 */ 6247 public static final String DATA_ACTIVITY_TIMEOUT_WIFI = "data_activity_timeout_wifi"; 6248 6249 /** 6250 * Whether or not data roaming is enabled. (0 = false, 1 = true) 6251 */ 6252 public static final String DATA_ROAMING = "data_roaming"; 6253 6254 /** 6255 * The value passed to a Mobile DataConnection via bringUp which defines the 6256 * number of retries to preform when setting up the initial connection. The default 6257 * value defined in DataConnectionTrackerBase#DEFAULT_MDC_INITIAL_RETRY is currently 1. 6258 * @hide 6259 */ 6260 public static final String MDC_INITIAL_MAX_RETRY = "mdc_initial_max_retry"; 6261 6262 /** 6263 * Whether user has enabled development settings. 6264 */ 6265 public static final String DEVELOPMENT_SETTINGS_ENABLED = "development_settings_enabled"; 6266 6267 /** 6268 * Whether the device has been provisioned (0 = false, 1 = true) 6269 */ 6270 public static final String DEVICE_PROVISIONED = "device_provisioned"; 6271 6272 /** 6273 * The saved value for WindowManagerService.setForcedDisplayDensity(). 6274 * One integer in dpi. If unset, then use the real display density. 6275 * @hide 6276 */ 6277 public static final String DISPLAY_DENSITY_FORCED = "display_density_forced"; 6278 6279 /** 6280 * The saved value for WindowManagerService.setForcedDisplaySize(). 6281 * Two integers separated by a comma. If unset, then use the real display size. 6282 * @hide 6283 */ 6284 public static final String DISPLAY_SIZE_FORCED = "display_size_forced"; 6285 6286 /** 6287 * The saved value for WindowManagerService.setForcedDisplayScalingMode(). 6288 * 0 or unset if scaling is automatic, 1 if scaling is disabled. 6289 * @hide 6290 */ 6291 public static final String DISPLAY_SCALING_FORCE = "display_scaling_force"; 6292 6293 /** 6294 * The maximum size, in bytes, of a download that the download manager will transfer over 6295 * a non-wifi connection. 6296 * @hide 6297 */ 6298 public static final String DOWNLOAD_MAX_BYTES_OVER_MOBILE = 6299 "download_manager_max_bytes_over_mobile"; 6300 6301 /** 6302 * The recommended maximum size, in bytes, of a download that the download manager should 6303 * transfer over a non-wifi connection. Over this size, the use will be warned, but will 6304 * have the option to start the download over the mobile connection anyway. 6305 * @hide 6306 */ 6307 public static final String DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE = 6308 "download_manager_recommended_max_bytes_over_mobile"; 6309 6310 /** 6311 * @deprecated Use {@link android.provider.Settings.Secure#INSTALL_NON_MARKET_APPS} instead 6312 */ 6313 @Deprecated 6314 public static final String INSTALL_NON_MARKET_APPS = Secure.INSTALL_NON_MARKET_APPS; 6315 6316 /** 6317 * Whether HDMI control shall be enabled. If disabled, no CEC/MHL command will be 6318 * sent or processed. (0 = false, 1 = true) 6319 * @hide 6320 */ 6321 public static final String HDMI_CONTROL_ENABLED = "hdmi_control_enabled"; 6322 6323 /** 6324 * Whether HDMI system audio is enabled. If enabled, TV internal speaker is muted, 6325 * and the output is redirected to AV Receiver connected via 6326 * {@Global#HDMI_SYSTEM_AUDIO_OUTPUT}. 6327 * @hide 6328 */ 6329 public static final String HDMI_SYSTEM_AUDIO_ENABLED = "hdmi_system_audio_enabled"; 6330 6331 /** 6332 * Whether TV will automatically turn on upon reception of the CEC command 6333 * <Text View On> or <Image View On>. (0 = false, 1 = true) 6334 * @hide 6335 */ 6336 public static final String HDMI_CONTROL_AUTO_WAKEUP_ENABLED = 6337 "hdmi_control_auto_wakeup_enabled"; 6338 6339 /** 6340 * Whether TV will also turn off other CEC devices when it goes to standby mode. 6341 * (0 = false, 1 = true) 6342 * @hide 6343 */ 6344 public static final String HDMI_CONTROL_AUTO_DEVICE_OFF_ENABLED = 6345 "hdmi_control_auto_device_off_enabled"; 6346 6347 /** 6348 * Whether to use the DHCP client from Lollipop and earlier instead of the newer Android DHCP 6349 * client. 6350 * (0 = false, 1 = true) 6351 * @hide 6352 */ 6353 public static final String LEGACY_DHCP_CLIENT = "legacy_dhcp_client"; 6354 6355 /** 6356 * Whether TV will switch to MHL port when a mobile device is plugged in. 6357 * (0 = false, 1 = true) 6358 * @hide 6359 */ 6360 public static final String MHL_INPUT_SWITCHING_ENABLED = "mhl_input_switching_enabled"; 6361 6362 /** 6363 * Whether TV will charge the mobile device connected at MHL port. (0 = false, 1 = true) 6364 * @hide 6365 */ 6366 public static final String MHL_POWER_CHARGE_ENABLED = "mhl_power_charge_enabled"; 6367 6368 /** 6369 * Whether mobile data connections are allowed by the user. See 6370 * ConnectivityManager for more info. 6371 * @hide 6372 */ 6373 public static final String MOBILE_DATA = "mobile_data"; 6374 6375 /** 6376 * Whether the mobile data connection should remain active even when higher 6377 * priority networks like WiFi are active, to help make network switching faster. 6378 * 6379 * See ConnectivityService for more info. 6380 * 6381 * (0 = disabled, 1 = enabled) 6382 * @hide 6383 */ 6384 public static final String MOBILE_DATA_ALWAYS_ON = "mobile_data_always_on"; 6385 6386 /** {@hide} */ 6387 public static final String NETSTATS_ENABLED = "netstats_enabled"; 6388 /** {@hide} */ 6389 public static final String NETSTATS_POLL_INTERVAL = "netstats_poll_interval"; 6390 /** {@hide} */ 6391 public static final String NETSTATS_TIME_CACHE_MAX_AGE = "netstats_time_cache_max_age"; 6392 /** {@hide} */ 6393 public static final String NETSTATS_GLOBAL_ALERT_BYTES = "netstats_global_alert_bytes"; 6394 /** {@hide} */ 6395 public static final String NETSTATS_SAMPLE_ENABLED = "netstats_sample_enabled"; 6396 6397 /** {@hide} */ 6398 public static final String NETSTATS_DEV_BUCKET_DURATION = "netstats_dev_bucket_duration"; 6399 /** {@hide} */ 6400 public static final String NETSTATS_DEV_PERSIST_BYTES = "netstats_dev_persist_bytes"; 6401 /** {@hide} */ 6402 public static final String NETSTATS_DEV_ROTATE_AGE = "netstats_dev_rotate_age"; 6403 /** {@hide} */ 6404 public static final String NETSTATS_DEV_DELETE_AGE = "netstats_dev_delete_age"; 6405 6406 /** {@hide} */ 6407 public static final String NETSTATS_UID_BUCKET_DURATION = "netstats_uid_bucket_duration"; 6408 /** {@hide} */ 6409 public static final String NETSTATS_UID_PERSIST_BYTES = "netstats_uid_persist_bytes"; 6410 /** {@hide} */ 6411 public static final String NETSTATS_UID_ROTATE_AGE = "netstats_uid_rotate_age"; 6412 /** {@hide} */ 6413 public static final String NETSTATS_UID_DELETE_AGE = "netstats_uid_delete_age"; 6414 6415 /** {@hide} */ 6416 public static final String NETSTATS_UID_TAG_BUCKET_DURATION = "netstats_uid_tag_bucket_duration"; 6417 /** {@hide} */ 6418 public static final String NETSTATS_UID_TAG_PERSIST_BYTES = "netstats_uid_tag_persist_bytes"; 6419 /** {@hide} */ 6420 public static final String NETSTATS_UID_TAG_ROTATE_AGE = "netstats_uid_tag_rotate_age"; 6421 /** {@hide} */ 6422 public static final String NETSTATS_UID_TAG_DELETE_AGE = "netstats_uid_tag_delete_age"; 6423 6424 /** 6425 * User preference for which network(s) should be used. Only the 6426 * connectivity service should touch this. 6427 */ 6428 public static final String NETWORK_PREFERENCE = "network_preference"; 6429 6430 /** 6431 * Which package name to use for network scoring. If null, or if the package is not a valid 6432 * scorer app, external network scores will neither be requested nor accepted. 6433 * @hide 6434 */ 6435 public static final String NETWORK_SCORER_APP = "network_scorer_app"; 6436 6437 /** 6438 * If the NITZ_UPDATE_DIFF time is exceeded then an automatic adjustment 6439 * to SystemClock will be allowed even if NITZ_UPDATE_SPACING has not been 6440 * exceeded. 6441 * @hide 6442 */ 6443 public static final String NITZ_UPDATE_DIFF = "nitz_update_diff"; 6444 6445 /** 6446 * The length of time in milli-seconds that automatic small adjustments to 6447 * SystemClock are ignored if NITZ_UPDATE_DIFF is not exceeded. 6448 * @hide 6449 */ 6450 public static final String NITZ_UPDATE_SPACING = "nitz_update_spacing"; 6451 6452 /** Preferred NTP server. {@hide} */ 6453 public static final String NTP_SERVER = "ntp_server"; 6454 /** Timeout in milliseconds to wait for NTP server. {@hide} */ 6455 public static final String NTP_TIMEOUT = "ntp_timeout"; 6456 6457 /** {@hide} */ 6458 public static final String STORAGE_BENCHMARK_INTERVAL = "storage_benchmark_interval"; 6459 6460 /** 6461 * Whether the package manager should send package verification broadcasts for verifiers to 6462 * review apps prior to installation. 6463 * 1 = request apps to be verified prior to installation, if a verifier exists. 6464 * 0 = do not verify apps before installation 6465 * @hide 6466 */ 6467 public static final String PACKAGE_VERIFIER_ENABLE = "package_verifier_enable"; 6468 6469 /** Timeout for package verification. 6470 * @hide */ 6471 public static final String PACKAGE_VERIFIER_TIMEOUT = "verifier_timeout"; 6472 6473 /** Default response code for package verification. 6474 * @hide */ 6475 public static final String PACKAGE_VERIFIER_DEFAULT_RESPONSE = "verifier_default_response"; 6476 6477 /** 6478 * Show package verification setting in the Settings app. 6479 * 1 = show (default) 6480 * 0 = hide 6481 * @hide 6482 */ 6483 public static final String PACKAGE_VERIFIER_SETTING_VISIBLE = "verifier_setting_visible"; 6484 6485 /** 6486 * Run package verification on apps installed through ADB/ADT/USB 6487 * 1 = perform package verification on ADB installs (default) 6488 * 0 = bypass package verification on ADB installs 6489 * @hide 6490 */ 6491 public static final String PACKAGE_VERIFIER_INCLUDE_ADB = "verifier_verify_adb_installs"; 6492 6493 /** 6494 * Time since last fstrim (milliseconds) after which we force one to happen 6495 * during device startup. If unset, the default is 3 days. 6496 * @hide 6497 */ 6498 public static final String FSTRIM_MANDATORY_INTERVAL = "fstrim_mandatory_interval"; 6499 6500 /** 6501 * The interval in milliseconds at which to check packet counts on the 6502 * mobile data interface when screen is on, to detect possible data 6503 * connection problems. 6504 * @hide 6505 */ 6506 public static final String PDP_WATCHDOG_POLL_INTERVAL_MS = 6507 "pdp_watchdog_poll_interval_ms"; 6508 6509 /** 6510 * The interval in milliseconds at which to check packet counts on the 6511 * mobile data interface when screen is off, to detect possible data 6512 * connection problems. 6513 * @hide 6514 */ 6515 public static final String PDP_WATCHDOG_LONG_POLL_INTERVAL_MS = 6516 "pdp_watchdog_long_poll_interval_ms"; 6517 6518 /** 6519 * The interval in milliseconds at which to check packet counts on the 6520 * mobile data interface after {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} 6521 * outgoing packets has been reached without incoming packets. 6522 * @hide 6523 */ 6524 public static final String PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS = 6525 "pdp_watchdog_error_poll_interval_ms"; 6526 6527 /** 6528 * The number of outgoing packets sent without seeing an incoming packet 6529 * that triggers a countdown (of {@link #PDP_WATCHDOG_ERROR_POLL_COUNT} 6530 * device is logged to the event log 6531 * @hide 6532 */ 6533 public static final String PDP_WATCHDOG_TRIGGER_PACKET_COUNT = 6534 "pdp_watchdog_trigger_packet_count"; 6535 6536 /** 6537 * The number of polls to perform (at {@link #PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS}) 6538 * after hitting {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} before 6539 * attempting data connection recovery. 6540 * @hide 6541 */ 6542 public static final String PDP_WATCHDOG_ERROR_POLL_COUNT = 6543 "pdp_watchdog_error_poll_count"; 6544 6545 /** 6546 * The number of failed PDP reset attempts before moving to something more 6547 * drastic: re-registering to the network. 6548 * @hide 6549 */ 6550 public static final String PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT = 6551 "pdp_watchdog_max_pdp_reset_fail_count"; 6552 6553 /** 6554 * A positive value indicates how often the SamplingProfiler 6555 * should take snapshots. Zero value means SamplingProfiler 6556 * is disabled. 6557 * 6558 * @hide 6559 */ 6560 public static final String SAMPLING_PROFILER_MS = "sampling_profiler_ms"; 6561 6562 /** 6563 * URL to open browser on to allow user to manage a prepay account 6564 * @hide 6565 */ 6566 public static final String SETUP_PREPAID_DATA_SERVICE_URL = 6567 "setup_prepaid_data_service_url"; 6568 6569 /** 6570 * URL to attempt a GET on to see if this is a prepay device 6571 * @hide 6572 */ 6573 public static final String SETUP_PREPAID_DETECTION_TARGET_URL = 6574 "setup_prepaid_detection_target_url"; 6575 6576 /** 6577 * Host to check for a redirect to after an attempt to GET 6578 * SETUP_PREPAID_DETECTION_TARGET_URL. (If we redirected there, 6579 * this is a prepaid device with zero balance.) 6580 * @hide 6581 */ 6582 public static final String SETUP_PREPAID_DETECTION_REDIR_HOST = 6583 "setup_prepaid_detection_redir_host"; 6584 6585 /** 6586 * The interval in milliseconds at which to check the number of SMS sent out without asking 6587 * for use permit, to limit the un-authorized SMS usage. 6588 * 6589 * @hide 6590 */ 6591 public static final String SMS_OUTGOING_CHECK_INTERVAL_MS = 6592 "sms_outgoing_check_interval_ms"; 6593 6594 /** 6595 * The number of outgoing SMS sent without asking for user permit (of {@link 6596 * #SMS_OUTGOING_CHECK_INTERVAL_MS} 6597 * 6598 * @hide 6599 */ 6600 public static final String SMS_OUTGOING_CHECK_MAX_COUNT = 6601 "sms_outgoing_check_max_count"; 6602 6603 /** 6604 * Used to disable SMS short code confirmation - defaults to true. 6605 * True indcates we will do the check, etc. Set to false to disable. 6606 * @see com.android.internal.telephony.SmsUsageMonitor 6607 * @hide 6608 */ 6609 public static final String SMS_SHORT_CODE_CONFIRMATION = "sms_short_code_confirmation"; 6610 6611 /** 6612 * Used to select which country we use to determine premium sms codes. 6613 * One of com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_SIM, 6614 * com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_NETWORK, 6615 * or com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_BOTH. 6616 * @hide 6617 */ 6618 public static final String SMS_SHORT_CODE_RULE = "sms_short_code_rule"; 6619 6620 /** 6621 * Used to select TCP's default initial receiver window size in segments - defaults to a build config value 6622 * @hide 6623 */ 6624 public static final String TCP_DEFAULT_INIT_RWND = "tcp_default_init_rwnd"; 6625 6626 /** 6627 * Used to disable Tethering on a device - defaults to true 6628 * @hide 6629 */ 6630 public static final String TETHER_SUPPORTED = "tether_supported"; 6631 6632 /** 6633 * Used to require DUN APN on the device or not - defaults to a build config value 6634 * which defaults to false 6635 * @hide 6636 */ 6637 public static final String TETHER_DUN_REQUIRED = "tether_dun_required"; 6638 6639 /** 6640 * Used to hold a gservices-provisioned apn value for DUN. If set, or the 6641 * corresponding build config values are set it will override the APN DB 6642 * values. 6643 * Consists of a comma seperated list of strings: 6644 * "name,apn,proxy,port,username,password,server,mmsc,mmsproxy,mmsport,mcc,mnc,auth,type" 6645 * note that empty fields can be ommitted: "name,apn,,,,,,,,,310,260,,DUN" 6646 * @hide 6647 */ 6648 public static final String TETHER_DUN_APN = "tether_dun_apn"; 6649 6650 /** 6651 * USB Mass Storage Enabled 6652 */ 6653 public static final String USB_MASS_STORAGE_ENABLED = "usb_mass_storage_enabled"; 6654 6655 /** 6656 * If this setting is set (to anything), then all references 6657 * to Gmail on the device must change to Google Mail. 6658 */ 6659 public static final String USE_GOOGLE_MAIL = "use_google_mail"; 6660 6661 /** 6662 * Webview Data reduction proxy key. 6663 * @hide 6664 */ 6665 public static final String WEBVIEW_DATA_REDUCTION_PROXY_KEY = 6666 "webview_data_reduction_proxy_key"; 6667 6668 /** 6669 * Whether Wifi display is enabled/disabled 6670 * 0=disabled. 1=enabled. 6671 * @hide 6672 */ 6673 public static final String WIFI_DISPLAY_ON = "wifi_display_on"; 6674 6675 /** 6676 * Whether Wifi display certification mode is enabled/disabled 6677 * 0=disabled. 1=enabled. 6678 * @hide 6679 */ 6680 public static final String WIFI_DISPLAY_CERTIFICATION_ON = 6681 "wifi_display_certification_on"; 6682 6683 /** 6684 * WPS Configuration method used by Wifi display, this setting only 6685 * takes effect when WIFI_DISPLAY_CERTIFICATION_ON is 1 (enabled). 6686 * 6687 * Possible values are: 6688 * 6689 * WpsInfo.INVALID: use default WPS method chosen by framework 6690 * WpsInfo.PBC : use Push button 6691 * WpsInfo.KEYPAD : use Keypad 6692 * WpsInfo.DISPLAY: use Display 6693 * @hide 6694 */ 6695 public static final String WIFI_DISPLAY_WPS_CONFIG = 6696 "wifi_display_wps_config"; 6697 6698 /** 6699 * Whether to notify the user of open networks. 6700 * <p> 6701 * If not connected and the scan results have an open network, we will 6702 * put this notification up. If we attempt to connect to a network or 6703 * the open network(s) disappear, we remove the notification. When we 6704 * show the notification, we will not show it again for 6705 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} time. 6706 */ 6707 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 6708 "wifi_networks_available_notification_on"; 6709 /** 6710 * {@hide} 6711 */ 6712 public static final String WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON = 6713 "wimax_networks_available_notification_on"; 6714 6715 /** 6716 * Delay (in seconds) before repeating the Wi-Fi networks available notification. 6717 * Connecting to a network will reset the timer. 6718 */ 6719 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 6720 "wifi_networks_available_repeat_delay"; 6721 6722 /** 6723 * 802.11 country code in ISO 3166 format 6724 * @hide 6725 */ 6726 public static final String WIFI_COUNTRY_CODE = "wifi_country_code"; 6727 6728 /** 6729 * The interval in milliseconds to issue wake up scans when wifi needs 6730 * to connect. This is necessary to connect to an access point when 6731 * device is on the move and the screen is off. 6732 * @hide 6733 */ 6734 public static final String WIFI_FRAMEWORK_SCAN_INTERVAL_MS = 6735 "wifi_framework_scan_interval_ms"; 6736 6737 /** 6738 * The interval in milliseconds after which Wi-Fi is considered idle. 6739 * When idle, it is possible for the device to be switched from Wi-Fi to 6740 * the mobile data network. 6741 * @hide 6742 */ 6743 public static final String WIFI_IDLE_MS = "wifi_idle_ms"; 6744 6745 /** 6746 * When the number of open networks exceeds this number, the 6747 * least-recently-used excess networks will be removed. 6748 */ 6749 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = "wifi_num_open_networks_kept"; 6750 6751 /** 6752 * Whether the Wi-Fi should be on. Only the Wi-Fi service should touch this. 6753 */ 6754 public static final String WIFI_ON = "wifi_on"; 6755 6756 /** 6757 * Setting to allow scans to be enabled even wifi is turned off for connectivity. 6758 * @hide 6759 */ 6760 public static final String WIFI_SCAN_ALWAYS_AVAILABLE = 6761 "wifi_scan_always_enabled"; 6762 6763 /** 6764 * Settings to allow BLE scans to be enabled even when Bluetooth is turned off for 6765 * connectivity. 6766 * @hide 6767 */ 6768 public static final String BLE_SCAN_ALWAYS_AVAILABLE = 6769 "ble_scan_always_enabled"; 6770 6771 /** 6772 * Used to save the Wifi_ON state prior to tethering. 6773 * This state will be checked to restore Wifi after 6774 * the user turns off tethering. 6775 * 6776 * @hide 6777 */ 6778 public static final String WIFI_SAVED_STATE = "wifi_saved_state"; 6779 6780 /** 6781 * The interval in milliseconds to scan as used by the wifi supplicant 6782 * @hide 6783 */ 6784 public static final String WIFI_SUPPLICANT_SCAN_INTERVAL_MS = 6785 "wifi_supplicant_scan_interval_ms"; 6786 6787 /** 6788 * whether frameworks handles wifi auto-join 6789 * @hide 6790 */ 6791 public static final String WIFI_ENHANCED_AUTO_JOIN = 6792 "wifi_enhanced_auto_join"; 6793 6794 /** 6795 * whether settings show RSSI 6796 * @hide 6797 */ 6798 public static final String WIFI_NETWORK_SHOW_RSSI = 6799 "wifi_network_show_rssi"; 6800 6801 /** 6802 * The interval in milliseconds to scan at supplicant when p2p is connected 6803 * @hide 6804 */ 6805 public static final String WIFI_SCAN_INTERVAL_WHEN_P2P_CONNECTED_MS = 6806 "wifi_scan_interval_p2p_connected_ms"; 6807 6808 /** 6809 * Whether the Wi-Fi watchdog is enabled. 6810 */ 6811 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 6812 6813 /** 6814 * Setting to turn off poor network avoidance on Wi-Fi. Feature is enabled by default and 6815 * the setting needs to be set to 0 to disable it. 6816 * @hide 6817 */ 6818 public static final String WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED = 6819 "wifi_watchdog_poor_network_test_enabled"; 6820 6821 /** 6822 * Setting to turn on suspend optimizations at screen off on Wi-Fi. Enabled by default and 6823 * needs to be set to 0 to disable it. 6824 * @hide 6825 */ 6826 public static final String WIFI_SUSPEND_OPTIMIZATIONS_ENABLED = 6827 "wifi_suspend_optimizations_enabled"; 6828 6829 /** 6830 * The maximum number of times we will retry a connection to an access 6831 * point for which we have failed in acquiring an IP address from DHCP. 6832 * A value of N means that we will make N+1 connection attempts in all. 6833 */ 6834 public static final String WIFI_MAX_DHCP_RETRY_COUNT = "wifi_max_dhcp_retry_count"; 6835 6836 /** 6837 * Maximum amount of time in milliseconds to hold a wakelock while waiting for mobile 6838 * data connectivity to be established after a disconnect from Wi-Fi. 6839 */ 6840 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 6841 "wifi_mobile_data_transition_wakelock_timeout_ms"; 6842 6843 /** 6844 * This setting controls whether WiFi configurations created by a Device Owner app 6845 * should be locked down (that is, be editable or removable only by the Device Owner App, 6846 * not even by Settings app). 6847 * This setting takes integer values. Non-zero values mean DO created configurations 6848 * are locked down. Value of zero means they are not. Default value in the absence of 6849 * actual value to this setting is 0. 6850 */ 6851 public static final String WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN = 6852 "wifi_device_owner_configs_lockdown"; 6853 6854 /** 6855 * The operational wifi frequency band 6856 * Set to one of {@link WifiManager#WIFI_FREQUENCY_BAND_AUTO}, 6857 * {@link WifiManager#WIFI_FREQUENCY_BAND_5GHZ} or 6858 * {@link WifiManager#WIFI_FREQUENCY_BAND_2GHZ} 6859 * 6860 * @hide 6861 */ 6862 public static final String WIFI_FREQUENCY_BAND = "wifi_frequency_band"; 6863 6864 /** 6865 * The Wi-Fi peer-to-peer device name 6866 * @hide 6867 */ 6868 public static final String WIFI_P2P_DEVICE_NAME = "wifi_p2p_device_name"; 6869 6870 /** 6871 * The min time between wifi disable and wifi enable 6872 * @hide 6873 */ 6874 public static final String WIFI_REENABLE_DELAY_MS = "wifi_reenable_delay"; 6875 6876 /** 6877 * Timeout for ephemeral networks when all known BSSIDs go out of range. We will disconnect 6878 * from an ephemeral network if there is no BSSID for that network with a non-null score that 6879 * has been seen in this time period. 6880 * 6881 * If this is less than or equal to zero, we use a more conservative behavior and only check 6882 * for a non-null score from the currently connected or target BSSID. 6883 * @hide 6884 */ 6885 public static final String WIFI_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS = 6886 "wifi_ephemeral_out_of_range_timeout_ms"; 6887 6888 /** 6889 * The number of milliseconds to delay when checking for data stalls during 6890 * non-aggressive detection. (screen is turned off.) 6891 * @hide 6892 */ 6893 public static final String DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS = 6894 "data_stall_alarm_non_aggressive_delay_in_ms"; 6895 6896 /** 6897 * The number of milliseconds to delay when checking for data stalls during 6898 * aggressive detection. (screen on or suspected data stall) 6899 * @hide 6900 */ 6901 public static final String DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS = 6902 "data_stall_alarm_aggressive_delay_in_ms"; 6903 6904 /** 6905 * The number of milliseconds to allow the provisioning apn to remain active 6906 * @hide 6907 */ 6908 public static final String PROVISIONING_APN_ALARM_DELAY_IN_MS = 6909 "provisioning_apn_alarm_delay_in_ms"; 6910 6911 /** 6912 * The interval in milliseconds at which to check gprs registration 6913 * after the first registration mismatch of gprs and voice service, 6914 * to detect possible data network registration problems. 6915 * 6916 * @hide 6917 */ 6918 public static final String GPRS_REGISTER_CHECK_PERIOD_MS = 6919 "gprs_register_check_period_ms"; 6920 6921 /** 6922 * Nonzero causes Log.wtf() to crash. 6923 * @hide 6924 */ 6925 public static final String WTF_IS_FATAL = "wtf_is_fatal"; 6926 6927 /** 6928 * Ringer mode. This is used internally, changing this value will not 6929 * change the ringer mode. See AudioManager. 6930 */ 6931 public static final String MODE_RINGER = "mode_ringer"; 6932 6933 /** 6934 * Overlay display devices setting. 6935 * The associated value is a specially formatted string that describes the 6936 * size and density of simulated secondary display devices. 6937 * <p> 6938 * Format: {width}x{height}/{dpi};... 6939 * </p><p> 6940 * Example: 6941 * <ul> 6942 * <li><code>1280x720/213</code>: make one overlay that is 1280x720 at 213dpi.</li> 6943 * <li><code>1920x1080/320;1280x720/213</code>: make two overlays, the first 6944 * at 1080p and the second at 720p.</li> 6945 * <li>If the value is empty, then no overlay display devices are created.</li> 6946 * </ul></p> 6947 * 6948 * @hide 6949 */ 6950 public static final String OVERLAY_DISPLAY_DEVICES = "overlay_display_devices"; 6951 6952 /** 6953 * Threshold values for the duration and level of a discharge cycle, 6954 * under which we log discharge cycle info. 6955 * 6956 * @hide 6957 */ 6958 public static final String 6959 BATTERY_DISCHARGE_DURATION_THRESHOLD = "battery_discharge_duration_threshold"; 6960 6961 /** @hide */ 6962 public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold"; 6963 6964 /** 6965 * Flag for allowing ActivityManagerService to send ACTION_APP_ERROR 6966 * intents on application crashes and ANRs. If this is disabled, the 6967 * crash/ANR dialog will never display the "Report" button. 6968 * <p> 6969 * Type: int (0 = disallow, 1 = allow) 6970 * 6971 * @hide 6972 */ 6973 public static final String SEND_ACTION_APP_ERROR = "send_action_app_error"; 6974 6975 /** 6976 * Maximum age of entries kept by {@link DropBoxManager}. 6977 * 6978 * @hide 6979 */ 6980 public static final String DROPBOX_AGE_SECONDS = "dropbox_age_seconds"; 6981 6982 /** 6983 * Maximum number of entry files which {@link DropBoxManager} will keep 6984 * around. 6985 * 6986 * @hide 6987 */ 6988 public static final String DROPBOX_MAX_FILES = "dropbox_max_files"; 6989 6990 /** 6991 * Maximum amount of disk space used by {@link DropBoxManager} no matter 6992 * what. 6993 * 6994 * @hide 6995 */ 6996 public static final String DROPBOX_QUOTA_KB = "dropbox_quota_kb"; 6997 6998 /** 6999 * Percent of free disk (excluding reserve) which {@link DropBoxManager} 7000 * will use. 7001 * 7002 * @hide 7003 */ 7004 public static final String DROPBOX_QUOTA_PERCENT = "dropbox_quota_percent"; 7005 7006 /** 7007 * Percent of total disk which {@link DropBoxManager} will never dip 7008 * into. 7009 * 7010 * @hide 7011 */ 7012 public static final String DROPBOX_RESERVE_PERCENT = "dropbox_reserve_percent"; 7013 7014 /** 7015 * Prefix for per-tag dropbox disable/enable settings. 7016 * 7017 * @hide 7018 */ 7019 public static final String DROPBOX_TAG_PREFIX = "dropbox:"; 7020 7021 /** 7022 * Lines of logcat to include with system crash/ANR/etc. reports, as a 7023 * prefix of the dropbox tag of the report type. For example, 7024 * "logcat_for_system_server_anr" controls the lines of logcat captured 7025 * with system server ANR reports. 0 to disable. 7026 * 7027 * @hide 7028 */ 7029 public static final String ERROR_LOGCAT_PREFIX = "logcat_for_"; 7030 7031 /** 7032 * The interval in minutes after which the amount of free storage left 7033 * on the device is logged to the event log 7034 * 7035 * @hide 7036 */ 7037 public static final String SYS_FREE_STORAGE_LOG_INTERVAL = "sys_free_storage_log_interval"; 7038 7039 /** 7040 * Threshold for the amount of change in disk free space required to 7041 * report the amount of free space. Used to prevent spamming the logs 7042 * when the disk free space isn't changing frequently. 7043 * 7044 * @hide 7045 */ 7046 public static final String 7047 DISK_FREE_CHANGE_REPORTING_THRESHOLD = "disk_free_change_reporting_threshold"; 7048 7049 /** 7050 * Minimum percentage of free storage on the device that is used to 7051 * determine if the device is running low on storage. The default is 10. 7052 * <p> 7053 * Say this value is set to 10, the device is considered running low on 7054 * storage if 90% or more of the device storage is filled up. 7055 * 7056 * @hide 7057 */ 7058 public static final String 7059 SYS_STORAGE_THRESHOLD_PERCENTAGE = "sys_storage_threshold_percentage"; 7060 7061 /** 7062 * Maximum byte size of the low storage threshold. This is to ensure 7063 * that {@link #SYS_STORAGE_THRESHOLD_PERCENTAGE} does not result in an 7064 * overly large threshold for large storage devices. Currently this must 7065 * be less than 2GB. This default is 500MB. 7066 * 7067 * @hide 7068 */ 7069 public static final String 7070 SYS_STORAGE_THRESHOLD_MAX_BYTES = "sys_storage_threshold_max_bytes"; 7071 7072 /** 7073 * Minimum bytes of free storage on the device before the data partition 7074 * is considered full. By default, 1 MB is reserved to avoid system-wide 7075 * SQLite disk full exceptions. 7076 * 7077 * @hide 7078 */ 7079 public static final String 7080 SYS_STORAGE_FULL_THRESHOLD_BYTES = "sys_storage_full_threshold_bytes"; 7081 7082 /** 7083 * The maximum reconnect delay for short network outages or when the 7084 * network is suspended due to phone use. 7085 * 7086 * @hide 7087 */ 7088 public static final String 7089 SYNC_MAX_RETRY_DELAY_IN_SECONDS = "sync_max_retry_delay_in_seconds"; 7090 7091 /** 7092 * The number of milliseconds to delay before sending out 7093 * {@link ConnectivityManager#CONNECTIVITY_ACTION} broadcasts. Ignored. 7094 * 7095 * @hide 7096 */ 7097 public static final String CONNECTIVITY_CHANGE_DELAY = "connectivity_change_delay"; 7098 7099 7100 /** 7101 * Network sampling interval, in seconds. We'll generate link information 7102 * about bytes/packets sent and error rates based on data sampled in this interval 7103 * 7104 * @hide 7105 */ 7106 7107 public static final String CONNECTIVITY_SAMPLING_INTERVAL_IN_SECONDS = 7108 "connectivity_sampling_interval_in_seconds"; 7109 7110 /** 7111 * The series of successively longer delays used in retrying to download PAC file. 7112 * Last delay is used between successful PAC downloads. 7113 * 7114 * @hide 7115 */ 7116 public static final String PAC_CHANGE_DELAY = "pac_change_delay"; 7117 7118 /** 7119 * Setting to turn off captive portal detection. Feature is enabled by 7120 * default and the setting needs to be set to 0 to disable it. 7121 * 7122 * @hide 7123 */ 7124 public static final String 7125 CAPTIVE_PORTAL_DETECTION_ENABLED = "captive_portal_detection_enabled"; 7126 7127 /** 7128 * The server used for captive portal detection upon a new conection. A 7129 * 204 response code from the server is used for validation. 7130 * 7131 * @hide 7132 */ 7133 public static final String CAPTIVE_PORTAL_SERVER = "captive_portal_server"; 7134 7135 /** 7136 * Whether network service discovery is enabled. 7137 * 7138 * @hide 7139 */ 7140 public static final String NSD_ON = "nsd_on"; 7141 7142 /** 7143 * Let user pick default install location. 7144 * 7145 * @hide 7146 */ 7147 public static final String SET_INSTALL_LOCATION = "set_install_location"; 7148 7149 /** 7150 * Default install location value. 7151 * 0 = auto, let system decide 7152 * 1 = internal 7153 * 2 = sdcard 7154 * @hide 7155 */ 7156 public static final String DEFAULT_INSTALL_LOCATION = "default_install_location"; 7157 7158 /** 7159 * ms during which to consume extra events related to Inet connection 7160 * condition after a transtion to fully-connected 7161 * 7162 * @hide 7163 */ 7164 public static final String 7165 INET_CONDITION_DEBOUNCE_UP_DELAY = "inet_condition_debounce_up_delay"; 7166 7167 /** 7168 * ms during which to consume extra events related to Inet connection 7169 * condtion after a transtion to partly-connected 7170 * 7171 * @hide 7172 */ 7173 public static final String 7174 INET_CONDITION_DEBOUNCE_DOWN_DELAY = "inet_condition_debounce_down_delay"; 7175 7176 /** {@hide} */ 7177 public static final String 7178 READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT = "read_external_storage_enforced_default"; 7179 7180 /** 7181 * Host name and port for global http proxy. Uses ':' seperator for 7182 * between host and port. 7183 */ 7184 public static final String HTTP_PROXY = "http_proxy"; 7185 7186 /** 7187 * Host name for global http proxy. Set via ConnectivityManager. 7188 * 7189 * @hide 7190 */ 7191 public static final String GLOBAL_HTTP_PROXY_HOST = "global_http_proxy_host"; 7192 7193 /** 7194 * Integer host port for global http proxy. Set via ConnectivityManager. 7195 * 7196 * @hide 7197 */ 7198 public static final String GLOBAL_HTTP_PROXY_PORT = "global_http_proxy_port"; 7199 7200 /** 7201 * Exclusion list for global proxy. This string contains a list of 7202 * comma-separated domains where the global proxy does not apply. 7203 * Domains should be listed in a comma- separated list. Example of 7204 * acceptable formats: ".domain1.com,my.domain2.com" Use 7205 * ConnectivityManager to set/get. 7206 * 7207 * @hide 7208 */ 7209 public static final String 7210 GLOBAL_HTTP_PROXY_EXCLUSION_LIST = "global_http_proxy_exclusion_list"; 7211 7212 /** 7213 * The location PAC File for the proxy. 7214 * @hide 7215 */ 7216 public static final String 7217 GLOBAL_HTTP_PROXY_PAC = "global_proxy_pac_url"; 7218 7219 /** 7220 * Enables the UI setting to allow the user to specify the global HTTP 7221 * proxy and associated exclusion list. 7222 * 7223 * @hide 7224 */ 7225 public static final String SET_GLOBAL_HTTP_PROXY = "set_global_http_proxy"; 7226 7227 /** 7228 * Setting for default DNS in case nobody suggests one 7229 * 7230 * @hide 7231 */ 7232 public static final String DEFAULT_DNS_SERVER = "default_dns_server"; 7233 7234 /** {@hide} */ 7235 public static final String 7236 BLUETOOTH_HEADSET_PRIORITY_PREFIX = "bluetooth_headset_priority_"; 7237 /** {@hide} */ 7238 public static final String 7239 BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX = "bluetooth_a2dp_sink_priority_"; 7240 /** {@hide} */ 7241 public static final String 7242 BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX = "bluetooth_input_device_priority_"; 7243 /** {@hide} */ 7244 public static final String 7245 BLUETOOTH_MAP_PRIORITY_PREFIX = "bluetooth_map_priority_"; 7246 /** {@hide} */ 7247 public static final String 7248 BLUETOOTH_SAP_PRIORITY_PREFIX = "bluetooth_sap_priority_"; 7249 7250 /** 7251 * Device Idle (Doze) specific settings. 7252 * This is encoded as a key=value list, separated by commas. Ex: 7253 * 7254 * "inactive_timeout=60000,sensing_timeout=400000" 7255 * 7256 * The following keys are supported: 7257 * 7258 * <pre> 7259 * inactive_to (long) 7260 * sensing_to (long) 7261 * motion_inactive_to (long) 7262 * idle_after_inactive_to (long) 7263 * idle_pending_to (long) 7264 * max_idle_pending_to (long) 7265 * idle_pending_factor (float) 7266 * idle_to (long) 7267 * max_idle_to (long) 7268 * idle_factor (float) 7269 * min_time_to_alarm (long) 7270 * max_temp_app_whitelist_duration (long) 7271 * </pre> 7272 * 7273 * <p> 7274 * Type: string 7275 * @hide 7276 * @see com.android.server.DeviceIdleController.Constants 7277 */ 7278 public static final String DEVICE_IDLE_CONSTANTS = "device_idle_constants"; 7279 7280 /** 7281 * App standby (app idle) specific settings. 7282 * This is encoded as a key=value list, separated by commas. Ex: 7283 * 7284 * "idle_duration=5000,parole_interval=4500" 7285 * 7286 * The following keys are supported: 7287 * 7288 * <pre> 7289 * idle_duration2 (long) 7290 * wallclock_threshold (long) 7291 * parole_interval (long) 7292 * parole_duration (long) 7293 * 7294 * idle_duration (long) // This is deprecated and used to circumvent b/26355386. 7295 * </pre> 7296 * 7297 * <p> 7298 * Type: string 7299 * @hide 7300 * @see com.android.server.usage.UsageStatsService.SettingsObserver 7301 */ 7302 public static final String APP_IDLE_CONSTANTS = "app_idle_constants"; 7303 7304 /** 7305 * Alarm manager specific settings. 7306 * This is encoded as a key=value list, separated by commas. Ex: 7307 * 7308 * "min_futurity=5000,allow_while_idle_short_time=4500" 7309 * 7310 * The following keys are supported: 7311 * 7312 * <pre> 7313 * min_futurity (long) 7314 * min_interval (long) 7315 * allow_while_idle_short_time (long) 7316 * allow_while_idle_long_time (long) 7317 * allow_while_idle_whitelist_duration (long) 7318 * </pre> 7319 * 7320 * <p> 7321 * Type: string 7322 * @hide 7323 * @see com.android.server.AlarmManagerService.Constants 7324 */ 7325 public static final String ALARM_MANAGER_CONSTANTS = "alarm_manager_constants"; 7326 7327 /** 7328 * Get the key that retrieves a bluetooth headset's priority. 7329 * @hide 7330 */ getBluetoothHeadsetPriorityKey(String address)7331 public static final String getBluetoothHeadsetPriorityKey(String address) { 7332 return BLUETOOTH_HEADSET_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7333 } 7334 7335 /** 7336 * Get the key that retrieves a bluetooth a2dp sink's priority. 7337 * @hide 7338 */ getBluetoothA2dpSinkPriorityKey(String address)7339 public static final String getBluetoothA2dpSinkPriorityKey(String address) { 7340 return BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7341 } 7342 7343 /** 7344 * Get the key that retrieves a bluetooth Input Device's priority. 7345 * @hide 7346 */ getBluetoothInputDevicePriorityKey(String address)7347 public static final String getBluetoothInputDevicePriorityKey(String address) { 7348 return BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7349 } 7350 7351 /** 7352 * Get the key that retrieves a bluetooth map priority. 7353 * @hide 7354 */ getBluetoothMapPriorityKey(String address)7355 public static final String getBluetoothMapPriorityKey(String address) { 7356 return BLUETOOTH_MAP_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7357 } 7358 7359 /** 7360 * Get the key that retrieves a bluetooth map priority. 7361 * @hide 7362 */ getBluetoothSapPriorityKey(String address)7363 public static final String getBluetoothSapPriorityKey(String address) { 7364 return BLUETOOTH_SAP_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7365 } 7366 7367 /** 7368 * Scaling factor for normal window animations. Setting to 0 will 7369 * disable window animations. 7370 */ 7371 public static final String WINDOW_ANIMATION_SCALE = "window_animation_scale"; 7372 7373 /** 7374 * Scaling factor for activity transition animations. Setting to 0 will 7375 * disable window animations. 7376 */ 7377 public static final String TRANSITION_ANIMATION_SCALE = "transition_animation_scale"; 7378 7379 /** 7380 * Scaling factor for Animator-based animations. This affects both the 7381 * start delay and duration of all such animations. Setting to 0 will 7382 * cause animations to end immediately. The default value is 1. 7383 */ 7384 public static final String ANIMATOR_DURATION_SCALE = "animator_duration_scale"; 7385 7386 /** 7387 * Scaling factor for normal window animations. Setting to 0 will 7388 * disable window animations. 7389 * 7390 * @hide 7391 */ 7392 public static final String FANCY_IME_ANIMATIONS = "fancy_ime_animations"; 7393 7394 /** 7395 * If 0, the compatibility mode is off for all applications. 7396 * If 1, older applications run under compatibility mode. 7397 * TODO: remove this settings before code freeze (bug/1907571) 7398 * @hide 7399 */ 7400 public static final String COMPATIBILITY_MODE = "compatibility_mode"; 7401 7402 /** 7403 * CDMA only settings 7404 * Emergency Tone 0 = Off 7405 * 1 = Alert 7406 * 2 = Vibrate 7407 * @hide 7408 */ 7409 public static final String EMERGENCY_TONE = "emergency_tone"; 7410 7411 /** 7412 * CDMA only settings 7413 * Whether the auto retry is enabled. The value is 7414 * boolean (1 or 0). 7415 * @hide 7416 */ 7417 public static final String CALL_AUTO_RETRY = "call_auto_retry"; 7418 7419 /** 7420 * See RIL_PreferredNetworkType in ril.h 7421 * @hide 7422 */ 7423 public static final String PREFERRED_NETWORK_MODE = 7424 "preferred_network_mode"; 7425 7426 /** 7427 * Name of an application package to be debugged. 7428 */ 7429 public static final String DEBUG_APP = "debug_app"; 7430 7431 /** 7432 * If 1, when launching DEBUG_APP it will wait for the debugger before 7433 * starting user code. If 0, it will run normally. 7434 */ 7435 public static final String WAIT_FOR_DEBUGGER = "wait_for_debugger"; 7436 7437 /** 7438 * Control whether the process CPU usage meter should be shown. 7439 */ 7440 public static final String SHOW_PROCESSES = "show_processes"; 7441 7442 /** 7443 * If 1 low power mode is enabled. 7444 * @hide 7445 */ 7446 public static final String LOW_POWER_MODE = "low_power"; 7447 7448 /** 7449 * Battery level [1-99] at which low power mode automatically turns on. 7450 * If 0, it will not automatically turn on. 7451 * @hide 7452 */ 7453 public static final String LOW_POWER_MODE_TRIGGER_LEVEL = "low_power_trigger_level"; 7454 7455 /** 7456 * If 1, the activity manager will aggressively finish activities and 7457 * processes as soon as they are no longer needed. If 0, the normal 7458 * extended lifetime is used. 7459 */ 7460 public static final String ALWAYS_FINISH_ACTIVITIES = "always_finish_activities"; 7461 7462 /** 7463 * Use Dock audio output for media: 7464 * 0 = disabled 7465 * 1 = enabled 7466 * @hide 7467 */ 7468 public static final String DOCK_AUDIO_MEDIA_ENABLED = "dock_audio_media_enabled"; 7469 7470 /** 7471 * Persisted safe headphone volume management state by AudioService 7472 * @hide 7473 */ 7474 public static final String AUDIO_SAFE_VOLUME_STATE = "audio_safe_volume_state"; 7475 7476 /** 7477 * URL for tzinfo (time zone) updates 7478 * @hide 7479 */ 7480 public static final String TZINFO_UPDATE_CONTENT_URL = "tzinfo_content_url"; 7481 7482 /** 7483 * URL for tzinfo (time zone) update metadata 7484 * @hide 7485 */ 7486 public static final String TZINFO_UPDATE_METADATA_URL = "tzinfo_metadata_url"; 7487 7488 /** 7489 * URL for selinux (mandatory access control) updates 7490 * @hide 7491 */ 7492 public static final String SELINUX_UPDATE_CONTENT_URL = "selinux_content_url"; 7493 7494 /** 7495 * URL for selinux (mandatory access control) update metadata 7496 * @hide 7497 */ 7498 public static final String SELINUX_UPDATE_METADATA_URL = "selinux_metadata_url"; 7499 7500 /** 7501 * URL for sms short code updates 7502 * @hide 7503 */ 7504 public static final String SMS_SHORT_CODES_UPDATE_CONTENT_URL = 7505 "sms_short_codes_content_url"; 7506 7507 /** 7508 * URL for sms short code update metadata 7509 * @hide 7510 */ 7511 public static final String SMS_SHORT_CODES_UPDATE_METADATA_URL = 7512 "sms_short_codes_metadata_url"; 7513 7514 /** 7515 * URL for cert pinlist updates 7516 * @hide 7517 */ 7518 public static final String CERT_PIN_UPDATE_CONTENT_URL = "cert_pin_content_url"; 7519 7520 /** 7521 * URL for cert pinlist updates 7522 * @hide 7523 */ 7524 public static final String CERT_PIN_UPDATE_METADATA_URL = "cert_pin_metadata_url"; 7525 7526 /** 7527 * URL for intent firewall updates 7528 * @hide 7529 */ 7530 public static final String INTENT_FIREWALL_UPDATE_CONTENT_URL = 7531 "intent_firewall_content_url"; 7532 7533 /** 7534 * URL for intent firewall update metadata 7535 * @hide 7536 */ 7537 public static final String INTENT_FIREWALL_UPDATE_METADATA_URL = 7538 "intent_firewall_metadata_url"; 7539 7540 /** 7541 * SELinux enforcement status. If 0, permissive; if 1, enforcing. 7542 * @hide 7543 */ 7544 public static final String SELINUX_STATUS = "selinux_status"; 7545 7546 /** 7547 * Developer setting to force RTL layout. 7548 * @hide 7549 */ 7550 public static final String DEVELOPMENT_FORCE_RTL = "debug.force_rtl"; 7551 7552 /** 7553 * Milliseconds after screen-off after which low battery sounds will be silenced. 7554 * 7555 * If zero, battery sounds will always play. 7556 * Defaults to @integer/def_low_battery_sound_timeout in SettingsProvider. 7557 * 7558 * @hide 7559 */ 7560 public static final String LOW_BATTERY_SOUND_TIMEOUT = "low_battery_sound_timeout"; 7561 7562 /** 7563 * Milliseconds to wait before bouncing Wi-Fi after settings is restored. Note that after 7564 * the caller is done with this, they should call {@link ContentResolver#delete} to 7565 * clean up any value that they may have written. 7566 * 7567 * @hide 7568 */ 7569 public static final String WIFI_BOUNCE_DELAY_OVERRIDE_MS = "wifi_bounce_delay_override_ms"; 7570 7571 /** 7572 * Defines global runtime overrides to window policy. 7573 * 7574 * See {@link com.android.server.policy.PolicyControl} for value format. 7575 * 7576 * @hide 7577 */ 7578 public static final String POLICY_CONTROL = "policy_control"; 7579 7580 /** 7581 * Defines global zen mode. ZEN_MODE_OFF, ZEN_MODE_IMPORTANT_INTERRUPTIONS, 7582 * or ZEN_MODE_NO_INTERRUPTIONS. 7583 * 7584 * @hide 7585 */ 7586 public static final String ZEN_MODE = "zen_mode"; 7587 7588 /** @hide */ public static final int ZEN_MODE_OFF = 0; 7589 /** @hide */ public static final int ZEN_MODE_IMPORTANT_INTERRUPTIONS = 1; 7590 /** @hide */ public static final int ZEN_MODE_NO_INTERRUPTIONS = 2; 7591 /** @hide */ public static final int ZEN_MODE_ALARMS = 3; 7592 zenModeToString(int mode)7593 /** @hide */ public static String zenModeToString(int mode) { 7594 if (mode == ZEN_MODE_IMPORTANT_INTERRUPTIONS) return "ZEN_MODE_IMPORTANT_INTERRUPTIONS"; 7595 if (mode == ZEN_MODE_ALARMS) return "ZEN_MODE_ALARMS"; 7596 if (mode == ZEN_MODE_NO_INTERRUPTIONS) return "ZEN_MODE_NO_INTERRUPTIONS"; 7597 return "ZEN_MODE_OFF"; 7598 } 7599 isValidZenMode(int value)7600 /** @hide */ public static boolean isValidZenMode(int value) { 7601 switch (value) { 7602 case Global.ZEN_MODE_OFF: 7603 case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: 7604 case Global.ZEN_MODE_ALARMS: 7605 case Global.ZEN_MODE_NO_INTERRUPTIONS: 7606 return true; 7607 default: 7608 return false; 7609 } 7610 } 7611 7612 /** 7613 * Value of the ringer before entering zen mode. 7614 * 7615 * @hide 7616 */ 7617 public static final String ZEN_MODE_RINGER_LEVEL = "zen_mode_ringer_level"; 7618 7619 /** 7620 * Opaque value, changes when persisted zen mode configuration changes. 7621 * 7622 * @hide 7623 */ 7624 public static final String ZEN_MODE_CONFIG_ETAG = "zen_mode_config_etag"; 7625 7626 /** 7627 * Defines global heads up toggle. One of HEADS_UP_OFF, HEADS_UP_ON. 7628 * 7629 * @hide 7630 */ 7631 public static final String HEADS_UP_NOTIFICATIONS_ENABLED = 7632 "heads_up_notifications_enabled"; 7633 7634 /** @hide */ public static final int HEADS_UP_OFF = 0; 7635 /** @hide */ public static final int HEADS_UP_ON = 1; 7636 7637 /** 7638 * The name of the device 7639 * 7640 * @hide 7641 */ 7642 public static final String DEVICE_NAME = "device_name"; 7643 7644 /** 7645 * Whether it should be possible to create a guest user on the device. 7646 * <p> 7647 * Type: int (0 for disabled, 1 for enabled) 7648 * @hide 7649 */ 7650 public static final String GUEST_USER_ENABLED = "guest_user_enabled"; 7651 7652 /** 7653 * Whether the NetworkScoringService has been first initialized. 7654 * <p> 7655 * Type: int (0 for false, 1 for true) 7656 * @hide 7657 */ 7658 public static final String NETWORK_SCORING_PROVISIONED = "network_scoring_provisioned"; 7659 7660 /** 7661 * Whether the user wants to be prompted for password to decrypt the device on boot. 7662 * This only matters if the storage is encrypted. 7663 * <p> 7664 * Type: int (0 for false, 1 for true) 7665 * @hide 7666 */ 7667 public static final String REQUIRE_PASSWORD_TO_DECRYPT = "require_password_to_decrypt"; 7668 7669 /** 7670 * Whether the Volte/VT is enabled 7671 * <p> 7672 * Type: int (0 for false, 1 for true) 7673 * @hide 7674 */ 7675 public static final String ENHANCED_4G_MODE_ENABLED = "volte_vt_enabled"; 7676 7677 /** 7678 * Whether WFC is enabled 7679 * <p> 7680 * Type: int (0 for false, 1 for true) 7681 * 7682 * @hide 7683 */ 7684 public static final String WFC_IMS_ENABLED = "wfc_ims_enabled"; 7685 7686 /** 7687 * WFC Mode. 7688 * <p> 7689 * Type: int - 2=Wi-Fi preferred, 1=Cellular preferred, 0=Wi-Fi only 7690 * 7691 * @hide 7692 */ 7693 public static final String WFC_IMS_MODE = "wfc_ims_mode"; 7694 7695 /** 7696 * Whether WFC roaming is enabled 7697 * <p> 7698 * Type: int (0 for false, 1 for true) 7699 * 7700 * @hide 7701 */ 7702 public static final String WFC_IMS_ROAMING_ENABLED = "wfc_ims_roaming_enabled"; 7703 7704 /** 7705 * Whether user can enable/disable LTE as a preferred network. A carrier might control 7706 * this via gservices, OMA-DM, carrier app, etc. 7707 * <p> 7708 * Type: int (0 for false, 1 for true) 7709 * @hide 7710 */ 7711 public static final String LTE_SERVICE_FORCED = "lte_service_forced"; 7712 7713 /** 7714 * Settings to backup. This is here so that it's in the same place as the settings 7715 * keys and easy to update. 7716 * 7717 * These keys may be mentioned in the SETTINGS_TO_BACKUP arrays in System 7718 * and Secure as well. This is because those tables drive both backup and 7719 * restore, and restore needs to properly whitelist keys that used to live 7720 * in those namespaces. The keys will only actually be backed up / restored 7721 * if they are also mentioned in this table (Global.SETTINGS_TO_BACKUP). 7722 * 7723 * NOTE: Settings are backed up and restored in the order they appear 7724 * in this array. If you have one setting depending on another, 7725 * make sure that they are ordered appropriately. 7726 * 7727 * @hide 7728 */ 7729 public static final String[] SETTINGS_TO_BACKUP = { 7730 BUGREPORT_IN_POWER_MENU, 7731 STAY_ON_WHILE_PLUGGED_IN, 7732 AUTO_TIME, 7733 AUTO_TIME_ZONE, 7734 POWER_SOUNDS_ENABLED, 7735 DOCK_SOUNDS_ENABLED, 7736 USB_MASS_STORAGE_ENABLED, 7737 ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 7738 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 7739 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 7740 WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, 7741 WIFI_NUM_OPEN_NETWORKS_KEPT, 7742 EMERGENCY_TONE, 7743 CALL_AUTO_RETRY, 7744 DOCK_AUDIO_MEDIA_ENABLED, 7745 LOW_POWER_MODE_TRIGGER_LEVEL 7746 }; 7747 7748 // Populated lazily, guarded by class object: 7749 private static NameValueCache sNameValueCache = new NameValueCache( 7750 SYS_PROP_SETTING_VERSION, 7751 CONTENT_URI, 7752 CALL_METHOD_GET_GLOBAL, 7753 CALL_METHOD_PUT_GLOBAL); 7754 7755 // Certain settings have been moved from global to the per-user secure namespace 7756 private static final HashSet<String> MOVED_TO_SECURE; 7757 static { 7758 MOVED_TO_SECURE = new HashSet<String>(1); 7759 MOVED_TO_SECURE.add(Settings.Global.INSTALL_NON_MARKET_APPS); 7760 } 7761 7762 /** @hide */ getMovedToSecureSettings(Set<String> outKeySet)7763 public static void getMovedToSecureSettings(Set<String> outKeySet) { 7764 outKeySet.addAll(MOVED_TO_SECURE); 7765 } 7766 7767 /** 7768 * Look up a name in the database. 7769 * @param resolver to access the database with 7770 * @param name to look up in the table 7771 * @return the corresponding value, or null if not present 7772 */ getString(ContentResolver resolver, String name)7773 public static String getString(ContentResolver resolver, String name) { 7774 return getStringForUser(resolver, name, UserHandle.myUserId()); 7775 } 7776 7777 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)7778 public static String getStringForUser(ContentResolver resolver, String name, 7779 int userHandle) { 7780 if (MOVED_TO_SECURE.contains(name)) { 7781 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Global" 7782 + " to android.provider.Settings.Secure, returning read-only value."); 7783 return Secure.getStringForUser(resolver, name, userHandle); 7784 } 7785 return sNameValueCache.getStringForUser(resolver, name, userHandle); 7786 } 7787 7788 /** 7789 * Store a name/value pair into the database. 7790 * @param resolver to access the database with 7791 * @param name to store 7792 * @param value to associate with the name 7793 * @return true if the value was set, false on database errors 7794 */ putString(ContentResolver resolver, String name, String value)7795 public static boolean putString(ContentResolver resolver, 7796 String name, String value) { 7797 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 7798 } 7799 7800 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)7801 public static boolean putStringForUser(ContentResolver resolver, 7802 String name, String value, int userHandle) { 7803 if (LOCAL_LOGV) { 7804 Log.v(TAG, "Global.putString(name=" + name + ", value=" + value 7805 + " for " + userHandle); 7806 } 7807 // Global and Secure have the same access policy so we can forward writes 7808 if (MOVED_TO_SECURE.contains(name)) { 7809 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Global" 7810 + " to android.provider.Settings.Secure, value is unchanged."); 7811 return Secure.putStringForUser(resolver, name, value, userHandle); 7812 } 7813 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 7814 } 7815 7816 /** 7817 * Construct the content URI for a particular name/value pair, 7818 * useful for monitoring changes with a ContentObserver. 7819 * @param name to look up in the table 7820 * @return the corresponding content URI, or null if not present 7821 */ getUriFor(String name)7822 public static Uri getUriFor(String name) { 7823 return getUriFor(CONTENT_URI, name); 7824 } 7825 7826 /** 7827 * Convenience function for retrieving a single secure settings value 7828 * as an integer. Note that internally setting values are always 7829 * stored as strings; this function converts the string to an integer 7830 * for you. The default value will be returned if the setting is 7831 * not defined or not an integer. 7832 * 7833 * @param cr The ContentResolver to access. 7834 * @param name The name of the setting to retrieve. 7835 * @param def Value to return if the setting is not defined. 7836 * 7837 * @return The setting's current value, or 'def' if it is not defined 7838 * or not a valid integer. 7839 */ getInt(ContentResolver cr, String name, int def)7840 public static int getInt(ContentResolver cr, String name, int def) { 7841 String v = getString(cr, name); 7842 try { 7843 return v != null ? Integer.parseInt(v) : def; 7844 } catch (NumberFormatException e) { 7845 return def; 7846 } 7847 } 7848 7849 /** 7850 * Convenience function for retrieving a single secure settings value 7851 * as an integer. Note that internally setting values are always 7852 * stored as strings; this function converts the string to an integer 7853 * for you. 7854 * <p> 7855 * This version does not take a default value. If the setting has not 7856 * been set, or the string value is not a number, 7857 * it throws {@link SettingNotFoundException}. 7858 * 7859 * @param cr The ContentResolver to access. 7860 * @param name The name of the setting to retrieve. 7861 * 7862 * @throws SettingNotFoundException Thrown if a setting by the given 7863 * name can't be found or the setting value is not an integer. 7864 * 7865 * @return The setting's current value. 7866 */ getInt(ContentResolver cr, String name)7867 public static int getInt(ContentResolver cr, String name) 7868 throws SettingNotFoundException { 7869 String v = getString(cr, name); 7870 try { 7871 return Integer.parseInt(v); 7872 } catch (NumberFormatException e) { 7873 throw new SettingNotFoundException(name); 7874 } 7875 } 7876 7877 /** 7878 * Convenience function for updating a single settings value as an 7879 * integer. This will either create a new entry in the table if the 7880 * given name does not exist, or modify the value of the existing row 7881 * with that name. Note that internally setting values are always 7882 * stored as strings, so this function converts the given value to a 7883 * string before storing it. 7884 * 7885 * @param cr The ContentResolver to access. 7886 * @param name The name of the setting to modify. 7887 * @param value The new value for the setting. 7888 * @return true if the value was set, false on database errors 7889 */ putInt(ContentResolver cr, String name, int value)7890 public static boolean putInt(ContentResolver cr, String name, int value) { 7891 return putString(cr, name, Integer.toString(value)); 7892 } 7893 7894 /** 7895 * Convenience function for retrieving a single secure settings value 7896 * as a {@code long}. Note that internally setting values are always 7897 * stored as strings; this function converts the string to a {@code long} 7898 * for you. The default value will be returned if the setting is 7899 * not defined or not a {@code long}. 7900 * 7901 * @param cr The ContentResolver to access. 7902 * @param name The name of the setting to retrieve. 7903 * @param def Value to return if the setting is not defined. 7904 * 7905 * @return The setting's current value, or 'def' if it is not defined 7906 * or not a valid {@code long}. 7907 */ getLong(ContentResolver cr, String name, long def)7908 public static long getLong(ContentResolver cr, String name, long def) { 7909 String valString = getString(cr, name); 7910 long value; 7911 try { 7912 value = valString != null ? Long.parseLong(valString) : def; 7913 } catch (NumberFormatException e) { 7914 value = def; 7915 } 7916 return value; 7917 } 7918 7919 /** 7920 * Convenience function for retrieving a single secure settings value 7921 * as a {@code long}. Note that internally setting values are always 7922 * stored as strings; this function converts the string to a {@code long} 7923 * for you. 7924 * <p> 7925 * This version does not take a default value. If the setting has not 7926 * been set, or the string value is not a number, 7927 * it throws {@link SettingNotFoundException}. 7928 * 7929 * @param cr The ContentResolver to access. 7930 * @param name The name of the setting to retrieve. 7931 * 7932 * @return The setting's current value. 7933 * @throws SettingNotFoundException Thrown if a setting by the given 7934 * name can't be found or the setting value is not an integer. 7935 */ getLong(ContentResolver cr, String name)7936 public static long getLong(ContentResolver cr, String name) 7937 throws SettingNotFoundException { 7938 String valString = getString(cr, name); 7939 try { 7940 return Long.parseLong(valString); 7941 } catch (NumberFormatException e) { 7942 throw new SettingNotFoundException(name); 7943 } 7944 } 7945 7946 /** 7947 * Convenience function for updating a secure settings value as a long 7948 * integer. This will either create a new entry in the table if the 7949 * given name does not exist, or modify the value of the existing row 7950 * with that name. Note that internally setting values are always 7951 * stored as strings, so this function converts the given value to a 7952 * string before storing it. 7953 * 7954 * @param cr The ContentResolver to access. 7955 * @param name The name of the setting to modify. 7956 * @param value The new value for the setting. 7957 * @return true if the value was set, false on database errors 7958 */ putLong(ContentResolver cr, String name, long value)7959 public static boolean putLong(ContentResolver cr, String name, long value) { 7960 return putString(cr, name, Long.toString(value)); 7961 } 7962 7963 /** 7964 * Convenience function for retrieving a single secure settings value 7965 * as a floating point number. Note that internally setting values are 7966 * always stored as strings; this function converts the string to an 7967 * float for you. The default value will be returned if the setting 7968 * is not defined or not a valid float. 7969 * 7970 * @param cr The ContentResolver to access. 7971 * @param name The name of the setting to retrieve. 7972 * @param def Value to return if the setting is not defined. 7973 * 7974 * @return The setting's current value, or 'def' if it is not defined 7975 * or not a valid float. 7976 */ getFloat(ContentResolver cr, String name, float def)7977 public static float getFloat(ContentResolver cr, String name, float def) { 7978 String v = getString(cr, name); 7979 try { 7980 return v != null ? Float.parseFloat(v) : def; 7981 } catch (NumberFormatException e) { 7982 return def; 7983 } 7984 } 7985 7986 /** 7987 * Convenience function for retrieving a single secure settings value 7988 * as a float. Note that internally setting values are always 7989 * stored as strings; this function converts the string to a float 7990 * for you. 7991 * <p> 7992 * This version does not take a default value. If the setting has not 7993 * been set, or the string value is not a number, 7994 * it throws {@link SettingNotFoundException}. 7995 * 7996 * @param cr The ContentResolver to access. 7997 * @param name The name of the setting to retrieve. 7998 * 7999 * @throws SettingNotFoundException Thrown if a setting by the given 8000 * name can't be found or the setting value is not a float. 8001 * 8002 * @return The setting's current value. 8003 */ getFloat(ContentResolver cr, String name)8004 public static float getFloat(ContentResolver cr, String name) 8005 throws SettingNotFoundException { 8006 String v = getString(cr, name); 8007 if (v == null) { 8008 throw new SettingNotFoundException(name); 8009 } 8010 try { 8011 return Float.parseFloat(v); 8012 } catch (NumberFormatException e) { 8013 throw new SettingNotFoundException(name); 8014 } 8015 } 8016 8017 /** 8018 * Convenience function for updating a single settings value as a 8019 * floating point number. This will either create a new entry in the 8020 * table if the given name does not exist, or modify the value of the 8021 * existing row with that name. Note that internally setting values 8022 * are always stored as strings, so this function converts the given 8023 * value to a string before storing it. 8024 * 8025 * @param cr The ContentResolver to access. 8026 * @param name The name of the setting to modify. 8027 * @param value The new value for the setting. 8028 * @return true if the value was set, false on database errors 8029 */ putFloat(ContentResolver cr, String name, float value)8030 public static boolean putFloat(ContentResolver cr, String name, float value) { 8031 return putString(cr, name, Float.toString(value)); 8032 } 8033 8034 8035 /** 8036 * Subscription to be used for voice call on a multi sim device. The supported values 8037 * are 0 = SUB1, 1 = SUB2 and etc. 8038 * @hide 8039 */ 8040 public static final String MULTI_SIM_VOICE_CALL_SUBSCRIPTION = "multi_sim_voice_call"; 8041 8042 /** 8043 * Used to provide option to user to select subscription during dial. 8044 * The supported values are 0 = disable or 1 = enable prompt. 8045 * @hide 8046 */ 8047 public static final String MULTI_SIM_VOICE_PROMPT = "multi_sim_voice_prompt"; 8048 8049 /** 8050 * Subscription to be used for data call on a multi sim device. The supported values 8051 * are 0 = SUB1, 1 = SUB2 and etc. 8052 * @hide 8053 */ 8054 public static final String MULTI_SIM_DATA_CALL_SUBSCRIPTION = "multi_sim_data_call"; 8055 8056 /** 8057 * Subscription to be used for SMS on a multi sim device. The supported values 8058 * are 0 = SUB1, 1 = SUB2 and etc. 8059 * @hide 8060 */ 8061 public static final String MULTI_SIM_SMS_SUBSCRIPTION = "multi_sim_sms"; 8062 8063 /** 8064 * Used to provide option to user to select subscription during send SMS. 8065 * The value 1 - enable, 0 - disable 8066 * @hide 8067 */ 8068 public static final String MULTI_SIM_SMS_PROMPT = "multi_sim_sms_prompt"; 8069 8070 8071 8072 /** User preferred subscriptions setting. 8073 * This holds the details of the user selected subscription from the card and 8074 * the activation status. Each settings string have the coma separated values 8075 * iccId,appType,appId,activationStatus,3gppIndex,3gpp2Index 8076 * @hide 8077 */ 8078 public static final String[] MULTI_SIM_USER_PREFERRED_SUBS = {"user_preferred_sub1", 8079 "user_preferred_sub2","user_preferred_sub3"}; 8080 8081 /** 8082 * Whether to enable new contacts aggregator or not. 8083 * The value 1 - enable, 0 - disable 8084 * @hide 8085 */ 8086 public static final String NEW_CONTACT_AGGREGATOR = "new_contact_aggregator"; 8087 8088 /** 8089 * Whether to enable contacts metadata syncing or not 8090 * The value 1 - enable, 0 - disable 8091 * @hide 8092 */ 8093 public static final String CONTACT_METADATA_SYNC = "contact_metadata_sync"; 8094 } 8095 8096 /** 8097 * User-defined bookmarks and shortcuts. The target of each bookmark is an 8098 * Intent URL, allowing it to be either a web page or a particular 8099 * application activity. 8100 * 8101 * @hide 8102 */ 8103 public static final class Bookmarks implements BaseColumns 8104 { 8105 private static final String TAG = "Bookmarks"; 8106 8107 /** 8108 * The content:// style URL for this table 8109 */ 8110 public static final Uri CONTENT_URI = 8111 Uri.parse("content://" + AUTHORITY + "/bookmarks"); 8112 8113 /** 8114 * The row ID. 8115 * <p>Type: INTEGER</p> 8116 */ 8117 public static final String ID = "_id"; 8118 8119 /** 8120 * Descriptive name of the bookmark that can be displayed to the user. 8121 * If this is empty, the title should be resolved at display time (use 8122 * {@link #getTitle(Context, Cursor)} any time you want to display the 8123 * title of a bookmark.) 8124 * <P> 8125 * Type: TEXT 8126 * </P> 8127 */ 8128 public static final String TITLE = "title"; 8129 8130 /** 8131 * Arbitrary string (displayed to the user) that allows bookmarks to be 8132 * organized into categories. There are some special names for 8133 * standard folders, which all start with '@'. The label displayed for 8134 * the folder changes with the locale (via {@link #getLabelForFolder}) but 8135 * the folder name does not change so you can consistently query for 8136 * the folder regardless of the current locale. 8137 * 8138 * <P>Type: TEXT</P> 8139 * 8140 */ 8141 public static final String FOLDER = "folder"; 8142 8143 /** 8144 * The Intent URL of the bookmark, describing what it points to. This 8145 * value is given to {@link android.content.Intent#getIntent} to create 8146 * an Intent that can be launched. 8147 * <P>Type: TEXT</P> 8148 */ 8149 public static final String INTENT = "intent"; 8150 8151 /** 8152 * Optional shortcut character associated with this bookmark. 8153 * <P>Type: INTEGER</P> 8154 */ 8155 public static final String SHORTCUT = "shortcut"; 8156 8157 /** 8158 * The order in which the bookmark should be displayed 8159 * <P>Type: INTEGER</P> 8160 */ 8161 public static final String ORDERING = "ordering"; 8162 8163 private static final String[] sIntentProjection = { INTENT }; 8164 private static final String[] sShortcutProjection = { ID, SHORTCUT }; 8165 private static final String sShortcutSelection = SHORTCUT + "=?"; 8166 8167 /** 8168 * Convenience function to retrieve the bookmarked Intent for a 8169 * particular shortcut key. 8170 * 8171 * @param cr The ContentResolver to query. 8172 * @param shortcut The shortcut key. 8173 * 8174 * @return Intent The bookmarked URL, or null if there is no bookmark 8175 * matching the given shortcut. 8176 */ getIntentForShortcut(ContentResolver cr, char shortcut)8177 public static Intent getIntentForShortcut(ContentResolver cr, char shortcut) 8178 { 8179 Intent intent = null; 8180 8181 Cursor c = cr.query(CONTENT_URI, 8182 sIntentProjection, sShortcutSelection, 8183 new String[] { String.valueOf((int) shortcut) }, ORDERING); 8184 // Keep trying until we find a valid shortcut 8185 try { 8186 while (intent == null && c.moveToNext()) { 8187 try { 8188 String intentURI = c.getString(c.getColumnIndexOrThrow(INTENT)); 8189 intent = Intent.parseUri(intentURI, 0); 8190 } catch (java.net.URISyntaxException e) { 8191 // The stored URL is bad... ignore it. 8192 } catch (IllegalArgumentException e) { 8193 // Column not found 8194 Log.w(TAG, "Intent column not found", e); 8195 } 8196 } 8197 } finally { 8198 if (c != null) c.close(); 8199 } 8200 8201 return intent; 8202 } 8203 8204 /** 8205 * Add a new bookmark to the system. 8206 * 8207 * @param cr The ContentResolver to query. 8208 * @param intent The desired target of the bookmark. 8209 * @param title Bookmark title that is shown to the user; null if none 8210 * or it should be resolved to the intent's title. 8211 * @param folder Folder in which to place the bookmark; null if none. 8212 * @param shortcut Shortcut that will invoke the bookmark; 0 if none. If 8213 * this is non-zero and there is an existing bookmark entry 8214 * with this same shortcut, then that existing shortcut is 8215 * cleared (the bookmark is not removed). 8216 * @return The unique content URL for the new bookmark entry. 8217 */ add(ContentResolver cr, Intent intent, String title, String folder, char shortcut, int ordering)8218 public static Uri add(ContentResolver cr, 8219 Intent intent, 8220 String title, 8221 String folder, 8222 char shortcut, 8223 int ordering) 8224 { 8225 // If a shortcut is supplied, and it is already defined for 8226 // another bookmark, then remove the old definition. 8227 if (shortcut != 0) { 8228 cr.delete(CONTENT_URI, sShortcutSelection, 8229 new String[] { String.valueOf((int) shortcut) }); 8230 } 8231 8232 ContentValues values = new ContentValues(); 8233 if (title != null) values.put(TITLE, title); 8234 if (folder != null) values.put(FOLDER, folder); 8235 values.put(INTENT, intent.toUri(0)); 8236 if (shortcut != 0) values.put(SHORTCUT, (int) shortcut); 8237 values.put(ORDERING, ordering); 8238 return cr.insert(CONTENT_URI, values); 8239 } 8240 8241 /** 8242 * Return the folder name as it should be displayed to the user. This 8243 * takes care of localizing special folders. 8244 * 8245 * @param r Resources object for current locale; only need access to 8246 * system resources. 8247 * @param folder The value found in the {@link #FOLDER} column. 8248 * 8249 * @return CharSequence The label for this folder that should be shown 8250 * to the user. 8251 */ getLabelForFolder(Resources r, String folder)8252 public static CharSequence getLabelForFolder(Resources r, String folder) { 8253 return folder; 8254 } 8255 8256 /** 8257 * Return the title as it should be displayed to the user. This takes 8258 * care of localizing bookmarks that point to activities. 8259 * 8260 * @param context A context. 8261 * @param cursor A cursor pointing to the row whose title should be 8262 * returned. The cursor must contain at least the {@link #TITLE} 8263 * and {@link #INTENT} columns. 8264 * @return A title that is localized and can be displayed to the user, 8265 * or the empty string if one could not be found. 8266 */ getTitle(Context context, Cursor cursor)8267 public static CharSequence getTitle(Context context, Cursor cursor) { 8268 int titleColumn = cursor.getColumnIndex(TITLE); 8269 int intentColumn = cursor.getColumnIndex(INTENT); 8270 if (titleColumn == -1 || intentColumn == -1) { 8271 throw new IllegalArgumentException( 8272 "The cursor must contain the TITLE and INTENT columns."); 8273 } 8274 8275 String title = cursor.getString(titleColumn); 8276 if (!TextUtils.isEmpty(title)) { 8277 return title; 8278 } 8279 8280 String intentUri = cursor.getString(intentColumn); 8281 if (TextUtils.isEmpty(intentUri)) { 8282 return ""; 8283 } 8284 8285 Intent intent; 8286 try { 8287 intent = Intent.parseUri(intentUri, 0); 8288 } catch (URISyntaxException e) { 8289 return ""; 8290 } 8291 8292 PackageManager packageManager = context.getPackageManager(); 8293 ResolveInfo info = packageManager.resolveActivity(intent, 0); 8294 return info != null ? info.loadLabel(packageManager) : ""; 8295 } 8296 } 8297 8298 /** 8299 * Returns the device ID that we should use when connecting to the mobile gtalk server. 8300 * This is a string like "android-0x1242", where the hex string is the Android ID obtained 8301 * from the GoogleLoginService. 8302 * 8303 * @param androidId The Android ID for this device. 8304 * @return The device ID that should be used when connecting to the mobile gtalk server. 8305 * @hide 8306 */ getGTalkDeviceId(long androidId)8307 public static String getGTalkDeviceId(long androidId) { 8308 return "android-" + Long.toHexString(androidId); 8309 } 8310 8311 private static final String[] PM_WRITE_SETTINGS = { 8312 android.Manifest.permission.WRITE_SETTINGS 8313 }; 8314 private static final String[] PM_CHANGE_NETWORK_STATE = { 8315 android.Manifest.permission.CHANGE_NETWORK_STATE, 8316 android.Manifest.permission.WRITE_SETTINGS 8317 }; 8318 private static final String[] PM_SYSTEM_ALERT_WINDOW = { 8319 android.Manifest.permission.SYSTEM_ALERT_WINDOW 8320 }; 8321 8322 /** 8323 * Performs a strict and comprehensive check of whether a calling package is allowed to 8324 * write/modify system settings, as the condition differs for pre-M, M+, and 8325 * privileged/preinstalled apps. If the provided uid does not match the 8326 * callingPackage, a negative result will be returned. 8327 * @hide 8328 */ isCallingPackageAllowedToWriteSettings(Context context, int uid, String callingPackage, boolean throwException)8329 public static boolean isCallingPackageAllowedToWriteSettings(Context context, int uid, 8330 String callingPackage, boolean throwException) { 8331 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8332 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8333 PM_WRITE_SETTINGS, false); 8334 } 8335 8336 /** 8337 * Performs a strict and comprehensive check of whether a calling package is allowed to 8338 * write/modify system settings, as the condition differs for pre-M, M+, and 8339 * privileged/preinstalled apps. If the provided uid does not match the 8340 * callingPackage, a negative result will be returned. The caller is expected to have 8341 * the WRITE_SETTINGS permission declared. 8342 * 8343 * Note: if the check is successful, the operation of this app will be updated to the 8344 * current time. 8345 * @hide 8346 */ checkAndNoteWriteSettingsOperation(Context context, int uid, String callingPackage, boolean throwException)8347 public static boolean checkAndNoteWriteSettingsOperation(Context context, int uid, 8348 String callingPackage, boolean throwException) { 8349 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8350 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8351 PM_WRITE_SETTINGS, true); 8352 } 8353 8354 /** 8355 * Performs a strict and comprehensive check of whether a calling package is allowed to 8356 * change the state of network, as the condition differs for pre-M, M+, and 8357 * privileged/preinstalled apps. The caller is expected to have either the 8358 * CHANGE_NETWORK_STATE or the WRITE_SETTINGS permission declared. Either of these 8359 * permissions allow changing network state; WRITE_SETTINGS is a runtime permission and 8360 * can be revoked, but (except in M, excluding M MRs), CHANGE_NETWORK_STATE is a normal 8361 * permission and cannot be revoked. See http://b/23597341 8362 * 8363 * Note: if the check succeeds because the application holds WRITE_SETTINGS, the operation 8364 * of this app will be updated to the current time. 8365 * @hide 8366 */ checkAndNoteChangeNetworkStateOperation(Context context, int uid, String callingPackage, boolean throwException)8367 public static boolean checkAndNoteChangeNetworkStateOperation(Context context, int uid, 8368 String callingPackage, boolean throwException) { 8369 if (context.checkCallingOrSelfPermission(android.Manifest.permission.CHANGE_NETWORK_STATE) 8370 == PackageManager.PERMISSION_GRANTED) { 8371 return true; 8372 } 8373 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8374 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8375 PM_CHANGE_NETWORK_STATE, true); 8376 } 8377 8378 /** 8379 * Performs a strict and comprehensive check of whether a calling package is allowed to 8380 * draw on top of other apps, as the conditions differs for pre-M, M+, and 8381 * privileged/preinstalled apps. If the provided uid does not match the callingPackage, 8382 * a negative result will be returned. 8383 * @hide 8384 */ isCallingPackageAllowedToDrawOverlays(Context context, int uid, String callingPackage, boolean throwException)8385 public static boolean isCallingPackageAllowedToDrawOverlays(Context context, int uid, 8386 String callingPackage, boolean throwException) { 8387 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8388 callingPackage, throwException, AppOpsManager.OP_SYSTEM_ALERT_WINDOW, 8389 PM_SYSTEM_ALERT_WINDOW, false); 8390 } 8391 8392 /** 8393 * Performs a strict and comprehensive check of whether a calling package is allowed to 8394 * draw on top of other apps, as the conditions differs for pre-M, M+, and 8395 * privileged/preinstalled apps. If the provided uid does not match the callingPackage, 8396 * a negative result will be returned. 8397 * 8398 * Note: if the check is successful, the operation of this app will be updated to the 8399 * current time. 8400 * @hide 8401 */ checkAndNoteDrawOverlaysOperation(Context context, int uid, String callingPackage, boolean throwException)8402 public static boolean checkAndNoteDrawOverlaysOperation(Context context, int uid, String 8403 callingPackage, boolean throwException) { 8404 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8405 callingPackage, throwException, AppOpsManager.OP_SYSTEM_ALERT_WINDOW, 8406 PM_SYSTEM_ALERT_WINDOW, true); 8407 } 8408 8409 /** 8410 * Helper method to perform a general and comprehensive check of whether an operation that is 8411 * protected by appops can be performed by a caller or not. e.g. OP_SYSTEM_ALERT_WINDOW and 8412 * OP_WRITE_SETTINGS 8413 * @hide 8414 */ isCallingPackageAllowedToPerformAppOpsProtectedOperation(Context context, int uid, String callingPackage, boolean throwException, int appOpsOpCode, String[] permissions, boolean makeNote)8415 public static boolean isCallingPackageAllowedToPerformAppOpsProtectedOperation(Context context, 8416 int uid, String callingPackage, boolean throwException, int appOpsOpCode, String[] 8417 permissions, boolean makeNote) { 8418 if (callingPackage == null) { 8419 return false; 8420 } 8421 8422 AppOpsManager appOpsMgr = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE); 8423 int mode = AppOpsManager.MODE_DEFAULT; 8424 if (makeNote) { 8425 mode = appOpsMgr.noteOpNoThrow(appOpsOpCode, uid, callingPackage); 8426 } else { 8427 mode = appOpsMgr.checkOpNoThrow(appOpsOpCode, uid, callingPackage); 8428 } 8429 8430 switch (mode) { 8431 case AppOpsManager.MODE_ALLOWED: 8432 return true; 8433 8434 case AppOpsManager.MODE_DEFAULT: 8435 // this is the default operating mode after an app's installation 8436 // In this case we will check all associated static permission to see 8437 // if it is granted during install time. 8438 for (String permission : permissions) { 8439 if (context.checkCallingOrSelfPermission(permission) == PackageManager 8440 .PERMISSION_GRANTED) { 8441 // if either of the permissions are granted, we will allow it 8442 return true; 8443 } 8444 } 8445 8446 default: 8447 // this is for all other cases trickled down here... 8448 if (!throwException) { 8449 return false; 8450 } 8451 } 8452 8453 // prepare string to throw SecurityException 8454 StringBuilder exceptionMessage = new StringBuilder(); 8455 exceptionMessage.append(callingPackage); 8456 exceptionMessage.append(" was not granted "); 8457 if (permissions.length > 1) { 8458 exceptionMessage.append(" either of these permissions: "); 8459 } else { 8460 exceptionMessage.append(" this permission: "); 8461 } 8462 for (int i = 0; i < permissions.length; i++) { 8463 exceptionMessage.append(permissions[i]); 8464 exceptionMessage.append((i == permissions.length - 1) ? "." : ", "); 8465 } 8466 8467 throw new SecurityException(exceptionMessage.toString()); 8468 } 8469 8470 /** 8471 * Retrieves a correponding package name for a given uid. It will query all 8472 * packages that are associated with the given uid, but it will return only 8473 * the zeroth result. 8474 * Note: If package could not be found, a null is returned. 8475 * @hide 8476 */ getPackageNameForUid(Context context, int uid)8477 public static String getPackageNameForUid(Context context, int uid) { 8478 String[] packages = context.getPackageManager().getPackagesForUid(uid); 8479 if (packages == null) { 8480 return null; 8481 } 8482 return packages[0]; 8483 } 8484 } 8485