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.app.SearchManager; 22 import android.app.WallpaperManager; 23 import android.content.ComponentName; 24 import android.content.ContentResolver; 25 import android.content.ContentValues; 26 import android.content.Context; 27 import android.content.IContentProvider; 28 import android.content.Intent; 29 import android.content.pm.ActivityInfo; 30 import android.content.pm.PackageManager; 31 import android.content.pm.ResolveInfo; 32 import android.content.res.Configuration; 33 import android.content.res.Resources; 34 import android.database.Cursor; 35 import android.database.SQLException; 36 import android.net.ConnectivityManager; 37 import android.net.Uri; 38 import android.net.wifi.WifiManager; 39 import android.os.BatteryManager; 40 import android.os.Bundle; 41 import android.os.DropBoxManager; 42 import android.os.IBinder; 43 import android.os.Process; 44 import android.os.RemoteException; 45 import android.os.ServiceManager; 46 import android.os.SystemProperties; 47 import android.os.UserHandle; 48 import android.os.Build.VERSION_CODES; 49 import android.speech.tts.TextToSpeech; 50 import android.text.TextUtils; 51 import android.util.AndroidException; 52 import android.util.Log; 53 import android.view.WindowOrientationListener; 54 55 import com.android.internal.widget.ILockSettings; 56 57 import java.net.URISyntaxException; 58 import java.util.HashMap; 59 import java.util.HashSet; 60 61 /** 62 * The Settings provider contains global system-level device preferences. 63 */ 64 public final class Settings { 65 66 // Intent actions for Settings 67 68 /** 69 * Activity Action: Show system settings. 70 * <p> 71 * Input: Nothing. 72 * <p> 73 * Output: Nothing. 74 */ 75 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 76 public static final String ACTION_SETTINGS = "android.settings.SETTINGS"; 77 78 /** 79 * Activity Action: Show settings to allow configuration of APNs. 80 * <p> 81 * Input: Nothing. 82 * <p> 83 * Output: Nothing. 84 */ 85 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 86 public static final String ACTION_APN_SETTINGS = "android.settings.APN_SETTINGS"; 87 88 /** 89 * Activity Action: Show settings to allow configuration of current location 90 * sources. 91 * <p> 92 * In some cases, a matching Activity may not exist, so ensure you 93 * safeguard against this. 94 * <p> 95 * Input: Nothing. 96 * <p> 97 * Output: Nothing. 98 */ 99 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 100 public static final String ACTION_LOCATION_SOURCE_SETTINGS = 101 "android.settings.LOCATION_SOURCE_SETTINGS"; 102 103 /** 104 * Activity Action: Show settings to allow configuration of wireless controls 105 * such as Wi-Fi, Bluetooth and Mobile networks. 106 * <p> 107 * In some cases, a matching Activity may not exist, so ensure you 108 * safeguard against this. 109 * <p> 110 * Input: Nothing. 111 * <p> 112 * Output: Nothing. 113 */ 114 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 115 public static final String ACTION_WIRELESS_SETTINGS = 116 "android.settings.WIRELESS_SETTINGS"; 117 118 /** 119 * Activity Action: Show settings to allow entering/exiting airplane mode. 120 * <p> 121 * In some cases, a matching Activity may not exist, so ensure you 122 * safeguard against this. 123 * <p> 124 * Input: Nothing. 125 * <p> 126 * Output: Nothing. 127 */ 128 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 129 public static final String ACTION_AIRPLANE_MODE_SETTINGS = 130 "android.settings.AIRPLANE_MODE_SETTINGS"; 131 132 /** 133 * Activity Action: Show settings for accessibility modules. 134 * <p> 135 * In some cases, a matching Activity may not exist, so ensure you 136 * safeguard against this. 137 * <p> 138 * Input: Nothing. 139 * <p> 140 * Output: Nothing. 141 */ 142 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 143 public static final String ACTION_ACCESSIBILITY_SETTINGS = 144 "android.settings.ACCESSIBILITY_SETTINGS"; 145 146 /** 147 * Activity Action: Show settings to allow configuration of security and 148 * location privacy. 149 * <p> 150 * In some cases, a matching Activity may not exist, so ensure you 151 * safeguard against this. 152 * <p> 153 * Input: Nothing. 154 * <p> 155 * Output: Nothing. 156 */ 157 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 158 public static final String ACTION_SECURITY_SETTINGS = 159 "android.settings.SECURITY_SETTINGS"; 160 161 /** 162 * Activity Action: Show settings to allow configuration of privacy options. 163 * <p> 164 * In some cases, a matching Activity may not exist, so ensure you 165 * safeguard against this. 166 * <p> 167 * Input: Nothing. 168 * <p> 169 * Output: Nothing. 170 */ 171 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 172 public static final String ACTION_PRIVACY_SETTINGS = 173 "android.settings.PRIVACY_SETTINGS"; 174 175 /** 176 * Activity Action: Show settings to allow configuration of Wi-Fi. 177 178 * <p> 179 * In some cases, a matching Activity may not exist, so ensure you 180 * safeguard against this. 181 * <p> 182 * Input: Nothing. 183 * <p> 184 * Output: Nothing. 185 186 */ 187 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 188 public static final String ACTION_WIFI_SETTINGS = 189 "android.settings.WIFI_SETTINGS"; 190 191 /** 192 * Activity Action: Show settings to allow configuration of a static IP 193 * address for Wi-Fi. 194 * <p> 195 * In some cases, a matching Activity may not exist, so ensure you safeguard 196 * against this. 197 * <p> 198 * Input: Nothing. 199 * <p> 200 * Output: Nothing. 201 */ 202 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 203 public static final String ACTION_WIFI_IP_SETTINGS = 204 "android.settings.WIFI_IP_SETTINGS"; 205 206 /** 207 * Activity Action: Show settings to allow configuration of Bluetooth. 208 * <p> 209 * In some cases, a matching Activity may not exist, so ensure you 210 * safeguard against this. 211 * <p> 212 * Input: Nothing. 213 * <p> 214 * Output: Nothing. 215 */ 216 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 217 public static final String ACTION_BLUETOOTH_SETTINGS = 218 "android.settings.BLUETOOTH_SETTINGS"; 219 220 /** 221 * Activity Action: Show settings to allow configuration of Wifi Displays. 222 * <p> 223 * In some cases, a matching Activity may not exist, so ensure you 224 * safeguard against this. 225 * <p> 226 * Input: Nothing. 227 * <p> 228 * Output: Nothing. 229 * @hide 230 */ 231 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 232 public static final String ACTION_WIFI_DISPLAY_SETTINGS = 233 "android.settings.WIFI_DISPLAY_SETTINGS"; 234 235 /** 236 * Activity Action: Show settings to allow configuration of date and time. 237 * <p> 238 * In some cases, a matching Activity may not exist, so ensure you 239 * safeguard against this. 240 * <p> 241 * Input: Nothing. 242 * <p> 243 * Output: Nothing. 244 */ 245 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 246 public static final String ACTION_DATE_SETTINGS = 247 "android.settings.DATE_SETTINGS"; 248 249 /** 250 * Activity Action: Show settings to allow configuration of sound and volume. 251 * <p> 252 * In some cases, a matching Activity may not exist, so ensure you 253 * safeguard against this. 254 * <p> 255 * Input: Nothing. 256 * <p> 257 * Output: Nothing. 258 */ 259 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 260 public static final String ACTION_SOUND_SETTINGS = 261 "android.settings.SOUND_SETTINGS"; 262 263 /** 264 * Activity Action: Show settings to allow configuration of display. 265 * <p> 266 * In some cases, a matching Activity may not exist, so ensure you 267 * safeguard against this. 268 * <p> 269 * Input: Nothing. 270 * <p> 271 * Output: Nothing. 272 */ 273 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 274 public static final String ACTION_DISPLAY_SETTINGS = 275 "android.settings.DISPLAY_SETTINGS"; 276 277 /** 278 * Activity Action: Show settings to allow configuration of locale. 279 * <p> 280 * In some cases, a matching Activity may not exist, so ensure you 281 * safeguard against this. 282 * <p> 283 * Input: Nothing. 284 * <p> 285 * Output: Nothing. 286 */ 287 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 288 public static final String ACTION_LOCALE_SETTINGS = 289 "android.settings.LOCALE_SETTINGS"; 290 291 /** 292 * Activity Action: Show settings to configure input methods, in particular 293 * allowing the user to enable input methods. 294 * <p> 295 * In some cases, a matching Activity may not exist, so ensure you 296 * safeguard against this. 297 * <p> 298 * Input: Nothing. 299 * <p> 300 * Output: Nothing. 301 */ 302 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 303 public static final String ACTION_INPUT_METHOD_SETTINGS = 304 "android.settings.INPUT_METHOD_SETTINGS"; 305 306 /** 307 * Activity Action: Show settings to enable/disable input method subtypes. 308 * <p> 309 * In some cases, a matching Activity may not exist, so ensure you 310 * safeguard against this. 311 * <p> 312 * To tell which input method's subtypes are displayed in the settings, add 313 * {@link #EXTRA_INPUT_METHOD_ID} extra to this Intent with the input method id. 314 * If there is no extra in this Intent, subtypes from all installed input methods 315 * will be displayed in the settings. 316 * 317 * @see android.view.inputmethod.InputMethodInfo#getId 318 * <p> 319 * Input: Nothing. 320 * <p> 321 * Output: Nothing. 322 */ 323 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 324 public static final String ACTION_INPUT_METHOD_SUBTYPE_SETTINGS = 325 "android.settings.INPUT_METHOD_SUBTYPE_SETTINGS"; 326 327 /** 328 * Activity Action: Show a dialog to select input method. 329 * <p> 330 * In some cases, a matching Activity may not exist, so ensure you 331 * safeguard against this. 332 * <p> 333 * Input: Nothing. 334 * <p> 335 * Output: Nothing. 336 * @hide 337 */ 338 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 339 public static final String ACTION_SHOW_INPUT_METHOD_PICKER = 340 "android.settings.SHOW_INPUT_METHOD_PICKER"; 341 342 /** 343 * Activity Action: Show settings to manage the user input dictionary. 344 * <p> 345 * In some cases, a matching Activity may not exist, so ensure you 346 * safeguard against this. 347 * <p> 348 * Input: Nothing. 349 * <p> 350 * Output: Nothing. 351 */ 352 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 353 public static final String ACTION_USER_DICTIONARY_SETTINGS = 354 "android.settings.USER_DICTIONARY_SETTINGS"; 355 356 /** 357 * Activity Action: Adds a word to the user dictionary. 358 * <p> 359 * In some cases, a matching Activity may not exist, so ensure you 360 * safeguard against this. 361 * <p> 362 * Input: An extra with key <code>word</code> that contains the word 363 * that should be added to the dictionary. 364 * <p> 365 * Output: Nothing. 366 * 367 * @hide 368 */ 369 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 370 public static final String ACTION_USER_DICTIONARY_INSERT = 371 "com.android.settings.USER_DICTIONARY_INSERT"; 372 373 /** 374 * Activity Action: Show settings to allow configuration of application-related settings. 375 * <p> 376 * In some cases, a matching Activity may not exist, so ensure you 377 * safeguard against this. 378 * <p> 379 * Input: Nothing. 380 * <p> 381 * Output: Nothing. 382 */ 383 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 384 public static final String ACTION_APPLICATION_SETTINGS = 385 "android.settings.APPLICATION_SETTINGS"; 386 387 /** 388 * Activity Action: Show settings to allow configuration of application 389 * development-related settings. As of 390 * {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} this action is 391 * a required part of the platform. 392 * <p> 393 * Input: Nothing. 394 * <p> 395 * Output: Nothing. 396 */ 397 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 398 public static final String ACTION_APPLICATION_DEVELOPMENT_SETTINGS = 399 "android.settings.APPLICATION_DEVELOPMENT_SETTINGS"; 400 401 /** 402 * Activity Action: Show settings to allow configuration of quick launch shortcuts. 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_QUICK_LAUNCH_SETTINGS = 413 "android.settings.QUICK_LAUNCH_SETTINGS"; 414 415 /** 416 * Activity Action: Show settings to manage installed applications. 417 * <p> 418 * In some cases, a matching Activity may not exist, so ensure you 419 * safeguard against this. 420 * <p> 421 * Input: Nothing. 422 * <p> 423 * Output: Nothing. 424 */ 425 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 426 public static final String ACTION_MANAGE_APPLICATIONS_SETTINGS = 427 "android.settings.MANAGE_APPLICATIONS_SETTINGS"; 428 429 /** 430 * Activity Action: Show settings to manage all applications. 431 * <p> 432 * In some cases, a matching Activity may not exist, so ensure you 433 * safeguard against this. 434 * <p> 435 * Input: Nothing. 436 * <p> 437 * Output: Nothing. 438 */ 439 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 440 public static final String ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS = 441 "android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS"; 442 443 /** 444 * Activity Action: Show screen of details about a particular application. 445 * <p> 446 * In some cases, a matching Activity may not exist, so ensure you 447 * safeguard against this. 448 * <p> 449 * Input: The Intent's data URI specifies the application package name 450 * to be shown, with the "package" scheme. That is "package:com.my.app". 451 * <p> 452 * Output: Nothing. 453 */ 454 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 455 public static final String ACTION_APPLICATION_DETAILS_SETTINGS = 456 "android.settings.APPLICATION_DETAILS_SETTINGS"; 457 458 /** 459 * Activity Action: Show settings for system update functionality. 460 * <p> 461 * In some cases, a matching Activity may not exist, so ensure you 462 * safeguard against this. 463 * <p> 464 * Input: Nothing. 465 * <p> 466 * Output: Nothing. 467 * 468 * @hide 469 */ 470 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 471 public static final String ACTION_SYSTEM_UPDATE_SETTINGS = 472 "android.settings.SYSTEM_UPDATE_SETTINGS"; 473 474 /** 475 * Activity Action: Show settings to allow configuration of sync settings. 476 * <p> 477 * In some cases, a matching Activity may not exist, so ensure you 478 * safeguard against this. 479 * <p> 480 * The account types available to add via the add account button may be restricted by adding an 481 * {@link #EXTRA_AUTHORITIES} extra to this Intent with one or more syncable content provider's 482 * authorities. Only account types which can sync with that content provider will be offered to 483 * the user. 484 * <p> 485 * Input: Nothing. 486 * <p> 487 * Output: Nothing. 488 */ 489 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 490 public static final String ACTION_SYNC_SETTINGS = 491 "android.settings.SYNC_SETTINGS"; 492 493 /** 494 * Activity Action: Show add account screen for creating a new account. 495 * <p> 496 * In some cases, a matching Activity may not exist, so ensure you 497 * safeguard against this. 498 * <p> 499 * The account types available to add may be restricted by adding an {@link #EXTRA_AUTHORITIES} 500 * extra to the Intent with one or more syncable content provider's authorities. Only account 501 * types which can sync with that content provider will be offered to the user. 502 * <p> 503 * Input: Nothing. 504 * <p> 505 * Output: Nothing. 506 */ 507 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 508 public static final String ACTION_ADD_ACCOUNT = 509 "android.settings.ADD_ACCOUNT_SETTINGS"; 510 511 /** 512 * Activity Action: Show settings for selecting the network operator. 513 * <p> 514 * In some cases, a matching Activity may not exist, so ensure you 515 * safeguard against this. 516 * <p> 517 * Input: Nothing. 518 * <p> 519 * Output: Nothing. 520 */ 521 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 522 public static final String ACTION_NETWORK_OPERATOR_SETTINGS = 523 "android.settings.NETWORK_OPERATOR_SETTINGS"; 524 525 /** 526 * Activity Action: Show settings for selection of 2G/3G. 527 * <p> 528 * In some cases, a matching Activity may not exist, so ensure you 529 * safeguard against this. 530 * <p> 531 * Input: Nothing. 532 * <p> 533 * Output: Nothing. 534 */ 535 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 536 public static final String ACTION_DATA_ROAMING_SETTINGS = 537 "android.settings.DATA_ROAMING_SETTINGS"; 538 539 /** 540 * Activity Action: Show settings for internal storage. 541 * <p> 542 * In some cases, a matching Activity may not exist, so ensure you 543 * safeguard against this. 544 * <p> 545 * Input: Nothing. 546 * <p> 547 * Output: Nothing. 548 */ 549 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 550 public static final String ACTION_INTERNAL_STORAGE_SETTINGS = 551 "android.settings.INTERNAL_STORAGE_SETTINGS"; 552 /** 553 * Activity Action: Show settings for memory card storage. 554 * <p> 555 * In some cases, a matching Activity may not exist, so ensure you 556 * safeguard against this. 557 * <p> 558 * Input: Nothing. 559 * <p> 560 * Output: Nothing. 561 */ 562 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 563 public static final String ACTION_MEMORY_CARD_SETTINGS = 564 "android.settings.MEMORY_CARD_SETTINGS"; 565 566 /** 567 * Activity Action: Show settings for global search. 568 * <p> 569 * In some cases, a matching Activity may not exist, so ensure you 570 * safeguard against this. 571 * <p> 572 * Input: Nothing. 573 * <p> 574 * Output: Nothing 575 */ 576 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 577 public static final String ACTION_SEARCH_SETTINGS = 578 "android.search.action.SEARCH_SETTINGS"; 579 580 /** 581 * Activity Action: Show general device information settings (serial 582 * number, software version, phone number, etc.). 583 * <p> 584 * In some cases, a matching Activity may not exist, so ensure you 585 * safeguard against this. 586 * <p> 587 * Input: Nothing. 588 * <p> 589 * Output: Nothing 590 */ 591 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 592 public static final String ACTION_DEVICE_INFO_SETTINGS = 593 "android.settings.DEVICE_INFO_SETTINGS"; 594 595 /** 596 * Activity Action: Show NFC settings. 597 * <p> 598 * This shows UI that allows NFC to be turned on or off. 599 * <p> 600 * In some cases, a matching Activity may not exist, so ensure you 601 * safeguard against this. 602 * <p> 603 * Input: Nothing. 604 * <p> 605 * Output: Nothing 606 * @see android.nfc.NfcAdapter#isEnabled() 607 */ 608 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 609 public static final String ACTION_NFC_SETTINGS = "android.settings.NFC_SETTINGS"; 610 611 /** 612 * Activity Action: Show NFC Sharing settings. 613 * <p> 614 * This shows UI that allows NDEF Push (Android Beam) to be turned on or 615 * off. 616 * <p> 617 * In some cases, a matching Activity may not exist, so ensure you 618 * safeguard against this. 619 * <p> 620 * Input: Nothing. 621 * <p> 622 * Output: Nothing 623 * @see android.nfc.NfcAdapter#isNdefPushEnabled() 624 */ 625 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 626 public static final String ACTION_NFCSHARING_SETTINGS = 627 "android.settings.NFCSHARING_SETTINGS"; 628 629 /** 630 * Activity Action: Show Daydream settings. 631 * <p> 632 * In some cases, a matching Activity may not exist, so ensure you 633 * safeguard against this. 634 * <p> 635 * Input: Nothing. 636 * <p> 637 * Output: Nothing. 638 * @see android.service.dreams.DreamService 639 * @hide 640 */ 641 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 642 public static final String ACTION_DREAM_SETTINGS = "android.settings.DREAM_SETTINGS"; 643 644 // End of Intent actions for Settings 645 646 /** 647 * @hide - Private call() method on SettingsProvider to read from 'system' table. 648 */ 649 public static final String CALL_METHOD_GET_SYSTEM = "GET_system"; 650 651 /** 652 * @hide - Private call() method on SettingsProvider to read from 'secure' table. 653 */ 654 public static final String CALL_METHOD_GET_SECURE = "GET_secure"; 655 656 /** 657 * @hide - Private call() method on SettingsProvider to read from 'global' table. 658 */ 659 public static final String CALL_METHOD_GET_GLOBAL = "GET_global"; 660 661 /** 662 * @hide - User handle argument extra to the fast-path call()-based requests 663 */ 664 public static final String CALL_METHOD_USER_KEY = "_user"; 665 666 /** @hide - Private call() method to write to 'system' table */ 667 public static final String CALL_METHOD_PUT_SYSTEM = "PUT_system"; 668 669 /** @hide - Private call() method to write to 'secure' table */ 670 public static final String CALL_METHOD_PUT_SECURE = "PUT_secure"; 671 672 /** @hide - Private call() method to write to 'global' table */ 673 public static final String CALL_METHOD_PUT_GLOBAL= "PUT_global"; 674 675 /** 676 * Activity Extra: Limit available options in launched activity based on the given authority. 677 * <p> 678 * This can be passed as an extra field in an Activity Intent with one or more syncable content 679 * provider's authorities as a String[]. This field is used by some intents to alter the 680 * behavior of the called activity. 681 * <p> 682 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types available based 683 * on the authority given. 684 */ 685 public static final String EXTRA_AUTHORITIES = 686 "authorities"; 687 688 public static final String EXTRA_INPUT_METHOD_ID = "input_method_id"; 689 690 private static final String JID_RESOURCE_PREFIX = "android"; 691 692 public static final String AUTHORITY = "settings"; 693 694 private static final String TAG = "Settings"; 695 private static final boolean LOCAL_LOGV = false; 696 697 public static class SettingNotFoundException extends AndroidException { SettingNotFoundException(String msg)698 public SettingNotFoundException(String msg) { 699 super(msg); 700 } 701 } 702 703 /** 704 * Common base for tables of name/value settings. 705 */ 706 public static class NameValueTable implements BaseColumns { 707 public static final String NAME = "name"; 708 public static final String VALUE = "value"; 709 putString(ContentResolver resolver, Uri uri, String name, String value)710 protected static boolean putString(ContentResolver resolver, Uri uri, 711 String name, String value) { 712 // The database will take care of replacing duplicates. 713 try { 714 ContentValues values = new ContentValues(); 715 values.put(NAME, name); 716 values.put(VALUE, value); 717 resolver.insert(uri, values); 718 return true; 719 } catch (SQLException e) { 720 Log.w(TAG, "Can't set key " + name + " in " + uri, e); 721 return false; 722 } 723 } 724 getUriFor(Uri uri, String name)725 public static Uri getUriFor(Uri uri, String name) { 726 return Uri.withAppendedPath(uri, name); 727 } 728 } 729 730 // Thread-safe. 731 private static class NameValueCache { 732 private final String mVersionSystemProperty; 733 private final Uri mUri; 734 735 private static final String[] SELECT_VALUE = 736 new String[] { Settings.NameValueTable.VALUE }; 737 private static final String NAME_EQ_PLACEHOLDER = "name=?"; 738 739 // Must synchronize on 'this' to access mValues and mValuesVersion. 740 private final HashMap<String, String> mValues = new HashMap<String, String>(); 741 private long mValuesVersion = 0; 742 743 // Initially null; set lazily and held forever. Synchronized on 'this'. 744 private IContentProvider mContentProvider = null; 745 746 // The method we'll call (or null, to not use) on the provider 747 // for the fast path of retrieving settings. 748 private final String mCallGetCommand; 749 private final String mCallSetCommand; 750 NameValueCache(String versionSystemProperty, Uri uri, String getCommand, String setCommand)751 public NameValueCache(String versionSystemProperty, Uri uri, 752 String getCommand, String setCommand) { 753 mVersionSystemProperty = versionSystemProperty; 754 mUri = uri; 755 mCallGetCommand = getCommand; 756 mCallSetCommand = setCommand; 757 } 758 lazyGetProvider(ContentResolver cr)759 private IContentProvider lazyGetProvider(ContentResolver cr) { 760 IContentProvider cp = null; 761 synchronized (this) { 762 cp = mContentProvider; 763 if (cp == null) { 764 cp = mContentProvider = cr.acquireProvider(mUri.getAuthority()); 765 } 766 } 767 return cp; 768 } 769 putStringForUser(ContentResolver cr, String name, String value, final int userHandle)770 public boolean putStringForUser(ContentResolver cr, String name, String value, 771 final int userHandle) { 772 try { 773 Bundle arg = new Bundle(); 774 arg.putString(Settings.NameValueTable.VALUE, value); 775 arg.putInt(CALL_METHOD_USER_KEY, userHandle); 776 IContentProvider cp = lazyGetProvider(cr); 777 cp.call(mCallSetCommand, name, arg); 778 } catch (RemoteException e) { 779 Log.w(TAG, "Can't set key " + name + " in " + mUri, e); 780 return false; 781 } 782 return true; 783 } 784 getStringForUser(ContentResolver cr, String name, final int userHandle)785 public String getStringForUser(ContentResolver cr, String name, final int userHandle) { 786 final boolean isSelf = (userHandle == UserHandle.myUserId()); 787 if (isSelf) { 788 long newValuesVersion = SystemProperties.getLong(mVersionSystemProperty, 0); 789 790 // Our own user's settings data uses a client-side cache 791 synchronized (this) { 792 if (mValuesVersion != newValuesVersion) { 793 if (LOCAL_LOGV || false) { 794 Log.v(TAG, "invalidate [" + mUri.getLastPathSegment() + "]: current " 795 + newValuesVersion + " != cached " + mValuesVersion); 796 } 797 798 mValues.clear(); 799 mValuesVersion = newValuesVersion; 800 } 801 802 if (mValues.containsKey(name)) { 803 return mValues.get(name); // Could be null, that's OK -- negative caching 804 } 805 } 806 } else { 807 if (LOCAL_LOGV) Log.v(TAG, "get setting for user " + userHandle 808 + " by user " + UserHandle.myUserId() + " so skipping cache"); 809 } 810 811 IContentProvider cp = lazyGetProvider(cr); 812 813 // Try the fast path first, not using query(). If this 814 // fails (alternate Settings provider that doesn't support 815 // this interface?) then we fall back to the query/table 816 // interface. 817 if (mCallGetCommand != null) { 818 try { 819 Bundle args = null; 820 if (!isSelf) { 821 args = new Bundle(); 822 args.putInt(CALL_METHOD_USER_KEY, userHandle); 823 } 824 Bundle b = cp.call(mCallGetCommand, name, args); 825 if (b != null) { 826 String value = b.getPairValue(); 827 // Don't update our cache for reads of other users' data 828 if (isSelf) { 829 synchronized (this) { 830 mValues.put(name, value); 831 } 832 } else { 833 if (LOCAL_LOGV) Log.i(TAG, "call-query of user " + userHandle 834 + " by " + UserHandle.myUserId() 835 + " so not updating cache"); 836 } 837 return value; 838 } 839 // If the response Bundle is null, we fall through 840 // to the query interface below. 841 } catch (RemoteException e) { 842 // Not supported by the remote side? Fall through 843 // to query(). 844 } 845 } 846 847 Cursor c = null; 848 try { 849 c = cp.query(mUri, SELECT_VALUE, NAME_EQ_PLACEHOLDER, 850 new String[]{name}, null, null); 851 if (c == null) { 852 Log.w(TAG, "Can't get key " + name + " from " + mUri); 853 return null; 854 } 855 856 String value = c.moveToNext() ? c.getString(0) : null; 857 synchronized (this) { 858 mValues.put(name, value); 859 } 860 if (LOCAL_LOGV) { 861 Log.v(TAG, "cache miss [" + mUri.getLastPathSegment() + "]: " + 862 name + " = " + (value == null ? "(null)" : value)); 863 } 864 return value; 865 } catch (RemoteException e) { 866 Log.w(TAG, "Can't get key " + name + " from " + mUri, e); 867 return null; // Return null, but don't cache it. 868 } finally { 869 if (c != null) c.close(); 870 } 871 } 872 } 873 874 /** 875 * System settings, containing miscellaneous system preferences. This 876 * table holds simple name/value pairs. There are convenience 877 * functions for accessing individual settings entries. 878 */ 879 public static final class System extends NameValueTable { 880 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_system_version"; 881 882 /** 883 * The content:// style URL for this table 884 */ 885 public static final Uri CONTENT_URI = 886 Uri.parse("content://" + AUTHORITY + "/system"); 887 888 private static final NameValueCache sNameValueCache = new NameValueCache( 889 SYS_PROP_SETTING_VERSION, 890 CONTENT_URI, 891 CALL_METHOD_GET_SYSTEM, 892 CALL_METHOD_PUT_SYSTEM); 893 894 private static final HashSet<String> MOVED_TO_SECURE; 895 static { 896 MOVED_TO_SECURE = new HashSet<String>(30); 897 MOVED_TO_SECURE.add(Secure.ANDROID_ID); 898 MOVED_TO_SECURE.add(Secure.HTTP_PROXY); 899 MOVED_TO_SECURE.add(Secure.LOCATION_PROVIDERS_ALLOWED); 900 MOVED_TO_SECURE.add(Secure.LOCK_BIOMETRIC_WEAK_FLAGS); 901 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_ENABLED); 902 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_VISIBLE); 903 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 904 MOVED_TO_SECURE.add(Secure.LOGGING_ID); 905 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_ENABLED); 906 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_LAST_UPDATE); 907 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_REDIRECT_URL); 908 MOVED_TO_SECURE.add(Secure.SETTINGS_CLASSNAME); 909 MOVED_TO_SECURE.add(Secure.USE_GOOGLE_MAIL); 910 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 911 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 912 MOVED_TO_SECURE.add(Secure.WIFI_NUM_OPEN_NETWORKS_KEPT); 913 MOVED_TO_SECURE.add(Secure.WIFI_ON); 914 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE); 915 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_AP_COUNT); 916 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS); 917 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED); 918 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS); 919 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT); 920 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_MAX_AP_CHECKS); 921 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ON); 922 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_COUNT); 923 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_DELAY_MS); 924 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS); 925 } 926 927 private static final HashSet<String> MOVED_TO_GLOBAL; 928 private static final HashSet<String> MOVED_TO_SECURE_THEN_GLOBAL; 929 static { 930 MOVED_TO_GLOBAL = new HashSet<String>(); 931 MOVED_TO_SECURE_THEN_GLOBAL = new HashSet<String>(); 932 933 // these were originally in system but migrated to secure in the past, 934 // so are duplicated in the Secure.* namespace 935 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.ADB_ENABLED); 936 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.BLUETOOTH_ON); 937 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DATA_ROAMING); 938 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DEVICE_PROVISIONED); 939 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.INSTALL_NON_MARKET_APPS); 940 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.USB_MASS_STORAGE_ENABLED); 941 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.HTTP_PROXY); 942 943 // these are moving directly from system to global 944 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_ON); 945 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_RADIOS); 946 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS); 947 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME); 948 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME_ZONE); 949 MOVED_TO_GLOBAL.add(Settings.Global.CAR_DOCK_SOUND); 950 MOVED_TO_GLOBAL.add(Settings.Global.CAR_UNDOCK_SOUND); 951 MOVED_TO_GLOBAL.add(Settings.Global.DESK_DOCK_SOUND); 952 MOVED_TO_GLOBAL.add(Settings.Global.DESK_UNDOCK_SOUND); 953 MOVED_TO_GLOBAL.add(Settings.Global.DOCK_SOUNDS_ENABLED); 954 MOVED_TO_GLOBAL.add(Settings.Global.LOCK_SOUND); 955 MOVED_TO_GLOBAL.add(Settings.Global.UNLOCK_SOUND); 956 MOVED_TO_GLOBAL.add(Settings.Global.LOW_BATTERY_SOUND); 957 MOVED_TO_GLOBAL.add(Settings.Global.POWER_SOUNDS_ENABLED); 958 MOVED_TO_GLOBAL.add(Settings.Global.STAY_ON_WHILE_PLUGGED_IN); 959 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SLEEP_POLICY); 960 MOVED_TO_GLOBAL.add(Settings.Global.MODE_RINGER); 961 MOVED_TO_GLOBAL.add(Settings.Global.WINDOW_ANIMATION_SCALE); 962 MOVED_TO_GLOBAL.add(Settings.Global.TRANSITION_ANIMATION_SCALE); 963 MOVED_TO_GLOBAL.add(Settings.Global.ANIMATOR_DURATION_SCALE); 964 MOVED_TO_GLOBAL.add(Settings.Global.FANCY_IME_ANIMATIONS); 965 MOVED_TO_GLOBAL.add(Settings.Global.COMPATIBILITY_MODE); 966 MOVED_TO_GLOBAL.add(Settings.Global.EMERGENCY_TONE); 967 MOVED_TO_GLOBAL.add(Settings.Global.CALL_AUTO_RETRY); 968 MOVED_TO_GLOBAL.add(Settings.Global.DEBUG_APP); 969 MOVED_TO_GLOBAL.add(Settings.Global.WAIT_FOR_DEBUGGER); 970 MOVED_TO_GLOBAL.add(Settings.Global.SHOW_PROCESSES); 971 MOVED_TO_GLOBAL.add(Settings.Global.ALWAYS_FINISH_ACTIVITIES); 972 } 973 974 /** @hide */ getMovedKeys(HashSet<String> outKeySet)975 public static void getMovedKeys(HashSet<String> outKeySet) { 976 outKeySet.addAll(MOVED_TO_GLOBAL); 977 outKeySet.addAll(MOVED_TO_SECURE_THEN_GLOBAL); 978 } 979 980 /** @hide */ getNonLegacyMovedKeys(HashSet<String> outKeySet)981 public static void getNonLegacyMovedKeys(HashSet<String> outKeySet) { 982 outKeySet.addAll(MOVED_TO_GLOBAL); 983 } 984 985 /** 986 * Look up a name in the database. 987 * @param resolver to access the database with 988 * @param name to look up in the table 989 * @return the corresponding value, or null if not present 990 */ getString(ContentResolver resolver, String name)991 public static String getString(ContentResolver resolver, String name) { 992 return getStringForUser(resolver, name, UserHandle.myUserId()); 993 } 994 995 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)996 public static String getStringForUser(ContentResolver resolver, String name, 997 int userHandle) { 998 if (MOVED_TO_SECURE.contains(name)) { 999 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1000 + " to android.provider.Settings.Secure, returning read-only value."); 1001 return Secure.getStringForUser(resolver, name, userHandle); 1002 } 1003 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1004 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1005 + " to android.provider.Settings.Global, returning read-only value."); 1006 return Global.getStringForUser(resolver, name, userHandle); 1007 } 1008 return sNameValueCache.getStringForUser(resolver, name, userHandle); 1009 } 1010 1011 /** 1012 * Store a name/value pair into the database. 1013 * @param resolver to access the database with 1014 * @param name to store 1015 * @param value to associate with the name 1016 * @return true if the value was set, false on database errors 1017 */ putString(ContentResolver resolver, String name, String value)1018 public static boolean putString(ContentResolver resolver, String name, String value) { 1019 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 1020 } 1021 1022 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)1023 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 1024 int userHandle) { 1025 if (MOVED_TO_SECURE.contains(name)) { 1026 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1027 + " to android.provider.Settings.Secure, value is unchanged."); 1028 return false; 1029 } 1030 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1031 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1032 + " to android.provider.Settings.Global, value is unchanged."); 1033 return false; 1034 } 1035 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 1036 } 1037 1038 /** 1039 * Construct the content URI for a particular name/value pair, 1040 * useful for monitoring changes with a ContentObserver. 1041 * @param name to look up in the table 1042 * @return the corresponding content URI, or null if not present 1043 */ getUriFor(String name)1044 public static Uri getUriFor(String name) { 1045 if (MOVED_TO_SECURE.contains(name)) { 1046 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1047 + " to android.provider.Settings.Secure, returning Secure URI."); 1048 return Secure.getUriFor(Secure.CONTENT_URI, name); 1049 } 1050 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1051 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1052 + " to android.provider.Settings.Global, returning read-only global URI."); 1053 return Global.getUriFor(Global.CONTENT_URI, name); 1054 } 1055 return getUriFor(CONTENT_URI, name); 1056 } 1057 1058 /** 1059 * Convenience function for retrieving a single system settings value 1060 * as an integer. Note that internally setting values are always 1061 * stored as strings; this function converts the string to an integer 1062 * for you. The default value will be returned if the setting is 1063 * not defined or not an integer. 1064 * 1065 * @param cr The ContentResolver to access. 1066 * @param name The name of the setting to retrieve. 1067 * @param def Value to return if the setting is not defined. 1068 * 1069 * @return The setting's current value, or 'def' if it is not defined 1070 * or not a valid integer. 1071 */ getInt(ContentResolver cr, String name, int def)1072 public static int getInt(ContentResolver cr, String name, int def) { 1073 return getIntForUser(cr, name, def, UserHandle.myUserId()); 1074 } 1075 1076 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)1077 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 1078 String v = getStringForUser(cr, name, userHandle); 1079 try { 1080 return v != null ? Integer.parseInt(v) : def; 1081 } catch (NumberFormatException e) { 1082 return def; 1083 } 1084 } 1085 1086 /** 1087 * Convenience function for retrieving a single system settings value 1088 * as an integer. Note that internally setting values are always 1089 * stored as strings; this function converts the string to an integer 1090 * for you. 1091 * <p> 1092 * This version does not take a default value. If the setting has not 1093 * been set, or the string value is not a number, 1094 * it throws {@link SettingNotFoundException}. 1095 * 1096 * @param cr The ContentResolver to access. 1097 * @param name The name of the setting to retrieve. 1098 * 1099 * @throws SettingNotFoundException Thrown if a setting by the given 1100 * name can't be found or the setting value is not an integer. 1101 * 1102 * @return The setting's current value. 1103 */ getInt(ContentResolver cr, String name)1104 public static int getInt(ContentResolver cr, String name) 1105 throws SettingNotFoundException { 1106 return getIntForUser(cr, name, UserHandle.myUserId()); 1107 } 1108 1109 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)1110 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 1111 throws SettingNotFoundException { 1112 String v = getStringForUser(cr, name, userHandle); 1113 try { 1114 return Integer.parseInt(v); 1115 } catch (NumberFormatException e) { 1116 throw new SettingNotFoundException(name); 1117 } 1118 } 1119 1120 /** 1121 * Convenience function for updating a single settings value as an 1122 * integer. This will either create a new entry in the table if the 1123 * given name does not exist, or modify the value of the existing row 1124 * with that name. Note that internally setting values are always 1125 * stored as strings, so this function converts the given value to a 1126 * string before storing it. 1127 * 1128 * @param cr The ContentResolver to access. 1129 * @param name The name of the setting to modify. 1130 * @param value The new value for the setting. 1131 * @return true if the value was set, false on database errors 1132 */ putInt(ContentResolver cr, String name, int value)1133 public static boolean putInt(ContentResolver cr, String name, int value) { 1134 return putIntForUser(cr, name, value, UserHandle.myUserId()); 1135 } 1136 1137 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)1138 public static boolean putIntForUser(ContentResolver cr, String name, int value, 1139 int userHandle) { 1140 return putStringForUser(cr, name, Integer.toString(value), userHandle); 1141 } 1142 1143 /** 1144 * Convenience function for retrieving a single system settings value 1145 * as a {@code long}. Note that internally setting values are always 1146 * stored as strings; this function converts the string to a {@code long} 1147 * for you. The default value will be returned if the setting is 1148 * not defined or not a {@code long}. 1149 * 1150 * @param cr The ContentResolver to access. 1151 * @param name The name of the setting to retrieve. 1152 * @param def Value to return if the setting is not defined. 1153 * 1154 * @return The setting's current value, or 'def' if it is not defined 1155 * or not a valid {@code long}. 1156 */ getLong(ContentResolver cr, String name, long def)1157 public static long getLong(ContentResolver cr, String name, long def) { 1158 return getLongForUser(cr, name, def, UserHandle.myUserId()); 1159 } 1160 1161 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)1162 public static long getLongForUser(ContentResolver cr, String name, long def, 1163 int userHandle) { 1164 String valString = getStringForUser(cr, name, userHandle); 1165 long value; 1166 try { 1167 value = valString != null ? Long.parseLong(valString) : def; 1168 } catch (NumberFormatException e) { 1169 value = def; 1170 } 1171 return value; 1172 } 1173 1174 /** 1175 * Convenience function for retrieving a single system settings value 1176 * as a {@code long}. Note that internally setting values are always 1177 * stored as strings; this function converts the string to a {@code long} 1178 * for you. 1179 * <p> 1180 * This version does not take a default value. If the setting has not 1181 * been set, or the string value is not a number, 1182 * it throws {@link SettingNotFoundException}. 1183 * 1184 * @param cr The ContentResolver to access. 1185 * @param name The name of the setting to retrieve. 1186 * 1187 * @return The setting's current value. 1188 * @throws SettingNotFoundException Thrown if a setting by the given 1189 * name can't be found or the setting value is not an integer. 1190 */ getLong(ContentResolver cr, String name)1191 public static long getLong(ContentResolver cr, String name) 1192 throws SettingNotFoundException { 1193 return getLongForUser(cr, name, UserHandle.myUserId()); 1194 } 1195 1196 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)1197 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 1198 throws SettingNotFoundException { 1199 String valString = getStringForUser(cr, name, userHandle); 1200 try { 1201 return Long.parseLong(valString); 1202 } catch (NumberFormatException e) { 1203 throw new SettingNotFoundException(name); 1204 } 1205 } 1206 1207 /** 1208 * Convenience function for updating a single settings value as a long 1209 * integer. This will either create a new entry in the table if the 1210 * given name does not exist, or modify the value of the existing row 1211 * with that name. Note that internally setting values are always 1212 * stored as strings, so this function converts the given value to a 1213 * string before storing it. 1214 * 1215 * @param cr The ContentResolver to access. 1216 * @param name The name of the setting to modify. 1217 * @param value The new value for the setting. 1218 * @return true if the value was set, false on database errors 1219 */ putLong(ContentResolver cr, String name, long value)1220 public static boolean putLong(ContentResolver cr, String name, long value) { 1221 return putLongForUser(cr, name, value, UserHandle.myUserId()); 1222 } 1223 1224 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)1225 public static boolean putLongForUser(ContentResolver cr, String name, long value, 1226 int userHandle) { 1227 return putStringForUser(cr, name, Long.toString(value), userHandle); 1228 } 1229 1230 /** 1231 * Convenience function for retrieving a single system settings value 1232 * as a floating point number. Note that internally setting values are 1233 * always stored as strings; this function converts the string to an 1234 * float for you. The default value will be returned if the setting 1235 * is not defined or not a valid float. 1236 * 1237 * @param cr The ContentResolver to access. 1238 * @param name The name of the setting to retrieve. 1239 * @param def Value to return if the setting is not defined. 1240 * 1241 * @return The setting's current value, or 'def' if it is not defined 1242 * or not a valid float. 1243 */ getFloat(ContentResolver cr, String name, float def)1244 public static float getFloat(ContentResolver cr, String name, float def) { 1245 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 1246 } 1247 1248 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)1249 public static float getFloatForUser(ContentResolver cr, String name, float def, 1250 int userHandle) { 1251 String v = getStringForUser(cr, name, userHandle); 1252 try { 1253 return v != null ? Float.parseFloat(v) : def; 1254 } catch (NumberFormatException e) { 1255 return def; 1256 } 1257 } 1258 1259 /** 1260 * Convenience function for retrieving a single system settings value 1261 * as a float. Note that internally setting values are always 1262 * stored as strings; this function converts the string to a float 1263 * for you. 1264 * <p> 1265 * This version does not take a default value. If the setting has not 1266 * been set, or the string value is not a number, 1267 * it throws {@link SettingNotFoundException}. 1268 * 1269 * @param cr The ContentResolver to access. 1270 * @param name The name of the setting to retrieve. 1271 * 1272 * @throws SettingNotFoundException Thrown if a setting by the given 1273 * name can't be found or the setting value is not a float. 1274 * 1275 * @return The setting's current value. 1276 */ getFloat(ContentResolver cr, String name)1277 public static float getFloat(ContentResolver cr, String name) 1278 throws SettingNotFoundException { 1279 return getFloatForUser(cr, name, UserHandle.myUserId()); 1280 } 1281 1282 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)1283 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 1284 throws SettingNotFoundException { 1285 String v = getStringForUser(cr, name, userHandle); 1286 if (v == null) { 1287 throw new SettingNotFoundException(name); 1288 } 1289 try { 1290 return Float.parseFloat(v); 1291 } catch (NumberFormatException e) { 1292 throw new SettingNotFoundException(name); 1293 } 1294 } 1295 1296 /** 1297 * Convenience function for updating a single settings value as a 1298 * floating point number. This will either create a new entry in the 1299 * table if the given name does not exist, or modify the value of the 1300 * existing row with that name. Note that internally setting values 1301 * are always stored as strings, so this function converts the given 1302 * value to a string before storing it. 1303 * 1304 * @param cr The ContentResolver to access. 1305 * @param name The name of the setting to modify. 1306 * @param value The new value for the setting. 1307 * @return true if the value was set, false on database errors 1308 */ putFloat(ContentResolver cr, String name, float value)1309 public static boolean putFloat(ContentResolver cr, String name, float value) { 1310 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 1311 } 1312 1313 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)1314 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 1315 int userHandle) { 1316 return putStringForUser(cr, name, Float.toString(value), userHandle); 1317 } 1318 1319 /** 1320 * Convenience function to read all of the current 1321 * configuration-related settings into a 1322 * {@link Configuration} object. 1323 * 1324 * @param cr The ContentResolver to access. 1325 * @param outConfig Where to place the configuration settings. 1326 */ getConfiguration(ContentResolver cr, Configuration outConfig)1327 public static void getConfiguration(ContentResolver cr, Configuration outConfig) { 1328 getConfigurationForUser(cr, outConfig, UserHandle.myUserId()); 1329 } 1330 1331 /** @hide */ getConfigurationForUser(ContentResolver cr, Configuration outConfig, int userHandle)1332 public static void getConfigurationForUser(ContentResolver cr, Configuration outConfig, 1333 int userHandle) { 1334 outConfig.fontScale = Settings.System.getFloatForUser( 1335 cr, FONT_SCALE, outConfig.fontScale, userHandle); 1336 if (outConfig.fontScale < 0) { 1337 outConfig.fontScale = 1; 1338 } 1339 } 1340 1341 /** 1342 * @hide Erase the fields in the Configuration that should be applied 1343 * by the settings. 1344 */ clearConfiguration(Configuration inoutConfig)1345 public static void clearConfiguration(Configuration inoutConfig) { 1346 inoutConfig.fontScale = 0; 1347 } 1348 1349 /** 1350 * Convenience function to write a batch of configuration-related 1351 * settings from a {@link Configuration} object. 1352 * 1353 * @param cr The ContentResolver to access. 1354 * @param config The settings to write. 1355 * @return true if the values were set, false on database errors 1356 */ putConfiguration(ContentResolver cr, Configuration config)1357 public static boolean putConfiguration(ContentResolver cr, Configuration config) { 1358 return putConfigurationForUser(cr, config, UserHandle.myUserId()); 1359 } 1360 1361 /** @hide */ putConfigurationForUser(ContentResolver cr, Configuration config, int userHandle)1362 public static boolean putConfigurationForUser(ContentResolver cr, Configuration config, 1363 int userHandle) { 1364 return Settings.System.putFloatForUser(cr, FONT_SCALE, config.fontScale, userHandle); 1365 } 1366 1367 /** @hide */ hasInterestingConfigurationChanges(int changes)1368 public static boolean hasInterestingConfigurationChanges(int changes) { 1369 return (changes&ActivityInfo.CONFIG_FONT_SCALE) != 0; 1370 } 1371 1372 /** @deprecated - Do not use */ 1373 @Deprecated getShowGTalkServiceStatus(ContentResolver cr)1374 public static boolean getShowGTalkServiceStatus(ContentResolver cr) { 1375 return getShowGTalkServiceStatusForUser(cr, UserHandle.myUserId()); 1376 } 1377 1378 /** 1379 * @hide 1380 * @deprecated - Do not use 1381 */ getShowGTalkServiceStatusForUser(ContentResolver cr, int userHandle)1382 public static boolean getShowGTalkServiceStatusForUser(ContentResolver cr, 1383 int userHandle) { 1384 return getIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, 0, userHandle) != 0; 1385 } 1386 1387 /** @deprecated - Do not use */ 1388 @Deprecated setShowGTalkServiceStatus(ContentResolver cr, boolean flag)1389 public static void setShowGTalkServiceStatus(ContentResolver cr, boolean flag) { 1390 setShowGTalkServiceStatusForUser(cr, flag, UserHandle.myUserId()); 1391 } 1392 1393 /** 1394 * @hide 1395 * @deprecated - Do not use 1396 */ 1397 @Deprecated setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, int userHandle)1398 public static void setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, 1399 int userHandle) { 1400 putIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, flag ? 1 : 0, userHandle); 1401 } 1402 1403 /** 1404 * @deprecated Use {@link android.provider.Settings.Global#STAY_ON_WHILE_PLUGGED_IN} instead 1405 */ 1406 @Deprecated 1407 public static final String STAY_ON_WHILE_PLUGGED_IN = Global.STAY_ON_WHILE_PLUGGED_IN; 1408 1409 /** 1410 * What happens when the user presses the end call button if they're not 1411 * on a call.<br/> 1412 * <b>Values:</b><br/> 1413 * 0 - The end button does nothing.<br/> 1414 * 1 - The end button goes to the home screen.<br/> 1415 * 2 - The end button puts the device to sleep and locks the keyguard.<br/> 1416 * 3 - The end button goes to the home screen. If the user is already on the 1417 * home screen, it puts the device to sleep. 1418 */ 1419 public static final String END_BUTTON_BEHAVIOR = "end_button_behavior"; 1420 1421 /** 1422 * END_BUTTON_BEHAVIOR value for "go home". 1423 * @hide 1424 */ 1425 public static final int END_BUTTON_BEHAVIOR_HOME = 0x1; 1426 1427 /** 1428 * END_BUTTON_BEHAVIOR value for "go to sleep". 1429 * @hide 1430 */ 1431 public static final int END_BUTTON_BEHAVIOR_SLEEP = 0x2; 1432 1433 /** 1434 * END_BUTTON_BEHAVIOR default value. 1435 * @hide 1436 */ 1437 public static final int END_BUTTON_BEHAVIOR_DEFAULT = END_BUTTON_BEHAVIOR_SLEEP; 1438 1439 /** 1440 * Is advanced settings mode turned on. 0 == no, 1 == yes 1441 * @hide 1442 */ 1443 public static final String ADVANCED_SETTINGS = "advanced_settings"; 1444 1445 /** 1446 * ADVANCED_SETTINGS default value. 1447 * @hide 1448 */ 1449 public static final int ADVANCED_SETTINGS_DEFAULT = 0; 1450 1451 /** 1452 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_ON} instead 1453 */ 1454 @Deprecated 1455 public static final String AIRPLANE_MODE_ON = Global.AIRPLANE_MODE_ON; 1456 1457 /** 1458 * @deprecated Use {@link android.provider.Settings.Global#RADIO_BLUETOOTH} instead 1459 */ 1460 @Deprecated 1461 public static final String RADIO_BLUETOOTH = Global.RADIO_BLUETOOTH; 1462 1463 /** 1464 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIFI} instead 1465 */ 1466 @Deprecated 1467 public static final String RADIO_WIFI = Global.RADIO_WIFI; 1468 1469 /** 1470 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIMAX} instead 1471 * {@hide} 1472 */ 1473 @Deprecated 1474 public static final String RADIO_WIMAX = Global.RADIO_WIMAX; 1475 1476 /** 1477 * @deprecated Use {@link android.provider.Settings.Global#RADIO_CELL} instead 1478 */ 1479 @Deprecated 1480 public static final String RADIO_CELL = Global.RADIO_CELL; 1481 1482 /** 1483 * @deprecated Use {@link android.provider.Settings.Global#RADIO_NFC} instead 1484 */ 1485 @Deprecated 1486 public static final String RADIO_NFC = Global.RADIO_NFC; 1487 1488 /** 1489 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_RADIOS} instead 1490 */ 1491 @Deprecated 1492 public static final String AIRPLANE_MODE_RADIOS = Global.AIRPLANE_MODE_RADIOS; 1493 1494 /** 1495 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_TOGGLEABLE_RADIOS} instead 1496 * 1497 * {@hide} 1498 */ 1499 @Deprecated 1500 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = 1501 Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS; 1502 1503 /** 1504 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY} instead 1505 */ 1506 @Deprecated 1507 public static final String WIFI_SLEEP_POLICY = Global.WIFI_SLEEP_POLICY; 1508 1509 /** 1510 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_DEFAULT} instead 1511 */ 1512 @Deprecated 1513 public static final int WIFI_SLEEP_POLICY_DEFAULT = Global.WIFI_SLEEP_POLICY_DEFAULT; 1514 1515 /** 1516 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED} instead 1517 */ 1518 @Deprecated 1519 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1520 Global.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED; 1521 1522 /** 1523 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER} instead 1524 */ 1525 @Deprecated 1526 public static final int WIFI_SLEEP_POLICY_NEVER = Global.WIFI_SLEEP_POLICY_NEVER; 1527 1528 /** 1529 * @deprecated Use {@link android.provider.Settings.Global#MODE_RINGER} instead 1530 */ 1531 @Deprecated 1532 public static final String MODE_RINGER = Global.MODE_RINGER; 1533 1534 /** 1535 * Whether to use static IP and other static network attributes. 1536 * <p> 1537 * Set to 1 for true and 0 for false. 1538 * 1539 * @deprecated Use {@link WifiManager} instead 1540 */ 1541 @Deprecated 1542 public static final String WIFI_USE_STATIC_IP = "wifi_use_static_ip"; 1543 1544 /** 1545 * The static IP address. 1546 * <p> 1547 * Example: "192.168.1.51" 1548 * 1549 * @deprecated Use {@link WifiManager} instead 1550 */ 1551 @Deprecated 1552 public static final String WIFI_STATIC_IP = "wifi_static_ip"; 1553 1554 /** 1555 * If using static IP, the gateway's IP address. 1556 * <p> 1557 * Example: "192.168.1.1" 1558 * 1559 * @deprecated Use {@link WifiManager} instead 1560 */ 1561 @Deprecated 1562 public static final String WIFI_STATIC_GATEWAY = "wifi_static_gateway"; 1563 1564 /** 1565 * If using static IP, the net mask. 1566 * <p> 1567 * Example: "255.255.255.0" 1568 * 1569 * @deprecated Use {@link WifiManager} instead 1570 */ 1571 @Deprecated 1572 public static final String WIFI_STATIC_NETMASK = "wifi_static_netmask"; 1573 1574 /** 1575 * If using static IP, the primary DNS's IP address. 1576 * <p> 1577 * Example: "192.168.1.1" 1578 * 1579 * @deprecated Use {@link WifiManager} instead 1580 */ 1581 @Deprecated 1582 public static final String WIFI_STATIC_DNS1 = "wifi_static_dns1"; 1583 1584 /** 1585 * If using static IP, the secondary DNS's IP address. 1586 * <p> 1587 * Example: "192.168.1.2" 1588 * 1589 * @deprecated Use {@link WifiManager} instead 1590 */ 1591 @Deprecated 1592 public static final String WIFI_STATIC_DNS2 = "wifi_static_dns2"; 1593 1594 1595 /** 1596 * Determines whether remote devices may discover and/or connect to 1597 * this device. 1598 * <P>Type: INT</P> 1599 * 2 -- discoverable and connectable 1600 * 1 -- connectable but not discoverable 1601 * 0 -- neither connectable nor discoverable 1602 */ 1603 public static final String BLUETOOTH_DISCOVERABILITY = 1604 "bluetooth_discoverability"; 1605 1606 /** 1607 * Bluetooth discoverability timeout. If this value is nonzero, then 1608 * Bluetooth becomes discoverable for a certain number of seconds, 1609 * after which is becomes simply connectable. The value is in seconds. 1610 */ 1611 public static final String BLUETOOTH_DISCOVERABILITY_TIMEOUT = 1612 "bluetooth_discoverability_timeout"; 1613 1614 /** 1615 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_ENABLED} 1616 * instead 1617 */ 1618 @Deprecated 1619 public static final String LOCK_PATTERN_ENABLED = Secure.LOCK_PATTERN_ENABLED; 1620 1621 /** 1622 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_VISIBLE} 1623 * instead 1624 */ 1625 @Deprecated 1626 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 1627 1628 /** 1629 * @deprecated Use 1630 * {@link android.provider.Settings.Secure#LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED} 1631 * instead 1632 */ 1633 @Deprecated 1634 public static final String LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = 1635 "lock_pattern_tactile_feedback_enabled"; 1636 1637 1638 /** 1639 * A formatted string of the next alarm that is set, or the empty string 1640 * if there is no alarm set. 1641 */ 1642 public static final String NEXT_ALARM_FORMATTED = "next_alarm_formatted"; 1643 1644 /** 1645 * Scaling factor for fonts, float. 1646 */ 1647 public static final String FONT_SCALE = "font_scale"; 1648 1649 /** 1650 * Name of an application package to be debugged. 1651 * 1652 * @deprecated Use {@link Global#DEBUG_APP} instead 1653 */ 1654 @Deprecated 1655 public static final String DEBUG_APP = Global.DEBUG_APP; 1656 1657 /** 1658 * If 1, when launching DEBUG_APP it will wait for the debugger before 1659 * starting user code. If 0, it will run normally. 1660 * 1661 * @deprecated Use {@link Global#WAIT_FOR_DEBUGGER} instead 1662 */ 1663 @Deprecated 1664 public static final String WAIT_FOR_DEBUGGER = Global.WAIT_FOR_DEBUGGER; 1665 1666 /** 1667 * Whether or not to dim the screen. 0=no 1=yes 1668 * @deprecated This setting is no longer used. 1669 */ 1670 @Deprecated 1671 public static final String DIM_SCREEN = "dim_screen"; 1672 1673 /** 1674 * The timeout before the screen turns off. 1675 */ 1676 public static final String SCREEN_OFF_TIMEOUT = "screen_off_timeout"; 1677 1678 /** 1679 * The screen backlight brightness between 0 and 255. 1680 */ 1681 public static final String SCREEN_BRIGHTNESS = "screen_brightness"; 1682 1683 /** 1684 * Control whether to enable automatic brightness mode. 1685 */ 1686 public static final String SCREEN_BRIGHTNESS_MODE = "screen_brightness_mode"; 1687 1688 /** 1689 * Adjustment to auto-brightness to make it generally more (>0.0 <1.0) 1690 * or less (<0.0 >-1.0) bright. 1691 * @hide 1692 */ 1693 public static final String SCREEN_AUTO_BRIGHTNESS_ADJ = "screen_auto_brightness_adj"; 1694 1695 /** 1696 * SCREEN_BRIGHTNESS_MODE value for manual mode. 1697 */ 1698 public static final int SCREEN_BRIGHTNESS_MODE_MANUAL = 0; 1699 1700 /** 1701 * SCREEN_BRIGHTNESS_MODE value for automatic mode. 1702 */ 1703 public static final int SCREEN_BRIGHTNESS_MODE_AUTOMATIC = 1; 1704 1705 /** 1706 * Control whether the process CPU usage meter should be shown. 1707 * 1708 * @deprecated Use {@link Global#SHOW_PROCESSES} instead 1709 */ 1710 @Deprecated 1711 public static final String SHOW_PROCESSES = Global.SHOW_PROCESSES; 1712 1713 /** 1714 * If 1, the activity manager will aggressively finish activities and 1715 * processes as soon as they are no longer needed. If 0, the normal 1716 * extended lifetime is used. 1717 * 1718 * @deprecated Use {@link Global#ALWAYS_FINISH_ACTIVITIES} instead 1719 */ 1720 @Deprecated 1721 public static final String ALWAYS_FINISH_ACTIVITIES = Global.ALWAYS_FINISH_ACTIVITIES; 1722 1723 /** 1724 * Determines which streams are affected by ringer mode changes. The 1725 * stream type's bit should be set to 1 if it should be muted when going 1726 * into an inaudible ringer mode. 1727 */ 1728 public static final String MODE_RINGER_STREAMS_AFFECTED = "mode_ringer_streams_affected"; 1729 1730 /** 1731 * Determines which streams are affected by mute. The 1732 * stream type's bit should be set to 1 if it should be muted when a mute request 1733 * is received. 1734 */ 1735 public static final String MUTE_STREAMS_AFFECTED = "mute_streams_affected"; 1736 1737 /** 1738 * Whether vibrate is on for different events. This is used internally, 1739 * changing this value will not change the vibrate. See AudioManager. 1740 */ 1741 public static final String VIBRATE_ON = "vibrate_on"; 1742 1743 /** 1744 * If 1, redirects the system vibrator to all currently attached input devices 1745 * that support vibration. If there are no such input devices, then the system 1746 * vibrator is used instead. 1747 * If 0, does not register the system vibrator. 1748 * 1749 * This setting is mainly intended to provide a compatibility mechanism for 1750 * applications that only know about the system vibrator and do not use the 1751 * input device vibrator API. 1752 * 1753 * @hide 1754 */ 1755 public static final String VIBRATE_INPUT_DEVICES = "vibrate_input_devices"; 1756 1757 /** 1758 * Ringer volume. This is used internally, changing this value will not 1759 * change the volume. See AudioManager. 1760 */ 1761 public static final String VOLUME_RING = "volume_ring"; 1762 1763 /** 1764 * System/notifications volume. This is used internally, changing this 1765 * value will not change the volume. See AudioManager. 1766 */ 1767 public static final String VOLUME_SYSTEM = "volume_system"; 1768 1769 /** 1770 * Voice call volume. This is used internally, changing this value will 1771 * not change the volume. See AudioManager. 1772 */ 1773 public static final String VOLUME_VOICE = "volume_voice"; 1774 1775 /** 1776 * Music/media/gaming volume. This is used internally, changing this 1777 * value will not change the volume. See AudioManager. 1778 */ 1779 public static final String VOLUME_MUSIC = "volume_music"; 1780 1781 /** 1782 * Alarm volume. This is used internally, changing this 1783 * value will not change the volume. See AudioManager. 1784 */ 1785 public static final String VOLUME_ALARM = "volume_alarm"; 1786 1787 /** 1788 * Notification volume. This is used internally, changing this 1789 * value will not change the volume. See AudioManager. 1790 */ 1791 public static final String VOLUME_NOTIFICATION = "volume_notification"; 1792 1793 /** 1794 * Bluetooth Headset volume. This is used internally, changing this value will 1795 * not change the volume. See AudioManager. 1796 */ 1797 public static final String VOLUME_BLUETOOTH_SCO = "volume_bluetooth_sco"; 1798 1799 /** 1800 * Master volume (float in the range 0.0f to 1.0f). 1801 * @hide 1802 */ 1803 public static final String VOLUME_MASTER = "volume_master"; 1804 1805 /** 1806 * Master volume mute (int 1 = mute, 0 = not muted). 1807 * 1808 * @hide 1809 */ 1810 public static final String VOLUME_MASTER_MUTE = "volume_master_mute"; 1811 1812 /** 1813 * Whether the notifications should use the ring volume (value of 1) or 1814 * a separate notification volume (value of 0). In most cases, users 1815 * will have this enabled so the notification and ringer volumes will be 1816 * the same. However, power users can disable this and use the separate 1817 * notification volume control. 1818 * <p> 1819 * Note: This is a one-off setting that will be removed in the future 1820 * when there is profile support. For this reason, it is kept hidden 1821 * from the public APIs. 1822 * 1823 * @hide 1824 * @deprecated 1825 */ 1826 @Deprecated 1827 public static final String NOTIFICATIONS_USE_RING_VOLUME = 1828 "notifications_use_ring_volume"; 1829 1830 /** 1831 * Whether silent mode should allow vibration feedback. This is used 1832 * internally in AudioService and the Sound settings activity to 1833 * coordinate decoupling of vibrate and silent modes. This setting 1834 * will likely be removed in a future release with support for 1835 * audio/vibe feedback profiles. 1836 * 1837 * Not used anymore. On devices with vibrator, the user explicitly selects 1838 * silent or vibrate mode. 1839 * Kept for use by legacy database upgrade code in DatabaseHelper. 1840 * @hide 1841 */ 1842 public static final String VIBRATE_IN_SILENT = "vibrate_in_silent"; 1843 1844 /** 1845 * The mapping of stream type (integer) to its setting. 1846 */ 1847 public static final String[] VOLUME_SETTINGS = { 1848 VOLUME_VOICE, VOLUME_SYSTEM, VOLUME_RING, VOLUME_MUSIC, 1849 VOLUME_ALARM, VOLUME_NOTIFICATION, VOLUME_BLUETOOTH_SCO 1850 }; 1851 1852 /** 1853 * Appended to various volume related settings to record the previous 1854 * values before they the settings were affected by a silent/vibrate 1855 * ringer mode change. 1856 */ 1857 public static final String APPEND_FOR_LAST_AUDIBLE = "_last_audible"; 1858 1859 /** 1860 * Persistent store for the system-wide default ringtone URI. 1861 * <p> 1862 * If you need to play the default ringtone at any given time, it is recommended 1863 * you give {@link #DEFAULT_RINGTONE_URI} to the media player. It will resolve 1864 * to the set default ringtone at the time of playing. 1865 * 1866 * @see #DEFAULT_RINGTONE_URI 1867 */ 1868 public static final String RINGTONE = "ringtone"; 1869 1870 /** 1871 * A {@link Uri} that will point to the current default ringtone at any 1872 * given time. 1873 * <p> 1874 * If the current default ringtone is in the DRM provider and the caller 1875 * does not have permission, the exception will be a 1876 * FileNotFoundException. 1877 */ 1878 public static final Uri DEFAULT_RINGTONE_URI = getUriFor(RINGTONE); 1879 1880 /** 1881 * Persistent store for the system-wide default notification sound. 1882 * 1883 * @see #RINGTONE 1884 * @see #DEFAULT_NOTIFICATION_URI 1885 */ 1886 public static final String NOTIFICATION_SOUND = "notification_sound"; 1887 1888 /** 1889 * A {@link Uri} that will point to the current default notification 1890 * sound at any given time. 1891 * 1892 * @see #DEFAULT_RINGTONE_URI 1893 */ 1894 public static final Uri DEFAULT_NOTIFICATION_URI = getUriFor(NOTIFICATION_SOUND); 1895 1896 /** 1897 * Persistent store for the system-wide default alarm alert. 1898 * 1899 * @see #RINGTONE 1900 * @see #DEFAULT_ALARM_ALERT_URI 1901 */ 1902 public static final String ALARM_ALERT = "alarm_alert"; 1903 1904 /** 1905 * A {@link Uri} that will point to the current default alarm alert at 1906 * any given time. 1907 * 1908 * @see #DEFAULT_ALARM_ALERT_URI 1909 */ 1910 public static final Uri DEFAULT_ALARM_ALERT_URI = getUriFor(ALARM_ALERT); 1911 1912 /** 1913 * Persistent store for the system default media button event receiver. 1914 * 1915 * @hide 1916 */ 1917 public static final String MEDIA_BUTTON_RECEIVER = "media_button_receiver"; 1918 1919 /** 1920 * Setting to enable Auto Replace (AutoText) in text editors. 1 = On, 0 = Off 1921 */ 1922 public static final String TEXT_AUTO_REPLACE = "auto_replace"; 1923 1924 /** 1925 * Setting to enable Auto Caps in text editors. 1 = On, 0 = Off 1926 */ 1927 public static final String TEXT_AUTO_CAPS = "auto_caps"; 1928 1929 /** 1930 * Setting to enable Auto Punctuate in text editors. 1 = On, 0 = Off. This 1931 * feature converts two spaces to a "." and space. 1932 */ 1933 public static final String TEXT_AUTO_PUNCTUATE = "auto_punctuate"; 1934 1935 /** 1936 * Setting to showing password characters in text editors. 1 = On, 0 = Off 1937 */ 1938 public static final String TEXT_SHOW_PASSWORD = "show_password"; 1939 1940 public static final String SHOW_GTALK_SERVICE_STATUS = 1941 "SHOW_GTALK_SERVICE_STATUS"; 1942 1943 /** 1944 * Name of activity to use for wallpaper on the home screen. 1945 * 1946 * @deprecated Use {@link WallpaperManager} instead. 1947 */ 1948 @Deprecated 1949 public static final String WALLPAPER_ACTIVITY = "wallpaper_activity"; 1950 1951 /** 1952 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME} 1953 * instead 1954 */ 1955 @Deprecated 1956 public static final String AUTO_TIME = Global.AUTO_TIME; 1957 1958 /** 1959 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME_ZONE} 1960 * instead 1961 */ 1962 @Deprecated 1963 public static final String AUTO_TIME_ZONE = Global.AUTO_TIME_ZONE; 1964 1965 /** 1966 * Display times as 12 or 24 hours 1967 * 12 1968 * 24 1969 */ 1970 public static final String TIME_12_24 = "time_12_24"; 1971 1972 /** 1973 * Date format string 1974 * mm/dd/yyyy 1975 * dd/mm/yyyy 1976 * yyyy/mm/dd 1977 */ 1978 public static final String DATE_FORMAT = "date_format"; 1979 1980 /** 1981 * Whether the setup wizard has been run before (on first boot), or if 1982 * it still needs to be run. 1983 * 1984 * nonzero = it has been run in the past 1985 * 0 = it has not been run in the past 1986 */ 1987 public static final String SETUP_WIZARD_HAS_RUN = "setup_wizard_has_run"; 1988 1989 /** 1990 * Scaling factor for normal window animations. Setting to 0 will disable window 1991 * animations. 1992 * 1993 * @deprecated Use {@link Global#WINDOW_ANIMATION_SCALE} instead 1994 */ 1995 @Deprecated 1996 public static final String WINDOW_ANIMATION_SCALE = Global.WINDOW_ANIMATION_SCALE; 1997 1998 /** 1999 * Scaling factor for activity transition animations. Setting to 0 will disable window 2000 * animations. 2001 * 2002 * @deprecated Use {@link Global#TRANSITION_ANIMATION_SCALE} instead 2003 */ 2004 @Deprecated 2005 public static final String TRANSITION_ANIMATION_SCALE = Global.TRANSITION_ANIMATION_SCALE; 2006 2007 /** 2008 * Scaling factor for Animator-based animations. This affects both the start delay and 2009 * duration of all such animations. Setting to 0 will cause animations to end immediately. 2010 * The default value is 1. 2011 * 2012 * @deprecated Use {@link Global#ANIMATOR_DURATION_SCALE} instead 2013 */ 2014 @Deprecated 2015 public static final String ANIMATOR_DURATION_SCALE = Global.ANIMATOR_DURATION_SCALE; 2016 2017 /** 2018 * Control whether the accelerometer will be used to change screen 2019 * orientation. If 0, it will not be used unless explicitly requested 2020 * by the application; if 1, it will be used by default unless explicitly 2021 * disabled by the application. 2022 */ 2023 public static final String ACCELEROMETER_ROTATION = "accelerometer_rotation"; 2024 2025 /** 2026 * Default screen rotation when no other policy applies. 2027 * When {@link #ACCELEROMETER_ROTATION} is zero and no on-screen Activity expresses a 2028 * preference, this rotation value will be used. Must be one of the 2029 * {@link android.view.Surface#ROTATION_0 Surface rotation constants}. 2030 * 2031 * @see Display#getRotation 2032 */ 2033 public static final String USER_ROTATION = "user_rotation"; 2034 2035 /** 2036 * Control whether the rotation lock toggle in the System UI should be hidden. 2037 * Typically this is done for accessibility purposes to make it harder for 2038 * the user to accidentally toggle the rotation lock while the display rotation 2039 * has been locked for accessibility. 2040 * 2041 * If 0, then rotation lock toggle is not hidden for accessibility (although it may be 2042 * unavailable for other reasons). If 1, then the rotation lock toggle is hidden. 2043 * 2044 * @hide 2045 */ 2046 public static final String HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY = 2047 "hide_rotation_lock_toggle_for_accessibility"; 2048 2049 /** 2050 * Whether the phone vibrates when it is ringing due to an incoming call. This will 2051 * be used by Phone and Setting apps; it shouldn't affect other apps. 2052 * The value is boolean (1 or 0). 2053 * 2054 * Note: this is not same as "vibrate on ring", which had been available until ICS. 2055 * It was about AudioManager's setting and thus affected all the applications which 2056 * relied on the setting, while this is purely about the vibration setting for incoming 2057 * calls. 2058 * 2059 * @hide 2060 */ 2061 public static final String VIBRATE_WHEN_RINGING = "vibrate_when_ringing"; 2062 2063 /** 2064 * Whether the audible DTMF tones are played by the dialer when dialing. The value is 2065 * boolean (1 or 0). 2066 */ 2067 public static final String DTMF_TONE_WHEN_DIALING = "dtmf_tone"; 2068 2069 /** 2070 * CDMA only settings 2071 * DTMF tone type played by the dialer when dialing. 2072 * 0 = Normal 2073 * 1 = Long 2074 * @hide 2075 */ 2076 public static final String DTMF_TONE_TYPE_WHEN_DIALING = "dtmf_tone_type"; 2077 2078 /** 2079 * Whether the hearing aid is enabled. The value is 2080 * boolean (1 or 0). 2081 * @hide 2082 */ 2083 public static final String HEARING_AID = "hearing_aid"; 2084 2085 /** 2086 * CDMA only settings 2087 * TTY Mode 2088 * 0 = OFF 2089 * 1 = FULL 2090 * 2 = VCO 2091 * 3 = HCO 2092 * @hide 2093 */ 2094 public static final String TTY_MODE = "tty_mode"; 2095 2096 /** 2097 * Whether the sounds effects (key clicks, lid open ...) are enabled. The value is 2098 * boolean (1 or 0). 2099 */ 2100 public static final String SOUND_EFFECTS_ENABLED = "sound_effects_enabled"; 2101 2102 /** 2103 * Whether the haptic feedback (long presses, ...) are enabled. The value is 2104 * boolean (1 or 0). 2105 */ 2106 public static final String HAPTIC_FEEDBACK_ENABLED = "haptic_feedback_enabled"; 2107 2108 /** 2109 * @deprecated Each application that shows web suggestions should have its own 2110 * setting for this. 2111 */ 2112 @Deprecated 2113 public static final String SHOW_WEB_SUGGESTIONS = "show_web_suggestions"; 2114 2115 /** 2116 * Whether the notification LED should repeatedly flash when a notification is 2117 * pending. The value is boolean (1 or 0). 2118 * @hide 2119 */ 2120 public static final String NOTIFICATION_LIGHT_PULSE = "notification_light_pulse"; 2121 2122 /** 2123 * Show pointer location on screen? 2124 * 0 = no 2125 * 1 = yes 2126 * @hide 2127 */ 2128 public static final String POINTER_LOCATION = "pointer_location"; 2129 2130 /** 2131 * Show touch positions on screen? 2132 * 0 = no 2133 * 1 = yes 2134 * @hide 2135 */ 2136 public static final String SHOW_TOUCHES = "show_touches"; 2137 2138 /** 2139 * Log raw orientation data from {@link WindowOrientationListener} for use with the 2140 * orientationplot.py tool. 2141 * 0 = no 2142 * 1 = yes 2143 * @hide 2144 */ 2145 public static final String WINDOW_ORIENTATION_LISTENER_LOG = 2146 "window_orientation_listener_log"; 2147 2148 /** 2149 * @deprecated Use {@link android.provider.Settings.Global#POWER_SOUNDS_ENABLED} 2150 * instead 2151 * @hide 2152 */ 2153 @Deprecated 2154 public static final String POWER_SOUNDS_ENABLED = Global.POWER_SOUNDS_ENABLED; 2155 2156 /** 2157 * @deprecated Use {@link android.provider.Settings.Global#DOCK_SOUNDS_ENABLED} 2158 * instead 2159 * @hide 2160 */ 2161 @Deprecated 2162 public static final String DOCK_SOUNDS_ENABLED = Global.DOCK_SOUNDS_ENABLED; 2163 2164 /** 2165 * Whether to play sounds when the keyguard is shown and dismissed. 2166 * @hide 2167 */ 2168 public static final String LOCKSCREEN_SOUNDS_ENABLED = "lockscreen_sounds_enabled"; 2169 2170 /** 2171 * Whether the lockscreen should be completely disabled. 2172 * @hide 2173 */ 2174 public static final String LOCKSCREEN_DISABLED = "lockscreen.disabled"; 2175 2176 /** 2177 * @deprecated Use {@link android.provider.Settings.Global#LOW_BATTERY_SOUND} 2178 * instead 2179 * @hide 2180 */ 2181 @Deprecated 2182 public static final String LOW_BATTERY_SOUND = Global.LOW_BATTERY_SOUND; 2183 2184 /** 2185 * @deprecated Use {@link android.provider.Settings.Global#DESK_DOCK_SOUND} 2186 * instead 2187 * @hide 2188 */ 2189 @Deprecated 2190 public static final String DESK_DOCK_SOUND = Global.DESK_DOCK_SOUND; 2191 2192 /** 2193 * @deprecated Use {@link android.provider.Settings.Global#DESK_UNDOCK_SOUND} 2194 * instead 2195 * @hide 2196 */ 2197 @Deprecated 2198 public static final String DESK_UNDOCK_SOUND = Global.DESK_UNDOCK_SOUND; 2199 2200 /** 2201 * @deprecated Use {@link android.provider.Settings.Global#CAR_DOCK_SOUND} 2202 * instead 2203 * @hide 2204 */ 2205 @Deprecated 2206 public static final String CAR_DOCK_SOUND = Global.CAR_DOCK_SOUND; 2207 2208 /** 2209 * @deprecated Use {@link android.provider.Settings.Global#CAR_UNDOCK_SOUND} 2210 * instead 2211 * @hide 2212 */ 2213 @Deprecated 2214 public static final String CAR_UNDOCK_SOUND = Global.CAR_UNDOCK_SOUND; 2215 2216 /** 2217 * @deprecated Use {@link android.provider.Settings.Global#LOCK_SOUND} 2218 * instead 2219 * @hide 2220 */ 2221 @Deprecated 2222 public static final String LOCK_SOUND = Global.LOCK_SOUND; 2223 2224 /** 2225 * @deprecated Use {@link android.provider.Settings.Global#UNLOCK_SOUND} 2226 * instead 2227 * @hide 2228 */ 2229 @Deprecated 2230 public static final String UNLOCK_SOUND = Global.UNLOCK_SOUND; 2231 2232 /** 2233 * Receive incoming SIP calls? 2234 * 0 = no 2235 * 1 = yes 2236 * @hide 2237 */ 2238 public static final String SIP_RECEIVE_CALLS = "sip_receive_calls"; 2239 2240 /** 2241 * Call Preference String. 2242 * "SIP_ALWAYS" : Always use SIP with network access 2243 * "SIP_ADDRESS_ONLY" : Only if destination is a SIP address 2244 * "SIP_ASK_ME_EACH_TIME" : Always ask me each time 2245 * @hide 2246 */ 2247 public static final String SIP_CALL_OPTIONS = "sip_call_options"; 2248 2249 /** 2250 * One of the sip call options: Always use SIP with network access. 2251 * @hide 2252 */ 2253 public static final String SIP_ALWAYS = "SIP_ALWAYS"; 2254 2255 /** 2256 * One of the sip call options: Only if destination is a SIP address. 2257 * @hide 2258 */ 2259 public static final String SIP_ADDRESS_ONLY = "SIP_ADDRESS_ONLY"; 2260 2261 /** 2262 * One of the sip call options: Always ask me each time. 2263 * @hide 2264 */ 2265 public static final String SIP_ASK_ME_EACH_TIME = "SIP_ASK_ME_EACH_TIME"; 2266 2267 /** 2268 * Pointer speed setting. 2269 * This is an integer value in a range between -7 and +7, so there are 15 possible values. 2270 * -7 = slowest 2271 * 0 = default speed 2272 * +7 = fastest 2273 * @hide 2274 */ 2275 public static final String POINTER_SPEED = "pointer_speed"; 2276 2277 /** 2278 * Settings to backup. This is here so that it's in the same place as the settings 2279 * keys and easy to update. 2280 * 2281 * NOTE: Settings are backed up and restored in the order they appear 2282 * in this array. If you have one setting depending on another, 2283 * make sure that they are ordered appropriately. 2284 * 2285 * @hide 2286 */ 2287 public static final String[] SETTINGS_TO_BACKUP = { 2288 STAY_ON_WHILE_PLUGGED_IN, // moved to global 2289 WIFI_USE_STATIC_IP, 2290 WIFI_STATIC_IP, 2291 WIFI_STATIC_GATEWAY, 2292 WIFI_STATIC_NETMASK, 2293 WIFI_STATIC_DNS1, 2294 WIFI_STATIC_DNS2, 2295 BLUETOOTH_DISCOVERABILITY, 2296 BLUETOOTH_DISCOVERABILITY_TIMEOUT, 2297 DIM_SCREEN, 2298 SCREEN_OFF_TIMEOUT, 2299 SCREEN_BRIGHTNESS, 2300 SCREEN_BRIGHTNESS_MODE, 2301 SCREEN_AUTO_BRIGHTNESS_ADJ, 2302 VIBRATE_INPUT_DEVICES, 2303 MODE_RINGER, // moved to global 2304 MODE_RINGER_STREAMS_AFFECTED, 2305 MUTE_STREAMS_AFFECTED, 2306 VOLUME_VOICE, 2307 VOLUME_SYSTEM, 2308 VOLUME_RING, 2309 VOLUME_MUSIC, 2310 VOLUME_ALARM, 2311 VOLUME_NOTIFICATION, 2312 VOLUME_BLUETOOTH_SCO, 2313 VOLUME_VOICE + APPEND_FOR_LAST_AUDIBLE, 2314 VOLUME_SYSTEM + APPEND_FOR_LAST_AUDIBLE, 2315 VOLUME_RING + APPEND_FOR_LAST_AUDIBLE, 2316 VOLUME_MUSIC + APPEND_FOR_LAST_AUDIBLE, 2317 VOLUME_ALARM + APPEND_FOR_LAST_AUDIBLE, 2318 VOLUME_NOTIFICATION + APPEND_FOR_LAST_AUDIBLE, 2319 VOLUME_BLUETOOTH_SCO + APPEND_FOR_LAST_AUDIBLE, 2320 TEXT_AUTO_REPLACE, 2321 TEXT_AUTO_CAPS, 2322 TEXT_AUTO_PUNCTUATE, 2323 TEXT_SHOW_PASSWORD, 2324 AUTO_TIME, // moved to global 2325 AUTO_TIME_ZONE, // moved to global 2326 TIME_12_24, 2327 DATE_FORMAT, 2328 DTMF_TONE_WHEN_DIALING, 2329 DTMF_TONE_TYPE_WHEN_DIALING, 2330 HEARING_AID, 2331 TTY_MODE, 2332 SOUND_EFFECTS_ENABLED, 2333 HAPTIC_FEEDBACK_ENABLED, 2334 POWER_SOUNDS_ENABLED, // moved to global 2335 DOCK_SOUNDS_ENABLED, // moved to global 2336 LOCKSCREEN_SOUNDS_ENABLED, 2337 SHOW_WEB_SUGGESTIONS, 2338 NOTIFICATION_LIGHT_PULSE, 2339 SIP_CALL_OPTIONS, 2340 SIP_RECEIVE_CALLS, 2341 POINTER_SPEED, 2342 VIBRATE_WHEN_RINGING 2343 }; 2344 2345 // Settings moved to Settings.Secure 2346 2347 /** 2348 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} 2349 * instead 2350 */ 2351 @Deprecated 2352 public static final String ADB_ENABLED = Global.ADB_ENABLED; 2353 2354 /** 2355 * @deprecated Use {@link android.provider.Settings.Secure#ANDROID_ID} instead 2356 */ 2357 @Deprecated 2358 public static final String ANDROID_ID = Secure.ANDROID_ID; 2359 2360 /** 2361 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 2362 */ 2363 @Deprecated 2364 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 2365 2366 /** 2367 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 2368 */ 2369 @Deprecated 2370 public static final String DATA_ROAMING = Global.DATA_ROAMING; 2371 2372 /** 2373 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 2374 */ 2375 @Deprecated 2376 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 2377 2378 /** 2379 * @deprecated Use {@link android.provider.Settings.Global#HTTP_PROXY} instead 2380 */ 2381 @Deprecated 2382 public static final String HTTP_PROXY = Global.HTTP_PROXY; 2383 2384 /** 2385 * @deprecated Use {@link android.provider.Settings.Global#INSTALL_NON_MARKET_APPS} instead 2386 */ 2387 @Deprecated 2388 public static final String INSTALL_NON_MARKET_APPS = Global.INSTALL_NON_MARKET_APPS; 2389 2390 /** 2391 * @deprecated Use {@link android.provider.Settings.Secure#LOCATION_PROVIDERS_ALLOWED} 2392 * instead 2393 */ 2394 @Deprecated 2395 public static final String LOCATION_PROVIDERS_ALLOWED = Secure.LOCATION_PROVIDERS_ALLOWED; 2396 2397 /** 2398 * @deprecated Use {@link android.provider.Settings.Secure#LOGGING_ID} instead 2399 */ 2400 @Deprecated 2401 public static final String LOGGING_ID = Secure.LOGGING_ID; 2402 2403 /** 2404 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 2405 */ 2406 @Deprecated 2407 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 2408 2409 /** 2410 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_ENABLED} 2411 * instead 2412 */ 2413 @Deprecated 2414 public static final String PARENTAL_CONTROL_ENABLED = Secure.PARENTAL_CONTROL_ENABLED; 2415 2416 /** 2417 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_LAST_UPDATE} 2418 * instead 2419 */ 2420 @Deprecated 2421 public static final String PARENTAL_CONTROL_LAST_UPDATE = Secure.PARENTAL_CONTROL_LAST_UPDATE; 2422 2423 /** 2424 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_REDIRECT_URL} 2425 * instead 2426 */ 2427 @Deprecated 2428 public static final String PARENTAL_CONTROL_REDIRECT_URL = 2429 Secure.PARENTAL_CONTROL_REDIRECT_URL; 2430 2431 /** 2432 * @deprecated Use {@link android.provider.Settings.Secure#SETTINGS_CLASSNAME} instead 2433 */ 2434 @Deprecated 2435 public static final String SETTINGS_CLASSNAME = Secure.SETTINGS_CLASSNAME; 2436 2437 /** 2438 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 2439 */ 2440 @Deprecated 2441 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 2442 2443 /** 2444 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 2445 */ 2446 @Deprecated 2447 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 2448 2449 /** 2450 * @deprecated Use 2451 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 2452 */ 2453 @Deprecated 2454 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 2455 2456 /** 2457 * @deprecated Use 2458 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 2459 */ 2460 @Deprecated 2461 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 2462 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 2463 2464 /** 2465 * @deprecated Use 2466 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} instead 2467 */ 2468 @Deprecated 2469 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 2470 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 2471 2472 /** 2473 * @deprecated Use 2474 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} instead 2475 */ 2476 @Deprecated 2477 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 2478 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 2479 2480 /** 2481 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 2482 * instead 2483 */ 2484 @Deprecated 2485 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 2486 2487 /** 2488 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} instead 2489 */ 2490 @Deprecated 2491 public static final String WIFI_ON = Global.WIFI_ON; 2492 2493 /** 2494 * @deprecated Use 2495 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE} 2496 * instead 2497 */ 2498 @Deprecated 2499 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 2500 Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE; 2501 2502 /** 2503 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_AP_COUNT} instead 2504 */ 2505 @Deprecated 2506 public static final String WIFI_WATCHDOG_AP_COUNT = Secure.WIFI_WATCHDOG_AP_COUNT; 2507 2508 /** 2509 * @deprecated Use 2510 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS} instead 2511 */ 2512 @Deprecated 2513 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 2514 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS; 2515 2516 /** 2517 * @deprecated Use 2518 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED} instead 2519 */ 2520 @Deprecated 2521 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 2522 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED; 2523 2524 /** 2525 * @deprecated Use 2526 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS} 2527 * instead 2528 */ 2529 @Deprecated 2530 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 2531 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS; 2532 2533 /** 2534 * @deprecated Use 2535 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT} instead 2536 */ 2537 @Deprecated 2538 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 2539 Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT; 2540 2541 /** 2542 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS} 2543 * instead 2544 */ 2545 @Deprecated 2546 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = Secure.WIFI_WATCHDOG_MAX_AP_CHECKS; 2547 2548 /** 2549 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 2550 */ 2551 @Deprecated 2552 public static final String WIFI_WATCHDOG_ON = Global.WIFI_WATCHDOG_ON; 2553 2554 /** 2555 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_COUNT} instead 2556 */ 2557 @Deprecated 2558 public static final String WIFI_WATCHDOG_PING_COUNT = Secure.WIFI_WATCHDOG_PING_COUNT; 2559 2560 /** 2561 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_DELAY_MS} 2562 * instead 2563 */ 2564 @Deprecated 2565 public static final String WIFI_WATCHDOG_PING_DELAY_MS = Secure.WIFI_WATCHDOG_PING_DELAY_MS; 2566 2567 /** 2568 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_TIMEOUT_MS} 2569 * instead 2570 */ 2571 @Deprecated 2572 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = 2573 Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS; 2574 } 2575 2576 /** 2577 * Secure system settings, containing system preferences that applications 2578 * can read but are not allowed to write. These are for preferences that 2579 * the user must explicitly modify through the system UI or specialized 2580 * APIs for those values, not modified directly by applications. 2581 */ 2582 public static final class Secure extends NameValueTable { 2583 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_secure_version"; 2584 2585 /** 2586 * The content:// style URL for this table 2587 */ 2588 public static final Uri CONTENT_URI = 2589 Uri.parse("content://" + AUTHORITY + "/secure"); 2590 2591 // Populated lazily, guarded by class object: 2592 private static final NameValueCache sNameValueCache = new NameValueCache( 2593 SYS_PROP_SETTING_VERSION, 2594 CONTENT_URI, 2595 CALL_METHOD_GET_SECURE, 2596 CALL_METHOD_PUT_SECURE); 2597 2598 private static ILockSettings sLockSettings = null; 2599 2600 private static boolean sIsSystemProcess; 2601 private static final HashSet<String> MOVED_TO_LOCK_SETTINGS; 2602 private static final HashSet<String> MOVED_TO_GLOBAL; 2603 static { 2604 MOVED_TO_LOCK_SETTINGS = new HashSet<String>(3); 2605 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_ENABLED); 2606 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_VISIBLE); 2607 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 2608 2609 MOVED_TO_GLOBAL = new HashSet<String>(); 2610 MOVED_TO_GLOBAL.add(Settings.Global.ADB_ENABLED); 2611 MOVED_TO_GLOBAL.add(Settings.Global.ASSISTED_GPS_ENABLED); 2612 MOVED_TO_GLOBAL.add(Settings.Global.BLUETOOTH_ON); 2613 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_CELL_BROADCAST_SMS); 2614 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_ROAMING_MODE); 2615 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_SUBSCRIPTION_MODE); 2616 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_MOBILE); 2617 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_WIFI); 2618 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ROAMING); 2619 MOVED_TO_GLOBAL.add(Settings.Global.DEVELOPMENT_SETTINGS_ENABLED); 2620 MOVED_TO_GLOBAL.add(Settings.Global.DEVICE_PROVISIONED); 2621 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_DENSITY_FORCED); 2622 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_SIZE_FORCED); 2623 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_MAX_BYTES_OVER_MOBILE); 2624 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE); 2625 MOVED_TO_GLOBAL.add(Settings.Global.INSTALL_NON_MARKET_APPS); 2626 MOVED_TO_GLOBAL.add(Settings.Global.MOBILE_DATA); 2627 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_BUCKET_DURATION); 2628 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_DELETE_AGE); 2629 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_PERSIST_BYTES); 2630 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_ROTATE_AGE); 2631 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_ENABLED); 2632 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_GLOBAL_ALERT_BYTES); 2633 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_POLL_INTERVAL); 2634 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_REPORT_XT_OVER_DEV); 2635 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_SAMPLE_ENABLED); 2636 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_TIME_CACHE_MAX_AGE); 2637 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_BUCKET_DURATION); 2638 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_DELETE_AGE); 2639 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_PERSIST_BYTES); 2640 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_ROTATE_AGE); 2641 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_BUCKET_DURATION); 2642 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_DELETE_AGE); 2643 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_PERSIST_BYTES); 2644 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_ROTATE_AGE); 2645 MOVED_TO_GLOBAL.add(Settings.Global.NETWORK_PREFERENCE); 2646 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_DIFF); 2647 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_SPACING); 2648 MOVED_TO_GLOBAL.add(Settings.Global.NTP_SERVER); 2649 MOVED_TO_GLOBAL.add(Settings.Global.NTP_TIMEOUT); 2650 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_ERROR_POLL_COUNT); 2651 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_LONG_POLL_INTERVAL_MS); 2652 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT); 2653 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_POLL_INTERVAL_MS); 2654 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_TRIGGER_PACKET_COUNT); 2655 MOVED_TO_GLOBAL.add(Settings.Global.SAMPLING_PROFILER_MS); 2656 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); 2657 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_REDIR_HOST); 2658 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_TARGET_URL); 2659 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_APN); 2660 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_REQUIRED); 2661 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_SUPPORTED); 2662 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_HELP_URI); 2663 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_MAX_NTP_CACHE_AGE_SEC); 2664 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_NOTIFICATION_TYPE); 2665 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_POLLING_SEC); 2666 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_RESET_DAY); 2667 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_THRESHOLD_BYTES); 2668 MOVED_TO_GLOBAL.add(Settings.Global.THROTTLE_VALUE_KBITSPS); 2669 MOVED_TO_GLOBAL.add(Settings.Global.USB_MASS_STORAGE_ENABLED); 2670 MOVED_TO_GLOBAL.add(Settings.Global.USE_GOOGLE_MAIL); 2671 MOVED_TO_GLOBAL.add(Settings.Global.WEB_AUTOFILL_QUERY_URL); 2672 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_COUNTRY_CODE); 2673 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FRAMEWORK_SCAN_INTERVAL_MS); 2674 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FREQUENCY_BAND); 2675 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_IDLE_MS); 2676 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT); 2677 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS); 2678 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 2679 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 2680 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NUM_OPEN_NETWORKS_KEPT); 2681 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_ON); 2682 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_P2P_DEVICE_NAME); 2683 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SAVED_STATE); 2684 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUPPLICANT_SCAN_INTERVAL_MS); 2685 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED); 2686 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_ON); 2687 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED); 2688 MOVED_TO_GLOBAL.add(Settings.Global.WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON); 2689 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_ENABLE); 2690 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_TIMEOUT); 2691 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE); 2692 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS); 2693 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS); 2694 MOVED_TO_GLOBAL.add(Settings.Global.GPRS_REGISTER_CHECK_PERIOD_MS); 2695 MOVED_TO_GLOBAL.add(Settings.Global.WTF_IS_FATAL); 2696 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD); 2697 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_THRESHOLD); 2698 MOVED_TO_GLOBAL.add(Settings.Global.SEND_ACTION_APP_ERROR); 2699 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_AGE_SECONDS); 2700 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_MAX_FILES); 2701 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_KB); 2702 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_PERCENT); 2703 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_RESERVE_PERCENT); 2704 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_TAG_PREFIX); 2705 MOVED_TO_GLOBAL.add(Settings.Global.ERROR_LOGCAT_PREFIX); 2706 MOVED_TO_GLOBAL.add(Settings.Global.SYS_FREE_STORAGE_LOG_INTERVAL); 2707 MOVED_TO_GLOBAL.add(Settings.Global.DISK_FREE_CHANGE_REPORTING_THRESHOLD); 2708 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_PERCENTAGE); 2709 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_MAX_BYTES); 2710 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_FULL_THRESHOLD_BYTES); 2711 MOVED_TO_GLOBAL.add(Settings.Global.SYNC_MAX_RETRY_DELAY_IN_SECONDS); 2712 MOVED_TO_GLOBAL.add(Settings.Global.CONNECTIVITY_CHANGE_DELAY); 2713 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_DETECTION_ENABLED); 2714 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_SERVER); 2715 MOVED_TO_GLOBAL.add(Settings.Global.NSD_ON); 2716 MOVED_TO_GLOBAL.add(Settings.Global.SET_INSTALL_LOCATION); 2717 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_INSTALL_LOCATION); 2718 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_UP_DELAY); 2719 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_DOWN_DELAY); 2720 MOVED_TO_GLOBAL.add(Settings.Global.READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT); 2721 MOVED_TO_GLOBAL.add(Settings.Global.HTTP_PROXY); 2722 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_HOST); 2723 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_PORT); 2724 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_EXCLUSION_LIST); 2725 MOVED_TO_GLOBAL.add(Settings.Global.SET_GLOBAL_HTTP_PROXY); 2726 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_DNS_SERVER); 2727 MOVED_TO_GLOBAL.add(Settings.Global.PREFERRED_NETWORK_MODE); 2728 MOVED_TO_GLOBAL.add(Settings.Global.PREFERRED_CDMA_SUBSCRIPTION); 2729 } 2730 2731 /** @hide */ getMovedKeys(HashSet<String> outKeySet)2732 public static void getMovedKeys(HashSet<String> outKeySet) { 2733 outKeySet.addAll(MOVED_TO_GLOBAL); 2734 } 2735 2736 /** 2737 * Look up a name in the database. 2738 * @param resolver to access the database with 2739 * @param name to look up in the table 2740 * @return the corresponding value, or null if not present 2741 */ getString(ContentResolver resolver, String name)2742 public static String getString(ContentResolver resolver, String name) { 2743 return getStringForUser(resolver, name, UserHandle.myUserId()); 2744 } 2745 2746 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)2747 public static String getStringForUser(ContentResolver resolver, String name, 2748 int userHandle) { 2749 if (MOVED_TO_GLOBAL.contains(name)) { 2750 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 2751 + " to android.provider.Settings.Global."); 2752 return Global.getStringForUser(resolver, name, userHandle); 2753 } 2754 2755 if (MOVED_TO_LOCK_SETTINGS.contains(name)) { 2756 synchronized (Secure.class) { 2757 if (sLockSettings == null) { 2758 sLockSettings = ILockSettings.Stub.asInterface( 2759 (IBinder) ServiceManager.getService("lock_settings")); 2760 sIsSystemProcess = Process.myUid() == Process.SYSTEM_UID; 2761 } 2762 } 2763 if (sLockSettings != null && !sIsSystemProcess) { 2764 try { 2765 return sLockSettings.getString(name, "0", userHandle); 2766 } catch (RemoteException re) { 2767 // Fall through 2768 } 2769 } 2770 } 2771 2772 return sNameValueCache.getStringForUser(resolver, name, userHandle); 2773 } 2774 2775 /** 2776 * Store a name/value pair into the database. 2777 * @param resolver to access the database with 2778 * @param name to store 2779 * @param value to associate with the name 2780 * @return true if the value was set, false on database errors 2781 */ putString(ContentResolver resolver, String name, String value)2782 public static boolean putString(ContentResolver resolver, String name, String value) { 2783 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 2784 } 2785 2786 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)2787 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 2788 int userHandle) { 2789 if (MOVED_TO_GLOBAL.contains(name)) { 2790 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 2791 + " to android.provider.Settings.Global"); 2792 return Global.putStringForUser(resolver, name, value, userHandle); 2793 } 2794 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 2795 } 2796 2797 /** 2798 * Construct the content URI for a particular name/value pair, 2799 * useful for monitoring changes with a ContentObserver. 2800 * @param name to look up in the table 2801 * @return the corresponding content URI, or null if not present 2802 */ getUriFor(String name)2803 public static Uri getUriFor(String name) { 2804 if (MOVED_TO_GLOBAL.contains(name)) { 2805 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 2806 + " to android.provider.Settings.Global, returning global URI."); 2807 return Global.getUriFor(Global.CONTENT_URI, name); 2808 } 2809 return getUriFor(CONTENT_URI, name); 2810 } 2811 2812 /** 2813 * Convenience function for retrieving a single secure settings value 2814 * as an integer. Note that internally setting values are always 2815 * stored as strings; this function converts the string to an integer 2816 * for you. The default value will be returned if the setting is 2817 * not defined or not an integer. 2818 * 2819 * @param cr The ContentResolver to access. 2820 * @param name The name of the setting to retrieve. 2821 * @param def Value to return if the setting is not defined. 2822 * 2823 * @return The setting's current value, or 'def' if it is not defined 2824 * or not a valid integer. 2825 */ getInt(ContentResolver cr, String name, int def)2826 public static int getInt(ContentResolver cr, String name, int def) { 2827 return getIntForUser(cr, name, def, UserHandle.myUserId()); 2828 } 2829 2830 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)2831 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 2832 String v = getStringForUser(cr, name, userHandle); 2833 try { 2834 return v != null ? Integer.parseInt(v) : def; 2835 } catch (NumberFormatException e) { 2836 return def; 2837 } 2838 } 2839 2840 /** 2841 * Convenience function for retrieving a single secure settings value 2842 * as an integer. Note that internally setting values are always 2843 * stored as strings; this function converts the string to an integer 2844 * for you. 2845 * <p> 2846 * This version does not take a default value. If the setting has not 2847 * been set, or the string value is not a number, 2848 * it throws {@link SettingNotFoundException}. 2849 * 2850 * @param cr The ContentResolver to access. 2851 * @param name The name of the setting to retrieve. 2852 * 2853 * @throws SettingNotFoundException Thrown if a setting by the given 2854 * name can't be found or the setting value is not an integer. 2855 * 2856 * @return The setting's current value. 2857 */ getInt(ContentResolver cr, String name)2858 public static int getInt(ContentResolver cr, String name) 2859 throws SettingNotFoundException { 2860 return getIntForUser(cr, name, UserHandle.myUserId()); 2861 } 2862 2863 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)2864 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 2865 throws SettingNotFoundException { 2866 String v = getStringForUser(cr, name, userHandle); 2867 try { 2868 return Integer.parseInt(v); 2869 } catch (NumberFormatException e) { 2870 throw new SettingNotFoundException(name); 2871 } 2872 } 2873 2874 /** 2875 * Convenience function for updating a single settings value as an 2876 * integer. This will either create a new entry in the table if the 2877 * given name does not exist, or modify the value of the existing row 2878 * with that name. Note that internally setting values are always 2879 * stored as strings, so this function converts the given value to a 2880 * string before storing it. 2881 * 2882 * @param cr The ContentResolver to access. 2883 * @param name The name of the setting to modify. 2884 * @param value The new value for the setting. 2885 * @return true if the value was set, false on database errors 2886 */ putInt(ContentResolver cr, String name, int value)2887 public static boolean putInt(ContentResolver cr, String name, int value) { 2888 return putIntForUser(cr, name, value, UserHandle.myUserId()); 2889 } 2890 2891 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)2892 public static boolean putIntForUser(ContentResolver cr, String name, int value, 2893 int userHandle) { 2894 return putStringForUser(cr, name, Integer.toString(value), userHandle); 2895 } 2896 2897 /** 2898 * Convenience function for retrieving a single secure settings value 2899 * as a {@code long}. Note that internally setting values are always 2900 * stored as strings; this function converts the string to a {@code long} 2901 * for you. The default value will be returned if the setting is 2902 * not defined or not a {@code long}. 2903 * 2904 * @param cr The ContentResolver to access. 2905 * @param name The name of the setting to retrieve. 2906 * @param def Value to return if the setting is not defined. 2907 * 2908 * @return The setting's current value, or 'def' if it is not defined 2909 * or not a valid {@code long}. 2910 */ getLong(ContentResolver cr, String name, long def)2911 public static long getLong(ContentResolver cr, String name, long def) { 2912 return getLongForUser(cr, name, def, UserHandle.myUserId()); 2913 } 2914 2915 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)2916 public static long getLongForUser(ContentResolver cr, String name, long def, 2917 int userHandle) { 2918 String valString = getStringForUser(cr, name, userHandle); 2919 long value; 2920 try { 2921 value = valString != null ? Long.parseLong(valString) : def; 2922 } catch (NumberFormatException e) { 2923 value = def; 2924 } 2925 return value; 2926 } 2927 2928 /** 2929 * Convenience function for retrieving a single secure settings value 2930 * as a {@code long}. Note that internally setting values are always 2931 * stored as strings; this function converts the string to a {@code long} 2932 * for you. 2933 * <p> 2934 * This version does not take a default value. If the setting has not 2935 * been set, or the string value is not a number, 2936 * it throws {@link SettingNotFoundException}. 2937 * 2938 * @param cr The ContentResolver to access. 2939 * @param name The name of the setting to retrieve. 2940 * 2941 * @return The setting's current value. 2942 * @throws SettingNotFoundException Thrown if a setting by the given 2943 * name can't be found or the setting value is not an integer. 2944 */ getLong(ContentResolver cr, String name)2945 public static long getLong(ContentResolver cr, String name) 2946 throws SettingNotFoundException { 2947 return getLongForUser(cr, name, UserHandle.myUserId()); 2948 } 2949 2950 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)2951 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 2952 throws SettingNotFoundException { 2953 String valString = getStringForUser(cr, name, userHandle); 2954 try { 2955 return Long.parseLong(valString); 2956 } catch (NumberFormatException e) { 2957 throw new SettingNotFoundException(name); 2958 } 2959 } 2960 2961 /** 2962 * Convenience function for updating a secure settings value as a long 2963 * integer. This will either create a new entry in the table if the 2964 * given name does not exist, or modify the value of the existing row 2965 * with that name. Note that internally setting values are always 2966 * stored as strings, so this function converts the given value to a 2967 * string before storing it. 2968 * 2969 * @param cr The ContentResolver to access. 2970 * @param name The name of the setting to modify. 2971 * @param value The new value for the setting. 2972 * @return true if the value was set, false on database errors 2973 */ putLong(ContentResolver cr, String name, long value)2974 public static boolean putLong(ContentResolver cr, String name, long value) { 2975 return putLongForUser(cr, name, value, UserHandle.myUserId()); 2976 } 2977 2978 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)2979 public static boolean putLongForUser(ContentResolver cr, String name, long value, 2980 int userHandle) { 2981 return putStringForUser(cr, name, Long.toString(value), userHandle); 2982 } 2983 2984 /** 2985 * Convenience function for retrieving a single secure settings value 2986 * as a floating point number. Note that internally setting values are 2987 * always stored as strings; this function converts the string to an 2988 * float for you. The default value will be returned if the setting 2989 * is not defined or not a valid float. 2990 * 2991 * @param cr The ContentResolver to access. 2992 * @param name The name of the setting to retrieve. 2993 * @param def Value to return if the setting is not defined. 2994 * 2995 * @return The setting's current value, or 'def' if it is not defined 2996 * or not a valid float. 2997 */ getFloat(ContentResolver cr, String name, float def)2998 public static float getFloat(ContentResolver cr, String name, float def) { 2999 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 3000 } 3001 3002 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)3003 public static float getFloatForUser(ContentResolver cr, String name, float def, 3004 int userHandle) { 3005 String v = getStringForUser(cr, name, userHandle); 3006 try { 3007 return v != null ? Float.parseFloat(v) : def; 3008 } catch (NumberFormatException e) { 3009 return def; 3010 } 3011 } 3012 3013 /** 3014 * Convenience function for retrieving a single secure settings value 3015 * as a float. Note that internally setting values are always 3016 * stored as strings; this function converts the string to a float 3017 * for you. 3018 * <p> 3019 * This version does not take a default value. If the setting has not 3020 * been set, or the string value is not a number, 3021 * it throws {@link SettingNotFoundException}. 3022 * 3023 * @param cr The ContentResolver to access. 3024 * @param name The name of the setting to retrieve. 3025 * 3026 * @throws SettingNotFoundException Thrown if a setting by the given 3027 * name can't be found or the setting value is not a float. 3028 * 3029 * @return The setting's current value. 3030 */ getFloat(ContentResolver cr, String name)3031 public static float getFloat(ContentResolver cr, String name) 3032 throws SettingNotFoundException { 3033 return getFloatForUser(cr, name, UserHandle.myUserId()); 3034 } 3035 3036 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)3037 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 3038 throws SettingNotFoundException { 3039 String v = getStringForUser(cr, name, userHandle); 3040 if (v == null) { 3041 throw new SettingNotFoundException(name); 3042 } 3043 try { 3044 return Float.parseFloat(v); 3045 } catch (NumberFormatException e) { 3046 throw new SettingNotFoundException(name); 3047 } 3048 } 3049 3050 /** 3051 * Convenience function for updating a single settings value as a 3052 * floating point number. This will either create a new entry in the 3053 * table if the given name does not exist, or modify the value of the 3054 * existing row with that name. Note that internally setting values 3055 * are always stored as strings, so this function converts the given 3056 * value to a string before storing it. 3057 * 3058 * @param cr The ContentResolver to access. 3059 * @param name The name of the setting to modify. 3060 * @param value The new value for the setting. 3061 * @return true if the value was set, false on database errors 3062 */ putFloat(ContentResolver cr, String name, float value)3063 public static boolean putFloat(ContentResolver cr, String name, float value) { 3064 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 3065 } 3066 3067 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)3068 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 3069 int userHandle) { 3070 return putStringForUser(cr, name, Float.toString(value), userHandle); 3071 } 3072 3073 /** 3074 * @deprecated Use {@link android.provider.Settings.Global#DEVELOPMENT_SETTINGS_ENABLED} 3075 * instead 3076 */ 3077 @Deprecated 3078 public static final String DEVELOPMENT_SETTINGS_ENABLED = 3079 Global.DEVELOPMENT_SETTINGS_ENABLED; 3080 3081 /** 3082 * When the user has enable the option to have a "bug report" command 3083 * in the power menu. 3084 * @hide 3085 */ 3086 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 3087 3088 /** 3089 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} instead 3090 */ 3091 @Deprecated 3092 public static final String ADB_ENABLED = Global.ADB_ENABLED; 3093 3094 /** 3095 * Setting to allow mock locations and location provider status to be injected into the 3096 * LocationManager service for testing purposes during application development. These 3097 * locations and status values override actual location and status information generated 3098 * by network, gps, or other location providers. 3099 */ 3100 public static final String ALLOW_MOCK_LOCATION = "mock_location"; 3101 3102 /** 3103 * A 64-bit number (as a hex string) that is randomly 3104 * generated on the device's first boot and should remain 3105 * constant for the lifetime of the device. (The value may 3106 * change if a factory reset is performed on the device.) 3107 */ 3108 public static final String ANDROID_ID = "android_id"; 3109 3110 /** 3111 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 3112 */ 3113 @Deprecated 3114 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 3115 3116 /** 3117 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 3118 */ 3119 @Deprecated 3120 public static final String DATA_ROAMING = Global.DATA_ROAMING; 3121 3122 /** 3123 * Setting to record the input method used by default, holding the ID 3124 * of the desired method. 3125 */ 3126 public static final String DEFAULT_INPUT_METHOD = "default_input_method"; 3127 3128 /** 3129 * Setting to record the input method subtype used by default, holding the ID 3130 * of the desired method. 3131 */ 3132 public static final String SELECTED_INPUT_METHOD_SUBTYPE = 3133 "selected_input_method_subtype"; 3134 3135 /** 3136 * Setting to record the history of input method subtype, holding the pair of ID of IME 3137 * and its last used subtype. 3138 * @hide 3139 */ 3140 public static final String INPUT_METHODS_SUBTYPE_HISTORY = 3141 "input_methods_subtype_history"; 3142 3143 /** 3144 * Setting to record the visibility of input method selector 3145 */ 3146 public static final String INPUT_METHOD_SELECTOR_VISIBILITY = 3147 "input_method_selector_visibility"; 3148 3149 /** 3150 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 3151 */ 3152 @Deprecated 3153 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 3154 3155 /** 3156 * Whether the current user has been set up via setup wizard (0 = false, 1 = true) 3157 * @hide 3158 */ 3159 public static final String USER_SETUP_COMPLETE = "user_setup_complete"; 3160 3161 /** 3162 * List of input methods that are currently enabled. This is a string 3163 * containing the IDs of all enabled input methods, each ID separated 3164 * by ':'. 3165 */ 3166 public static final String ENABLED_INPUT_METHODS = "enabled_input_methods"; 3167 3168 /** 3169 * List of system input methods that are currently disabled. This is a string 3170 * containing the IDs of all disabled input methods, each ID separated 3171 * by ':'. 3172 * @hide 3173 */ 3174 public static final String DISABLED_SYSTEM_INPUT_METHODS = "disabled_system_input_methods"; 3175 3176 /** 3177 * Host name and port for global http proxy. Uses ':' seperator for 3178 * between host and port. 3179 * 3180 * @deprecated Use {@link Global#HTTP_PROXY} 3181 */ 3182 @Deprecated 3183 public static final String HTTP_PROXY = Global.HTTP_PROXY; 3184 3185 /** 3186 * @deprecated Use {@link android.provider.Settings.Global#INSTALL_NON_MARKET_APPS} instead 3187 */ 3188 @Deprecated 3189 public static final String INSTALL_NON_MARKET_APPS = Global.INSTALL_NON_MARKET_APPS; 3190 3191 /** 3192 * Comma-separated list of location providers that activities may access. 3193 */ 3194 public static final String LOCATION_PROVIDERS_ALLOWED = "location_providers_allowed"; 3195 3196 /** 3197 * A flag containing settings used for biometric weak 3198 * @hide 3199 */ 3200 public static final String LOCK_BIOMETRIC_WEAK_FLAGS = 3201 "lock_biometric_weak_flags"; 3202 3203 /** 3204 * Whether autolock is enabled (0 = false, 1 = true) 3205 */ 3206 public static final String LOCK_PATTERN_ENABLED = "lock_pattern_autolock"; 3207 3208 /** 3209 * Whether lock pattern is visible as user enters (0 = false, 1 = true) 3210 */ 3211 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 3212 3213 /** 3214 * Whether lock pattern will vibrate as user enters (0 = false, 1 = 3215 * true) 3216 * 3217 * @deprecated Starting in {@link VERSION_CODES#JELLY_BEAN_MR1} the 3218 * lockscreen uses 3219 * {@link Settings.System#HAPTIC_FEEDBACK_ENABLED}. 3220 */ 3221 @Deprecated 3222 public static final String 3223 LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = "lock_pattern_tactile_feedback_enabled"; 3224 3225 /** 3226 * This preference allows the device to be locked given time after screen goes off, 3227 * subject to current DeviceAdmin policy limits. 3228 * @hide 3229 */ 3230 public static final String LOCK_SCREEN_LOCK_AFTER_TIMEOUT = "lock_screen_lock_after_timeout"; 3231 3232 3233 /** 3234 * This preference contains the string that shows for owner info on LockScreen. 3235 * @hide 3236 */ 3237 public static final String LOCK_SCREEN_OWNER_INFO = "lock_screen_owner_info"; 3238 3239 /** 3240 * Ids of the user-selected appwidgets on the lockscreen (comma-delimited). 3241 * @hide 3242 */ 3243 public static final String LOCK_SCREEN_APPWIDGET_IDS = 3244 "lock_screen_appwidget_ids"; 3245 3246 /** 3247 * Id of the appwidget shown on the lock screen when appwidgets are disabled. 3248 * @hide 3249 */ 3250 public static final String LOCK_SCREEN_FALLBACK_APPWIDGET_ID = 3251 "lock_screen_fallback_appwidget_id"; 3252 3253 /** 3254 * Index of the lockscreen appwidget to restore, -1 if none. 3255 * @hide 3256 */ 3257 public static final String LOCK_SCREEN_STICKY_APPWIDGET = 3258 "lock_screen_sticky_appwidget"; 3259 3260 /** 3261 * This preference enables showing the owner info on LockScreen. 3262 * @hide 3263 */ 3264 public static final String LOCK_SCREEN_OWNER_INFO_ENABLED = 3265 "lock_screen_owner_info_enabled"; 3266 3267 /** 3268 * The Logging ID (a unique 64-bit value) as a hex string. 3269 * Used as a pseudonymous identifier for logging. 3270 * @deprecated This identifier is poorly initialized and has 3271 * many collisions. It should not be used. 3272 */ 3273 @Deprecated 3274 public static final String LOGGING_ID = "logging_id"; 3275 3276 /** 3277 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 3278 */ 3279 @Deprecated 3280 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 3281 3282 /** 3283 * No longer supported. 3284 */ 3285 public static final String PARENTAL_CONTROL_ENABLED = "parental_control_enabled"; 3286 3287 /** 3288 * No longer supported. 3289 */ 3290 public static final String PARENTAL_CONTROL_LAST_UPDATE = "parental_control_last_update"; 3291 3292 /** 3293 * No longer supported. 3294 */ 3295 public static final String PARENTAL_CONTROL_REDIRECT_URL = "parental_control_redirect_url"; 3296 3297 /** 3298 * Settings classname to launch when Settings is clicked from All 3299 * Applications. Needed because of user testing between the old 3300 * and new Settings apps. 3301 */ 3302 // TODO: 881807 3303 public static final String SETTINGS_CLASSNAME = "settings_classname"; 3304 3305 /** 3306 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 3307 */ 3308 @Deprecated 3309 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 3310 3311 /** 3312 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 3313 */ 3314 @Deprecated 3315 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 3316 3317 /** 3318 * If accessibility is enabled. 3319 */ 3320 public static final String ACCESSIBILITY_ENABLED = "accessibility_enabled"; 3321 3322 /** 3323 * If touch exploration is enabled. 3324 */ 3325 public static final String TOUCH_EXPLORATION_ENABLED = "touch_exploration_enabled"; 3326 3327 /** 3328 * List of the enabled accessibility providers. 3329 */ 3330 public static final String ENABLED_ACCESSIBILITY_SERVICES = 3331 "enabled_accessibility_services"; 3332 3333 /** 3334 * List of the accessibility services to which the user has granted 3335 * permission to put the device into touch exploration mode. 3336 * 3337 * @hide 3338 */ 3339 public static final String TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES = 3340 "touch_exploration_granted_accessibility_services"; 3341 3342 /** 3343 * Whether to speak passwords while in accessibility mode. 3344 */ 3345 public static final String ACCESSIBILITY_SPEAK_PASSWORD = "speak_password"; 3346 3347 /** 3348 * If injection of accessibility enhancing JavaScript screen-reader 3349 * is enabled. 3350 * <p> 3351 * Note: The JavaScript based screen-reader is served by the 3352 * Google infrastructure and enable users with disabilities to 3353 * efficiently navigate in and explore web content. 3354 * </p> 3355 * <p> 3356 * This property represents a boolean value. 3357 * </p> 3358 * @hide 3359 */ 3360 public static final String ACCESSIBILITY_SCRIPT_INJECTION = 3361 "accessibility_script_injection"; 3362 3363 /** 3364 * The URL for the injected JavaScript based screen-reader used 3365 * for providing accessibility of content in WebView. 3366 * <p> 3367 * Note: The JavaScript based screen-reader is served by the 3368 * Google infrastructure and enable users with disabilities to 3369 * efficiently navigate in and explore web content. 3370 * </p> 3371 * <p> 3372 * This property represents a string value. 3373 * </p> 3374 * @hide 3375 */ 3376 public static final String ACCESSIBILITY_SCREEN_READER_URL = 3377 "accessibility_script_injection_url"; 3378 3379 /** 3380 * Key bindings for navigation in built-in accessibility support for web content. 3381 * <p> 3382 * Note: These key bindings are for the built-in accessibility navigation for 3383 * web content which is used as a fall back solution if JavaScript in a WebView 3384 * is not enabled or the user has not opted-in script injection from Google. 3385 * </p> 3386 * <p> 3387 * The bindings are separated by semi-colon. A binding is a mapping from 3388 * a key to a sequence of actions (for more details look at 3389 * android.webkit.AccessibilityInjector). A key is represented as the hexademical 3390 * string representation of an integer obtained from a meta state (optional) shifted 3391 * sixteen times left and bitwise ored with a key code. An action is represented 3392 * as a hexademical string representation of an integer where the first two digits 3393 * are navigation action index, the second, the third, and the fourth digit pairs 3394 * represent the action arguments. The separate actions in a binding are colon 3395 * separated. The key and the action sequence it maps to are separated by equals. 3396 * </p> 3397 * <p> 3398 * For example, the binding below maps the DPAD right button to traverse the 3399 * current navigation axis once without firing an accessibility event and to 3400 * perform the same traversal again but to fire an event: 3401 * <code> 3402 * 0x16=0x01000100:0x01000101; 3403 * </code> 3404 * </p> 3405 * <p> 3406 * The goal of this binding is to enable dynamic rebinding of keys to 3407 * navigation actions for web content without requiring a framework change. 3408 * </p> 3409 * <p> 3410 * This property represents a string value. 3411 * </p> 3412 * @hide 3413 */ 3414 public static final String ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS = 3415 "accessibility_web_content_key_bindings"; 3416 3417 /** 3418 * Setting that specifies whether the display magnification is enabled. 3419 * Display magnifications allows the user to zoom in the display content 3420 * and is targeted to low vision users. The current magnification scale 3421 * is controlled by {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE}. 3422 * 3423 * @hide 3424 */ 3425 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED = 3426 "accessibility_display_magnification_enabled"; 3427 3428 /** 3429 * Setting that specifies what the display magnification scale is. 3430 * Display magnifications allows the user to zoom in the display 3431 * content and is targeted to low vision users. Whether a display 3432 * magnification is performed is controlled by 3433 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 3434 * 3435 * @hide 3436 */ 3437 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE = 3438 "accessibility_display_magnification_scale"; 3439 3440 /** 3441 * Setting that specifies whether the display magnification should be 3442 * automatically updated. If this fearture is enabled the system will 3443 * exit magnification mode or pan the viewport when a context change 3444 * occurs. For example, on staring a new activity or rotating the screen, 3445 * the system may zoom out so the user can see the new context he is in. 3446 * Another example is on showing a window that is not visible in the 3447 * magnified viewport the system may pan the viewport to make the window 3448 * the has popped up so the user knows that the context has changed. 3449 * Whether a screen magnification is performed is controlled by 3450 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 3451 * 3452 * @hide 3453 */ 3454 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE = 3455 "accessibility_display_magnification_auto_update"; 3456 3457 /** 3458 * The timout for considering a press to be a long press in milliseconds. 3459 * @hide 3460 */ 3461 public static final String LONG_PRESS_TIMEOUT = "long_press_timeout"; 3462 3463 /** 3464 * Setting to always use the default text-to-speech settings regardless 3465 * of the application settings. 3466 * 1 = override application settings, 3467 * 0 = use application settings (if specified). 3468 * 3469 * @deprecated The value of this setting is no longer respected by 3470 * the framework text to speech APIs as of the Ice Cream Sandwich release. 3471 */ 3472 @Deprecated 3473 public static final String TTS_USE_DEFAULTS = "tts_use_defaults"; 3474 3475 /** 3476 * Default text-to-speech engine speech rate. 100 = 1x 3477 */ 3478 public static final String TTS_DEFAULT_RATE = "tts_default_rate"; 3479 3480 /** 3481 * Default text-to-speech engine pitch. 100 = 1x 3482 */ 3483 public static final String TTS_DEFAULT_PITCH = "tts_default_pitch"; 3484 3485 /** 3486 * Default text-to-speech engine. 3487 */ 3488 public static final String TTS_DEFAULT_SYNTH = "tts_default_synth"; 3489 3490 /** 3491 * Default text-to-speech language. 3492 * 3493 * @deprecated this setting is no longer in use, as of the Ice Cream 3494 * Sandwich release. Apps should never need to read this setting directly, 3495 * instead can query the TextToSpeech framework classes for the default 3496 * locale. {@link TextToSpeech#getLanguage()}. 3497 */ 3498 @Deprecated 3499 public static final String TTS_DEFAULT_LANG = "tts_default_lang"; 3500 3501 /** 3502 * Default text-to-speech country. 3503 * 3504 * @deprecated this setting is no longer in use, as of the Ice Cream 3505 * Sandwich release. Apps should never need to read this setting directly, 3506 * instead can query the TextToSpeech framework classes for the default 3507 * locale. {@link TextToSpeech#getLanguage()}. 3508 */ 3509 @Deprecated 3510 public static final String TTS_DEFAULT_COUNTRY = "tts_default_country"; 3511 3512 /** 3513 * Default text-to-speech locale variant. 3514 * 3515 * @deprecated this setting is no longer in use, as of the Ice Cream 3516 * Sandwich release. Apps should never need to read this setting directly, 3517 * instead can query the TextToSpeech framework classes for the 3518 * locale that is in use {@link TextToSpeech#getLanguage()}. 3519 */ 3520 @Deprecated 3521 public static final String TTS_DEFAULT_VARIANT = "tts_default_variant"; 3522 3523 /** 3524 * Stores the default tts locales on a per engine basis. Stored as 3525 * a comma seperated list of values, each value being of the form 3526 * {@code engine_name:locale} for example, 3527 * {@code com.foo.ttsengine:eng-USA,com.bar.ttsengine:esp-ESP}. This 3528 * supersedes {@link #TTS_DEFAULT_LANG}, {@link #TTS_DEFAULT_COUNTRY} and 3529 * {@link #TTS_DEFAULT_VARIANT}. Apps should never need to read this 3530 * setting directly, and can query the TextToSpeech framework classes 3531 * for the locale that is in use. 3532 * 3533 * @hide 3534 */ 3535 public static final String TTS_DEFAULT_LOCALE = "tts_default_locale"; 3536 3537 /** 3538 * Space delimited list of plugin packages that are enabled. 3539 */ 3540 public static final String TTS_ENABLED_PLUGINS = "tts_enabled_plugins"; 3541 3542 /** 3543 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} 3544 * instead. 3545 */ 3546 @Deprecated 3547 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 3548 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 3549 3550 /** 3551 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} 3552 * instead. 3553 */ 3554 @Deprecated 3555 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 3556 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 3557 3558 /** 3559 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 3560 * instead. 3561 */ 3562 @Deprecated 3563 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = 3564 Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 3565 3566 /** 3567 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} 3568 * instead. 3569 */ 3570 @Deprecated 3571 public static final String WIFI_ON = Global.WIFI_ON; 3572 3573 /** 3574 * The acceptable packet loss percentage (range 0 - 100) before trying 3575 * another AP on the same network. 3576 * @deprecated This setting is not used. 3577 */ 3578 @Deprecated 3579 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 3580 "wifi_watchdog_acceptable_packet_loss_percentage"; 3581 3582 /** 3583 * The number of access points required for a network in order for the 3584 * watchdog to monitor it. 3585 * @deprecated This setting is not used. 3586 */ 3587 @Deprecated 3588 public static final String WIFI_WATCHDOG_AP_COUNT = "wifi_watchdog_ap_count"; 3589 3590 /** 3591 * The delay between background checks. 3592 * @deprecated This setting is not used. 3593 */ 3594 @Deprecated 3595 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 3596 "wifi_watchdog_background_check_delay_ms"; 3597 3598 /** 3599 * Whether the Wi-Fi watchdog is enabled for background checking even 3600 * after it thinks the user has connected to a good access point. 3601 * @deprecated This setting is not used. 3602 */ 3603 @Deprecated 3604 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 3605 "wifi_watchdog_background_check_enabled"; 3606 3607 /** 3608 * The timeout for a background ping 3609 * @deprecated This setting is not used. 3610 */ 3611 @Deprecated 3612 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 3613 "wifi_watchdog_background_check_timeout_ms"; 3614 3615 /** 3616 * The number of initial pings to perform that *may* be ignored if they 3617 * fail. Again, if these fail, they will *not* be used in packet loss 3618 * calculation. For example, one network always seemed to time out for 3619 * the first couple pings, so this is set to 3 by default. 3620 * @deprecated This setting is not used. 3621 */ 3622 @Deprecated 3623 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 3624 "wifi_watchdog_initial_ignored_ping_count"; 3625 3626 /** 3627 * The maximum number of access points (per network) to attempt to test. 3628 * If this number is reached, the watchdog will no longer monitor the 3629 * initial connection state for the network. This is a safeguard for 3630 * networks containing multiple APs whose DNS does not respond to pings. 3631 * @deprecated This setting is not used. 3632 */ 3633 @Deprecated 3634 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = "wifi_watchdog_max_ap_checks"; 3635 3636 /** 3637 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 3638 */ 3639 @Deprecated 3640 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 3641 3642 /** 3643 * A comma-separated list of SSIDs for which the Wi-Fi watchdog should be enabled. 3644 * @deprecated This setting is not used. 3645 */ 3646 @Deprecated 3647 public static final String WIFI_WATCHDOG_WATCH_LIST = "wifi_watchdog_watch_list"; 3648 3649 /** 3650 * The number of pings to test if an access point is a good connection. 3651 * @deprecated This setting is not used. 3652 */ 3653 @Deprecated 3654 public static final String WIFI_WATCHDOG_PING_COUNT = "wifi_watchdog_ping_count"; 3655 3656 /** 3657 * The delay between pings. 3658 * @deprecated This setting is not used. 3659 */ 3660 @Deprecated 3661 public static final String WIFI_WATCHDOG_PING_DELAY_MS = "wifi_watchdog_ping_delay_ms"; 3662 3663 /** 3664 * The timeout per ping. 3665 * @deprecated This setting is not used. 3666 */ 3667 @Deprecated 3668 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = "wifi_watchdog_ping_timeout_ms"; 3669 3670 /** 3671 * @deprecated Use 3672 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 3673 */ 3674 @Deprecated 3675 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 3676 3677 /** 3678 * @deprecated Use 3679 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 3680 */ 3681 @Deprecated 3682 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 3683 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 3684 3685 /** 3686 * Whether background data usage is allowed. 3687 * 3688 * @deprecated As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, 3689 * availability of background data depends on several 3690 * combined factors. When background data is unavailable, 3691 * {@link ConnectivityManager#getActiveNetworkInfo()} will 3692 * now appear disconnected. 3693 */ 3694 @Deprecated 3695 public static final String BACKGROUND_DATA = "background_data"; 3696 3697 /** 3698 * Origins for which browsers should allow geolocation by default. 3699 * The value is a space-separated list of origins. 3700 */ 3701 public static final String ALLOWED_GEOLOCATION_ORIGINS 3702 = "allowed_geolocation_origins"; 3703 3704 /** 3705 * The preferred TTY mode 0 = TTy Off, CDMA default 3706 * 1 = TTY Full 3707 * 2 = TTY HCO 3708 * 3 = TTY VCO 3709 * @hide 3710 */ 3711 public static final String PREFERRED_TTY_MODE = 3712 "preferred_tty_mode"; 3713 3714 /** 3715 * Whether the enhanced voice privacy mode is enabled. 3716 * 0 = normal voice privacy 3717 * 1 = enhanced voice privacy 3718 * @hide 3719 */ 3720 public static final String ENHANCED_VOICE_PRIVACY_ENABLED = "enhanced_voice_privacy_enabled"; 3721 3722 /** 3723 * Whether the TTY mode mode is enabled. 3724 * 0 = disabled 3725 * 1 = enabled 3726 * @hide 3727 */ 3728 public static final String TTY_MODE_ENABLED = "tty_mode_enabled"; 3729 3730 /** 3731 * Controls whether settings backup is enabled. 3732 * Type: int ( 0 = disabled, 1 = enabled ) 3733 * @hide 3734 */ 3735 public static final String BACKUP_ENABLED = "backup_enabled"; 3736 3737 /** 3738 * Controls whether application data is automatically restored from backup 3739 * at install time. 3740 * Type: int ( 0 = disabled, 1 = enabled ) 3741 * @hide 3742 */ 3743 public static final String BACKUP_AUTO_RESTORE = "backup_auto_restore"; 3744 3745 /** 3746 * Indicates whether settings backup has been fully provisioned. 3747 * Type: int ( 0 = unprovisioned, 1 = fully provisioned ) 3748 * @hide 3749 */ 3750 public static final String BACKUP_PROVISIONED = "backup_provisioned"; 3751 3752 /** 3753 * Component of the transport to use for backup/restore. 3754 * @hide 3755 */ 3756 public static final String BACKUP_TRANSPORT = "backup_transport"; 3757 3758 /** 3759 * Version for which the setup wizard was last shown. Bumped for 3760 * each release when there is new setup information to show. 3761 * @hide 3762 */ 3763 public static final String LAST_SETUP_SHOWN = "last_setup_shown"; 3764 3765 /** 3766 * The interval in milliseconds after which Wi-Fi is considered idle. 3767 * When idle, it is possible for the device to be switched from Wi-Fi to 3768 * the mobile data network. 3769 * @hide 3770 * @deprecated Use {@link android.provider.Settings.Global#WIFI_IDLE_MS} 3771 * instead. 3772 */ 3773 @Deprecated 3774 public static final String WIFI_IDLE_MS = Global.WIFI_IDLE_MS; 3775 3776 /** 3777 * The global search provider chosen by the user (if multiple global 3778 * search providers are installed). This will be the provider returned 3779 * by {@link SearchManager#getGlobalSearchActivity()} if it's still 3780 * installed. This setting is stored as a flattened component name as 3781 * per {@link ComponentName#flattenToString()}. 3782 * 3783 * @hide 3784 */ 3785 public static final String SEARCH_GLOBAL_SEARCH_ACTIVITY = 3786 "search_global_search_activity"; 3787 3788 /** 3789 * The number of promoted sources in GlobalSearch. 3790 * @hide 3791 */ 3792 public static final String SEARCH_NUM_PROMOTED_SOURCES = "search_num_promoted_sources"; 3793 /** 3794 * The maximum number of suggestions returned by GlobalSearch. 3795 * @hide 3796 */ 3797 public static final String SEARCH_MAX_RESULTS_TO_DISPLAY = "search_max_results_to_display"; 3798 /** 3799 * The number of suggestions GlobalSearch will ask each non-web search source for. 3800 * @hide 3801 */ 3802 public static final String SEARCH_MAX_RESULTS_PER_SOURCE = "search_max_results_per_source"; 3803 /** 3804 * The number of suggestions the GlobalSearch will ask the web search source for. 3805 * @hide 3806 */ 3807 public static final String SEARCH_WEB_RESULTS_OVERRIDE_LIMIT = 3808 "search_web_results_override_limit"; 3809 /** 3810 * The number of milliseconds that GlobalSearch will wait for suggestions from 3811 * promoted sources before continuing with all other sources. 3812 * @hide 3813 */ 3814 public static final String SEARCH_PROMOTED_SOURCE_DEADLINE_MILLIS = 3815 "search_promoted_source_deadline_millis"; 3816 /** 3817 * The number of milliseconds before GlobalSearch aborts search suggesiton queries. 3818 * @hide 3819 */ 3820 public static final String SEARCH_SOURCE_TIMEOUT_MILLIS = "search_source_timeout_millis"; 3821 /** 3822 * The maximum number of milliseconds that GlobalSearch shows the previous results 3823 * after receiving a new query. 3824 * @hide 3825 */ 3826 public static final String SEARCH_PREFILL_MILLIS = "search_prefill_millis"; 3827 /** 3828 * The maximum age of log data used for shortcuts in GlobalSearch. 3829 * @hide 3830 */ 3831 public static final String SEARCH_MAX_STAT_AGE_MILLIS = "search_max_stat_age_millis"; 3832 /** 3833 * The maximum age of log data used for source ranking in GlobalSearch. 3834 * @hide 3835 */ 3836 public static final String SEARCH_MAX_SOURCE_EVENT_AGE_MILLIS = 3837 "search_max_source_event_age_millis"; 3838 /** 3839 * The minimum number of impressions needed to rank a source in GlobalSearch. 3840 * @hide 3841 */ 3842 public static final String SEARCH_MIN_IMPRESSIONS_FOR_SOURCE_RANKING = 3843 "search_min_impressions_for_source_ranking"; 3844 /** 3845 * The minimum number of clicks needed to rank a source in GlobalSearch. 3846 * @hide 3847 */ 3848 public static final String SEARCH_MIN_CLICKS_FOR_SOURCE_RANKING = 3849 "search_min_clicks_for_source_ranking"; 3850 /** 3851 * The maximum number of shortcuts shown by GlobalSearch. 3852 * @hide 3853 */ 3854 public static final String SEARCH_MAX_SHORTCUTS_RETURNED = "search_max_shortcuts_returned"; 3855 /** 3856 * The size of the core thread pool for suggestion queries in GlobalSearch. 3857 * @hide 3858 */ 3859 public static final String SEARCH_QUERY_THREAD_CORE_POOL_SIZE = 3860 "search_query_thread_core_pool_size"; 3861 /** 3862 * The maximum size of the thread pool for suggestion queries in GlobalSearch. 3863 * @hide 3864 */ 3865 public static final String SEARCH_QUERY_THREAD_MAX_POOL_SIZE = 3866 "search_query_thread_max_pool_size"; 3867 /** 3868 * The size of the core thread pool for shortcut refreshing in GlobalSearch. 3869 * @hide 3870 */ 3871 public static final String SEARCH_SHORTCUT_REFRESH_CORE_POOL_SIZE = 3872 "search_shortcut_refresh_core_pool_size"; 3873 /** 3874 * The maximum size of the thread pool for shortcut refreshing in GlobalSearch. 3875 * @hide 3876 */ 3877 public static final String SEARCH_SHORTCUT_REFRESH_MAX_POOL_SIZE = 3878 "search_shortcut_refresh_max_pool_size"; 3879 /** 3880 * The maximun time that excess threads in the GlobalSeach thread pools will 3881 * wait before terminating. 3882 * @hide 3883 */ 3884 public static final String SEARCH_THREAD_KEEPALIVE_SECONDS = 3885 "search_thread_keepalive_seconds"; 3886 /** 3887 * The maximum number of concurrent suggestion queries to each source. 3888 * @hide 3889 */ 3890 public static final String SEARCH_PER_SOURCE_CONCURRENT_QUERY_LIMIT = 3891 "search_per_source_concurrent_query_limit"; 3892 3893 /** 3894 * Whether or not alert sounds are played on MountService events. (0 = false, 1 = true) 3895 * @hide 3896 */ 3897 public static final String MOUNT_PLAY_NOTIFICATION_SND = "mount_play_not_snd"; 3898 3899 /** 3900 * Whether or not UMS auto-starts on UMS host detection. (0 = false, 1 = true) 3901 * @hide 3902 */ 3903 public static final String MOUNT_UMS_AUTOSTART = "mount_ums_autostart"; 3904 3905 /** 3906 * Whether or not a notification is displayed on UMS host detection. (0 = false, 1 = true) 3907 * @hide 3908 */ 3909 public static final String MOUNT_UMS_PROMPT = "mount_ums_prompt"; 3910 3911 /** 3912 * Whether or not a notification is displayed while UMS is enabled. (0 = false, 1 = true) 3913 * @hide 3914 */ 3915 public static final String MOUNT_UMS_NOTIFY_ENABLED = "mount_ums_notify_enabled"; 3916 3917 /** 3918 * If nonzero, ANRs in invisible background processes bring up a dialog. 3919 * Otherwise, the process will be silently killed. 3920 * @hide 3921 */ 3922 public static final String ANR_SHOW_BACKGROUND = "anr_show_background"; 3923 3924 /** 3925 * The {@link ComponentName} string of the service to be used as the voice recognition 3926 * service. 3927 * 3928 * @hide 3929 */ 3930 public static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service"; 3931 3932 3933 /** 3934 * The {@link ComponentName} string of the selected spell checker service which is 3935 * one of the services managed by the text service manager. 3936 * 3937 * @hide 3938 */ 3939 public static final String SELECTED_SPELL_CHECKER = "selected_spell_checker"; 3940 3941 /** 3942 * The {@link ComponentName} string of the selected subtype of the selected spell checker 3943 * service which is one of the services managed by the text service manager. 3944 * 3945 * @hide 3946 */ 3947 public static final String SELECTED_SPELL_CHECKER_SUBTYPE = 3948 "selected_spell_checker_subtype"; 3949 3950 /** 3951 * The {@link ComponentName} string whether spell checker is enabled or not. 3952 * 3953 * @hide 3954 */ 3955 public static final String SPELL_CHECKER_ENABLED = "spell_checker_enabled"; 3956 3957 /** 3958 * What happens when the user presses the Power button while in-call 3959 * and the screen is on.<br/> 3960 * <b>Values:</b><br/> 3961 * 1 - The Power button turns off the screen and locks the device. (Default behavior)<br/> 3962 * 2 - The Power button hangs up the current call.<br/> 3963 * 3964 * @hide 3965 */ 3966 public static final String INCALL_POWER_BUTTON_BEHAVIOR = "incall_power_button_behavior"; 3967 3968 /** 3969 * INCALL_POWER_BUTTON_BEHAVIOR value for "turn off screen". 3970 * @hide 3971 */ 3972 public static final int INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF = 0x1; 3973 3974 /** 3975 * INCALL_POWER_BUTTON_BEHAVIOR value for "hang up". 3976 * @hide 3977 */ 3978 public static final int INCALL_POWER_BUTTON_BEHAVIOR_HANGUP = 0x2; 3979 3980 /** 3981 * INCALL_POWER_BUTTON_BEHAVIOR default value. 3982 * @hide 3983 */ 3984 public static final int INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT = 3985 INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF; 3986 3987 /** 3988 * The current night mode that has been selected by the user. Owned 3989 * and controlled by UiModeManagerService. Constants are as per 3990 * UiModeManager. 3991 * @hide 3992 */ 3993 public static final String UI_NIGHT_MODE = "ui_night_mode"; 3994 3995 /** 3996 * Whether screensavers are enabled. 3997 * @hide 3998 */ 3999 public static final String SCREENSAVER_ENABLED = "screensaver_enabled"; 4000 4001 /** 4002 * The user's chosen screensaver components. 4003 * 4004 * These will be launched by the PhoneWindowManager after a timeout when not on 4005 * battery, or upon dock insertion (if SCREENSAVER_ACTIVATE_ON_DOCK is set to 1). 4006 * @hide 4007 */ 4008 public static final String SCREENSAVER_COMPONENTS = "screensaver_components"; 4009 4010 /** 4011 * If screensavers are enabled, whether the screensaver should be automatically launched 4012 * when the device is inserted into a (desk) dock. 4013 * @hide 4014 */ 4015 public static final String SCREENSAVER_ACTIVATE_ON_DOCK = "screensaver_activate_on_dock"; 4016 4017 /** 4018 * If screensavers are enabled, whether the screensaver should be automatically launched 4019 * when the screen times out when not on battery. 4020 * @hide 4021 */ 4022 public static final String SCREENSAVER_ACTIVATE_ON_SLEEP = "screensaver_activate_on_sleep"; 4023 4024 /** 4025 * If screensavers are enabled, the default screensaver component. 4026 * @hide 4027 */ 4028 public static final String SCREENSAVER_DEFAULT_COMPONENT = "screensaver_default_component"; 4029 4030 /** 4031 * This are the settings to be backed up. 4032 * 4033 * NOTE: Settings are backed up and restored in the order they appear 4034 * in this array. If you have one setting depending on another, 4035 * make sure that they are ordered appropriately. 4036 * 4037 * @hide 4038 */ 4039 public static final String[] SETTINGS_TO_BACKUP = { 4040 BUGREPORT_IN_POWER_MENU, 4041 ALLOW_MOCK_LOCATION, 4042 PARENTAL_CONTROL_ENABLED, 4043 PARENTAL_CONTROL_REDIRECT_URL, 4044 USB_MASS_STORAGE_ENABLED, // moved to global 4045 ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 4046 ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE, 4047 ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE, 4048 ACCESSIBILITY_SCRIPT_INJECTION, 4049 BACKUP_AUTO_RESTORE, 4050 ENABLED_ACCESSIBILITY_SERVICES, 4051 TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, 4052 TOUCH_EXPLORATION_ENABLED, 4053 ACCESSIBILITY_ENABLED, 4054 ACCESSIBILITY_SPEAK_PASSWORD, 4055 TTS_USE_DEFAULTS, 4056 TTS_DEFAULT_RATE, 4057 TTS_DEFAULT_PITCH, 4058 TTS_DEFAULT_SYNTH, 4059 TTS_DEFAULT_LANG, 4060 TTS_DEFAULT_COUNTRY, 4061 TTS_ENABLED_PLUGINS, 4062 TTS_DEFAULT_LOCALE, 4063 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, // moved to global 4064 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, // moved to global 4065 WIFI_NUM_OPEN_NETWORKS_KEPT, // moved to global 4066 MOUNT_PLAY_NOTIFICATION_SND, 4067 MOUNT_UMS_AUTOSTART, 4068 MOUNT_UMS_PROMPT, 4069 MOUNT_UMS_NOTIFY_ENABLED, 4070 UI_NIGHT_MODE, 4071 LOCK_SCREEN_OWNER_INFO, 4072 LOCK_SCREEN_OWNER_INFO_ENABLED 4073 }; 4074 4075 /** 4076 * Helper method for determining if a location provider is enabled. 4077 * @param cr the content resolver to use 4078 * @param provider the location provider to query 4079 * @return true if the provider is enabled 4080 */ isLocationProviderEnabled(ContentResolver cr, String provider)4081 public static final boolean isLocationProviderEnabled(ContentResolver cr, String provider) { 4082 return isLocationProviderEnabledForUser(cr, provider, UserHandle.myUserId()); 4083 } 4084 4085 /** 4086 * Helper method for determining if a location provider is enabled. 4087 * @param cr the content resolver to use 4088 * @param provider the location provider to query 4089 * @param userId the userId to query 4090 * @return true if the provider is enabled 4091 * @hide 4092 */ isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId)4093 public static final boolean isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId) { 4094 String allowedProviders = Settings.Secure.getStringForUser(cr, 4095 LOCATION_PROVIDERS_ALLOWED, userId); 4096 return TextUtils.delimitedStringContains(allowedProviders, ',', provider); 4097 } 4098 4099 /** 4100 * Thread-safe method for enabling or disabling a single location provider. 4101 * @param cr the content resolver to use 4102 * @param provider the location provider to enable or disable 4103 * @param enabled true if the provider should be enabled 4104 */ setLocationProviderEnabled(ContentResolver cr, String provider, boolean enabled)4105 public static final void setLocationProviderEnabled(ContentResolver cr, 4106 String provider, boolean enabled) { 4107 setLocationProviderEnabledForUser(cr, provider, enabled, UserHandle.myUserId()); 4108 } 4109 4110 /** 4111 * Thread-safe method for enabling or disabling a single location provider. 4112 * @param cr the content resolver to use 4113 * @param provider the location provider to enable or disable 4114 * @param enabled true if the provider should be enabled 4115 * @param userId the userId for which to enable/disable providers 4116 * @hide 4117 */ setLocationProviderEnabledForUser(ContentResolver cr, String provider, boolean enabled, int userId)4118 public static final void setLocationProviderEnabledForUser(ContentResolver cr, 4119 String provider, boolean enabled, int userId) { 4120 // to ensure thread safety, we write the provider name with a '+' or '-' 4121 // and let the SettingsProvider handle it rather than reading and modifying 4122 // the list of enabled providers. 4123 if (enabled) { 4124 provider = "+" + provider; 4125 } else { 4126 provider = "-" + provider; 4127 } 4128 putStringForUser(cr, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, provider, 4129 userId); 4130 } 4131 } 4132 4133 /** 4134 * Global system settings, containing preferences that always apply identically 4135 * to all defined users. Applications can read these but are not allowed to write; 4136 * like the "Secure" settings, these are for preferences that the user must 4137 * explicitly modify through the system UI or specialized APIs for those values. 4138 */ 4139 public static final class Global extends NameValueTable { 4140 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_global_version"; 4141 4142 /** 4143 * The content:// style URL for global secure settings items. Not public. 4144 */ 4145 public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/global"); 4146 4147 /** 4148 * Setting whether the global gesture for enabling accessibility is enabled. 4149 * If this gesture is enabled the user will be able to perfrom it to enable 4150 * the accessibility state without visiting the settings app. 4151 * @hide 4152 */ 4153 public static final String ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED = 4154 "enable_accessibility_global_gesture_enabled"; 4155 4156 /** 4157 * Whether Airplane Mode is on. 4158 */ 4159 public static final String AIRPLANE_MODE_ON = "airplane_mode_on"; 4160 4161 /** 4162 * Constant for use in AIRPLANE_MODE_RADIOS to specify Bluetooth radio. 4163 */ 4164 public static final String RADIO_BLUETOOTH = "bluetooth"; 4165 4166 /** 4167 * Constant for use in AIRPLANE_MODE_RADIOS to specify Wi-Fi radio. 4168 */ 4169 public static final String RADIO_WIFI = "wifi"; 4170 4171 /** 4172 * {@hide} 4173 */ 4174 public static final String RADIO_WIMAX = "wimax"; 4175 /** 4176 * Constant for use in AIRPLANE_MODE_RADIOS to specify Cellular radio. 4177 */ 4178 public static final String RADIO_CELL = "cell"; 4179 4180 /** 4181 * Constant for use in AIRPLANE_MODE_RADIOS to specify NFC radio. 4182 */ 4183 public static final String RADIO_NFC = "nfc"; 4184 4185 /** 4186 * A comma separated list of radios that need to be disabled when airplane mode 4187 * is on. This overrides WIFI_ON and BLUETOOTH_ON, if Wi-Fi and bluetooth are 4188 * included in the comma separated list. 4189 */ 4190 public static final String AIRPLANE_MODE_RADIOS = "airplane_mode_radios"; 4191 4192 /** 4193 * A comma separated list of radios that should to be disabled when airplane mode 4194 * is on, but can be manually reenabled by the user. For example, if RADIO_WIFI is 4195 * added to both AIRPLANE_MODE_RADIOS and AIRPLANE_MODE_TOGGLEABLE_RADIOS, then Wifi 4196 * will be turned off when entering airplane mode, but the user will be able to reenable 4197 * Wifi in the Settings app. 4198 * 4199 * {@hide} 4200 */ 4201 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = "airplane_mode_toggleable_radios"; 4202 4203 /** 4204 * The policy for deciding when Wi-Fi should go to sleep (which will in 4205 * turn switch to using the mobile data as an Internet connection). 4206 * <p> 4207 * Set to one of {@link #WIFI_SLEEP_POLICY_DEFAULT}, 4208 * {@link #WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED}, or 4209 * {@link #WIFI_SLEEP_POLICY_NEVER}. 4210 */ 4211 public static final String WIFI_SLEEP_POLICY = "wifi_sleep_policy"; 4212 4213 /** 4214 * Value for {@link #WIFI_SLEEP_POLICY} to use the default Wi-Fi sleep 4215 * policy, which is to sleep shortly after the turning off 4216 * according to the {@link #STAY_ON_WHILE_PLUGGED_IN} setting. 4217 */ 4218 public static final int WIFI_SLEEP_POLICY_DEFAULT = 0; 4219 4220 /** 4221 * Value for {@link #WIFI_SLEEP_POLICY} to use the default policy when 4222 * the device is on battery, and never go to sleep when the device is 4223 * plugged in. 4224 */ 4225 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1; 4226 4227 /** 4228 * Value for {@link #WIFI_SLEEP_POLICY} to never go to sleep. 4229 */ 4230 public static final int WIFI_SLEEP_POLICY_NEVER = 2; 4231 4232 /** 4233 * Value to specify if the user prefers the date, time and time zone 4234 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 4235 */ 4236 public static final String AUTO_TIME = "auto_time"; 4237 4238 /** 4239 * Value to specify if the user prefers the time zone 4240 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 4241 */ 4242 public static final String AUTO_TIME_ZONE = "auto_time_zone"; 4243 4244 /** 4245 * URI for the car dock "in" event sound. 4246 * @hide 4247 */ 4248 public static final String CAR_DOCK_SOUND = "car_dock_sound"; 4249 4250 /** 4251 * URI for the car dock "out" event sound. 4252 * @hide 4253 */ 4254 public static final String CAR_UNDOCK_SOUND = "car_undock_sound"; 4255 4256 /** 4257 * URI for the desk dock "in" event sound. 4258 * @hide 4259 */ 4260 public static final String DESK_DOCK_SOUND = "desk_dock_sound"; 4261 4262 /** 4263 * URI for the desk dock "out" event sound. 4264 * @hide 4265 */ 4266 public static final String DESK_UNDOCK_SOUND = "desk_undock_sound"; 4267 4268 /** 4269 * Whether to play a sound for dock events. 4270 * @hide 4271 */ 4272 public static final String DOCK_SOUNDS_ENABLED = "dock_sounds_enabled"; 4273 4274 /** 4275 * URI for the "device locked" (keyguard shown) sound. 4276 * @hide 4277 */ 4278 public static final String LOCK_SOUND = "lock_sound"; 4279 4280 /** 4281 * URI for the "device unlocked" sound. 4282 * @hide 4283 */ 4284 public static final String UNLOCK_SOUND = "unlock_sound"; 4285 4286 /** 4287 * URI for the low battery sound file. 4288 * @hide 4289 */ 4290 public static final String LOW_BATTERY_SOUND = "low_battery_sound"; 4291 4292 /** 4293 * Whether to play a sound for low-battery alerts. 4294 * @hide 4295 */ 4296 public static final String POWER_SOUNDS_ENABLED = "power_sounds_enabled"; 4297 4298 /** 4299 * URI for the "wireless charging started" sound. 4300 * @hide 4301 */ 4302 public static final String WIRELESS_CHARGING_STARTED_SOUND = 4303 "wireless_charging_started_sound"; 4304 4305 /** 4306 * Whether we keep the device on while the device is plugged in. 4307 * Supported values are: 4308 * <ul> 4309 * <li>{@code 0} to never stay on while plugged in</li> 4310 * <li>{@link BatteryManager#BATTERY_PLUGGED_AC} to stay on for AC charger</li> 4311 * <li>{@link BatteryManager#BATTERY_PLUGGED_USB} to stay on for USB charger</li> 4312 * <li>{@link BatteryManager#BATTERY_PLUGGED_WIRELESS} to stay on for wireless charger</li> 4313 * </ul> 4314 * These values can be OR-ed together. 4315 */ 4316 public static final String STAY_ON_WHILE_PLUGGED_IN = "stay_on_while_plugged_in"; 4317 4318 /** 4319 * Whether ADB is enabled. 4320 */ 4321 public static final String ADB_ENABLED = "adb_enabled"; 4322 4323 /** 4324 * Whether assisted GPS should be enabled or not. 4325 * @hide 4326 */ 4327 public static final String ASSISTED_GPS_ENABLED = "assisted_gps_enabled"; 4328 4329 /** 4330 * Whether bluetooth is enabled/disabled 4331 * 0=disabled. 1=enabled. 4332 */ 4333 public static final String BLUETOOTH_ON = "bluetooth_on"; 4334 4335 /** 4336 * CDMA Cell Broadcast SMS 4337 * 0 = CDMA Cell Broadcast SMS disabled 4338 * 1 = CDMA Cell Broadcast SMS enabled 4339 * @hide 4340 */ 4341 public static final String CDMA_CELL_BROADCAST_SMS = 4342 "cdma_cell_broadcast_sms"; 4343 4344 /** 4345 * The CDMA roaming mode 0 = Home Networks, CDMA default 4346 * 1 = Roaming on Affiliated networks 4347 * 2 = Roaming on any networks 4348 * @hide 4349 */ 4350 public static final String CDMA_ROAMING_MODE = "roaming_settings"; 4351 4352 /** 4353 * The CDMA subscription mode 0 = RUIM/SIM (default) 4354 * 1 = NV 4355 * @hide 4356 */ 4357 public static final String CDMA_SUBSCRIPTION_MODE = "subscription_mode"; 4358 4359 /** Inactivity timeout to track mobile data activity. 4360 * 4361 * If set to a positive integer, it indicates the inactivity timeout value in seconds to 4362 * infer the data activity of mobile network. After a period of no activity on mobile 4363 * networks with length specified by the timeout, an {@code ACTION_DATA_ACTIVITY_CHANGE} 4364 * intent is fired to indicate a transition of network status from "active" to "idle". Any 4365 * subsequent activity on mobile networks triggers the firing of {@code 4366 * ACTION_DATA_ACTIVITY_CHANGE} intent indicating transition from "idle" to "active". 4367 * 4368 * Network activity refers to transmitting or receiving data on the network interfaces. 4369 * 4370 * Tracking is disabled if set to zero or negative value. 4371 * 4372 * @hide 4373 */ 4374 public static final String DATA_ACTIVITY_TIMEOUT_MOBILE = "data_activity_timeout_mobile"; 4375 4376 /** Timeout to tracking Wifi data activity. Same as {@code DATA_ACTIVITY_TIMEOUT_MOBILE} 4377 * but for Wifi network. 4378 * @hide 4379 */ 4380 public static final String DATA_ACTIVITY_TIMEOUT_WIFI = "data_activity_timeout_wifi"; 4381 4382 /** 4383 * Whether or not data roaming is enabled. (0 = false, 1 = true) 4384 */ 4385 public static final String DATA_ROAMING = "data_roaming"; 4386 4387 /** 4388 * Whether user has enabled development settings. 4389 */ 4390 public static final String DEVELOPMENT_SETTINGS_ENABLED = "development_settings_enabled"; 4391 4392 /** 4393 * Whether the device has been provisioned (0 = false, 1 = true) 4394 */ 4395 public static final String DEVICE_PROVISIONED = "device_provisioned"; 4396 4397 /** 4398 * The saved value for WindowManagerService.setForcedDisplayDensity(). 4399 * One integer in dpi. If unset, then use the real display density. 4400 * @hide 4401 */ 4402 public static final String DISPLAY_DENSITY_FORCED = "display_density_forced"; 4403 4404 /** 4405 * The saved value for WindowManagerService.setForcedDisplaySize(). 4406 * Two integers separated by a comma. If unset, then use the real display size. 4407 * @hide 4408 */ 4409 public static final String DISPLAY_SIZE_FORCED = "display_size_forced"; 4410 4411 /** 4412 * The maximum size, in bytes, of a download that the download manager will transfer over 4413 * a non-wifi connection. 4414 * @hide 4415 */ 4416 public static final String DOWNLOAD_MAX_BYTES_OVER_MOBILE = 4417 "download_manager_max_bytes_over_mobile"; 4418 4419 /** 4420 * The recommended maximum size, in bytes, of a download that the download manager should 4421 * transfer over a non-wifi connection. Over this size, the use will be warned, but will 4422 * have the option to start the download over the mobile connection anyway. 4423 * @hide 4424 */ 4425 public static final String DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE = 4426 "download_manager_recommended_max_bytes_over_mobile"; 4427 4428 /** 4429 * Whether the package installer should allow installation of apps downloaded from 4430 * sources other than Google Play. 4431 * 4432 * 1 = allow installing from other sources 4433 * 0 = only allow installing from Google Play 4434 */ 4435 public static final String INSTALL_NON_MARKET_APPS = "install_non_market_apps"; 4436 4437 /** 4438 * Whether mobile data connections are allowed by the user. See 4439 * ConnectivityManager for more info. 4440 * @hide 4441 */ 4442 public static final String MOBILE_DATA = "mobile_data"; 4443 4444 /** {@hide} */ 4445 public static final String NETSTATS_ENABLED = "netstats_enabled"; 4446 /** {@hide} */ 4447 public static final String NETSTATS_POLL_INTERVAL = "netstats_poll_interval"; 4448 /** {@hide} */ 4449 public static final String NETSTATS_TIME_CACHE_MAX_AGE = "netstats_time_cache_max_age"; 4450 /** {@hide} */ 4451 public static final String NETSTATS_GLOBAL_ALERT_BYTES = "netstats_global_alert_bytes"; 4452 /** {@hide} */ 4453 public static final String NETSTATS_SAMPLE_ENABLED = "netstats_sample_enabled"; 4454 /** {@hide} */ 4455 public static final String NETSTATS_REPORT_XT_OVER_DEV = "netstats_report_xt_over_dev"; 4456 4457 /** {@hide} */ 4458 public static final String NETSTATS_DEV_BUCKET_DURATION = "netstats_dev_bucket_duration"; 4459 /** {@hide} */ 4460 public static final String NETSTATS_DEV_PERSIST_BYTES = "netstats_dev_persist_bytes"; 4461 /** {@hide} */ 4462 public static final String NETSTATS_DEV_ROTATE_AGE = "netstats_dev_rotate_age"; 4463 /** {@hide} */ 4464 public static final String NETSTATS_DEV_DELETE_AGE = "netstats_dev_delete_age"; 4465 4466 /** {@hide} */ 4467 public static final String NETSTATS_UID_BUCKET_DURATION = "netstats_uid_bucket_duration"; 4468 /** {@hide} */ 4469 public static final String NETSTATS_UID_PERSIST_BYTES = "netstats_uid_persist_bytes"; 4470 /** {@hide} */ 4471 public static final String NETSTATS_UID_ROTATE_AGE = "netstats_uid_rotate_age"; 4472 /** {@hide} */ 4473 public static final String NETSTATS_UID_DELETE_AGE = "netstats_uid_delete_age"; 4474 4475 /** {@hide} */ 4476 public static final String NETSTATS_UID_TAG_BUCKET_DURATION = "netstats_uid_tag_bucket_duration"; 4477 /** {@hide} */ 4478 public static final String NETSTATS_UID_TAG_PERSIST_BYTES = "netstats_uid_tag_persist_bytes"; 4479 /** {@hide} */ 4480 public static final String NETSTATS_UID_TAG_ROTATE_AGE = "netstats_uid_tag_rotate_age"; 4481 /** {@hide} */ 4482 public static final String NETSTATS_UID_TAG_DELETE_AGE = "netstats_uid_tag_delete_age"; 4483 4484 /** 4485 * User preference for which network(s) should be used. Only the 4486 * connectivity service should touch this. 4487 */ 4488 public static final String NETWORK_PREFERENCE = "network_preference"; 4489 4490 /** 4491 * If the NITZ_UPDATE_DIFF time is exceeded then an automatic adjustment 4492 * to SystemClock will be allowed even if NITZ_UPDATE_SPACING has not been 4493 * exceeded. 4494 * @hide 4495 */ 4496 public static final String NITZ_UPDATE_DIFF = "nitz_update_diff"; 4497 4498 /** 4499 * The length of time in milli-seconds that automatic small adjustments to 4500 * SystemClock are ignored if NITZ_UPDATE_DIFF is not exceeded. 4501 * @hide 4502 */ 4503 public static final String NITZ_UPDATE_SPACING = "nitz_update_spacing"; 4504 4505 /** Preferred NTP server. {@hide} */ 4506 public static final String NTP_SERVER = "ntp_server"; 4507 /** Timeout in milliseconds to wait for NTP server. {@hide} */ 4508 public static final String NTP_TIMEOUT = "ntp_timeout"; 4509 4510 /** 4511 * Whether the package manager should send package verification broadcasts for verifiers to 4512 * review apps prior to installation. 4513 * 1 = request apps to be verified prior to installation, if a verifier exists. 4514 * 0 = do not verify apps before installation 4515 * @hide 4516 */ 4517 public static final String PACKAGE_VERIFIER_ENABLE = "package_verifier_enable"; 4518 4519 /** Timeout for package verification. 4520 * @hide */ 4521 public static final String PACKAGE_VERIFIER_TIMEOUT = "verifier_timeout"; 4522 4523 /** Default response code for package verification. 4524 * @hide */ 4525 public static final String PACKAGE_VERIFIER_DEFAULT_RESPONSE = "verifier_default_response"; 4526 4527 /** 4528 * Show package verification setting in the Settings app. 4529 * 1 = show (default) 4530 * 0 = hide 4531 * @hide 4532 */ 4533 public static final String PACKAGE_VERIFIER_SETTING_VISIBLE = "verifier_setting_visible"; 4534 4535 /** 4536 * Run package verificaiton on apps installed through ADB/ADT/USB 4537 * 1 = perform package verification on ADB installs (default) 4538 * 0 = bypass package verification on ADB installs 4539 * @hide 4540 */ 4541 public static final String PACKAGE_VERIFIER_INCLUDE_ADB = "verifier_verify_adb_installs"; 4542 4543 /** 4544 * The interval in milliseconds at which to check packet counts on the 4545 * mobile data interface when screen is on, to detect possible data 4546 * connection problems. 4547 * @hide 4548 */ 4549 public static final String PDP_WATCHDOG_POLL_INTERVAL_MS = 4550 "pdp_watchdog_poll_interval_ms"; 4551 4552 /** 4553 * The interval in milliseconds at which to check packet counts on the 4554 * mobile data interface when screen is off, to detect possible data 4555 * connection problems. 4556 * @hide 4557 */ 4558 public static final String PDP_WATCHDOG_LONG_POLL_INTERVAL_MS = 4559 "pdp_watchdog_long_poll_interval_ms"; 4560 4561 /** 4562 * The interval in milliseconds at which to check packet counts on the 4563 * mobile data interface after {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} 4564 * outgoing packets has been reached without incoming packets. 4565 * @hide 4566 */ 4567 public static final String PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS = 4568 "pdp_watchdog_error_poll_interval_ms"; 4569 4570 /** 4571 * The number of outgoing packets sent without seeing an incoming packet 4572 * that triggers a countdown (of {@link #PDP_WATCHDOG_ERROR_POLL_COUNT} 4573 * device is logged to the event log 4574 * @hide 4575 */ 4576 public static final String PDP_WATCHDOG_TRIGGER_PACKET_COUNT = 4577 "pdp_watchdog_trigger_packet_count"; 4578 4579 /** 4580 * The number of polls to perform (at {@link #PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS}) 4581 * after hitting {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} before 4582 * attempting data connection recovery. 4583 * @hide 4584 */ 4585 public static final String PDP_WATCHDOG_ERROR_POLL_COUNT = 4586 "pdp_watchdog_error_poll_count"; 4587 4588 /** 4589 * The number of failed PDP reset attempts before moving to something more 4590 * drastic: re-registering to the network. 4591 * @hide 4592 */ 4593 public static final String PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT = 4594 "pdp_watchdog_max_pdp_reset_fail_count"; 4595 4596 /** 4597 * A positive value indicates how often the SamplingProfiler 4598 * should take snapshots. Zero value means SamplingProfiler 4599 * is disabled. 4600 * 4601 * @hide 4602 */ 4603 public static final String SAMPLING_PROFILER_MS = "sampling_profiler_ms"; 4604 4605 /** 4606 * URL to open browser on to allow user to manage a prepay account 4607 * @hide 4608 */ 4609 public static final String SETUP_PREPAID_DATA_SERVICE_URL = 4610 "setup_prepaid_data_service_url"; 4611 4612 /** 4613 * URL to attempt a GET on to see if this is a prepay device 4614 * @hide 4615 */ 4616 public static final String SETUP_PREPAID_DETECTION_TARGET_URL = 4617 "setup_prepaid_detection_target_url"; 4618 4619 /** 4620 * Host to check for a redirect to after an attempt to GET 4621 * SETUP_PREPAID_DETECTION_TARGET_URL. (If we redirected there, 4622 * this is a prepaid device with zero balance.) 4623 * @hide 4624 */ 4625 public static final String SETUP_PREPAID_DETECTION_REDIR_HOST = 4626 "setup_prepaid_detection_redir_host"; 4627 4628 /** 4629 * The interval in milliseconds at which to check the number of SMS sent out without asking 4630 * for use permit, to limit the un-authorized SMS usage. 4631 * 4632 * @hide 4633 */ 4634 public static final String SMS_OUTGOING_CHECK_INTERVAL_MS = 4635 "sms_outgoing_check_interval_ms"; 4636 4637 /** 4638 * The number of outgoing SMS sent without asking for user permit (of {@link 4639 * #SMS_OUTGOING_CHECK_INTERVAL_MS} 4640 * 4641 * @hide 4642 */ 4643 public static final String SMS_OUTGOING_CHECK_MAX_COUNT = 4644 "sms_outgoing_check_max_count"; 4645 4646 /** 4647 * Used to disable SMS short code confirmation - defaults to true. 4648 * True indcates we will do the check, etc. Set to false to disable. 4649 * @see com.android.internal.telephony.SmsUsageMonitor 4650 * @hide 4651 */ 4652 public static final String SMS_SHORT_CODE_CONFIRMATION = "sms_short_code_confirmation"; 4653 4654 /** 4655 * Used to select which country we use to determine premium sms codes. 4656 * One of com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_SIM, 4657 * com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_NETWORK, 4658 * or com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_BOTH. 4659 * @hide 4660 */ 4661 public static final String SMS_SHORT_CODE_RULE = "sms_short_code_rule"; 4662 4663 /** 4664 * Used to disable Tethering on a device - defaults to true 4665 * @hide 4666 */ 4667 public static final String TETHER_SUPPORTED = "tether_supported"; 4668 4669 /** 4670 * Used to require DUN APN on the device or not - defaults to a build config value 4671 * which defaults to false 4672 * @hide 4673 */ 4674 public static final String TETHER_DUN_REQUIRED = "tether_dun_required"; 4675 4676 /** 4677 * Used to hold a gservices-provisioned apn value for DUN. If set, or the 4678 * corresponding build config values are set it will override the APN DB 4679 * values. 4680 * Consists of a comma seperated list of strings: 4681 * "name,apn,proxy,port,username,password,server,mmsc,mmsproxy,mmsport,mcc,mnc,auth,type" 4682 * note that empty fields can be ommitted: "name,apn,,,,,,,,,310,260,,DUN" 4683 * @hide 4684 */ 4685 public static final String TETHER_DUN_APN = "tether_dun_apn"; 4686 4687 /** 4688 * The bandwidth throttle polling freqency in seconds 4689 * @hide 4690 */ 4691 public static final String THROTTLE_POLLING_SEC = "throttle_polling_sec"; 4692 4693 /** 4694 * The bandwidth throttle threshold (long) 4695 * @hide 4696 */ 4697 public static final String THROTTLE_THRESHOLD_BYTES = "throttle_threshold_bytes"; 4698 4699 /** 4700 * The bandwidth throttle value (kbps) 4701 * @hide 4702 */ 4703 public static final String THROTTLE_VALUE_KBITSPS = "throttle_value_kbitsps"; 4704 4705 /** 4706 * The bandwidth throttle reset calendar day (1-28) 4707 * @hide 4708 */ 4709 public static final String THROTTLE_RESET_DAY = "throttle_reset_day"; 4710 4711 /** 4712 * The throttling notifications we should send 4713 * @hide 4714 */ 4715 public static final String THROTTLE_NOTIFICATION_TYPE = "throttle_notification_type"; 4716 4717 /** 4718 * Help URI for data throttling policy 4719 * @hide 4720 */ 4721 public static final String THROTTLE_HELP_URI = "throttle_help_uri"; 4722 4723 /** 4724 * The length of time in Sec that we allow our notion of NTP time 4725 * to be cached before we refresh it 4726 * @hide 4727 */ 4728 public static final String THROTTLE_MAX_NTP_CACHE_AGE_SEC = 4729 "throttle_max_ntp_cache_age_sec"; 4730 4731 /** 4732 * USB Mass Storage Enabled 4733 */ 4734 public static final String USB_MASS_STORAGE_ENABLED = "usb_mass_storage_enabled"; 4735 4736 /** 4737 * If this setting is set (to anything), then all references 4738 * to Gmail on the device must change to Google Mail. 4739 */ 4740 public static final String USE_GOOGLE_MAIL = "use_google_mail"; 4741 4742 /** Autofill server address (Used in WebView/browser). 4743 * {@hide} */ 4744 public static final String WEB_AUTOFILL_QUERY_URL = 4745 "web_autofill_query_url"; 4746 4747 /** 4748 * Whether Wifi display is enabled/disabled 4749 * 0=disabled. 1=enabled. 4750 * @hide 4751 */ 4752 public static final String WIFI_DISPLAY_ON = "wifi_display_on"; 4753 4754 /** 4755 * Whether to notify the user of open networks. 4756 * <p> 4757 * If not connected and the scan results have an open network, we will 4758 * put this notification up. If we attempt to connect to a network or 4759 * the open network(s) disappear, we remove the notification. When we 4760 * show the notification, we will not show it again for 4761 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} time. 4762 */ 4763 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 4764 "wifi_networks_available_notification_on"; 4765 /** 4766 * {@hide} 4767 */ 4768 public static final String WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON = 4769 "wimax_networks_available_notification_on"; 4770 4771 /** 4772 * Delay (in seconds) before repeating the Wi-Fi networks available notification. 4773 * Connecting to a network will reset the timer. 4774 */ 4775 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 4776 "wifi_networks_available_repeat_delay"; 4777 4778 /** 4779 * 802.11 country code in ISO 3166 format 4780 * @hide 4781 */ 4782 public static final String WIFI_COUNTRY_CODE = "wifi_country_code"; 4783 4784 /** 4785 * The interval in milliseconds to issue wake up scans when wifi needs 4786 * to connect. This is necessary to connect to an access point when 4787 * device is on the move and the screen is off. 4788 * @hide 4789 */ 4790 public static final String WIFI_FRAMEWORK_SCAN_INTERVAL_MS = 4791 "wifi_framework_scan_interval_ms"; 4792 4793 /** 4794 * The interval in milliseconds after which Wi-Fi is considered idle. 4795 * When idle, it is possible for the device to be switched from Wi-Fi to 4796 * the mobile data network. 4797 * @hide 4798 */ 4799 public static final String WIFI_IDLE_MS = "wifi_idle_ms"; 4800 4801 /** 4802 * When the number of open networks exceeds this number, the 4803 * least-recently-used excess networks will be removed. 4804 */ 4805 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = "wifi_num_open_networks_kept"; 4806 4807 /** 4808 * Whether the Wi-Fi should be on. Only the Wi-Fi service should touch this. 4809 */ 4810 public static final String WIFI_ON = "wifi_on"; 4811 4812 /** 4813 * Used to save the Wifi_ON state prior to tethering. 4814 * This state will be checked to restore Wifi after 4815 * the user turns off tethering. 4816 * 4817 * @hide 4818 */ 4819 public static final String WIFI_SAVED_STATE = "wifi_saved_state"; 4820 4821 /** 4822 * The interval in milliseconds to scan as used by the wifi supplicant 4823 * @hide 4824 */ 4825 public static final String WIFI_SUPPLICANT_SCAN_INTERVAL_MS = 4826 "wifi_supplicant_scan_interval_ms"; 4827 4828 /** 4829 * The interval in milliseconds to scan at supplicant when p2p is connected 4830 * @hide 4831 */ 4832 public static final String WIFI_SCAN_INTERVAL_WHEN_P2P_CONNECTED_MS = 4833 "wifi_scan_interval_p2p_connected_ms"; 4834 4835 /** 4836 * Whether the Wi-Fi watchdog is enabled. 4837 */ 4838 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 4839 4840 /** 4841 * Setting to turn off poor network avoidance on Wi-Fi. Feature is enabled by default and 4842 * the setting needs to be set to 0 to disable it. 4843 * @hide 4844 */ 4845 public static final String WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED = 4846 "wifi_watchdog_poor_network_test_enabled"; 4847 4848 /** 4849 * Setting to turn on suspend optimizations at screen off on Wi-Fi. Enabled by default and 4850 * needs to be set to 0 to disable it. 4851 * @hide 4852 */ 4853 public static final String WIFI_SUSPEND_OPTIMIZATIONS_ENABLED = 4854 "wifi_suspend_optimizations_enabled"; 4855 4856 /** 4857 * The maximum number of times we will retry a connection to an access 4858 * point for which we have failed in acquiring an IP address from DHCP. 4859 * A value of N means that we will make N+1 connection attempts in all. 4860 */ 4861 public static final String WIFI_MAX_DHCP_RETRY_COUNT = "wifi_max_dhcp_retry_count"; 4862 4863 /** 4864 * Maximum amount of time in milliseconds to hold a wakelock while waiting for mobile 4865 * data connectivity to be established after a disconnect from Wi-Fi. 4866 */ 4867 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 4868 "wifi_mobile_data_transition_wakelock_timeout_ms"; 4869 4870 /** 4871 * The operational wifi frequency band 4872 * Set to one of {@link WifiManager#WIFI_FREQUENCY_BAND_AUTO}, 4873 * {@link WifiManager#WIFI_FREQUENCY_BAND_5GHZ} or 4874 * {@link WifiManager#WIFI_FREQUENCY_BAND_2GHZ} 4875 * 4876 * @hide 4877 */ 4878 public static final String WIFI_FREQUENCY_BAND = "wifi_frequency_band"; 4879 4880 /** 4881 * The Wi-Fi peer-to-peer device name 4882 * @hide 4883 */ 4884 public static final String WIFI_P2P_DEVICE_NAME = "wifi_p2p_device_name"; 4885 4886 /** 4887 * The number of milliseconds to delay when checking for data stalls during 4888 * non-aggressive detection. (screen is turned off.) 4889 * @hide 4890 */ 4891 public static final String DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS = 4892 "data_stall_alarm_non_aggressive_delay_in_ms"; 4893 4894 /** 4895 * The number of milliseconds to delay when checking for data stalls during 4896 * aggressive detection. (screen on or suspected data stall) 4897 * @hide 4898 */ 4899 public static final String DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS = 4900 "data_stall_alarm_aggressive_delay_in_ms"; 4901 4902 /** 4903 * The interval in milliseconds at which to check gprs registration 4904 * after the first registration mismatch of gprs and voice service, 4905 * to detect possible data network registration problems. 4906 * 4907 * @hide 4908 */ 4909 public static final String GPRS_REGISTER_CHECK_PERIOD_MS = 4910 "gprs_register_check_period_ms"; 4911 4912 /** 4913 * Nonzero causes Log.wtf() to crash. 4914 * @hide 4915 */ 4916 public static final String WTF_IS_FATAL = "wtf_is_fatal"; 4917 4918 /** 4919 * Ringer mode. This is used internally, changing this value will not 4920 * change the ringer mode. See AudioManager. 4921 */ 4922 public static final String MODE_RINGER = "mode_ringer"; 4923 4924 /** 4925 * Overlay display devices setting. 4926 * The associated value is a specially formatted string that describes the 4927 * size and density of simulated secondary display devices. 4928 * <p> 4929 * Format: {width}x{height}/{dpi};... 4930 * </p><p> 4931 * Example: 4932 * <ul> 4933 * <li><code>1280x720/213</code>: make one overlay that is 1280x720 at 213dpi.</li> 4934 * <li><code>1920x1080/320;1280x720/213</code>: make two overlays, the first 4935 * at 1080p and the second at 720p.</li> 4936 * <li>If the value is empty, then no overlay display devices are created.</li> 4937 * </ul></p> 4938 * 4939 * @hide 4940 */ 4941 public static final String OVERLAY_DISPLAY_DEVICES = "overlay_display_devices"; 4942 4943 /** 4944 * Threshold values for the duration and level of a discharge cycle, 4945 * under which we log discharge cycle info. 4946 * 4947 * @hide 4948 */ 4949 public static final String 4950 BATTERY_DISCHARGE_DURATION_THRESHOLD = "battery_discharge_duration_threshold"; 4951 4952 /** @hide */ 4953 public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold"; 4954 4955 /** 4956 * Flag for allowing ActivityManagerService to send ACTION_APP_ERROR 4957 * intents on application crashes and ANRs. If this is disabled, the 4958 * crash/ANR dialog will never display the "Report" button. 4959 * <p> 4960 * Type: int (0 = disallow, 1 = allow) 4961 * 4962 * @hide 4963 */ 4964 public static final String SEND_ACTION_APP_ERROR = "send_action_app_error"; 4965 4966 /** 4967 * Maximum age of entries kept by {@link DropBoxManager}. 4968 * 4969 * @hide 4970 */ 4971 public static final String DROPBOX_AGE_SECONDS = "dropbox_age_seconds"; 4972 4973 /** 4974 * Maximum number of entry files which {@link DropBoxManager} will keep 4975 * around. 4976 * 4977 * @hide 4978 */ 4979 public static final String DROPBOX_MAX_FILES = "dropbox_max_files"; 4980 4981 /** 4982 * Maximum amount of disk space used by {@link DropBoxManager} no matter 4983 * what. 4984 * 4985 * @hide 4986 */ 4987 public static final String DROPBOX_QUOTA_KB = "dropbox_quota_kb"; 4988 4989 /** 4990 * Percent of free disk (excluding reserve) which {@link DropBoxManager} 4991 * will use. 4992 * 4993 * @hide 4994 */ 4995 public static final String DROPBOX_QUOTA_PERCENT = "dropbox_quota_percent"; 4996 4997 /** 4998 * Percent of total disk which {@link DropBoxManager} will never dip 4999 * into. 5000 * 5001 * @hide 5002 */ 5003 public static final String DROPBOX_RESERVE_PERCENT = "dropbox_reserve_percent"; 5004 5005 /** 5006 * Prefix for per-tag dropbox disable/enable settings. 5007 * 5008 * @hide 5009 */ 5010 public static final String DROPBOX_TAG_PREFIX = "dropbox:"; 5011 5012 /** 5013 * Lines of logcat to include with system crash/ANR/etc. reports, as a 5014 * prefix of the dropbox tag of the report type. For example, 5015 * "logcat_for_system_server_anr" controls the lines of logcat captured 5016 * with system server ANR reports. 0 to disable. 5017 * 5018 * @hide 5019 */ 5020 public static final String ERROR_LOGCAT_PREFIX = "logcat_for_"; 5021 5022 /** 5023 * The interval in minutes after which the amount of free storage left 5024 * on the device is logged to the event log 5025 * 5026 * @hide 5027 */ 5028 public static final String SYS_FREE_STORAGE_LOG_INTERVAL = "sys_free_storage_log_interval"; 5029 5030 /** 5031 * Threshold for the amount of change in disk free space required to 5032 * report the amount of free space. Used to prevent spamming the logs 5033 * when the disk free space isn't changing frequently. 5034 * 5035 * @hide 5036 */ 5037 public static final String 5038 DISK_FREE_CHANGE_REPORTING_THRESHOLD = "disk_free_change_reporting_threshold"; 5039 5040 /** 5041 * Minimum percentage of free storage on the device that is used to 5042 * determine if the device is running low on storage. The default is 10. 5043 * <p> 5044 * Say this value is set to 10, the device is considered running low on 5045 * storage if 90% or more of the device storage is filled up. 5046 * 5047 * @hide 5048 */ 5049 public static final String 5050 SYS_STORAGE_THRESHOLD_PERCENTAGE = "sys_storage_threshold_percentage"; 5051 5052 /** 5053 * Maximum byte size of the low storage threshold. This is to ensure 5054 * that {@link #SYS_STORAGE_THRESHOLD_PERCENTAGE} does not result in an 5055 * overly large threshold for large storage devices. Currently this must 5056 * be less than 2GB. This default is 500MB. 5057 * 5058 * @hide 5059 */ 5060 public static final String 5061 SYS_STORAGE_THRESHOLD_MAX_BYTES = "sys_storage_threshold_max_bytes"; 5062 5063 /** 5064 * Minimum bytes of free storage on the device before the data partition 5065 * is considered full. By default, 1 MB is reserved to avoid system-wide 5066 * SQLite disk full exceptions. 5067 * 5068 * @hide 5069 */ 5070 public static final String 5071 SYS_STORAGE_FULL_THRESHOLD_BYTES = "sys_storage_full_threshold_bytes"; 5072 5073 /** 5074 * The maximum reconnect delay for short network outages or when the 5075 * network is suspended due to phone use. 5076 * 5077 * @hide 5078 */ 5079 public static final String 5080 SYNC_MAX_RETRY_DELAY_IN_SECONDS = "sync_max_retry_delay_in_seconds"; 5081 5082 /** 5083 * The number of milliseconds to delay before sending out 5084 * {@link ConnectivityManager#CONNECTIVITY_ACTION} broadcasts. 5085 * 5086 * @hide 5087 */ 5088 public static final String CONNECTIVITY_CHANGE_DELAY = "connectivity_change_delay"; 5089 5090 /** 5091 * Setting to turn off captive portal detection. Feature is enabled by 5092 * default and the setting needs to be set to 0 to disable it. 5093 * 5094 * @hide 5095 */ 5096 public static final String 5097 CAPTIVE_PORTAL_DETECTION_ENABLED = "captive_portal_detection_enabled"; 5098 5099 /** 5100 * The server used for captive portal detection upon a new conection. A 5101 * 204 response code from the server is used for validation. 5102 * 5103 * @hide 5104 */ 5105 public static final String CAPTIVE_PORTAL_SERVER = "captive_portal_server"; 5106 5107 /** 5108 * Whether network service discovery is enabled. 5109 * 5110 * @hide 5111 */ 5112 public static final String NSD_ON = "nsd_on"; 5113 5114 /** 5115 * Let user pick default install location. 5116 * 5117 * @hide 5118 */ 5119 public static final String SET_INSTALL_LOCATION = "set_install_location"; 5120 5121 /** 5122 * Default install location value. 5123 * 0 = auto, let system decide 5124 * 1 = internal 5125 * 2 = sdcard 5126 * @hide 5127 */ 5128 public static final String DEFAULT_INSTALL_LOCATION = "default_install_location"; 5129 5130 /** 5131 * ms during which to consume extra events related to Inet connection 5132 * condition after a transtion to fully-connected 5133 * 5134 * @hide 5135 */ 5136 public static final String 5137 INET_CONDITION_DEBOUNCE_UP_DELAY = "inet_condition_debounce_up_delay"; 5138 5139 /** 5140 * ms during which to consume extra events related to Inet connection 5141 * condtion after a transtion to partly-connected 5142 * 5143 * @hide 5144 */ 5145 public static final String 5146 INET_CONDITION_DEBOUNCE_DOWN_DELAY = "inet_condition_debounce_down_delay"; 5147 5148 /** {@hide} */ 5149 public static final String 5150 READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT = "read_external_storage_enforced_default"; 5151 5152 /** 5153 * Host name and port for global http proxy. Uses ':' seperator for 5154 * between host and port. 5155 */ 5156 public static final String HTTP_PROXY = "http_proxy"; 5157 5158 /** 5159 * Host name for global http proxy. Set via ConnectivityManager. 5160 * 5161 * @hide 5162 */ 5163 public static final String GLOBAL_HTTP_PROXY_HOST = "global_http_proxy_host"; 5164 5165 /** 5166 * Integer host port for global http proxy. Set via ConnectivityManager. 5167 * 5168 * @hide 5169 */ 5170 public static final String GLOBAL_HTTP_PROXY_PORT = "global_http_proxy_port"; 5171 5172 /** 5173 * Exclusion list for global proxy. This string contains a list of 5174 * comma-separated domains where the global proxy does not apply. 5175 * Domains should be listed in a comma- separated list. Example of 5176 * acceptable formats: ".domain1.com,my.domain2.com" Use 5177 * ConnectivityManager to set/get. 5178 * 5179 * @hide 5180 */ 5181 public static final String 5182 GLOBAL_HTTP_PROXY_EXCLUSION_LIST = "global_http_proxy_exclusion_list"; 5183 5184 /** 5185 * Enables the UI setting to allow the user to specify the global HTTP 5186 * proxy and associated exclusion list. 5187 * 5188 * @hide 5189 */ 5190 public static final String SET_GLOBAL_HTTP_PROXY = "set_global_http_proxy"; 5191 5192 /** 5193 * Setting for default DNS in case nobody suggests one 5194 * 5195 * @hide 5196 */ 5197 public static final String DEFAULT_DNS_SERVER = "default_dns_server"; 5198 5199 /** {@hide} */ 5200 public static final String 5201 BLUETOOTH_HEADSET_PRIORITY_PREFIX = "bluetooth_headset_priority_"; 5202 /** {@hide} */ 5203 public static final String 5204 BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX = "bluetooth_a2dp_sink_priority_"; 5205 /** {@hide} */ 5206 public static final String 5207 BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX = "bluetooth_input_device_priority_"; 5208 5209 /** 5210 * Get the key that retrieves a bluetooth headset's priority. 5211 * @hide 5212 */ getBluetoothHeadsetPriorityKey(String address)5213 public static final String getBluetoothHeadsetPriorityKey(String address) { 5214 return BLUETOOTH_HEADSET_PRIORITY_PREFIX + address.toUpperCase(); 5215 } 5216 5217 /** 5218 * Get the key that retrieves a bluetooth a2dp sink's priority. 5219 * @hide 5220 */ getBluetoothA2dpSinkPriorityKey(String address)5221 public static final String getBluetoothA2dpSinkPriorityKey(String address) { 5222 return BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX + address.toUpperCase(); 5223 } 5224 5225 /** 5226 * Get the key that retrieves a bluetooth Input Device's priority. 5227 * @hide 5228 */ getBluetoothInputDevicePriorityKey(String address)5229 public static final String getBluetoothInputDevicePriorityKey(String address) { 5230 return BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX + address.toUpperCase(); 5231 } 5232 5233 /** 5234 * Scaling factor for normal window animations. Setting to 0 will 5235 * disable window animations. 5236 */ 5237 public static final String WINDOW_ANIMATION_SCALE = "window_animation_scale"; 5238 5239 /** 5240 * Scaling factor for activity transition animations. Setting to 0 will 5241 * disable window animations. 5242 */ 5243 public static final String TRANSITION_ANIMATION_SCALE = "transition_animation_scale"; 5244 5245 /** 5246 * Scaling factor for Animator-based animations. This affects both the 5247 * start delay and duration of all such animations. Setting to 0 will 5248 * cause animations to end immediately. The default value is 1. 5249 */ 5250 public static final String ANIMATOR_DURATION_SCALE = "animator_duration_scale"; 5251 5252 /** 5253 * Scaling factor for normal window animations. Setting to 0 will 5254 * disable window animations. 5255 * 5256 * @hide 5257 */ 5258 public static final String FANCY_IME_ANIMATIONS = "fancy_ime_animations"; 5259 5260 /** 5261 * If 0, the compatibility mode is off for all applications. 5262 * If 1, older applications run under compatibility mode. 5263 * TODO: remove this settings before code freeze (bug/1907571) 5264 * @hide 5265 */ 5266 public static final String COMPATIBILITY_MODE = "compatibility_mode"; 5267 5268 /** 5269 * CDMA only settings 5270 * Emergency Tone 0 = Off 5271 * 1 = Alert 5272 * 2 = Vibrate 5273 * @hide 5274 */ 5275 public static final String EMERGENCY_TONE = "emergency_tone"; 5276 5277 /** 5278 * CDMA only settings 5279 * Whether the auto retry is enabled. The value is 5280 * boolean (1 or 0). 5281 * @hide 5282 */ 5283 public static final String CALL_AUTO_RETRY = "call_auto_retry"; 5284 5285 /** 5286 * The preferred network mode 7 = Global 5287 * 6 = EvDo only 5288 * 5 = CDMA w/o EvDo 5289 * 4 = CDMA / EvDo auto 5290 * 3 = GSM / WCDMA auto 5291 * 2 = WCDMA only 5292 * 1 = GSM only 5293 * 0 = GSM / WCDMA preferred 5294 * @hide 5295 */ 5296 public static final String PREFERRED_NETWORK_MODE = 5297 "preferred_network_mode"; 5298 5299 /** 5300 * The cdma subscription 0 = Subscription from RUIM, when available 5301 * 1 = Subscription from NV 5302 * @hide 5303 */ 5304 public static final String PREFERRED_CDMA_SUBSCRIPTION = 5305 "preferred_cdma_subscription"; 5306 5307 /** 5308 * Name of an application package to be debugged. 5309 */ 5310 public static final String DEBUG_APP = "debug_app"; 5311 5312 /** 5313 * If 1, when launching DEBUG_APP it will wait for the debugger before 5314 * starting user code. If 0, it will run normally. 5315 */ 5316 public static final String WAIT_FOR_DEBUGGER = "wait_for_debugger"; 5317 5318 /** 5319 * Control whether the process CPU usage meter should be shown. 5320 */ 5321 public static final String SHOW_PROCESSES = "show_processes"; 5322 5323 /** 5324 * If 1, the activity manager will aggressively finish activities and 5325 * processes as soon as they are no longer needed. If 0, the normal 5326 * extended lifetime is used. 5327 */ 5328 public static final String ALWAYS_FINISH_ACTIVITIES = 5329 "always_finish_activities"; 5330 5331 /** 5332 * Use Dock audio output for media: 5333 * 0 = disabled 5334 * 1 = enabled 5335 * @hide 5336 */ 5337 public static final String DOCK_AUDIO_MEDIA_ENABLED = "dock_audio_media_enabled"; 5338 5339 /** 5340 * Persisted safe headphone volume management state by AudioService 5341 * @hide 5342 */ 5343 public static final String AUDIO_SAFE_VOLUME_STATE = "audio_safe_volume_state"; 5344 5345 /** 5346 * Settings to backup. This is here so that it's in the same place as the settings 5347 * keys and easy to update. 5348 * 5349 * These keys may be mentioned in the SETTINGS_TO_BACKUP arrays in System 5350 * and Secure as well. This is because those tables drive both backup and 5351 * restore, and restore needs to properly whitelist keys that used to live 5352 * in those namespaces. The keys will only actually be backed up / restored 5353 * if they are also mentioned in this table (Global.SETTINGS_TO_BACKUP). 5354 * 5355 * NOTE: Settings are backed up and restored in the order they appear 5356 * in this array. If you have one setting depending on another, 5357 * make sure that they are ordered appropriately. 5358 * 5359 * @hide 5360 */ 5361 public static final String[] SETTINGS_TO_BACKUP = { 5362 STAY_ON_WHILE_PLUGGED_IN, 5363 MODE_RINGER, 5364 AUTO_TIME, 5365 AUTO_TIME_ZONE, 5366 POWER_SOUNDS_ENABLED, 5367 DOCK_SOUNDS_ENABLED, 5368 USB_MASS_STORAGE_ENABLED, 5369 ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 5370 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 5371 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 5372 WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, 5373 WIFI_NUM_OPEN_NETWORKS_KEPT, 5374 EMERGENCY_TONE, 5375 CALL_AUTO_RETRY, 5376 DOCK_AUDIO_MEDIA_ENABLED 5377 }; 5378 5379 // Populated lazily, guarded by class object: 5380 private static NameValueCache sNameValueCache = new NameValueCache( 5381 SYS_PROP_SETTING_VERSION, 5382 CONTENT_URI, 5383 CALL_METHOD_GET_GLOBAL, 5384 CALL_METHOD_PUT_GLOBAL); 5385 5386 /** 5387 * Look up a name in the database. 5388 * @param resolver to access the database with 5389 * @param name to look up in the table 5390 * @return the corresponding value, or null if not present 5391 */ getString(ContentResolver resolver, String name)5392 public static String getString(ContentResolver resolver, String name) { 5393 return getStringForUser(resolver, name, UserHandle.myUserId()); 5394 } 5395 5396 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)5397 public static String getStringForUser(ContentResolver resolver, String name, 5398 int userHandle) { 5399 return sNameValueCache.getStringForUser(resolver, name, userHandle); 5400 } 5401 5402 /** 5403 * Store a name/value pair into the database. 5404 * @param resolver to access the database with 5405 * @param name to store 5406 * @param value to associate with the name 5407 * @return true if the value was set, false on database errors 5408 */ putString(ContentResolver resolver, String name, String value)5409 public static boolean putString(ContentResolver resolver, 5410 String name, String value) { 5411 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 5412 } 5413 5414 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)5415 public static boolean putStringForUser(ContentResolver resolver, 5416 String name, String value, int userHandle) { 5417 if (LOCAL_LOGV) { 5418 Log.v(TAG, "Global.putString(name=" + name + ", value=" + value 5419 + " for " + userHandle); 5420 } 5421 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 5422 } 5423 5424 /** 5425 * Construct the content URI for a particular name/value pair, 5426 * useful for monitoring changes with a ContentObserver. 5427 * @param name to look up in the table 5428 * @return the corresponding content URI, or null if not present 5429 */ getUriFor(String name)5430 public static Uri getUriFor(String name) { 5431 return getUriFor(CONTENT_URI, name); 5432 } 5433 5434 /** 5435 * Convenience function for retrieving a single secure settings value 5436 * as an integer. Note that internally setting values are always 5437 * stored as strings; this function converts the string to an integer 5438 * for you. The default value will be returned if the setting is 5439 * not defined or not an integer. 5440 * 5441 * @param cr The ContentResolver to access. 5442 * @param name The name of the setting to retrieve. 5443 * @param def Value to return if the setting is not defined. 5444 * 5445 * @return The setting's current value, or 'def' if it is not defined 5446 * or not a valid integer. 5447 */ getInt(ContentResolver cr, String name, int def)5448 public static int getInt(ContentResolver cr, String name, int def) { 5449 String v = getString(cr, name); 5450 try { 5451 return v != null ? Integer.parseInt(v) : def; 5452 } catch (NumberFormatException e) { 5453 return def; 5454 } 5455 } 5456 5457 /** 5458 * Convenience function for retrieving a single secure settings value 5459 * as an integer. Note that internally setting values are always 5460 * stored as strings; this function converts the string to an integer 5461 * for you. 5462 * <p> 5463 * This version does not take a default value. If the setting has not 5464 * been set, or the string value is not a number, 5465 * it throws {@link SettingNotFoundException}. 5466 * 5467 * @param cr The ContentResolver to access. 5468 * @param name The name of the setting to retrieve. 5469 * 5470 * @throws SettingNotFoundException Thrown if a setting by the given 5471 * name can't be found or the setting value is not an integer. 5472 * 5473 * @return The setting's current value. 5474 */ getInt(ContentResolver cr, String name)5475 public static int getInt(ContentResolver cr, String name) 5476 throws SettingNotFoundException { 5477 String v = getString(cr, name); 5478 try { 5479 return Integer.parseInt(v); 5480 } catch (NumberFormatException e) { 5481 throw new SettingNotFoundException(name); 5482 } 5483 } 5484 5485 /** 5486 * Convenience function for updating a single settings value as an 5487 * integer. This will either create a new entry in the table if the 5488 * given name does not exist, or modify the value of the existing row 5489 * with that name. Note that internally setting values are always 5490 * stored as strings, so this function converts the given value to a 5491 * string before storing it. 5492 * 5493 * @param cr The ContentResolver to access. 5494 * @param name The name of the setting to modify. 5495 * @param value The new value for the setting. 5496 * @return true if the value was set, false on database errors 5497 */ putInt(ContentResolver cr, String name, int value)5498 public static boolean putInt(ContentResolver cr, String name, int value) { 5499 return putString(cr, name, Integer.toString(value)); 5500 } 5501 5502 /** 5503 * Convenience function for retrieving a single secure settings value 5504 * as a {@code long}. Note that internally setting values are always 5505 * stored as strings; this function converts the string to a {@code long} 5506 * for you. The default value will be returned if the setting is 5507 * not defined or not a {@code long}. 5508 * 5509 * @param cr The ContentResolver to access. 5510 * @param name The name of the setting to retrieve. 5511 * @param def Value to return if the setting is not defined. 5512 * 5513 * @return The setting's current value, or 'def' if it is not defined 5514 * or not a valid {@code long}. 5515 */ getLong(ContentResolver cr, String name, long def)5516 public static long getLong(ContentResolver cr, String name, long def) { 5517 String valString = getString(cr, name); 5518 long value; 5519 try { 5520 value = valString != null ? Long.parseLong(valString) : def; 5521 } catch (NumberFormatException e) { 5522 value = def; 5523 } 5524 return value; 5525 } 5526 5527 /** 5528 * Convenience function for retrieving a single secure settings value 5529 * as a {@code long}. Note that internally setting values are always 5530 * stored as strings; this function converts the string to a {@code long} 5531 * for you. 5532 * <p> 5533 * This version does not take a default value. If the setting has not 5534 * been set, or the string value is not a number, 5535 * it throws {@link SettingNotFoundException}. 5536 * 5537 * @param cr The ContentResolver to access. 5538 * @param name The name of the setting to retrieve. 5539 * 5540 * @return The setting's current value. 5541 * @throws SettingNotFoundException Thrown if a setting by the given 5542 * name can't be found or the setting value is not an integer. 5543 */ getLong(ContentResolver cr, String name)5544 public static long getLong(ContentResolver cr, String name) 5545 throws SettingNotFoundException { 5546 String valString = getString(cr, name); 5547 try { 5548 return Long.parseLong(valString); 5549 } catch (NumberFormatException e) { 5550 throw new SettingNotFoundException(name); 5551 } 5552 } 5553 5554 /** 5555 * Convenience function for updating a secure settings value as a long 5556 * integer. This will either create a new entry in the table if the 5557 * given name does not exist, or modify the value of the existing row 5558 * with that name. Note that internally setting values are always 5559 * stored as strings, so this function converts the given value to a 5560 * string before storing it. 5561 * 5562 * @param cr The ContentResolver to access. 5563 * @param name The name of the setting to modify. 5564 * @param value The new value for the setting. 5565 * @return true if the value was set, false on database errors 5566 */ putLong(ContentResolver cr, String name, long value)5567 public static boolean putLong(ContentResolver cr, String name, long value) { 5568 return putString(cr, name, Long.toString(value)); 5569 } 5570 5571 /** 5572 * Convenience function for retrieving a single secure settings value 5573 * as a floating point number. Note that internally setting values are 5574 * always stored as strings; this function converts the string to an 5575 * float for you. The default value will be returned if the setting 5576 * is not defined or not a valid float. 5577 * 5578 * @param cr The ContentResolver to access. 5579 * @param name The name of the setting to retrieve. 5580 * @param def Value to return if the setting is not defined. 5581 * 5582 * @return The setting's current value, or 'def' if it is not defined 5583 * or not a valid float. 5584 */ getFloat(ContentResolver cr, String name, float def)5585 public static float getFloat(ContentResolver cr, String name, float def) { 5586 String v = getString(cr, name); 5587 try { 5588 return v != null ? Float.parseFloat(v) : def; 5589 } catch (NumberFormatException e) { 5590 return def; 5591 } 5592 } 5593 5594 /** 5595 * Convenience function for retrieving a single secure settings value 5596 * as a float. Note that internally setting values are always 5597 * stored as strings; this function converts the string to a float 5598 * for you. 5599 * <p> 5600 * This version does not take a default value. If the setting has not 5601 * been set, or the string value is not a number, 5602 * it throws {@link SettingNotFoundException}. 5603 * 5604 * @param cr The ContentResolver to access. 5605 * @param name The name of the setting to retrieve. 5606 * 5607 * @throws SettingNotFoundException Thrown if a setting by the given 5608 * name can't be found or the setting value is not a float. 5609 * 5610 * @return The setting's current value. 5611 */ getFloat(ContentResolver cr, String name)5612 public static float getFloat(ContentResolver cr, String name) 5613 throws SettingNotFoundException { 5614 String v = getString(cr, name); 5615 if (v == null) { 5616 throw new SettingNotFoundException(name); 5617 } 5618 try { 5619 return Float.parseFloat(v); 5620 } catch (NumberFormatException e) { 5621 throw new SettingNotFoundException(name); 5622 } 5623 } 5624 5625 /** 5626 * Convenience function for updating a single settings value as a 5627 * floating point number. This will either create a new entry in the 5628 * table if the given name does not exist, or modify the value of the 5629 * existing row with that name. Note that internally setting values 5630 * are always stored as strings, so this function converts the given 5631 * value to a string before storing it. 5632 * 5633 * @param cr The ContentResolver to access. 5634 * @param name The name of the setting to modify. 5635 * @param value The new value for the setting. 5636 * @return true if the value was set, false on database errors 5637 */ putFloat(ContentResolver cr, String name, float value)5638 public static boolean putFloat(ContentResolver cr, String name, float value) { 5639 return putString(cr, name, Float.toString(value)); 5640 } 5641 } 5642 5643 /** 5644 * User-defined bookmarks and shortcuts. The target of each bookmark is an 5645 * Intent URL, allowing it to be either a web page or a particular 5646 * application activity. 5647 * 5648 * @hide 5649 */ 5650 public static final class Bookmarks implements BaseColumns 5651 { 5652 private static final String TAG = "Bookmarks"; 5653 5654 /** 5655 * The content:// style URL for this table 5656 */ 5657 public static final Uri CONTENT_URI = 5658 Uri.parse("content://" + AUTHORITY + "/bookmarks"); 5659 5660 /** 5661 * The row ID. 5662 * <p>Type: INTEGER</p> 5663 */ 5664 public static final String ID = "_id"; 5665 5666 /** 5667 * Descriptive name of the bookmark that can be displayed to the user. 5668 * If this is empty, the title should be resolved at display time (use 5669 * {@link #getTitle(Context, Cursor)} any time you want to display the 5670 * title of a bookmark.) 5671 * <P> 5672 * Type: TEXT 5673 * </P> 5674 */ 5675 public static final String TITLE = "title"; 5676 5677 /** 5678 * Arbitrary string (displayed to the user) that allows bookmarks to be 5679 * organized into categories. There are some special names for 5680 * standard folders, which all start with '@'. The label displayed for 5681 * the folder changes with the locale (via {@link #getLabelForFolder}) but 5682 * the folder name does not change so you can consistently query for 5683 * the folder regardless of the current locale. 5684 * 5685 * <P>Type: TEXT</P> 5686 * 5687 */ 5688 public static final String FOLDER = "folder"; 5689 5690 /** 5691 * The Intent URL of the bookmark, describing what it points to. This 5692 * value is given to {@link android.content.Intent#getIntent} to create 5693 * an Intent that can be launched. 5694 * <P>Type: TEXT</P> 5695 */ 5696 public static final String INTENT = "intent"; 5697 5698 /** 5699 * Optional shortcut character associated with this bookmark. 5700 * <P>Type: INTEGER</P> 5701 */ 5702 public static final String SHORTCUT = "shortcut"; 5703 5704 /** 5705 * The order in which the bookmark should be displayed 5706 * <P>Type: INTEGER</P> 5707 */ 5708 public static final String ORDERING = "ordering"; 5709 5710 private static final String[] sIntentProjection = { INTENT }; 5711 private static final String[] sShortcutProjection = { ID, SHORTCUT }; 5712 private static final String sShortcutSelection = SHORTCUT + "=?"; 5713 5714 /** 5715 * Convenience function to retrieve the bookmarked Intent for a 5716 * particular shortcut key. 5717 * 5718 * @param cr The ContentResolver to query. 5719 * @param shortcut The shortcut key. 5720 * 5721 * @return Intent The bookmarked URL, or null if there is no bookmark 5722 * matching the given shortcut. 5723 */ getIntentForShortcut(ContentResolver cr, char shortcut)5724 public static Intent getIntentForShortcut(ContentResolver cr, char shortcut) 5725 { 5726 Intent intent = null; 5727 5728 Cursor c = cr.query(CONTENT_URI, 5729 sIntentProjection, sShortcutSelection, 5730 new String[] { String.valueOf((int) shortcut) }, ORDERING); 5731 // Keep trying until we find a valid shortcut 5732 try { 5733 while (intent == null && c.moveToNext()) { 5734 try { 5735 String intentURI = c.getString(c.getColumnIndexOrThrow(INTENT)); 5736 intent = Intent.parseUri(intentURI, 0); 5737 } catch (java.net.URISyntaxException e) { 5738 // The stored URL is bad... ignore it. 5739 } catch (IllegalArgumentException e) { 5740 // Column not found 5741 Log.w(TAG, "Intent column not found", e); 5742 } 5743 } 5744 } finally { 5745 if (c != null) c.close(); 5746 } 5747 5748 return intent; 5749 } 5750 5751 /** 5752 * Add a new bookmark to the system. 5753 * 5754 * @param cr The ContentResolver to query. 5755 * @param intent The desired target of the bookmark. 5756 * @param title Bookmark title that is shown to the user; null if none 5757 * or it should be resolved to the intent's title. 5758 * @param folder Folder in which to place the bookmark; null if none. 5759 * @param shortcut Shortcut that will invoke the bookmark; 0 if none. If 5760 * this is non-zero and there is an existing bookmark entry 5761 * with this same shortcut, then that existing shortcut is 5762 * cleared (the bookmark is not removed). 5763 * @return The unique content URL for the new bookmark entry. 5764 */ add(ContentResolver cr, Intent intent, String title, String folder, char shortcut, int ordering)5765 public static Uri add(ContentResolver cr, 5766 Intent intent, 5767 String title, 5768 String folder, 5769 char shortcut, 5770 int ordering) 5771 { 5772 // If a shortcut is supplied, and it is already defined for 5773 // another bookmark, then remove the old definition. 5774 if (shortcut != 0) { 5775 cr.delete(CONTENT_URI, sShortcutSelection, 5776 new String[] { String.valueOf((int) shortcut) }); 5777 } 5778 5779 ContentValues values = new ContentValues(); 5780 if (title != null) values.put(TITLE, title); 5781 if (folder != null) values.put(FOLDER, folder); 5782 values.put(INTENT, intent.toUri(0)); 5783 if (shortcut != 0) values.put(SHORTCUT, (int) shortcut); 5784 values.put(ORDERING, ordering); 5785 return cr.insert(CONTENT_URI, values); 5786 } 5787 5788 /** 5789 * Return the folder name as it should be displayed to the user. This 5790 * takes care of localizing special folders. 5791 * 5792 * @param r Resources object for current locale; only need access to 5793 * system resources. 5794 * @param folder The value found in the {@link #FOLDER} column. 5795 * 5796 * @return CharSequence The label for this folder that should be shown 5797 * to the user. 5798 */ getLabelForFolder(Resources r, String folder)5799 public static CharSequence getLabelForFolder(Resources r, String folder) { 5800 return folder; 5801 } 5802 5803 /** 5804 * Return the title as it should be displayed to the user. This takes 5805 * care of localizing bookmarks that point to activities. 5806 * 5807 * @param context A context. 5808 * @param cursor A cursor pointing to the row whose title should be 5809 * returned. The cursor must contain at least the {@link #TITLE} 5810 * and {@link #INTENT} columns. 5811 * @return A title that is localized and can be displayed to the user, 5812 * or the empty string if one could not be found. 5813 */ getTitle(Context context, Cursor cursor)5814 public static CharSequence getTitle(Context context, Cursor cursor) { 5815 int titleColumn = cursor.getColumnIndex(TITLE); 5816 int intentColumn = cursor.getColumnIndex(INTENT); 5817 if (titleColumn == -1 || intentColumn == -1) { 5818 throw new IllegalArgumentException( 5819 "The cursor must contain the TITLE and INTENT columns."); 5820 } 5821 5822 String title = cursor.getString(titleColumn); 5823 if (!TextUtils.isEmpty(title)) { 5824 return title; 5825 } 5826 5827 String intentUri = cursor.getString(intentColumn); 5828 if (TextUtils.isEmpty(intentUri)) { 5829 return ""; 5830 } 5831 5832 Intent intent; 5833 try { 5834 intent = Intent.parseUri(intentUri, 0); 5835 } catch (URISyntaxException e) { 5836 return ""; 5837 } 5838 5839 PackageManager packageManager = context.getPackageManager(); 5840 ResolveInfo info = packageManager.resolveActivity(intent, 0); 5841 return info != null ? info.loadLabel(packageManager) : ""; 5842 } 5843 } 5844 5845 /** 5846 * Returns the device ID that we should use when connecting to the mobile gtalk server. 5847 * This is a string like "android-0x1242", where the hex string is the Android ID obtained 5848 * from the GoogleLoginService. 5849 * 5850 * @param androidId The Android ID for this device. 5851 * @return The device ID that should be used when connecting to the mobile gtalk server. 5852 * @hide 5853 */ getGTalkDeviceId(long androidId)5854 public static String getGTalkDeviceId(long androidId) { 5855 return "android-" + Long.toHexString(androidId); 5856 } 5857 } 5858