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.content.ComponentName; 23 import android.content.ContentResolver; 24 import android.content.ContentValues; 25 import android.content.Context; 26 import android.content.IContentProvider; 27 import android.content.Intent; 28 import android.content.pm.ActivityInfo; 29 import android.content.pm.PackageManager; 30 import android.content.pm.ResolveInfo; 31 import android.content.res.Configuration; 32 import android.content.res.Resources; 33 import android.database.Cursor; 34 import android.database.SQLException; 35 import android.net.Uri; 36 import android.net.wifi.WifiManager; 37 import android.os.BatteryManager; 38 import android.os.Bundle; 39 import android.os.RemoteException; 40 import android.os.SystemProperties; 41 import android.speech.tts.TextToSpeech; 42 import android.text.TextUtils; 43 import android.util.AndroidException; 44 import android.util.Log; 45 import android.view.WindowOrientationListener; 46 47 import java.net.URISyntaxException; 48 import java.util.HashMap; 49 import java.util.HashSet; 50 51 /** 52 * The Settings provider contains global system-level device preferences. 53 */ 54 public final class Settings { 55 56 // Intent actions for Settings 57 58 /** 59 * Activity Action: Show system settings. 60 * <p> 61 * Input: Nothing. 62 * <p> 63 * Output: Nothing. 64 */ 65 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 66 public static final String ACTION_SETTINGS = "android.settings.SETTINGS"; 67 68 /** 69 * Activity Action: Show settings to allow configuration of APNs. 70 * <p> 71 * Input: Nothing. 72 * <p> 73 * Output: Nothing. 74 */ 75 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 76 public static final String ACTION_APN_SETTINGS = "android.settings.APN_SETTINGS"; 77 78 /** 79 * Activity Action: Show settings to allow configuration of current location 80 * sources. 81 * <p> 82 * In some cases, a matching Activity may not exist, so ensure you 83 * safeguard against this. 84 * <p> 85 * Input: Nothing. 86 * <p> 87 * Output: Nothing. 88 */ 89 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 90 public static final String ACTION_LOCATION_SOURCE_SETTINGS = 91 "android.settings.LOCATION_SOURCE_SETTINGS"; 92 93 /** 94 * Activity Action: Show settings to allow configuration of wireless controls 95 * such as Wi-Fi, Bluetooth and Mobile networks. 96 * <p> 97 * In some cases, a matching Activity may not exist, so ensure you 98 * safeguard against this. 99 * <p> 100 * Input: Nothing. 101 * <p> 102 * Output: Nothing. 103 */ 104 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 105 public static final String ACTION_WIRELESS_SETTINGS = 106 "android.settings.WIRELESS_SETTINGS"; 107 108 /** 109 * Activity Action: Show settings to allow entering/exiting airplane mode. 110 * <p> 111 * In some cases, a matching Activity may not exist, so ensure you 112 * safeguard against this. 113 * <p> 114 * Input: Nothing. 115 * <p> 116 * Output: Nothing. 117 */ 118 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 119 public static final String ACTION_AIRPLANE_MODE_SETTINGS = 120 "android.settings.AIRPLANE_MODE_SETTINGS"; 121 122 /** 123 * Activity Action: Show settings for accessibility modules. 124 * <p> 125 * In some cases, a matching Activity may not exist, so ensure you 126 * safeguard against this. 127 * <p> 128 * Input: Nothing. 129 * <p> 130 * Output: Nothing. 131 */ 132 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 133 public static final String ACTION_ACCESSIBILITY_SETTINGS = 134 "android.settings.ACCESSIBILITY_SETTINGS"; 135 136 /** 137 * Activity Action: Show settings to allow configuration of security and 138 * location privacy. 139 * <p> 140 * In some cases, a matching Activity may not exist, so ensure you 141 * safeguard against this. 142 * <p> 143 * Input: Nothing. 144 * <p> 145 * Output: Nothing. 146 */ 147 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 148 public static final String ACTION_SECURITY_SETTINGS = 149 "android.settings.SECURITY_SETTINGS"; 150 151 /** 152 * Activity Action: Show settings to allow configuration of privacy options. 153 * <p> 154 * In some cases, a matching Activity may not exist, so ensure you 155 * safeguard against this. 156 * <p> 157 * Input: Nothing. 158 * <p> 159 * Output: Nothing. 160 */ 161 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 162 public static final String ACTION_PRIVACY_SETTINGS = 163 "android.settings.PRIVACY_SETTINGS"; 164 165 /** 166 * Activity Action: Show settings to allow configuration of Wi-Fi. 167 168 * <p> 169 * In some cases, a matching Activity may not exist, so ensure you 170 * safeguard against this. 171 * <p> 172 * Input: Nothing. 173 * <p> 174 * Output: Nothing. 175 176 */ 177 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 178 public static final String ACTION_WIFI_SETTINGS = 179 "android.settings.WIFI_SETTINGS"; 180 181 /** 182 * Activity Action: Show settings to allow configuration of a static IP 183 * address for Wi-Fi. 184 * <p> 185 * In some cases, a matching Activity may not exist, so ensure you safeguard 186 * against this. 187 * <p> 188 * Input: Nothing. 189 * <p> 190 * Output: Nothing. 191 */ 192 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 193 public static final String ACTION_WIFI_IP_SETTINGS = 194 "android.settings.WIFI_IP_SETTINGS"; 195 196 /** 197 * Activity Action: Show settings to allow configuration of Bluetooth. 198 * <p> 199 * In some cases, a matching Activity may not exist, so ensure you 200 * safeguard against this. 201 * <p> 202 * Input: Nothing. 203 * <p> 204 * Output: Nothing. 205 */ 206 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 207 public static final String ACTION_BLUETOOTH_SETTINGS = 208 "android.settings.BLUETOOTH_SETTINGS"; 209 210 /** 211 * Activity Action: Show settings to allow configuration of date and time. 212 * <p> 213 * In some cases, a matching Activity may not exist, so ensure you 214 * safeguard against this. 215 * <p> 216 * Input: Nothing. 217 * <p> 218 * Output: Nothing. 219 */ 220 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 221 public static final String ACTION_DATE_SETTINGS = 222 "android.settings.DATE_SETTINGS"; 223 224 /** 225 * Activity Action: Show settings to allow configuration of sound and volume. 226 * <p> 227 * In some cases, a matching Activity may not exist, so ensure you 228 * safeguard against this. 229 * <p> 230 * Input: Nothing. 231 * <p> 232 * Output: Nothing. 233 */ 234 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 235 public static final String ACTION_SOUND_SETTINGS = 236 "android.settings.SOUND_SETTINGS"; 237 238 /** 239 * Activity Action: Show settings to allow configuration of display. 240 * <p> 241 * In some cases, a matching Activity may not exist, so ensure you 242 * safeguard against this. 243 * <p> 244 * Input: Nothing. 245 * <p> 246 * Output: Nothing. 247 */ 248 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 249 public static final String ACTION_DISPLAY_SETTINGS = 250 "android.settings.DISPLAY_SETTINGS"; 251 252 /** 253 * Activity Action: Show settings to allow configuration of locale. 254 * <p> 255 * In some cases, a matching Activity may not exist, so ensure you 256 * safeguard against this. 257 * <p> 258 * Input: Nothing. 259 * <p> 260 * Output: Nothing. 261 */ 262 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 263 public static final String ACTION_LOCALE_SETTINGS = 264 "android.settings.LOCALE_SETTINGS"; 265 266 /** 267 * Activity Action: Show settings to configure input methods, in particular 268 * allowing the user to enable input methods. 269 * <p> 270 * In some cases, a matching Activity may not exist, so ensure you 271 * safeguard against this. 272 * <p> 273 * Input: Nothing. 274 * <p> 275 * Output: Nothing. 276 */ 277 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 278 public static final String ACTION_INPUT_METHOD_SETTINGS = 279 "android.settings.INPUT_METHOD_SETTINGS"; 280 281 /** 282 * Activity Action: Show settings to enable/disable input method subtypes. 283 * <p> 284 * In some cases, a matching Activity may not exist, so ensure you 285 * safeguard against this. 286 * <p> 287 * To tell which input method's subtypes are displayed in the settings, add 288 * {@link #EXTRA_INPUT_METHOD_ID} extra to this Intent with the input method id. 289 * If there is no extra in this Intent, subtypes from all installed input methods 290 * will be displayed in the settings. 291 * 292 * @see android.view.inputmethod.InputMethodInfo#getId 293 * <p> 294 * Input: Nothing. 295 * <p> 296 * Output: Nothing. 297 */ 298 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 299 public static final String ACTION_INPUT_METHOD_SUBTYPE_SETTINGS = 300 "android.settings.INPUT_METHOD_SUBTYPE_SETTINGS"; 301 302 /** 303 * Activity Action: Show a dialog to select input method. 304 * <p> 305 * In some cases, a matching Activity may not exist, so ensure you 306 * safeguard against this. 307 * <p> 308 * Input: Nothing. 309 * <p> 310 * Output: Nothing. 311 * @hide 312 */ 313 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 314 public static final String ACTION_SHOW_INPUT_METHOD_PICKER = 315 "android.settings.SHOW_INPUT_METHOD_PICKER"; 316 317 /** 318 * Activity Action: Show settings to manage the user input dictionary. 319 * <p> 320 * In some cases, a matching Activity may not exist, so ensure you 321 * safeguard against this. 322 * <p> 323 * Input: Nothing. 324 * <p> 325 * Output: Nothing. 326 */ 327 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 328 public static final String ACTION_USER_DICTIONARY_SETTINGS = 329 "android.settings.USER_DICTIONARY_SETTINGS"; 330 331 /** 332 * Activity Action: Adds a word to the user dictionary. 333 * <p> 334 * In some cases, a matching Activity may not exist, so ensure you 335 * safeguard against this. 336 * <p> 337 * Input: An extra with key <code>word</code> that contains the word 338 * that should be added to the dictionary. 339 * <p> 340 * Output: Nothing. 341 * 342 * @hide 343 */ 344 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 345 public static final String ACTION_USER_DICTIONARY_INSERT = 346 "com.android.settings.USER_DICTIONARY_INSERT"; 347 348 /** 349 * Activity Action: Show settings to allow configuration of application-related settings. 350 * <p> 351 * In some cases, a matching Activity may not exist, so ensure you 352 * safeguard against this. 353 * <p> 354 * Input: Nothing. 355 * <p> 356 * Output: Nothing. 357 */ 358 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 359 public static final String ACTION_APPLICATION_SETTINGS = 360 "android.settings.APPLICATION_SETTINGS"; 361 362 /** 363 * Activity Action: Show settings to allow configuration of application 364 * development-related settings. 365 * <p> 366 * In some cases, a matching Activity may not exist, so ensure you safeguard 367 * against this. 368 * <p> 369 * Input: Nothing. 370 * <p> 371 * Output: Nothing. 372 */ 373 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 374 public static final String ACTION_APPLICATION_DEVELOPMENT_SETTINGS = 375 "android.settings.APPLICATION_DEVELOPMENT_SETTINGS"; 376 377 /** 378 * Activity Action: Show settings to allow configuration of quick launch shortcuts. 379 * <p> 380 * In some cases, a matching Activity may not exist, so ensure you 381 * safeguard against this. 382 * <p> 383 * Input: Nothing. 384 * <p> 385 * Output: Nothing. 386 */ 387 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 388 public static final String ACTION_QUICK_LAUNCH_SETTINGS = 389 "android.settings.QUICK_LAUNCH_SETTINGS"; 390 391 /** 392 * Activity Action: Show settings to manage installed applications. 393 * <p> 394 * In some cases, a matching Activity may not exist, so ensure you 395 * safeguard against this. 396 * <p> 397 * Input: Nothing. 398 * <p> 399 * Output: Nothing. 400 */ 401 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 402 public static final String ACTION_MANAGE_APPLICATIONS_SETTINGS = 403 "android.settings.MANAGE_APPLICATIONS_SETTINGS"; 404 405 /** 406 * Activity Action: Show settings to manage all applications. 407 * <p> 408 * In some cases, a matching Activity may not exist, so ensure you 409 * safeguard against this. 410 * <p> 411 * Input: Nothing. 412 * <p> 413 * Output: Nothing. 414 */ 415 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 416 public static final String ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS = 417 "android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS"; 418 419 /** 420 * Activity Action: Show screen of details about a particular application. 421 * <p> 422 * In some cases, a matching Activity may not exist, so ensure you 423 * safeguard against this. 424 * <p> 425 * Input: The Intent's data URI specifies the application package name 426 * to be shown, with the "package" scheme. That is "package:com.my.app". 427 * <p> 428 * Output: Nothing. 429 */ 430 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 431 public static final String ACTION_APPLICATION_DETAILS_SETTINGS = 432 "android.settings.APPLICATION_DETAILS_SETTINGS"; 433 434 /** 435 * Activity Action: Show settings for system update functionality. 436 * <p> 437 * In some cases, a matching Activity may not exist, so ensure you 438 * safeguard against this. 439 * <p> 440 * Input: Nothing. 441 * <p> 442 * Output: Nothing. 443 * 444 * @hide 445 */ 446 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 447 public static final String ACTION_SYSTEM_UPDATE_SETTINGS = 448 "android.settings.SYSTEM_UPDATE_SETTINGS"; 449 450 /** 451 * Activity Action: Show settings to allow configuration of sync settings. 452 * <p> 453 * In some cases, a matching Activity may not exist, so ensure you 454 * safeguard against this. 455 * <p> 456 * The account types available to add via the add account button may be restricted by adding an 457 * {@link #EXTRA_AUTHORITIES} extra to this Intent with one or more syncable content provider's 458 * authorities. Only account types which can sync with that content provider will be offered to 459 * the user. 460 * <p> 461 * Input: Nothing. 462 * <p> 463 * Output: Nothing. 464 */ 465 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 466 public static final String ACTION_SYNC_SETTINGS = 467 "android.settings.SYNC_SETTINGS"; 468 469 /** 470 * Activity Action: Show add account screen for creating a new account. 471 * <p> 472 * In some cases, a matching Activity may not exist, so ensure you 473 * safeguard against this. 474 * <p> 475 * The account types available to add may be restricted by adding an {@link #EXTRA_AUTHORITIES} 476 * extra to the Intent with one or more syncable content provider's authorities. Only account 477 * types which can sync with that content provider will be offered to the user. 478 * <p> 479 * Input: Nothing. 480 * <p> 481 * Output: Nothing. 482 */ 483 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 484 public static final String ACTION_ADD_ACCOUNT = 485 "android.settings.ADD_ACCOUNT_SETTINGS"; 486 487 /** 488 * Activity Action: Show settings for selecting the network operator. 489 * <p> 490 * In some cases, a matching Activity may not exist, so ensure you 491 * safeguard against this. 492 * <p> 493 * Input: Nothing. 494 * <p> 495 * Output: Nothing. 496 */ 497 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 498 public static final String ACTION_NETWORK_OPERATOR_SETTINGS = 499 "android.settings.NETWORK_OPERATOR_SETTINGS"; 500 501 /** 502 * Activity Action: Show settings for selection of 2G/3G. 503 * <p> 504 * In some cases, a matching Activity may not exist, so ensure you 505 * safeguard against this. 506 * <p> 507 * Input: Nothing. 508 * <p> 509 * Output: Nothing. 510 */ 511 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 512 public static final String ACTION_DATA_ROAMING_SETTINGS = 513 "android.settings.DATA_ROAMING_SETTINGS"; 514 515 /** 516 * Activity Action: Show settings for internal storage. 517 * <p> 518 * In some cases, a matching Activity may not exist, so ensure you 519 * safeguard against this. 520 * <p> 521 * Input: Nothing. 522 * <p> 523 * Output: Nothing. 524 */ 525 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 526 public static final String ACTION_INTERNAL_STORAGE_SETTINGS = 527 "android.settings.INTERNAL_STORAGE_SETTINGS"; 528 /** 529 * Activity Action: Show settings for memory card storage. 530 * <p> 531 * In some cases, a matching Activity may not exist, so ensure you 532 * safeguard against this. 533 * <p> 534 * Input: Nothing. 535 * <p> 536 * Output: Nothing. 537 */ 538 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 539 public static final String ACTION_MEMORY_CARD_SETTINGS = 540 "android.settings.MEMORY_CARD_SETTINGS"; 541 542 /** 543 * Activity Action: Show settings for global search. 544 * <p> 545 * In some cases, a matching Activity may not exist, so ensure you 546 * safeguard against this. 547 * <p> 548 * Input: Nothing. 549 * <p> 550 * Output: Nothing 551 */ 552 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 553 public static final String ACTION_SEARCH_SETTINGS = 554 "android.search.action.SEARCH_SETTINGS"; 555 556 /** 557 * Activity Action: Show general device information settings (serial 558 * number, software version, phone number, etc.). 559 * <p> 560 * In some cases, a matching Activity may not exist, so ensure you 561 * safeguard against this. 562 * <p> 563 * Input: Nothing. 564 * <p> 565 * Output: Nothing 566 */ 567 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 568 public static final String ACTION_DEVICE_INFO_SETTINGS = 569 "android.settings.DEVICE_INFO_SETTINGS"; 570 571 /** 572 * Activity Action: Show NFC sharing settings. 573 * <p> 574 * In some cases, a matching Activity may not exist, so ensure you 575 * safeguard against this. 576 * <p> 577 * Input: Nothing. 578 * <p> 579 * Output: Nothing 580 */ 581 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 582 public static final String ACTION_NFCSHARING_SETTINGS = 583 "android.settings.NFCSHARING_SETTINGS"; 584 585 // End of Intent actions for Settings 586 587 /** 588 * @hide - Private call() method on SettingsProvider to read from 'system' table. 589 */ 590 public static final String CALL_METHOD_GET_SYSTEM = "GET_system"; 591 592 /** 593 * @hide - Private call() method on SettingsProvider to read from 'secure' table. 594 */ 595 public static final String CALL_METHOD_GET_SECURE = "GET_secure"; 596 597 /** 598 * Activity Extra: Limit available options in launched activity based on the given authority. 599 * <p> 600 * This can be passed as an extra field in an Activity Intent with one or more syncable content 601 * provider's authorities as a String[]. This field is used by some intents to alter the 602 * behavior of the called activity. 603 * <p> 604 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types available based 605 * on the authority given. 606 */ 607 public static final String EXTRA_AUTHORITIES = 608 "authorities"; 609 610 public static final String EXTRA_INPUT_METHOD_ID = "input_method_id"; 611 612 private static final String JID_RESOURCE_PREFIX = "android"; 613 614 public static final String AUTHORITY = "settings"; 615 616 private static final String TAG = "Settings"; 617 private static final boolean LOCAL_LOGV = false || false; 618 619 public static class SettingNotFoundException extends AndroidException { SettingNotFoundException(String msg)620 public SettingNotFoundException(String msg) { 621 super(msg); 622 } 623 } 624 625 /** 626 * Common base for tables of name/value settings. 627 */ 628 public static class NameValueTable implements BaseColumns { 629 public static final String NAME = "name"; 630 public static final String VALUE = "value"; 631 putString(ContentResolver resolver, Uri uri, String name, String value)632 protected static boolean putString(ContentResolver resolver, Uri uri, 633 String name, String value) { 634 // The database will take care of replacing duplicates. 635 try { 636 ContentValues values = new ContentValues(); 637 values.put(NAME, name); 638 values.put(VALUE, value); 639 resolver.insert(uri, values); 640 return true; 641 } catch (SQLException e) { 642 Log.w(TAG, "Can't set key " + name + " in " + uri, e); 643 return false; 644 } 645 } 646 getUriFor(Uri uri, String name)647 public static Uri getUriFor(Uri uri, String name) { 648 return Uri.withAppendedPath(uri, name); 649 } 650 } 651 652 // Thread-safe. 653 private static class NameValueCache { 654 private final String mVersionSystemProperty; 655 private final Uri mUri; 656 657 private static final String[] SELECT_VALUE = 658 new String[] { Settings.NameValueTable.VALUE }; 659 private static final String NAME_EQ_PLACEHOLDER = "name=?"; 660 661 // Must synchronize on 'this' to access mValues and mValuesVersion. 662 private final HashMap<String, String> mValues = new HashMap<String, String>(); 663 private long mValuesVersion = 0; 664 665 // Initially null; set lazily and held forever. Synchronized on 'this'. 666 private IContentProvider mContentProvider = null; 667 668 // The method we'll call (or null, to not use) on the provider 669 // for the fast path of retrieving settings. 670 private final String mCallCommand; 671 NameValueCache(String versionSystemProperty, Uri uri, String callCommand)672 public NameValueCache(String versionSystemProperty, Uri uri, String callCommand) { 673 mVersionSystemProperty = versionSystemProperty; 674 mUri = uri; 675 mCallCommand = callCommand; 676 } 677 getString(ContentResolver cr, String name)678 public String getString(ContentResolver cr, String name) { 679 long newValuesVersion = SystemProperties.getLong(mVersionSystemProperty, 0); 680 681 synchronized (this) { 682 if (mValuesVersion != newValuesVersion) { 683 if (LOCAL_LOGV) { 684 Log.v(TAG, "invalidate [" + mUri.getLastPathSegment() + "]: current " + 685 newValuesVersion + " != cached " + mValuesVersion); 686 } 687 688 mValues.clear(); 689 mValuesVersion = newValuesVersion; 690 } 691 692 if (mValues.containsKey(name)) { 693 return mValues.get(name); // Could be null, that's OK -- negative caching 694 } 695 } 696 697 IContentProvider cp = null; 698 synchronized (this) { 699 cp = mContentProvider; 700 if (cp == null) { 701 cp = mContentProvider = cr.acquireProvider(mUri.getAuthority()); 702 } 703 } 704 705 // Try the fast path first, not using query(). If this 706 // fails (alternate Settings provider that doesn't support 707 // this interface?) then we fall back to the query/table 708 // interface. 709 if (mCallCommand != null) { 710 try { 711 Bundle b = cp.call(mCallCommand, name, null); 712 if (b != null) { 713 String value = b.getPairValue(); 714 synchronized (this) { 715 mValues.put(name, value); 716 } 717 return value; 718 } 719 // If the response Bundle is null, we fall through 720 // to the query interface below. 721 } catch (RemoteException e) { 722 // Not supported by the remote side? Fall through 723 // to query(). 724 } 725 } 726 727 Cursor c = null; 728 try { 729 c = cp.query(mUri, SELECT_VALUE, NAME_EQ_PLACEHOLDER, 730 new String[]{name}, null); 731 if (c == null) { 732 Log.w(TAG, "Can't get key " + name + " from " + mUri); 733 return null; 734 } 735 736 String value = c.moveToNext() ? c.getString(0) : null; 737 synchronized (this) { 738 mValues.put(name, value); 739 } 740 if (LOCAL_LOGV) { 741 Log.v(TAG, "cache miss [" + mUri.getLastPathSegment() + "]: " + 742 name + " = " + (value == null ? "(null)" : value)); 743 } 744 return value; 745 } catch (RemoteException e) { 746 Log.w(TAG, "Can't get key " + name + " from " + mUri, e); 747 return null; // Return null, but don't cache it. 748 } finally { 749 if (c != null) c.close(); 750 } 751 } 752 } 753 754 /** 755 * System settings, containing miscellaneous system preferences. This 756 * table holds simple name/value pairs. There are convenience 757 * functions for accessing individual settings entries. 758 */ 759 public static final class System extends NameValueTable { 760 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_system_version"; 761 762 // Populated lazily, guarded by class object: 763 private static NameValueCache sNameValueCache = null; 764 765 private static final HashSet<String> MOVED_TO_SECURE; 766 static { 767 MOVED_TO_SECURE = new HashSet<String>(30); 768 MOVED_TO_SECURE.add(Secure.ADB_ENABLED); 769 MOVED_TO_SECURE.add(Secure.ANDROID_ID); 770 MOVED_TO_SECURE.add(Secure.BLUETOOTH_ON); 771 MOVED_TO_SECURE.add(Secure.DATA_ROAMING); 772 MOVED_TO_SECURE.add(Secure.DEVICE_PROVISIONED); 773 MOVED_TO_SECURE.add(Secure.HTTP_PROXY); 774 MOVED_TO_SECURE.add(Secure.INSTALL_NON_MARKET_APPS); 775 MOVED_TO_SECURE.add(Secure.LOCATION_PROVIDERS_ALLOWED); 776 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_ENABLED); 777 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_VISIBLE); 778 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 779 MOVED_TO_SECURE.add(Secure.LOGGING_ID); 780 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_ENABLED); 781 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_LAST_UPDATE); 782 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_REDIRECT_URL); 783 MOVED_TO_SECURE.add(Secure.SETTINGS_CLASSNAME); 784 MOVED_TO_SECURE.add(Secure.USB_MASS_STORAGE_ENABLED); 785 MOVED_TO_SECURE.add(Secure.USE_GOOGLE_MAIL); 786 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 787 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 788 MOVED_TO_SECURE.add(Secure.WIFI_NUM_OPEN_NETWORKS_KEPT); 789 MOVED_TO_SECURE.add(Secure.WIFI_ON); 790 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE); 791 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_AP_COUNT); 792 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS); 793 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED); 794 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS); 795 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT); 796 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_MAX_AP_CHECKS); 797 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ON); 798 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_COUNT); 799 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_DELAY_MS); 800 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS); 801 } 802 803 /** 804 * Look up a name in the database. 805 * @param resolver to access the database with 806 * @param name to look up in the table 807 * @return the corresponding value, or null if not present 808 */ getString(ContentResolver resolver, String name)809 public synchronized static String getString(ContentResolver resolver, String name) { 810 if (MOVED_TO_SECURE.contains(name)) { 811 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 812 + " to android.provider.Settings.Secure, returning read-only value."); 813 return Secure.getString(resolver, name); 814 } 815 if (sNameValueCache == null) { 816 sNameValueCache = new NameValueCache(SYS_PROP_SETTING_VERSION, CONTENT_URI, 817 CALL_METHOD_GET_SYSTEM); 818 } 819 return sNameValueCache.getString(resolver, name); 820 } 821 822 /** 823 * Store a name/value pair into the database. 824 * @param resolver to access the database with 825 * @param name to store 826 * @param value to associate with the name 827 * @return true if the value was set, false on database errors 828 */ putString(ContentResolver resolver, String name, String value)829 public static boolean putString(ContentResolver resolver, String name, String value) { 830 if (MOVED_TO_SECURE.contains(name)) { 831 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 832 + " to android.provider.Settings.Secure, value is unchanged."); 833 return false; 834 } 835 return putString(resolver, CONTENT_URI, name, value); 836 } 837 838 /** 839 * Construct the content URI for a particular name/value pair, 840 * useful for monitoring changes with a ContentObserver. 841 * @param name to look up in the table 842 * @return the corresponding content URI, or null if not present 843 */ getUriFor(String name)844 public static Uri getUriFor(String name) { 845 if (MOVED_TO_SECURE.contains(name)) { 846 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 847 + " to android.provider.Settings.Secure, returning Secure URI."); 848 return Secure.getUriFor(Secure.CONTENT_URI, name); 849 } 850 return getUriFor(CONTENT_URI, name); 851 } 852 853 /** 854 * Convenience function for retrieving a single system settings value 855 * as an integer. Note that internally setting values are always 856 * stored as strings; this function converts the string to an integer 857 * for you. The default value will be returned if the setting is 858 * not defined or not an integer. 859 * 860 * @param cr The ContentResolver to access. 861 * @param name The name of the setting to retrieve. 862 * @param def Value to return if the setting is not defined. 863 * 864 * @return The setting's current value, or 'def' if it is not defined 865 * or not a valid integer. 866 */ getInt(ContentResolver cr, String name, int def)867 public static int getInt(ContentResolver cr, String name, int def) { 868 String v = getString(cr, name); 869 try { 870 return v != null ? Integer.parseInt(v) : def; 871 } catch (NumberFormatException e) { 872 return def; 873 } 874 } 875 876 /** 877 * Convenience function for retrieving a single system settings value 878 * as an integer. Note that internally setting values are always 879 * stored as strings; this function converts the string to an integer 880 * for you. 881 * <p> 882 * This version does not take a default value. If the setting has not 883 * been set, or the string value is not a number, 884 * it throws {@link SettingNotFoundException}. 885 * 886 * @param cr The ContentResolver to access. 887 * @param name The name of the setting to retrieve. 888 * 889 * @throws SettingNotFoundException Thrown if a setting by the given 890 * name can't be found or the setting value is not an integer. 891 * 892 * @return The setting's current value. 893 */ getInt(ContentResolver cr, String name)894 public static int getInt(ContentResolver cr, String name) 895 throws SettingNotFoundException { 896 String v = getString(cr, name); 897 try { 898 return Integer.parseInt(v); 899 } catch (NumberFormatException e) { 900 throw new SettingNotFoundException(name); 901 } 902 } 903 904 /** 905 * Convenience function for updating a single settings value as an 906 * integer. This will either create a new entry in the table if the 907 * given name does not exist, or modify the value of the existing row 908 * with that name. Note that internally setting values are always 909 * stored as strings, so this function converts the given value to a 910 * string before storing it. 911 * 912 * @param cr The ContentResolver to access. 913 * @param name The name of the setting to modify. 914 * @param value The new value for the setting. 915 * @return true if the value was set, false on database errors 916 */ putInt(ContentResolver cr, String name, int value)917 public static boolean putInt(ContentResolver cr, String name, int value) { 918 return putString(cr, name, Integer.toString(value)); 919 } 920 921 /** 922 * Convenience function for retrieving a single system settings value 923 * as a {@code long}. Note that internally setting values are always 924 * stored as strings; this function converts the string to a {@code long} 925 * for you. The default value will be returned if the setting is 926 * not defined or not a {@code long}. 927 * 928 * @param cr The ContentResolver to access. 929 * @param name The name of the setting to retrieve. 930 * @param def Value to return if the setting is not defined. 931 * 932 * @return The setting's current value, or 'def' if it is not defined 933 * or not a valid {@code long}. 934 */ getLong(ContentResolver cr, String name, long def)935 public static long getLong(ContentResolver cr, String name, long def) { 936 String valString = getString(cr, name); 937 long value; 938 try { 939 value = valString != null ? Long.parseLong(valString) : def; 940 } catch (NumberFormatException e) { 941 value = def; 942 } 943 return value; 944 } 945 946 /** 947 * Convenience function for retrieving a single system settings value 948 * as a {@code long}. Note that internally setting values are always 949 * stored as strings; this function converts the string to a {@code long} 950 * for you. 951 * <p> 952 * This version does not take a default value. If the setting has not 953 * been set, or the string value is not a number, 954 * it throws {@link SettingNotFoundException}. 955 * 956 * @param cr The ContentResolver to access. 957 * @param name The name of the setting to retrieve. 958 * 959 * @return The setting's current value. 960 * @throws SettingNotFoundException Thrown if a setting by the given 961 * name can't be found or the setting value is not an integer. 962 */ getLong(ContentResolver cr, String name)963 public static long getLong(ContentResolver cr, String name) 964 throws SettingNotFoundException { 965 String valString = getString(cr, name); 966 try { 967 return Long.parseLong(valString); 968 } catch (NumberFormatException e) { 969 throw new SettingNotFoundException(name); 970 } 971 } 972 973 /** 974 * Convenience function for updating a single settings value as a long 975 * integer. This will either create a new entry in the table if the 976 * given name does not exist, or modify the value of the existing row 977 * with that name. Note that internally setting values are always 978 * stored as strings, so this function converts the given value to a 979 * string before storing it. 980 * 981 * @param cr The ContentResolver to access. 982 * @param name The name of the setting to modify. 983 * @param value The new value for the setting. 984 * @return true if the value was set, false on database errors 985 */ putLong(ContentResolver cr, String name, long value)986 public static boolean putLong(ContentResolver cr, String name, long value) { 987 return putString(cr, name, Long.toString(value)); 988 } 989 990 /** 991 * Convenience function for retrieving a single system settings value 992 * as a floating point number. Note that internally setting values are 993 * always stored as strings; this function converts the string to an 994 * float for you. The default value will be returned if the setting 995 * is not defined or not a valid float. 996 * 997 * @param cr The ContentResolver to access. 998 * @param name The name of the setting to retrieve. 999 * @param def Value to return if the setting is not defined. 1000 * 1001 * @return The setting's current value, or 'def' if it is not defined 1002 * or not a valid float. 1003 */ getFloat(ContentResolver cr, String name, float def)1004 public static float getFloat(ContentResolver cr, String name, float def) { 1005 String v = getString(cr, name); 1006 try { 1007 return v != null ? Float.parseFloat(v) : def; 1008 } catch (NumberFormatException e) { 1009 return def; 1010 } 1011 } 1012 1013 /** 1014 * Convenience function for retrieving a single system settings value 1015 * as a float. Note that internally setting values are always 1016 * stored as strings; this function converts the string to a float 1017 * for you. 1018 * <p> 1019 * This version does not take a default value. If the setting has not 1020 * been set, or the string value is not a number, 1021 * it throws {@link SettingNotFoundException}. 1022 * 1023 * @param cr The ContentResolver to access. 1024 * @param name The name of the setting to retrieve. 1025 * 1026 * @throws SettingNotFoundException Thrown if a setting by the given 1027 * name can't be found or the setting value is not a float. 1028 * 1029 * @return The setting's current value. 1030 */ getFloat(ContentResolver cr, String name)1031 public static float getFloat(ContentResolver cr, String name) 1032 throws SettingNotFoundException { 1033 String v = getString(cr, name); 1034 if (v == null) { 1035 throw new SettingNotFoundException(name); 1036 } 1037 try { 1038 return Float.parseFloat(v); 1039 } catch (NumberFormatException e) { 1040 throw new SettingNotFoundException(name); 1041 } 1042 } 1043 1044 /** 1045 * Convenience function for updating a single settings value as a 1046 * floating point number. This will either create a new entry in the 1047 * table if the given name does not exist, or modify the value of the 1048 * existing row with that name. Note that internally setting values 1049 * are always stored as strings, so this function converts the given 1050 * value to a string before storing it. 1051 * 1052 * @param cr The ContentResolver to access. 1053 * @param name The name of the setting to modify. 1054 * @param value The new value for the setting. 1055 * @return true if the value was set, false on database errors 1056 */ putFloat(ContentResolver cr, String name, float value)1057 public static boolean putFloat(ContentResolver cr, String name, float value) { 1058 return putString(cr, name, Float.toString(value)); 1059 } 1060 1061 /** 1062 * Convenience function to read all of the current 1063 * configuration-related settings into a 1064 * {@link Configuration} object. 1065 * 1066 * @param cr The ContentResolver to access. 1067 * @param outConfig Where to place the configuration settings. 1068 */ getConfiguration(ContentResolver cr, Configuration outConfig)1069 public static void getConfiguration(ContentResolver cr, Configuration outConfig) { 1070 outConfig.fontScale = Settings.System.getFloat( 1071 cr, FONT_SCALE, outConfig.fontScale); 1072 if (outConfig.fontScale < 0) { 1073 outConfig.fontScale = 1; 1074 } 1075 } 1076 1077 /** 1078 * @hide Erase the fields in the Configuration that should be applied 1079 * by the settings. 1080 */ clearConfiguration(Configuration inoutConfig)1081 public static void clearConfiguration(Configuration inoutConfig) { 1082 inoutConfig.fontScale = 0; 1083 } 1084 1085 /** 1086 * Convenience function to write a batch of configuration-related 1087 * settings from a {@link Configuration} object. 1088 * 1089 * @param cr The ContentResolver to access. 1090 * @param config The settings to write. 1091 * @return true if the values were set, false on database errors 1092 */ putConfiguration(ContentResolver cr, Configuration config)1093 public static boolean putConfiguration(ContentResolver cr, Configuration config) { 1094 return Settings.System.putFloat(cr, FONT_SCALE, config.fontScale); 1095 } 1096 1097 /** @hide */ hasInterestingConfigurationChanges(int changes)1098 public static boolean hasInterestingConfigurationChanges(int changes) { 1099 return (changes&ActivityInfo.CONFIG_FONT_SCALE) != 0; 1100 } 1101 getShowGTalkServiceStatus(ContentResolver cr)1102 public static boolean getShowGTalkServiceStatus(ContentResolver cr) { 1103 return getInt(cr, SHOW_GTALK_SERVICE_STATUS, 0) != 0; 1104 } 1105 setShowGTalkServiceStatus(ContentResolver cr, boolean flag)1106 public static void setShowGTalkServiceStatus(ContentResolver cr, boolean flag) { 1107 putInt(cr, SHOW_GTALK_SERVICE_STATUS, flag ? 1 : 0); 1108 } 1109 1110 /** 1111 * The content:// style URL for this table 1112 */ 1113 public static final Uri CONTENT_URI = 1114 Uri.parse("content://" + AUTHORITY + "/system"); 1115 1116 /** 1117 * Whether we keep the device on while the device is plugged in. 1118 * Supported values are: 1119 * <ul> 1120 * <li>{@code 0} to never stay on while plugged in</li> 1121 * <li>{@link BatteryManager#BATTERY_PLUGGED_AC} to stay on for AC charger</li> 1122 * <li>{@link BatteryManager#BATTERY_PLUGGED_USB} to stay on for USB charger</li> 1123 * </ul> 1124 * These values can be OR-ed together. 1125 */ 1126 public static final String STAY_ON_WHILE_PLUGGED_IN = "stay_on_while_plugged_in"; 1127 1128 /** 1129 * What happens when the user presses the end call button if they're not 1130 * on a call.<br/> 1131 * <b>Values:</b><br/> 1132 * 0 - The end button does nothing.<br/> 1133 * 1 - The end button goes to the home screen.<br/> 1134 * 2 - The end button puts the device to sleep and locks the keyguard.<br/> 1135 * 3 - The end button goes to the home screen. If the user is already on the 1136 * home screen, it puts the device to sleep. 1137 */ 1138 public static final String END_BUTTON_BEHAVIOR = "end_button_behavior"; 1139 1140 /** 1141 * END_BUTTON_BEHAVIOR value for "go home". 1142 * @hide 1143 */ 1144 public static final int END_BUTTON_BEHAVIOR_HOME = 0x1; 1145 1146 /** 1147 * END_BUTTON_BEHAVIOR value for "go to sleep". 1148 * @hide 1149 */ 1150 public static final int END_BUTTON_BEHAVIOR_SLEEP = 0x2; 1151 1152 /** 1153 * END_BUTTON_BEHAVIOR default value. 1154 * @hide 1155 */ 1156 public static final int END_BUTTON_BEHAVIOR_DEFAULT = END_BUTTON_BEHAVIOR_SLEEP; 1157 1158 /** 1159 * Is advanced settings mode turned on. 0 == no, 1 == yes 1160 * @hide 1161 */ 1162 public static final String ADVANCED_SETTINGS = "advanced_settings"; 1163 1164 /** 1165 * ADVANCED_SETTINGS default value. 1166 * @hide 1167 */ 1168 public static final int ADVANCED_SETTINGS_DEFAULT = 0; 1169 1170 /** 1171 * Whether Airplane Mode is on. 1172 */ 1173 public static final String AIRPLANE_MODE_ON = "airplane_mode_on"; 1174 1175 /** 1176 * Constant for use in AIRPLANE_MODE_RADIOS to specify Bluetooth radio. 1177 */ 1178 public static final String RADIO_BLUETOOTH = "bluetooth"; 1179 1180 /** 1181 * Constant for use in AIRPLANE_MODE_RADIOS to specify Wi-Fi radio. 1182 */ 1183 public static final String RADIO_WIFI = "wifi"; 1184 1185 /** 1186 * Constant for use in AIRPLANE_MODE_RADIOS to specify Cellular radio. 1187 */ 1188 public static final String RADIO_CELL = "cell"; 1189 1190 /** 1191 * Constant for use in AIRPLANE_MODE_RADIOS to specify NFC radio. 1192 */ 1193 public static final String RADIO_NFC = "nfc"; 1194 1195 /** 1196 * A comma separated list of radios that need to be disabled when airplane mode 1197 * is on. This overrides WIFI_ON and BLUETOOTH_ON, if Wi-Fi and bluetooth are 1198 * included in the comma separated list. 1199 */ 1200 public static final String AIRPLANE_MODE_RADIOS = "airplane_mode_radios"; 1201 1202 /** 1203 * A comma separated list of radios that should to be disabled when airplane mode 1204 * is on, but can be manually reenabled by the user. For example, if RADIO_WIFI is 1205 * added to both AIRPLANE_MODE_RADIOS and AIRPLANE_MODE_TOGGLEABLE_RADIOS, then Wifi 1206 * will be turned off when entering airplane mode, but the user will be able to reenable 1207 * Wifi in the Settings app. 1208 * 1209 * {@hide} 1210 */ 1211 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = "airplane_mode_toggleable_radios"; 1212 1213 /** 1214 * The policy for deciding when Wi-Fi should go to sleep (which will in 1215 * turn switch to using the mobile data as an Internet connection). 1216 * <p> 1217 * Set to one of {@link #WIFI_SLEEP_POLICY_DEFAULT}, 1218 * {@link #WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED}, or 1219 * {@link #WIFI_SLEEP_POLICY_NEVER}. 1220 */ 1221 public static final String WIFI_SLEEP_POLICY = "wifi_sleep_policy"; 1222 1223 /** 1224 * Value for {@link #WIFI_SLEEP_POLICY} to use the default Wi-Fi sleep 1225 * policy, which is to sleep shortly after the turning off 1226 * according to the {@link #STAY_ON_WHILE_PLUGGED_IN} setting. 1227 */ 1228 public static final int WIFI_SLEEP_POLICY_DEFAULT = 0; 1229 1230 /** 1231 * Value for {@link #WIFI_SLEEP_POLICY} to use the default policy when 1232 * the device is on battery, and never go to sleep when the device is 1233 * plugged in. 1234 */ 1235 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1; 1236 1237 /** 1238 * Value for {@link #WIFI_SLEEP_POLICY} to never go to sleep. 1239 */ 1240 public static final int WIFI_SLEEP_POLICY_NEVER = 2; 1241 1242 //TODO: deprecate static IP constants 1243 /** 1244 * Whether to use static IP and other static network attributes. 1245 * <p> 1246 * Set to 1 for true and 0 for false. 1247 */ 1248 public static final String WIFI_USE_STATIC_IP = "wifi_use_static_ip"; 1249 1250 /** 1251 * The static IP address. 1252 * <p> 1253 * Example: "192.168.1.51" 1254 */ 1255 public static final String WIFI_STATIC_IP = "wifi_static_ip"; 1256 1257 /** 1258 * If using static IP, the gateway's IP address. 1259 * <p> 1260 * Example: "192.168.1.1" 1261 */ 1262 public static final String WIFI_STATIC_GATEWAY = "wifi_static_gateway"; 1263 1264 /** 1265 * If using static IP, the net mask. 1266 * <p> 1267 * Example: "255.255.255.0" 1268 */ 1269 public static final String WIFI_STATIC_NETMASK = "wifi_static_netmask"; 1270 1271 /** 1272 * If using static IP, the primary DNS's IP address. 1273 * <p> 1274 * Example: "192.168.1.1" 1275 */ 1276 public static final String WIFI_STATIC_DNS1 = "wifi_static_dns1"; 1277 1278 /** 1279 * If using static IP, the secondary DNS's IP address. 1280 * <p> 1281 * Example: "192.168.1.2" 1282 */ 1283 public static final String WIFI_STATIC_DNS2 = "wifi_static_dns2"; 1284 1285 1286 /** 1287 * Determines whether remote devices may discover and/or connect to 1288 * this device. 1289 * <P>Type: INT</P> 1290 * 2 -- discoverable and connectable 1291 * 1 -- connectable but not discoverable 1292 * 0 -- neither connectable nor discoverable 1293 */ 1294 public static final String BLUETOOTH_DISCOVERABILITY = 1295 "bluetooth_discoverability"; 1296 1297 /** 1298 * Bluetooth discoverability timeout. If this value is nonzero, then 1299 * Bluetooth becomes discoverable for a certain number of seconds, 1300 * after which is becomes simply connectable. The value is in seconds. 1301 */ 1302 public static final String BLUETOOTH_DISCOVERABILITY_TIMEOUT = 1303 "bluetooth_discoverability_timeout"; 1304 1305 /** 1306 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_ENABLED} 1307 * instead 1308 */ 1309 @Deprecated 1310 public static final String LOCK_PATTERN_ENABLED = Secure.LOCK_PATTERN_ENABLED; 1311 1312 /** 1313 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_VISIBLE} 1314 * instead 1315 */ 1316 @Deprecated 1317 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 1318 1319 /** 1320 * @deprecated Use 1321 * {@link android.provider.Settings.Secure#LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED} 1322 * instead 1323 */ 1324 @Deprecated 1325 public static final String LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = 1326 "lock_pattern_tactile_feedback_enabled"; 1327 1328 1329 /** 1330 * A formatted string of the next alarm that is set, or the empty string 1331 * if there is no alarm set. 1332 */ 1333 public static final String NEXT_ALARM_FORMATTED = "next_alarm_formatted"; 1334 1335 /** 1336 * Scaling factor for fonts, float. 1337 */ 1338 public static final String FONT_SCALE = "font_scale"; 1339 1340 /** 1341 * Name of an application package to be debugged. 1342 */ 1343 public static final String DEBUG_APP = "debug_app"; 1344 1345 /** 1346 * If 1, when launching DEBUG_APP it will wait for the debugger before 1347 * starting user code. If 0, it will run normally. 1348 */ 1349 public static final String WAIT_FOR_DEBUGGER = "wait_for_debugger"; 1350 1351 /** 1352 * Whether or not to dim the screen. 0=no 1=yes 1353 */ 1354 public static final String DIM_SCREEN = "dim_screen"; 1355 1356 /** 1357 * The timeout before the screen turns off. 1358 */ 1359 public static final String SCREEN_OFF_TIMEOUT = "screen_off_timeout"; 1360 1361 /** 1362 * If 0, the compatibility mode is off for all applications. 1363 * If 1, older applications run under compatibility mode. 1364 * TODO: remove this settings before code freeze (bug/1907571) 1365 * @hide 1366 */ 1367 public static final String COMPATIBILITY_MODE = "compatibility_mode"; 1368 1369 /** 1370 * The screen backlight brightness between 0 and 255. 1371 */ 1372 public static final String SCREEN_BRIGHTNESS = "screen_brightness"; 1373 1374 /** 1375 * Control whether to enable automatic brightness mode. 1376 */ 1377 public static final String SCREEN_BRIGHTNESS_MODE = "screen_brightness_mode"; 1378 1379 /** 1380 * SCREEN_BRIGHTNESS_MODE value for manual mode. 1381 */ 1382 public static final int SCREEN_BRIGHTNESS_MODE_MANUAL = 0; 1383 1384 /** 1385 * SCREEN_BRIGHTNESS_MODE value for manual mode. 1386 */ 1387 public static final int SCREEN_BRIGHTNESS_MODE_AUTOMATIC = 1; 1388 1389 /** 1390 * Control whether the process CPU usage meter should be shown. 1391 */ 1392 public static final String SHOW_PROCESSES = "show_processes"; 1393 1394 /** 1395 * If 1, the activity manager will aggressively finish activities and 1396 * processes as soon as they are no longer needed. If 0, the normal 1397 * extended lifetime is used. 1398 */ 1399 public static final String ALWAYS_FINISH_ACTIVITIES = 1400 "always_finish_activities"; 1401 1402 1403 /** 1404 * Ringer mode. This is used internally, changing this value will not 1405 * change the ringer mode. See AudioManager. 1406 */ 1407 public static final String MODE_RINGER = "mode_ringer"; 1408 1409 /** 1410 * Determines which streams are affected by ringer mode changes. The 1411 * stream type's bit should be set to 1 if it should be muted when going 1412 * into an inaudible ringer mode. 1413 */ 1414 public static final String MODE_RINGER_STREAMS_AFFECTED = "mode_ringer_streams_affected"; 1415 1416 /** 1417 * Determines which streams are affected by mute. The 1418 * stream type's bit should be set to 1 if it should be muted when a mute request 1419 * is received. 1420 */ 1421 public static final String MUTE_STREAMS_AFFECTED = "mute_streams_affected"; 1422 1423 /** 1424 * Whether vibrate is on for different events. This is used internally, 1425 * changing this value will not change the vibrate. See AudioManager. 1426 */ 1427 public static final String VIBRATE_ON = "vibrate_on"; 1428 1429 /** 1430 * Ringer volume. This is used internally, changing this value will not 1431 * change the volume. See AudioManager. 1432 */ 1433 public static final String VOLUME_RING = "volume_ring"; 1434 1435 /** 1436 * System/notifications volume. This is used internally, changing this 1437 * value will not change the volume. See AudioManager. 1438 */ 1439 public static final String VOLUME_SYSTEM = "volume_system"; 1440 1441 /** 1442 * Voice call volume. This is used internally, changing this value will 1443 * not change the volume. See AudioManager. 1444 */ 1445 public static final String VOLUME_VOICE = "volume_voice"; 1446 1447 /** 1448 * Music/media/gaming volume. This is used internally, changing this 1449 * value will not change the volume. See AudioManager. 1450 */ 1451 public static final String VOLUME_MUSIC = "volume_music"; 1452 1453 /** 1454 * Alarm volume. This is used internally, changing this 1455 * value will not change the volume. See AudioManager. 1456 */ 1457 public static final String VOLUME_ALARM = "volume_alarm"; 1458 1459 /** 1460 * Notification volume. This is used internally, changing this 1461 * value will not change the volume. See AudioManager. 1462 */ 1463 public static final String VOLUME_NOTIFICATION = "volume_notification"; 1464 1465 /** 1466 * Bluetooth Headset volume. This is used internally, changing this value will 1467 * not change the volume. See AudioManager. 1468 */ 1469 public static final String VOLUME_BLUETOOTH_SCO = "volume_bluetooth_sco"; 1470 1471 /** 1472 * Whether the notifications should use the ring volume (value of 1) or a separate 1473 * notification volume (value of 0). In most cases, users will have this enabled so the 1474 * notification and ringer volumes will be the same. However, power users can disable this 1475 * and use the separate notification volume control. 1476 * <p> 1477 * Note: This is a one-off setting that will be removed in the future when there is profile 1478 * support. For this reason, it is kept hidden from the public APIs. 1479 * 1480 * @hide 1481 * @deprecated 1482 */ 1483 @Deprecated 1484 public static final String NOTIFICATIONS_USE_RING_VOLUME = 1485 "notifications_use_ring_volume"; 1486 1487 /** 1488 * Whether silent mode should allow vibration feedback. This is used 1489 * internally in AudioService and the Sound settings activity to 1490 * coordinate decoupling of vibrate and silent modes. This setting 1491 * will likely be removed in a future release with support for 1492 * audio/vibe feedback profiles. 1493 * 1494 * @hide 1495 */ 1496 public static final String VIBRATE_IN_SILENT = "vibrate_in_silent"; 1497 1498 /** 1499 * The mapping of stream type (integer) to its setting. 1500 */ 1501 public static final String[] VOLUME_SETTINGS = { 1502 VOLUME_VOICE, VOLUME_SYSTEM, VOLUME_RING, VOLUME_MUSIC, 1503 VOLUME_ALARM, VOLUME_NOTIFICATION, VOLUME_BLUETOOTH_SCO 1504 }; 1505 1506 /** 1507 * Appended to various volume related settings to record the previous 1508 * values before they the settings were affected by a silent/vibrate 1509 * ringer mode change. 1510 */ 1511 public static final String APPEND_FOR_LAST_AUDIBLE = "_last_audible"; 1512 1513 /** 1514 * Persistent store for the system-wide default ringtone URI. 1515 * <p> 1516 * If you need to play the default ringtone at any given time, it is recommended 1517 * you give {@link #DEFAULT_RINGTONE_URI} to the media player. It will resolve 1518 * to the set default ringtone at the time of playing. 1519 * 1520 * @see #DEFAULT_RINGTONE_URI 1521 */ 1522 public static final String RINGTONE = "ringtone"; 1523 1524 /** 1525 * A {@link Uri} that will point to the current default ringtone at any 1526 * given time. 1527 * <p> 1528 * If the current default ringtone is in the DRM provider and the caller 1529 * does not have permission, the exception will be a 1530 * FileNotFoundException. 1531 */ 1532 public static final Uri DEFAULT_RINGTONE_URI = getUriFor(RINGTONE); 1533 1534 /** 1535 * Persistent store for the system-wide default notification sound. 1536 * 1537 * @see #RINGTONE 1538 * @see #DEFAULT_NOTIFICATION_URI 1539 */ 1540 public static final String NOTIFICATION_SOUND = "notification_sound"; 1541 1542 /** 1543 * A {@link Uri} that will point to the current default notification 1544 * sound at any given time. 1545 * 1546 * @see #DEFAULT_RINGTONE_URI 1547 */ 1548 public static final Uri DEFAULT_NOTIFICATION_URI = getUriFor(NOTIFICATION_SOUND); 1549 1550 /** 1551 * Persistent store for the system-wide default alarm alert. 1552 * 1553 * @see #RINGTONE 1554 * @see #DEFAULT_ALARM_ALERT_URI 1555 */ 1556 public static final String ALARM_ALERT = "alarm_alert"; 1557 1558 /** 1559 * A {@link Uri} that will point to the current default alarm alert at 1560 * any given time. 1561 * 1562 * @see #DEFAULT_ALARM_ALERT_URI 1563 */ 1564 public static final Uri DEFAULT_ALARM_ALERT_URI = getUriFor(ALARM_ALERT); 1565 1566 /** 1567 * Persistent store for the system default media button event receiver. 1568 * 1569 * @hide 1570 */ 1571 public static final String MEDIA_BUTTON_RECEIVER = "media_button_receiver"; 1572 1573 /** 1574 * Setting to enable Auto Replace (AutoText) in text editors. 1 = On, 0 = Off 1575 */ 1576 public static final String TEXT_AUTO_REPLACE = "auto_replace"; 1577 1578 /** 1579 * Setting to enable Auto Caps in text editors. 1 = On, 0 = Off 1580 */ 1581 public static final String TEXT_AUTO_CAPS = "auto_caps"; 1582 1583 /** 1584 * Setting to enable Auto Punctuate in text editors. 1 = On, 0 = Off. This 1585 * feature converts two spaces to a "." and space. 1586 */ 1587 public static final String TEXT_AUTO_PUNCTUATE = "auto_punctuate"; 1588 1589 /** 1590 * Setting to showing password characters in text editors. 1 = On, 0 = Off 1591 */ 1592 public static final String TEXT_SHOW_PASSWORD = "show_password"; 1593 1594 public static final String SHOW_GTALK_SERVICE_STATUS = 1595 "SHOW_GTALK_SERVICE_STATUS"; 1596 1597 /** 1598 * Name of activity to use for wallpaper on the home screen. 1599 */ 1600 public static final String WALLPAPER_ACTIVITY = "wallpaper_activity"; 1601 1602 /** 1603 * Value to specify if the user prefers the date, time and time zone 1604 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 1605 */ 1606 public static final String AUTO_TIME = "auto_time"; 1607 1608 /** 1609 * Value to specify if the user prefers the time zone 1610 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 1611 */ 1612 public static final String AUTO_TIME_ZONE = "auto_time_zone"; 1613 1614 /** 1615 * Display times as 12 or 24 hours 1616 * 12 1617 * 24 1618 */ 1619 public static final String TIME_12_24 = "time_12_24"; 1620 1621 /** 1622 * Date format string 1623 * mm/dd/yyyy 1624 * dd/mm/yyyy 1625 * yyyy/mm/dd 1626 */ 1627 public static final String DATE_FORMAT = "date_format"; 1628 1629 /** 1630 * Whether the setup wizard has been run before (on first boot), or if 1631 * it still needs to be run. 1632 * 1633 * nonzero = it has been run in the past 1634 * 0 = it has not been run in the past 1635 */ 1636 public static final String SETUP_WIZARD_HAS_RUN = "setup_wizard_has_run"; 1637 1638 /** 1639 * Scaling factor for normal window animations. Setting to 0 will disable window 1640 * animations. 1641 */ 1642 public static final String WINDOW_ANIMATION_SCALE = "window_animation_scale"; 1643 1644 /** 1645 * Scaling factor for activity transition animations. Setting to 0 will disable window 1646 * animations. 1647 */ 1648 public static final String TRANSITION_ANIMATION_SCALE = "transition_animation_scale"; 1649 1650 /** 1651 * Scaling factor for normal window animations. Setting to 0 will disable window 1652 * animations. 1653 * @hide 1654 */ 1655 public static final String FANCY_IME_ANIMATIONS = "fancy_ime_animations"; 1656 1657 /** 1658 * Control whether the accelerometer will be used to change screen 1659 * orientation. If 0, it will not be used unless explicitly requested 1660 * by the application; if 1, it will be used by default unless explicitly 1661 * disabled by the application. 1662 */ 1663 public static final String ACCELEROMETER_ROTATION = "accelerometer_rotation"; 1664 1665 /** 1666 * Default screen rotation when no other policy applies. 1667 * When {@link #ACCELEROMETER_ROTATION} is zero and no on-screen Activity expresses a 1668 * preference, this rotation value will be used. Must be one of the 1669 * {@link android.view.Surface#ROTATION_0 Surface rotation constants}. 1670 * 1671 * @see Display#getRotation 1672 */ 1673 public static final String USER_ROTATION = "user_rotation"; 1674 1675 /** 1676 * Whether the audible DTMF tones are played by the dialer when dialing. The value is 1677 * boolean (1 or 0). 1678 */ 1679 public static final String DTMF_TONE_WHEN_DIALING = "dtmf_tone"; 1680 1681 /** 1682 * CDMA only settings 1683 * DTMF tone type played by the dialer when dialing. 1684 * 0 = Normal 1685 * 1 = Long 1686 * @hide 1687 */ 1688 public static final String DTMF_TONE_TYPE_WHEN_DIALING = "dtmf_tone_type"; 1689 1690 /** 1691 * CDMA only settings 1692 * Emergency Tone 0 = Off 1693 * 1 = Alert 1694 * 2 = Vibrate 1695 * @hide 1696 */ 1697 public static final String EMERGENCY_TONE = "emergency_tone"; 1698 1699 /** 1700 * CDMA only settings 1701 * Whether the auto retry is enabled. The value is 1702 * boolean (1 or 0). 1703 * @hide 1704 */ 1705 public static final String CALL_AUTO_RETRY = "call_auto_retry"; 1706 1707 /** 1708 * Whether the hearing aid is enabled. The value is 1709 * boolean (1 or 0). 1710 * @hide 1711 */ 1712 public static final String HEARING_AID = "hearing_aid"; 1713 1714 /** 1715 * CDMA only settings 1716 * TTY Mode 1717 * 0 = OFF 1718 * 1 = FULL 1719 * 2 = VCO 1720 * 3 = HCO 1721 * @hide 1722 */ 1723 public static final String TTY_MODE = "tty_mode"; 1724 1725 /** 1726 * Whether the sounds effects (key clicks, lid open ...) are enabled. The value is 1727 * boolean (1 or 0). 1728 */ 1729 public static final String SOUND_EFFECTS_ENABLED = "sound_effects_enabled"; 1730 1731 /** 1732 * Whether the haptic feedback (long presses, ...) are enabled. The value is 1733 * boolean (1 or 0). 1734 */ 1735 public static final String HAPTIC_FEEDBACK_ENABLED = "haptic_feedback_enabled"; 1736 1737 /** 1738 * @deprecated Each application that shows web suggestions should have its own 1739 * setting for this. 1740 */ 1741 @Deprecated 1742 public static final String SHOW_WEB_SUGGESTIONS = "show_web_suggestions"; 1743 1744 /** 1745 * Whether the notification LED should repeatedly flash when a notification is 1746 * pending. The value is boolean (1 or 0). 1747 * @hide 1748 */ 1749 public static final String NOTIFICATION_LIGHT_PULSE = "notification_light_pulse"; 1750 1751 /** 1752 * Show pointer location on screen? 1753 * 0 = no 1754 * 1 = yes 1755 * @hide 1756 */ 1757 public static final String POINTER_LOCATION = "pointer_location"; 1758 1759 /** 1760 * Show touch positions on screen? 1761 * 0 = no 1762 * 1 = yes 1763 * @hide 1764 */ 1765 public static final String SHOW_TOUCHES = "show_touches"; 1766 1767 /** 1768 * Log raw orientation data from {@link WindowOrientationListener} for use with the 1769 * orientationplot.py tool. 1770 * 0 = no 1771 * 1 = yes 1772 * @hide 1773 */ 1774 public static final String WINDOW_ORIENTATION_LISTENER_LOG = 1775 "window_orientation_listener_log"; 1776 1777 /** 1778 * Whether to play a sound for low-battery alerts. 1779 * @hide 1780 */ 1781 public static final String POWER_SOUNDS_ENABLED = "power_sounds_enabled"; 1782 1783 /** 1784 * Whether to play a sound for dock events. 1785 * @hide 1786 */ 1787 public static final String DOCK_SOUNDS_ENABLED = "dock_sounds_enabled"; 1788 1789 /** 1790 * Whether to play sounds when the keyguard is shown and dismissed. 1791 * @hide 1792 */ 1793 public static final String LOCKSCREEN_SOUNDS_ENABLED = "lockscreen_sounds_enabled"; 1794 1795 /** 1796 * URI for the low battery sound file. 1797 * @hide 1798 */ 1799 public static final String LOW_BATTERY_SOUND = "low_battery_sound"; 1800 1801 /** 1802 * URI for the desk dock "in" event sound. 1803 * @hide 1804 */ 1805 public static final String DESK_DOCK_SOUND = "desk_dock_sound"; 1806 1807 /** 1808 * URI for the desk dock "out" event sound. 1809 * @hide 1810 */ 1811 public static final String DESK_UNDOCK_SOUND = "desk_undock_sound"; 1812 1813 /** 1814 * URI for the car dock "in" event sound. 1815 * @hide 1816 */ 1817 public static final String CAR_DOCK_SOUND = "car_dock_sound"; 1818 1819 /** 1820 * URI for the car dock "out" event sound. 1821 * @hide 1822 */ 1823 public static final String CAR_UNDOCK_SOUND = "car_undock_sound"; 1824 1825 /** 1826 * URI for the "device locked" (keyguard shown) sound. 1827 * @hide 1828 */ 1829 public static final String LOCK_SOUND = "lock_sound"; 1830 1831 /** 1832 * URI for the "device unlocked" (keyguard dismissed) sound. 1833 * @hide 1834 */ 1835 public static final String UNLOCK_SOUND = "unlock_sound"; 1836 1837 /** 1838 * Receive incoming SIP calls? 1839 * 0 = no 1840 * 1 = yes 1841 * @hide 1842 */ 1843 public static final String SIP_RECEIVE_CALLS = "sip_receive_calls"; 1844 1845 /** 1846 * Call Preference String. 1847 * "SIP_ALWAYS" : Always use SIP with network access 1848 * "SIP_ADDRESS_ONLY" : Only if destination is a SIP address 1849 * "SIP_ASK_ME_EACH_TIME" : Always ask me each time 1850 * @hide 1851 */ 1852 public static final String SIP_CALL_OPTIONS = "sip_call_options"; 1853 1854 /** 1855 * One of the sip call options: Always use SIP with network access. 1856 * @hide 1857 */ 1858 public static final String SIP_ALWAYS = "SIP_ALWAYS"; 1859 1860 /** 1861 * One of the sip call options: Only if destination is a SIP address. 1862 * @hide 1863 */ 1864 public static final String SIP_ADDRESS_ONLY = "SIP_ADDRESS_ONLY"; 1865 1866 /** 1867 * One of the sip call options: Always ask me each time. 1868 * @hide 1869 */ 1870 public static final String SIP_ASK_ME_EACH_TIME = "SIP_ASK_ME_EACH_TIME"; 1871 1872 /** 1873 * Pointer speed setting. 1874 * This is an integer value in a range between -7 and +7, so there are 15 possible values. 1875 * -7 = slowest 1876 * 0 = default speed 1877 * +7 = fastest 1878 * @hide 1879 */ 1880 public static final String POINTER_SPEED = "pointer_speed"; 1881 1882 /** 1883 * Settings to backup. This is here so that it's in the same place as the settings 1884 * keys and easy to update. 1885 * 1886 * NOTE: Settings are backed up and restored in the order they appear 1887 * in this array. If you have one setting depending on another, 1888 * make sure that they are ordered appropriately. 1889 * 1890 * @hide 1891 */ 1892 public static final String[] SETTINGS_TO_BACKUP = { 1893 STAY_ON_WHILE_PLUGGED_IN, 1894 WIFI_USE_STATIC_IP, 1895 WIFI_STATIC_IP, 1896 WIFI_STATIC_GATEWAY, 1897 WIFI_STATIC_NETMASK, 1898 WIFI_STATIC_DNS1, 1899 WIFI_STATIC_DNS2, 1900 BLUETOOTH_DISCOVERABILITY, 1901 BLUETOOTH_DISCOVERABILITY_TIMEOUT, 1902 DIM_SCREEN, 1903 SCREEN_OFF_TIMEOUT, 1904 SCREEN_BRIGHTNESS, 1905 SCREEN_BRIGHTNESS_MODE, 1906 VIBRATE_ON, 1907 MODE_RINGER, 1908 MODE_RINGER_STREAMS_AFFECTED, 1909 MUTE_STREAMS_AFFECTED, 1910 VOLUME_VOICE, 1911 VOLUME_SYSTEM, 1912 VOLUME_RING, 1913 VOLUME_MUSIC, 1914 VOLUME_ALARM, 1915 VOLUME_NOTIFICATION, 1916 VOLUME_BLUETOOTH_SCO, 1917 VOLUME_VOICE + APPEND_FOR_LAST_AUDIBLE, 1918 VOLUME_SYSTEM + APPEND_FOR_LAST_AUDIBLE, 1919 VOLUME_RING + APPEND_FOR_LAST_AUDIBLE, 1920 VOLUME_MUSIC + APPEND_FOR_LAST_AUDIBLE, 1921 VOLUME_ALARM + APPEND_FOR_LAST_AUDIBLE, 1922 VOLUME_NOTIFICATION + APPEND_FOR_LAST_AUDIBLE, 1923 VOLUME_BLUETOOTH_SCO + APPEND_FOR_LAST_AUDIBLE, 1924 VIBRATE_IN_SILENT, 1925 TEXT_AUTO_REPLACE, 1926 TEXT_AUTO_CAPS, 1927 TEXT_AUTO_PUNCTUATE, 1928 TEXT_SHOW_PASSWORD, 1929 AUTO_TIME, 1930 AUTO_TIME_ZONE, 1931 TIME_12_24, 1932 DATE_FORMAT, 1933 ACCELEROMETER_ROTATION, 1934 USER_ROTATION, 1935 DTMF_TONE_WHEN_DIALING, 1936 DTMF_TONE_TYPE_WHEN_DIALING, 1937 EMERGENCY_TONE, 1938 CALL_AUTO_RETRY, 1939 HEARING_AID, 1940 TTY_MODE, 1941 SOUND_EFFECTS_ENABLED, 1942 HAPTIC_FEEDBACK_ENABLED, 1943 POWER_SOUNDS_ENABLED, 1944 DOCK_SOUNDS_ENABLED, 1945 LOCKSCREEN_SOUNDS_ENABLED, 1946 SHOW_WEB_SUGGESTIONS, 1947 NOTIFICATION_LIGHT_PULSE, 1948 SIP_CALL_OPTIONS, 1949 SIP_RECEIVE_CALLS, 1950 POINTER_SPEED, 1951 }; 1952 1953 // Settings moved to Settings.Secure 1954 1955 /** 1956 * @deprecated Use {@link android.provider.Settings.Secure#ADB_ENABLED} 1957 * instead 1958 */ 1959 @Deprecated 1960 public static final String ADB_ENABLED = Secure.ADB_ENABLED; 1961 1962 /** 1963 * @deprecated Use {@link android.provider.Settings.Secure#ANDROID_ID} instead 1964 */ 1965 @Deprecated 1966 public static final String ANDROID_ID = Secure.ANDROID_ID; 1967 1968 /** 1969 * @deprecated Use {@link android.provider.Settings.Secure#BLUETOOTH_ON} instead 1970 */ 1971 @Deprecated 1972 public static final String BLUETOOTH_ON = Secure.BLUETOOTH_ON; 1973 1974 /** 1975 * @deprecated Use {@link android.provider.Settings.Secure#DATA_ROAMING} instead 1976 */ 1977 @Deprecated 1978 public static final String DATA_ROAMING = Secure.DATA_ROAMING; 1979 1980 /** 1981 * @deprecated Use {@link android.provider.Settings.Secure#DEVICE_PROVISIONED} instead 1982 */ 1983 @Deprecated 1984 public static final String DEVICE_PROVISIONED = Secure.DEVICE_PROVISIONED; 1985 1986 /** 1987 * @deprecated Use {@link android.provider.Settings.Secure#HTTP_PROXY} instead 1988 */ 1989 @Deprecated 1990 public static final String HTTP_PROXY = Secure.HTTP_PROXY; 1991 1992 /** 1993 * @deprecated Use {@link android.provider.Settings.Secure#INSTALL_NON_MARKET_APPS} instead 1994 */ 1995 @Deprecated 1996 public static final String INSTALL_NON_MARKET_APPS = Secure.INSTALL_NON_MARKET_APPS; 1997 1998 /** 1999 * @deprecated Use {@link android.provider.Settings.Secure#LOCATION_PROVIDERS_ALLOWED} 2000 * instead 2001 */ 2002 @Deprecated 2003 public static final String LOCATION_PROVIDERS_ALLOWED = Secure.LOCATION_PROVIDERS_ALLOWED; 2004 2005 /** 2006 * @deprecated Use {@link android.provider.Settings.Secure#LOGGING_ID} instead 2007 */ 2008 @Deprecated 2009 public static final String LOGGING_ID = Secure.LOGGING_ID; 2010 2011 /** 2012 * @deprecated Use {@link android.provider.Settings.Secure#NETWORK_PREFERENCE} instead 2013 */ 2014 @Deprecated 2015 public static final String NETWORK_PREFERENCE = Secure.NETWORK_PREFERENCE; 2016 2017 /** 2018 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_ENABLED} 2019 * instead 2020 */ 2021 @Deprecated 2022 public static final String PARENTAL_CONTROL_ENABLED = Secure.PARENTAL_CONTROL_ENABLED; 2023 2024 /** 2025 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_LAST_UPDATE} 2026 * instead 2027 */ 2028 @Deprecated 2029 public static final String PARENTAL_CONTROL_LAST_UPDATE = Secure.PARENTAL_CONTROL_LAST_UPDATE; 2030 2031 /** 2032 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_REDIRECT_URL} 2033 * instead 2034 */ 2035 @Deprecated 2036 public static final String PARENTAL_CONTROL_REDIRECT_URL = 2037 Secure.PARENTAL_CONTROL_REDIRECT_URL; 2038 2039 /** 2040 * @deprecated Use {@link android.provider.Settings.Secure#SETTINGS_CLASSNAME} instead 2041 */ 2042 @Deprecated 2043 public static final String SETTINGS_CLASSNAME = Secure.SETTINGS_CLASSNAME; 2044 2045 /** 2046 * @deprecated Use {@link android.provider.Settings.Secure#USB_MASS_STORAGE_ENABLED} instead 2047 */ 2048 @Deprecated 2049 public static final String USB_MASS_STORAGE_ENABLED = Secure.USB_MASS_STORAGE_ENABLED; 2050 2051 /** 2052 * @deprecated Use {@link android.provider.Settings.Secure#USE_GOOGLE_MAIL} instead 2053 */ 2054 @Deprecated 2055 public static final String USE_GOOGLE_MAIL = Secure.USE_GOOGLE_MAIL; 2056 2057 /** 2058 * @deprecated Use 2059 * {@link android.provider.Settings.Secure#WIFI_MAX_DHCP_RETRY_COUNT} instead 2060 */ 2061 @Deprecated 2062 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Secure.WIFI_MAX_DHCP_RETRY_COUNT; 2063 2064 /** 2065 * @deprecated Use 2066 * {@link android.provider.Settings.Secure#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 2067 */ 2068 @Deprecated 2069 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 2070 Secure.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 2071 2072 /** 2073 * @deprecated Use 2074 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} instead 2075 */ 2076 @Deprecated 2077 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 2078 Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 2079 2080 /** 2081 * @deprecated Use 2082 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} instead 2083 */ 2084 @Deprecated 2085 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 2086 Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 2087 2088 /** 2089 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_NUM_OPEN_NETWORKS_KEPT} 2090 * instead 2091 */ 2092 @Deprecated 2093 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = Secure.WIFI_NUM_OPEN_NETWORKS_KEPT; 2094 2095 /** 2096 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_ON} instead 2097 */ 2098 @Deprecated 2099 public static final String WIFI_ON = Secure.WIFI_ON; 2100 2101 /** 2102 * @deprecated Use 2103 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE} 2104 * instead 2105 */ 2106 @Deprecated 2107 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 2108 Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE; 2109 2110 /** 2111 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_AP_COUNT} instead 2112 */ 2113 @Deprecated 2114 public static final String WIFI_WATCHDOG_AP_COUNT = Secure.WIFI_WATCHDOG_AP_COUNT; 2115 2116 /** 2117 * @deprecated Use 2118 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS} instead 2119 */ 2120 @Deprecated 2121 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 2122 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS; 2123 2124 /** 2125 * @deprecated Use 2126 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED} instead 2127 */ 2128 @Deprecated 2129 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 2130 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED; 2131 2132 /** 2133 * @deprecated Use 2134 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS} 2135 * instead 2136 */ 2137 @Deprecated 2138 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 2139 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS; 2140 2141 /** 2142 * @deprecated Use 2143 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT} instead 2144 */ 2145 @Deprecated 2146 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 2147 Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT; 2148 2149 /** 2150 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS} 2151 * instead 2152 */ 2153 @Deprecated 2154 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = Secure.WIFI_WATCHDOG_MAX_AP_CHECKS; 2155 2156 /** 2157 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_ON} instead 2158 */ 2159 @Deprecated 2160 public static final String WIFI_WATCHDOG_ON = Secure.WIFI_WATCHDOG_ON; 2161 2162 /** 2163 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_COUNT} instead 2164 */ 2165 @Deprecated 2166 public static final String WIFI_WATCHDOG_PING_COUNT = Secure.WIFI_WATCHDOG_PING_COUNT; 2167 2168 /** 2169 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_DELAY_MS} 2170 * instead 2171 */ 2172 @Deprecated 2173 public static final String WIFI_WATCHDOG_PING_DELAY_MS = Secure.WIFI_WATCHDOG_PING_DELAY_MS; 2174 2175 /** 2176 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_TIMEOUT_MS} 2177 * instead 2178 */ 2179 @Deprecated 2180 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = 2181 Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS; 2182 } 2183 2184 /** 2185 * Secure system settings, containing system preferences that applications 2186 * can read but are not allowed to write. These are for preferences that 2187 * the user must explicitly modify through the system UI or specialized 2188 * APIs for those values, not modified directly by applications. 2189 */ 2190 public static final class Secure extends NameValueTable { 2191 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_secure_version"; 2192 2193 // Populated lazily, guarded by class object: 2194 private static NameValueCache sNameValueCache = null; 2195 2196 /** 2197 * Look up a name in the database. 2198 * @param resolver to access the database with 2199 * @param name to look up in the table 2200 * @return the corresponding value, or null if not present 2201 */ getString(ContentResolver resolver, String name)2202 public synchronized static String getString(ContentResolver resolver, String name) { 2203 if (sNameValueCache == null) { 2204 sNameValueCache = new NameValueCache(SYS_PROP_SETTING_VERSION, CONTENT_URI, 2205 CALL_METHOD_GET_SECURE); 2206 } 2207 return sNameValueCache.getString(resolver, name); 2208 } 2209 2210 /** 2211 * Store a name/value pair into the database. 2212 * @param resolver to access the database with 2213 * @param name to store 2214 * @param value to associate with the name 2215 * @return true if the value was set, false on database errors 2216 */ putString(ContentResolver resolver, String name, String value)2217 public static boolean putString(ContentResolver resolver, 2218 String name, String value) { 2219 return putString(resolver, CONTENT_URI, name, value); 2220 } 2221 2222 /** 2223 * Construct the content URI for a particular name/value pair, 2224 * useful for monitoring changes with a ContentObserver. 2225 * @param name to look up in the table 2226 * @return the corresponding content URI, or null if not present 2227 */ getUriFor(String name)2228 public static Uri getUriFor(String name) { 2229 return getUriFor(CONTENT_URI, name); 2230 } 2231 2232 /** 2233 * Convenience function for retrieving a single secure settings value 2234 * as an integer. Note that internally setting values are always 2235 * stored as strings; this function converts the string to an integer 2236 * for you. The default value will be returned if the setting is 2237 * not defined or not an integer. 2238 * 2239 * @param cr The ContentResolver to access. 2240 * @param name The name of the setting to retrieve. 2241 * @param def Value to return if the setting is not defined. 2242 * 2243 * @return The setting's current value, or 'def' if it is not defined 2244 * or not a valid integer. 2245 */ getInt(ContentResolver cr, String name, int def)2246 public static int getInt(ContentResolver cr, String name, int def) { 2247 String v = getString(cr, name); 2248 try { 2249 return v != null ? Integer.parseInt(v) : def; 2250 } catch (NumberFormatException e) { 2251 return def; 2252 } 2253 } 2254 2255 /** 2256 * Convenience function for retrieving a single secure settings value 2257 * as an integer. Note that internally setting values are always 2258 * stored as strings; this function converts the string to an integer 2259 * for you. 2260 * <p> 2261 * This version does not take a default value. If the setting has not 2262 * been set, or the string value is not a number, 2263 * it throws {@link SettingNotFoundException}. 2264 * 2265 * @param cr The ContentResolver to access. 2266 * @param name The name of the setting to retrieve. 2267 * 2268 * @throws SettingNotFoundException Thrown if a setting by the given 2269 * name can't be found or the setting value is not an integer. 2270 * 2271 * @return The setting's current value. 2272 */ getInt(ContentResolver cr, String name)2273 public static int getInt(ContentResolver cr, String name) 2274 throws SettingNotFoundException { 2275 String v = getString(cr, name); 2276 try { 2277 return Integer.parseInt(v); 2278 } catch (NumberFormatException e) { 2279 throw new SettingNotFoundException(name); 2280 } 2281 } 2282 2283 /** 2284 * Convenience function for updating a single settings value as an 2285 * integer. This will either create a new entry in the table if the 2286 * given name does not exist, or modify the value of the existing row 2287 * with that name. Note that internally setting values are always 2288 * stored as strings, so this function converts the given value to a 2289 * string before storing it. 2290 * 2291 * @param cr The ContentResolver to access. 2292 * @param name The name of the setting to modify. 2293 * @param value The new value for the setting. 2294 * @return true if the value was set, false on database errors 2295 */ putInt(ContentResolver cr, String name, int value)2296 public static boolean putInt(ContentResolver cr, String name, int value) { 2297 return putString(cr, name, Integer.toString(value)); 2298 } 2299 2300 /** 2301 * Convenience function for retrieving a single secure settings value 2302 * as a {@code long}. Note that internally setting values are always 2303 * stored as strings; this function converts the string to a {@code long} 2304 * for you. The default value will be returned if the setting is 2305 * not defined or not a {@code long}. 2306 * 2307 * @param cr The ContentResolver to access. 2308 * @param name The name of the setting to retrieve. 2309 * @param def Value to return if the setting is not defined. 2310 * 2311 * @return The setting's current value, or 'def' if it is not defined 2312 * or not a valid {@code long}. 2313 */ getLong(ContentResolver cr, String name, long def)2314 public static long getLong(ContentResolver cr, String name, long def) { 2315 String valString = getString(cr, name); 2316 long value; 2317 try { 2318 value = valString != null ? Long.parseLong(valString) : def; 2319 } catch (NumberFormatException e) { 2320 value = def; 2321 } 2322 return value; 2323 } 2324 2325 /** 2326 * Convenience function for retrieving a single secure settings value 2327 * as a {@code long}. Note that internally setting values are always 2328 * stored as strings; this function converts the string to a {@code long} 2329 * for you. 2330 * <p> 2331 * This version does not take a default value. If the setting has not 2332 * been set, or the string value is not a number, 2333 * it throws {@link SettingNotFoundException}. 2334 * 2335 * @param cr The ContentResolver to access. 2336 * @param name The name of the setting to retrieve. 2337 * 2338 * @return The setting's current value. 2339 * @throws SettingNotFoundException Thrown if a setting by the given 2340 * name can't be found or the setting value is not an integer. 2341 */ getLong(ContentResolver cr, String name)2342 public static long getLong(ContentResolver cr, String name) 2343 throws SettingNotFoundException { 2344 String valString = getString(cr, name); 2345 try { 2346 return Long.parseLong(valString); 2347 } catch (NumberFormatException e) { 2348 throw new SettingNotFoundException(name); 2349 } 2350 } 2351 2352 /** 2353 * Convenience function for updating a secure settings value as a long 2354 * integer. This will either create a new entry in the table if the 2355 * given name does not exist, or modify the value of the existing row 2356 * with that name. Note that internally setting values are always 2357 * stored as strings, so this function converts the given value to a 2358 * string before storing it. 2359 * 2360 * @param cr The ContentResolver to access. 2361 * @param name The name of the setting to modify. 2362 * @param value The new value for the setting. 2363 * @return true if the value was set, false on database errors 2364 */ putLong(ContentResolver cr, String name, long value)2365 public static boolean putLong(ContentResolver cr, String name, long value) { 2366 return putString(cr, name, Long.toString(value)); 2367 } 2368 2369 /** 2370 * Convenience function for retrieving a single secure settings value 2371 * as a floating point number. Note that internally setting values are 2372 * always stored as strings; this function converts the string to an 2373 * float for you. The default value will be returned if the setting 2374 * is not defined or not a valid float. 2375 * 2376 * @param cr The ContentResolver to access. 2377 * @param name The name of the setting to retrieve. 2378 * @param def Value to return if the setting is not defined. 2379 * 2380 * @return The setting's current value, or 'def' if it is not defined 2381 * or not a valid float. 2382 */ getFloat(ContentResolver cr, String name, float def)2383 public static float getFloat(ContentResolver cr, String name, float def) { 2384 String v = getString(cr, name); 2385 try { 2386 return v != null ? Float.parseFloat(v) : def; 2387 } catch (NumberFormatException e) { 2388 return def; 2389 } 2390 } 2391 2392 /** 2393 * Convenience function for retrieving a single secure settings value 2394 * as a float. Note that internally setting values are always 2395 * stored as strings; this function converts the string to a float 2396 * for you. 2397 * <p> 2398 * This version does not take a default value. If the setting has not 2399 * been set, or the string value is not a number, 2400 * it throws {@link SettingNotFoundException}. 2401 * 2402 * @param cr The ContentResolver to access. 2403 * @param name The name of the setting to retrieve. 2404 * 2405 * @throws SettingNotFoundException Thrown if a setting by the given 2406 * name can't be found or the setting value is not a float. 2407 * 2408 * @return The setting's current value. 2409 */ getFloat(ContentResolver cr, String name)2410 public static float getFloat(ContentResolver cr, String name) 2411 throws SettingNotFoundException { 2412 String v = getString(cr, name); 2413 if (v == null) { 2414 throw new SettingNotFoundException(name); 2415 } 2416 try { 2417 return Float.parseFloat(v); 2418 } catch (NumberFormatException e) { 2419 throw new SettingNotFoundException(name); 2420 } 2421 } 2422 2423 /** 2424 * Convenience function for updating a single settings value as a 2425 * floating point number. This will either create a new entry in the 2426 * table if the given name does not exist, or modify the value of the 2427 * existing row with that name. Note that internally setting values 2428 * are always stored as strings, so this function converts the given 2429 * value to a string before storing it. 2430 * 2431 * @param cr The ContentResolver to access. 2432 * @param name The name of the setting to modify. 2433 * @param value The new value for the setting. 2434 * @return true if the value was set, false on database errors 2435 */ putFloat(ContentResolver cr, String name, float value)2436 public static boolean putFloat(ContentResolver cr, String name, float value) { 2437 return putString(cr, name, Float.toString(value)); 2438 } 2439 2440 /** 2441 * The content:// style URL for this table 2442 */ 2443 public static final Uri CONTENT_URI = 2444 Uri.parse("content://" + AUTHORITY + "/secure"); 2445 2446 /** 2447 * Whether ADB is enabled. 2448 */ 2449 public static final String ADB_ENABLED = "adb_enabled"; 2450 2451 /** 2452 * Setting to allow mock locations and location provider status to be injected into the 2453 * LocationManager service for testing purposes during application development. These 2454 * locations and status values override actual location and status information generated 2455 * by network, gps, or other location providers. 2456 */ 2457 public static final String ALLOW_MOCK_LOCATION = "mock_location"; 2458 2459 /** 2460 * A 64-bit number (as a hex string) that is randomly 2461 * generated on the device's first boot and should remain 2462 * constant for the lifetime of the device. (The value may 2463 * change if a factory reset is performed on the device.) 2464 */ 2465 public static final String ANDROID_ID = "android_id"; 2466 2467 /** 2468 * Whether bluetooth is enabled/disabled 2469 * 0=disabled. 1=enabled. 2470 */ 2471 public static final String BLUETOOTH_ON = "bluetooth_on"; 2472 2473 /** 2474 * Get the key that retrieves a bluetooth headset's priority. 2475 * @hide 2476 */ getBluetoothHeadsetPriorityKey(String address)2477 public static final String getBluetoothHeadsetPriorityKey(String address) { 2478 return ("bluetooth_headset_priority_" + address.toUpperCase()); 2479 } 2480 2481 /** 2482 * Get the key that retrieves a bluetooth a2dp sink's priority. 2483 * @hide 2484 */ getBluetoothA2dpSinkPriorityKey(String address)2485 public static final String getBluetoothA2dpSinkPriorityKey(String address) { 2486 return ("bluetooth_a2dp_sink_priority_" + address.toUpperCase()); 2487 } 2488 2489 /** 2490 * Get the key that retrieves a bluetooth Input Device's priority. 2491 * @hide 2492 */ getBluetoothInputDevicePriorityKey(String address)2493 public static final String getBluetoothInputDevicePriorityKey(String address) { 2494 return ("bluetooth_input_device_priority_" + address.toUpperCase()); 2495 } 2496 2497 /** 2498 * Whether or not data roaming is enabled. (0 = false, 1 = true) 2499 */ 2500 public static final String DATA_ROAMING = "data_roaming"; 2501 2502 /** 2503 * Setting to record the input method used by default, holding the ID 2504 * of the desired method. 2505 */ 2506 public static final String DEFAULT_INPUT_METHOD = "default_input_method"; 2507 2508 /** 2509 * Setting to record the input method subtype used by default, holding the ID 2510 * of the desired method. 2511 */ 2512 public static final String SELECTED_INPUT_METHOD_SUBTYPE = 2513 "selected_input_method_subtype"; 2514 2515 /** 2516 * Setting to record the history of input method subtype, holding the pair of ID of IME 2517 * and its last used subtype. 2518 * @hide 2519 */ 2520 public static final String INPUT_METHODS_SUBTYPE_HISTORY = 2521 "input_methods_subtype_history"; 2522 2523 /** 2524 * Setting to record the visibility of input method selector 2525 */ 2526 public static final String INPUT_METHOD_SELECTOR_VISIBILITY = 2527 "input_method_selector_visibility"; 2528 2529 /** 2530 * Whether the device has been provisioned (0 = false, 1 = true) 2531 */ 2532 public static final String DEVICE_PROVISIONED = "device_provisioned"; 2533 2534 /** 2535 * List of input methods that are currently enabled. This is a string 2536 * containing the IDs of all enabled input methods, each ID separated 2537 * by ':'. 2538 */ 2539 public static final String ENABLED_INPUT_METHODS = "enabled_input_methods"; 2540 2541 /** 2542 * List of system input methods that are currently disabled. This is a string 2543 * containing the IDs of all disabled input methods, each ID separated 2544 * by ':'. 2545 * @hide 2546 */ 2547 public static final String DISABLED_SYSTEM_INPUT_METHODS = "disabled_system_input_methods"; 2548 2549 /** 2550 * Host name and port for global http proxy. Uses ':' seperator for between host and port 2551 * TODO - deprecate in favor of global_http_proxy_host, etc 2552 */ 2553 public static final String HTTP_PROXY = "http_proxy"; 2554 2555 /** 2556 * Host name for global http proxy. Set via ConnectivityManager. 2557 * @hide 2558 */ 2559 public static final String GLOBAL_HTTP_PROXY_HOST = "global_http_proxy_host"; 2560 2561 /** 2562 * Integer host port for global http proxy. Set via ConnectivityManager. 2563 * @hide 2564 */ 2565 public static final String GLOBAL_HTTP_PROXY_PORT = "global_http_proxy_port"; 2566 2567 /** 2568 * Exclusion list for global proxy. This string contains a list of comma-separated 2569 * domains where the global proxy does not apply. Domains should be listed in a comma- 2570 * separated list. Example of acceptable formats: ".domain1.com,my.domain2.com" 2571 * Use ConnectivityManager to set/get. 2572 * @hide 2573 */ 2574 public static final String GLOBAL_HTTP_PROXY_EXCLUSION_LIST = 2575 "global_http_proxy_exclusion_list"; 2576 2577 /** 2578 * Enables the UI setting to allow the user to specify the global HTTP proxy 2579 * and associated exclusion list. 2580 * @hide 2581 */ 2582 public static final String SET_GLOBAL_HTTP_PROXY = "set_global_http_proxy"; 2583 2584 /** 2585 * Setting for default DNS in case nobody suggests one 2586 * @hide 2587 */ 2588 public static final String DEFAULT_DNS_SERVER = "default_dns_server"; 2589 2590 /** 2591 * Whether the package installer should allow installation of apps downloaded from 2592 * sources other than the Android Market (vending machine). 2593 * 2594 * 1 = allow installing from other sources 2595 * 0 = only allow installing from the Android Market 2596 */ 2597 public static final String INSTALL_NON_MARKET_APPS = "install_non_market_apps"; 2598 2599 /** 2600 * Comma-separated list of location providers that activities may access. 2601 */ 2602 public static final String LOCATION_PROVIDERS_ALLOWED = "location_providers_allowed"; 2603 2604 /** 2605 * Whether autolock is enabled (0 = false, 1 = true) 2606 */ 2607 public static final String LOCK_PATTERN_ENABLED = "lock_pattern_autolock"; 2608 2609 /** 2610 * Whether lock pattern is visible as user enters (0 = false, 1 = true) 2611 */ 2612 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 2613 2614 /** 2615 * Whether lock pattern will vibrate as user enters (0 = false, 1 = true) 2616 */ 2617 public static final String LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = 2618 "lock_pattern_tactile_feedback_enabled"; 2619 2620 /** 2621 * This preference allows the device to be locked given time after screen goes off, 2622 * subject to current DeviceAdmin policy limits. 2623 * @hide 2624 */ 2625 public static final String LOCK_SCREEN_LOCK_AFTER_TIMEOUT = "lock_screen_lock_after_timeout"; 2626 2627 2628 /** 2629 * This preference contains the string that shows for owner info on LockScren. 2630 * @hide 2631 */ 2632 public static final String LOCK_SCREEN_OWNER_INFO = "lock_screen_owner_info"; 2633 2634 /** 2635 * This preference enables showing the owner info on LockScren. 2636 * @hide 2637 */ 2638 public static final String LOCK_SCREEN_OWNER_INFO_ENABLED = 2639 "lock_screen_owner_info_enabled"; 2640 2641 /** 2642 * The saved value for WindowManagerService.setForcedDisplaySize(). 2643 * Two integers separated by a comma. If unset, then use the real display size. 2644 * @hide 2645 */ 2646 public static final String DISPLAY_SIZE_FORCED = "display_size_forced"; 2647 2648 /** 2649 * Whether assisted GPS should be enabled or not. 2650 * @hide 2651 */ 2652 public static final String ASSISTED_GPS_ENABLED = "assisted_gps_enabled"; 2653 2654 /** 2655 * The Logging ID (a unique 64-bit value) as a hex string. 2656 * Used as a pseudonymous identifier for logging. 2657 * @deprecated This identifier is poorly initialized and has 2658 * many collisions. It should not be used. 2659 */ 2660 @Deprecated 2661 public static final String LOGGING_ID = "logging_id"; 2662 2663 /** 2664 * User preference for which network(s) should be used. Only the 2665 * connectivity service should touch this. 2666 */ 2667 public static final String NETWORK_PREFERENCE = "network_preference"; 2668 2669 /** 2670 * Used to disable Tethering on a device - defaults to true 2671 * @hide 2672 */ 2673 public static final String TETHER_SUPPORTED = "tether_supported"; 2674 2675 /** 2676 * Used to require DUN APN on the device or not - defaults to a build config value 2677 * which defaults to false 2678 * @hide 2679 */ 2680 public static final String TETHER_DUN_REQUIRED = "tether_dun_required"; 2681 2682 /** 2683 * Used to hold a gservices-provisioned apn value for DUN. If set, or the 2684 * corresponding build config values are set it will override the APN DB 2685 * values. 2686 * Consists of a comma seperated list of strings: 2687 * "name,apn,proxy,port,username,password,server,mmsc,mmsproxy,mmsport,mcc,mnc,auth,type" 2688 * note that empty fields can be ommitted: "name,apn,,,,,,,,,310,260,,DUN" 2689 * @hide 2690 */ 2691 public static final String TETHER_DUN_APN = "tether_dun_apn"; 2692 2693 /** 2694 * No longer supported. 2695 */ 2696 public static final String PARENTAL_CONTROL_ENABLED = "parental_control_enabled"; 2697 2698 /** 2699 * No longer supported. 2700 */ 2701 public static final String PARENTAL_CONTROL_LAST_UPDATE = "parental_control_last_update"; 2702 2703 /** 2704 * No longer supported. 2705 */ 2706 public static final String PARENTAL_CONTROL_REDIRECT_URL = "parental_control_redirect_url"; 2707 2708 /** 2709 * A positive value indicates how often the SamplingProfiler 2710 * should take snapshots. Zero value means SamplingProfiler 2711 * is disabled. 2712 * 2713 * @hide 2714 */ 2715 public static final String SAMPLING_PROFILER_MS = "sampling_profiler_ms"; 2716 2717 /** 2718 * Settings classname to launch when Settings is clicked from All 2719 * Applications. Needed because of user testing between the old 2720 * and new Settings apps. 2721 */ 2722 // TODO: 881807 2723 public static final String SETTINGS_CLASSNAME = "settings_classname"; 2724 2725 /** 2726 * USB Mass Storage Enabled 2727 */ 2728 public static final String USB_MASS_STORAGE_ENABLED = "usb_mass_storage_enabled"; 2729 2730 /** 2731 * If this setting is set (to anything), then all references 2732 * to Gmail on the device must change to Google Mail. 2733 */ 2734 public static final String USE_GOOGLE_MAIL = "use_google_mail"; 2735 2736 /** 2737 * If accessibility is enabled. 2738 */ 2739 public static final String ACCESSIBILITY_ENABLED = "accessibility_enabled"; 2740 2741 /** 2742 * If touch exploration is enabled. 2743 */ 2744 public static final String TOUCH_EXPLORATION_ENABLED = "touch_exploration_enabled"; 2745 2746 /** 2747 * List of the enabled accessibility providers. 2748 */ 2749 public static final String ENABLED_ACCESSIBILITY_SERVICES = 2750 "enabled_accessibility_services"; 2751 2752 /** 2753 * If injection of accessibility enhancing JavaScript scripts 2754 * is enabled. 2755 * <p> 2756 * Note: Accessibility injecting scripts are served by the 2757 * Google infrastructure and enable users with disabilities to 2758 * efficiantly navigate in and explore web content. 2759 * </p> 2760 * <p> 2761 * This property represents a boolean value. 2762 * </p> 2763 * @hide 2764 */ 2765 public static final String ACCESSIBILITY_SCRIPT_INJECTION = 2766 "accessibility_script_injection"; 2767 2768 /** 2769 * Key bindings for navigation in built-in accessibility support for web content. 2770 * <p> 2771 * Note: These key bindings are for the built-in accessibility navigation for 2772 * web content which is used as a fall back solution if JavaScript in a WebView 2773 * is not enabled or the user has not opted-in script injection from Google. 2774 * </p> 2775 * <p> 2776 * The bindings are separated by semi-colon. A binding is a mapping from 2777 * a key to a sequence of actions (for more details look at 2778 * android.webkit.AccessibilityInjector). A key is represented as the hexademical 2779 * string representation of an integer obtained from a meta state (optional) shifted 2780 * sixteen times left and bitwise ored with a key code. An action is represented 2781 * as a hexademical string representation of an integer where the first two digits 2782 * are navigation action index, the second, the third, and the fourth digit pairs 2783 * represent the action arguments. The separate actions in a binding are colon 2784 * separated. The key and the action sequence it maps to are separated by equals. 2785 * </p> 2786 * <p> 2787 * For example, the binding below maps the DPAD right button to traverse the 2788 * current navigation axis once without firing an accessibility event and to 2789 * perform the same traversal again but to fire an event: 2790 * <code> 2791 * 0x16=0x01000100:0x01000101; 2792 * </code> 2793 * </p> 2794 * <p> 2795 * The goal of this binding is to enable dynamic rebinding of keys to 2796 * navigation actions for web content without requiring a framework change. 2797 * </p> 2798 * <p> 2799 * This property represents a string value. 2800 * </p> 2801 * @hide 2802 */ 2803 public static final String ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS = 2804 "accessibility_web_content_key_bindings"; 2805 2806 /** 2807 * The timout for considering a press to be a long press in milliseconds. 2808 * @hide 2809 */ 2810 public static final String LONG_PRESS_TIMEOUT = "long_press_timeout"; 2811 2812 /** 2813 * Setting to always use the default text-to-speech settings regardless 2814 * of the application settings. 2815 * 1 = override application settings, 2816 * 0 = use application settings (if specified). 2817 * 2818 * @deprecated The value of this setting is no longer respected by 2819 * the framework text to speech APIs as of the Ice Cream Sandwich release. 2820 */ 2821 @Deprecated 2822 public static final String TTS_USE_DEFAULTS = "tts_use_defaults"; 2823 2824 /** 2825 * Default text-to-speech engine speech rate. 100 = 1x 2826 */ 2827 public static final String TTS_DEFAULT_RATE = "tts_default_rate"; 2828 2829 /** 2830 * Default text-to-speech engine pitch. 100 = 1x 2831 */ 2832 public static final String TTS_DEFAULT_PITCH = "tts_default_pitch"; 2833 2834 /** 2835 * Default text-to-speech engine. 2836 */ 2837 public static final String TTS_DEFAULT_SYNTH = "tts_default_synth"; 2838 2839 /** 2840 * Default text-to-speech language. 2841 * 2842 * @deprecated this setting is no longer in use, as of the Ice Cream 2843 * Sandwich release. Apps should never need to read this setting directly, 2844 * instead can query the TextToSpeech framework classes for the default 2845 * locale. {@link TextToSpeech#getLanguage()}. 2846 */ 2847 @Deprecated 2848 public static final String TTS_DEFAULT_LANG = "tts_default_lang"; 2849 2850 /** 2851 * Default text-to-speech country. 2852 * 2853 * @deprecated this setting is no longer in use, as of the Ice Cream 2854 * Sandwich release. Apps should never need to read this setting directly, 2855 * instead can query the TextToSpeech framework classes for the default 2856 * locale. {@link TextToSpeech#getLanguage()}. 2857 */ 2858 @Deprecated 2859 public static final String TTS_DEFAULT_COUNTRY = "tts_default_country"; 2860 2861 /** 2862 * Default text-to-speech locale variant. 2863 * 2864 * @deprecated this setting is no longer in use, as of the Ice Cream 2865 * Sandwich release. Apps should never need to read this setting directly, 2866 * instead can query the TextToSpeech framework classes for the 2867 * locale that is in use {@link TextToSpeech#getLanguage()}. 2868 */ 2869 @Deprecated 2870 public static final String TTS_DEFAULT_VARIANT = "tts_default_variant"; 2871 2872 /** 2873 * Stores the default tts locales on a per engine basis. Stored as 2874 * a comma seperated list of values, each value being of the form 2875 * {@code engine_name:locale} for example, 2876 * {@code com.foo.ttsengine:eng-USA,com.bar.ttsengine:esp-ESP}. This 2877 * supersedes {@link #TTS_DEFAULT_LANG}, {@link #TTS_DEFAULT_COUNTRY} and 2878 * {@link #TTS_DEFAULT_VARIANT}. Apps should never need to read this 2879 * setting directly, and can query the TextToSpeech framework classes 2880 * for the locale that is in use. 2881 * 2882 * @hide 2883 */ 2884 public static final String TTS_DEFAULT_LOCALE = "tts_default_locale"; 2885 2886 /** 2887 * Space delimited list of plugin packages that are enabled. 2888 */ 2889 public static final String TTS_ENABLED_PLUGINS = "tts_enabled_plugins"; 2890 2891 /** 2892 * Whether to notify the user of open networks. 2893 * <p> 2894 * If not connected and the scan results have an open network, we will 2895 * put this notification up. If we attempt to connect to a network or 2896 * the open network(s) disappear, we remove the notification. When we 2897 * show the notification, we will not show it again for 2898 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} time. 2899 */ 2900 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 2901 "wifi_networks_available_notification_on"; 2902 2903 /** 2904 * Delay (in seconds) before repeating the Wi-Fi networks available notification. 2905 * Connecting to a network will reset the timer. 2906 */ 2907 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 2908 "wifi_networks_available_repeat_delay"; 2909 2910 /** 2911 * 802.11 country code in ISO 3166 format 2912 * @hide 2913 */ 2914 public static final String WIFI_COUNTRY_CODE = "wifi_country_code"; 2915 2916 2917 /** 2918 * When the number of open networks exceeds this number, the 2919 * least-recently-used excess networks will be removed. 2920 */ 2921 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = "wifi_num_open_networks_kept"; 2922 2923 /** 2924 * Whether the Wi-Fi should be on. Only the Wi-Fi service should touch this. 2925 */ 2926 public static final String WIFI_ON = "wifi_on"; 2927 2928 /** 2929 * Used to save the Wifi_ON state prior to tethering. 2930 * This state will be checked to restore Wifi after 2931 * the user turns off tethering. 2932 * 2933 * @hide 2934 */ 2935 public static final String WIFI_SAVED_STATE = "wifi_saved_state"; 2936 2937 /** 2938 * AP SSID 2939 * 2940 * @hide 2941 */ 2942 public static final String WIFI_AP_SSID = "wifi_ap_ssid"; 2943 2944 /** 2945 * AP security 2946 * 2947 * @hide 2948 */ 2949 public static final String WIFI_AP_SECURITY = "wifi_ap_security"; 2950 2951 /** 2952 * AP passphrase 2953 * 2954 * @hide 2955 */ 2956 public static final String WIFI_AP_PASSWD = "wifi_ap_passwd"; 2957 2958 /** 2959 * The acceptable packet loss percentage (range 0 - 100) before trying 2960 * another AP on the same network. 2961 */ 2962 @Deprecated 2963 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 2964 "wifi_watchdog_acceptable_packet_loss_percentage"; 2965 2966 /** 2967 * The number of access points required for a network in order for the 2968 * watchdog to monitor it. 2969 */ 2970 @Deprecated 2971 public static final String WIFI_WATCHDOG_AP_COUNT = "wifi_watchdog_ap_count"; 2972 2973 /** 2974 * The delay between background checks. 2975 */ 2976 @Deprecated 2977 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 2978 "wifi_watchdog_background_check_delay_ms"; 2979 2980 /** 2981 * Whether the Wi-Fi watchdog is enabled for background checking even 2982 * after it thinks the user has connected to a good access point. 2983 */ 2984 @Deprecated 2985 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 2986 "wifi_watchdog_background_check_enabled"; 2987 2988 /** 2989 * The timeout for a background ping 2990 */ 2991 @Deprecated 2992 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 2993 "wifi_watchdog_background_check_timeout_ms"; 2994 2995 /** 2996 * The number of initial pings to perform that *may* be ignored if they 2997 * fail. Again, if these fail, they will *not* be used in packet loss 2998 * calculation. For example, one network always seemed to time out for 2999 * the first couple pings, so this is set to 3 by default. 3000 */ 3001 @Deprecated 3002 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 3003 "wifi_watchdog_initial_ignored_ping_count"; 3004 3005 /** 3006 * The maximum number of access points (per network) to attempt to test. 3007 * If this number is reached, the watchdog will no longer monitor the 3008 * initial connection state for the network. This is a safeguard for 3009 * networks containing multiple APs whose DNS does not respond to pings. 3010 */ 3011 @Deprecated 3012 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = "wifi_watchdog_max_ap_checks"; 3013 3014 /** 3015 * Whether the Wi-Fi watchdog is enabled. 3016 */ 3017 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 3018 3019 /** 3020 * A comma-separated list of SSIDs for which the Wi-Fi watchdog should be enabled. 3021 */ 3022 @Deprecated 3023 public static final String WIFI_WATCHDOG_WATCH_LIST = "wifi_watchdog_watch_list"; 3024 3025 /** 3026 * The number of pings to test if an access point is a good connection. 3027 */ 3028 @Deprecated 3029 public static final String WIFI_WATCHDOG_PING_COUNT = "wifi_watchdog_ping_count"; 3030 3031 /** 3032 * The delay between pings. 3033 */ 3034 @Deprecated 3035 public static final String WIFI_WATCHDOG_PING_DELAY_MS = "wifi_watchdog_ping_delay_ms"; 3036 3037 /** 3038 * The timeout per ping. 3039 */ 3040 @Deprecated 3041 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = "wifi_watchdog_ping_timeout_ms"; 3042 3043 /** 3044 * ms delay before rechecking an 'online' wifi connection when it is thought to be unstable. 3045 * @hide 3046 */ 3047 public static final String WIFI_WATCHDOG_DNS_CHECK_SHORT_INTERVAL_MS = 3048 "wifi_watchdog_dns_check_short_interval_ms"; 3049 3050 /** 3051 * ms delay before rechecking an 'online' wifi connection when it is thought to be stable. 3052 * @hide 3053 */ 3054 public static final String WIFI_WATCHDOG_DNS_CHECK_LONG_INTERVAL_MS = 3055 "wifi_watchdog_dns_check_long_interval_ms"; 3056 3057 /** 3058 * ms delay before rechecking a connect SSID for walled garden with a http download. 3059 * @hide 3060 */ 3061 public static final String WIFI_WATCHDOG_WALLED_GARDEN_INTERVAL_MS = 3062 "wifi_watchdog_walled_garden_interval_ms"; 3063 3064 /** 3065 * max blacklist calls on an SSID before full dns check failures disable the network. 3066 * @hide 3067 */ 3068 public static final String WIFI_WATCHDOG_MAX_SSID_BLACKLISTS = 3069 "wifi_watchdog_max_ssid_blacklists"; 3070 3071 /** 3072 * Number of dns pings per check. 3073 * @hide 3074 */ 3075 public static final String WIFI_WATCHDOG_NUM_DNS_PINGS = "wifi_watchdog_num_dns_pings"; 3076 3077 /** 3078 * Minimum number of responses to the dns pings to consider the test 'successful'. 3079 * @hide 3080 */ 3081 public static final String WIFI_WATCHDOG_MIN_DNS_RESPONSES = 3082 "wifi_watchdog_min_dns_responses"; 3083 3084 /** 3085 * Timeout on dns pings 3086 * @hide 3087 */ 3088 public static final String WIFI_WATCHDOG_DNS_PING_TIMEOUT_MS = 3089 "wifi_watchdog_dns_ping_timeout_ms"; 3090 3091 /** 3092 * We consider action from a 'blacklist' call to have finished by the end of 3093 * this interval. If we are connected to the same AP with no network connection, 3094 * we are likely stuck on an SSID with no external connectivity. 3095 * @hide 3096 */ 3097 public static final String WIFI_WATCHDOG_BLACKLIST_FOLLOWUP_INTERVAL_MS = 3098 "wifi_watchdog_blacklist_followup_interval_ms"; 3099 3100 /** 3101 * Setting to turn off walled garden test on Wi-Fi. Feature is enabled by default and 3102 * the setting needs to be set to 0 to disable it. 3103 * @hide 3104 */ 3105 public static final String WIFI_WATCHDOG_WALLED_GARDEN_TEST_ENABLED = 3106 "wifi_watchdog_walled_garden_test_enabled"; 3107 3108 /** 3109 * The URL used for walled garden check upon a new conection. WifiWatchdogService 3110 * fetches the URL and checks to see if {@link #WIFI_WATCHDOG_WALLED_GARDEN_PATTERN} 3111 * is not part of the title string to notify the user on the presence of a walled garden. 3112 * @hide 3113 */ 3114 public static final String WIFI_WATCHDOG_WALLED_GARDEN_URL = 3115 "wifi_watchdog_walled_garden_url"; 3116 3117 /** 3118 * Boolean to determine whether to notify on disabling a network. Secure setting used 3119 * to notify user only once. 3120 * @hide 3121 */ 3122 public static final String WIFI_WATCHDOG_SHOW_DISABLED_NETWORK_POPUP = 3123 "wifi_watchdog_show_disabled_network_popup"; 3124 3125 /** 3126 * The maximum number of times we will retry a connection to an access 3127 * point for which we have failed in acquiring an IP address from DHCP. 3128 * A value of N means that we will make N+1 connection attempts in all. 3129 */ 3130 public static final String WIFI_MAX_DHCP_RETRY_COUNT = "wifi_max_dhcp_retry_count"; 3131 3132 /** 3133 * The operational wifi frequency band 3134 * Set to one of {@link WifiManager#WIFI_FREQUENCY_BAND_AUTO}, 3135 * {@link WifiManager#WIFI_FREQUENCY_BAND_5GHZ} or 3136 * {@link WifiManager#WIFI_FREQUENCY_BAND_2GHZ} 3137 * 3138 * @hide 3139 */ 3140 public static final String WIFI_FREQUENCY_BAND = "wifi_frequency_band"; 3141 3142 /** 3143 * Maximum amount of time in milliseconds to hold a wakelock while waiting for mobile 3144 * data connectivity to be established after a disconnect from Wi-Fi. 3145 */ 3146 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 3147 "wifi_mobile_data_transition_wakelock_timeout_ms"; 3148 3149 /** 3150 * Whether background data usage is allowed by the user. See 3151 * ConnectivityManager for more info. 3152 */ 3153 @Deprecated 3154 public static final String BACKGROUND_DATA = "background_data"; 3155 3156 /** 3157 * Origins for which browsers should allow geolocation by default. 3158 * The value is a space-separated list of origins. 3159 */ 3160 public static final String ALLOWED_GEOLOCATION_ORIGINS 3161 = "allowed_geolocation_origins"; 3162 3163 /** 3164 * Whether mobile data connections are allowed by the user. See 3165 * ConnectivityManager for more info. 3166 * @hide 3167 */ 3168 public static final String MOBILE_DATA = "mobile_data"; 3169 3170 /** 3171 * The CDMA roaming mode 0 = Home Networks, CDMA default 3172 * 1 = Roaming on Affiliated networks 3173 * 2 = Roaming on any networks 3174 * @hide 3175 */ 3176 public static final String CDMA_ROAMING_MODE = "roaming_settings"; 3177 3178 /** 3179 * The CDMA subscription mode 0 = RUIM/SIM (default) 3180 * 1 = NV 3181 * @hide 3182 */ 3183 public static final String CDMA_SUBSCRIPTION_MODE = "subscription_mode"; 3184 3185 /** 3186 * The preferred network mode 7 = Global 3187 * 6 = EvDo only 3188 * 5 = CDMA w/o EvDo 3189 * 4 = CDMA / EvDo auto 3190 * 3 = GSM / WCDMA auto 3191 * 2 = WCDMA only 3192 * 1 = GSM only 3193 * 0 = GSM / WCDMA preferred 3194 * @hide 3195 */ 3196 public static final String PREFERRED_NETWORK_MODE = 3197 "preferred_network_mode"; 3198 3199 /** 3200 * The preferred TTY mode 0 = TTy Off, CDMA default 3201 * 1 = TTY Full 3202 * 2 = TTY HCO 3203 * 3 = TTY VCO 3204 * @hide 3205 */ 3206 public static final String PREFERRED_TTY_MODE = 3207 "preferred_tty_mode"; 3208 3209 3210 /** 3211 * CDMA Cell Broadcast SMS 3212 * 0 = CDMA Cell Broadcast SMS disabled 3213 * 1 = CDMA Cell Broadcast SMS enabled 3214 * @hide 3215 */ 3216 public static final String CDMA_CELL_BROADCAST_SMS = 3217 "cdma_cell_broadcast_sms"; 3218 3219 /** 3220 * The cdma subscription 0 = Subscription from RUIM, when available 3221 * 1 = Subscription from NV 3222 * @hide 3223 */ 3224 public static final String PREFERRED_CDMA_SUBSCRIPTION = 3225 "preferred_cdma_subscription"; 3226 3227 /** 3228 * Whether the enhanced voice privacy mode is enabled. 3229 * 0 = normal voice privacy 3230 * 1 = enhanced voice privacy 3231 * @hide 3232 */ 3233 public static final String ENHANCED_VOICE_PRIVACY_ENABLED = "enhanced_voice_privacy_enabled"; 3234 3235 /** 3236 * Whether the TTY mode mode is enabled. 3237 * 0 = disabled 3238 * 1 = enabled 3239 * @hide 3240 */ 3241 public static final String TTY_MODE_ENABLED = "tty_mode_enabled"; 3242 3243 /** 3244 * The number of milliseconds to delay before sending out Connectivyt Change broadcasts 3245 * @hide 3246 */ 3247 public static final String CONNECTIVITY_CHANGE_DELAY = "connectivity_change_delay"; 3248 3249 /** 3250 * Default value for CONNECTIVITY_CHANGE_DELAY in milliseconds. 3251 * @hide 3252 */ 3253 public static final int CONNECTIVITY_CHANGE_DELAY_DEFAULT = 3000; 3254 3255 /** 3256 * Controls whether settings backup is enabled. 3257 * Type: int ( 0 = disabled, 1 = enabled ) 3258 * @hide 3259 */ 3260 public static final String BACKUP_ENABLED = "backup_enabled"; 3261 3262 /** 3263 * Controls whether application data is automatically restored from backup 3264 * at install time. 3265 * Type: int ( 0 = disabled, 1 = enabled ) 3266 * @hide 3267 */ 3268 public static final String BACKUP_AUTO_RESTORE = "backup_auto_restore"; 3269 3270 /** 3271 * Indicates whether settings backup has been fully provisioned. 3272 * Type: int ( 0 = unprovisioned, 1 = fully provisioned ) 3273 * @hide 3274 */ 3275 public static final String BACKUP_PROVISIONED = "backup_provisioned"; 3276 3277 /** 3278 * Component of the transport to use for backup/restore. 3279 * @hide 3280 */ 3281 public static final String BACKUP_TRANSPORT = "backup_transport"; 3282 3283 /** 3284 * Version for which the setup wizard was last shown. Bumped for 3285 * each release when there is new setup information to show. 3286 * @hide 3287 */ 3288 public static final String LAST_SETUP_SHOWN = "last_setup_shown"; 3289 3290 /** 3291 * How frequently (in seconds) to check the memory status of the 3292 * device. 3293 * @hide 3294 */ 3295 public static final String MEMCHECK_INTERVAL = "memcheck_interval"; 3296 3297 /** 3298 * Max frequency (in seconds) to log memory check stats, in realtime 3299 * seconds. This allows for throttling of logs when the device is 3300 * running for large amounts of time. 3301 * @hide 3302 */ 3303 public static final String MEMCHECK_LOG_REALTIME_INTERVAL = 3304 "memcheck_log_realtime_interval"; 3305 3306 /** 3307 * Boolean indicating whether rebooting due to system memory checks 3308 * is enabled. 3309 * @hide 3310 */ 3311 public static final String MEMCHECK_SYSTEM_ENABLED = "memcheck_system_enabled"; 3312 3313 /** 3314 * How many bytes the system process must be below to avoid scheduling 3315 * a soft reboot. This reboot will happen when it is next determined 3316 * to be a good time. 3317 * @hide 3318 */ 3319 public static final String MEMCHECK_SYSTEM_SOFT_THRESHOLD = "memcheck_system_soft"; 3320 3321 /** 3322 * How many bytes the system process must be below to avoid scheduling 3323 * a hard reboot. This reboot will happen immediately. 3324 * @hide 3325 */ 3326 public static final String MEMCHECK_SYSTEM_HARD_THRESHOLD = "memcheck_system_hard"; 3327 3328 /** 3329 * How many bytes the phone process must be below to avoid scheduling 3330 * a soft restart. This restart will happen when it is next determined 3331 * to be a good time. 3332 * @hide 3333 */ 3334 public static final String MEMCHECK_PHONE_SOFT_THRESHOLD = "memcheck_phone_soft"; 3335 3336 /** 3337 * How many bytes the phone process must be below to avoid scheduling 3338 * a hard restart. This restart will happen immediately. 3339 * @hide 3340 */ 3341 public static final String MEMCHECK_PHONE_HARD_THRESHOLD = "memcheck_phone_hard"; 3342 3343 /** 3344 * Boolean indicating whether restarting the phone process due to 3345 * memory checks is enabled. 3346 * @hide 3347 */ 3348 public static final String MEMCHECK_PHONE_ENABLED = "memcheck_phone_enabled"; 3349 3350 /** 3351 * First time during the day it is okay to kill processes 3352 * or reboot the device due to low memory situations. This number is 3353 * in seconds since midnight. 3354 * @hide 3355 */ 3356 public static final String MEMCHECK_EXEC_START_TIME = "memcheck_exec_start_time"; 3357 3358 /** 3359 * Last time during the day it is okay to kill processes 3360 * or reboot the device due to low memory situations. This number is 3361 * in seconds since midnight. 3362 * @hide 3363 */ 3364 public static final String MEMCHECK_EXEC_END_TIME = "memcheck_exec_end_time"; 3365 3366 /** 3367 * How long the screen must have been off in order to kill processes 3368 * or reboot. This number is in seconds. A value of -1 means to 3369 * entirely disregard whether the screen is on. 3370 * @hide 3371 */ 3372 public static final String MEMCHECK_MIN_SCREEN_OFF = "memcheck_min_screen_off"; 3373 3374 /** 3375 * How much time there must be until the next alarm in order to kill processes 3376 * or reboot. This number is in seconds. Note: this value must be 3377 * smaller than {@link #MEMCHECK_RECHECK_INTERVAL} or else it will 3378 * always see an alarm scheduled within its time. 3379 * @hide 3380 */ 3381 public static final String MEMCHECK_MIN_ALARM = "memcheck_min_alarm"; 3382 3383 /** 3384 * How frequently to check whether it is a good time to restart things, 3385 * if the device is in a bad state. This number is in seconds. Note: 3386 * this value must be larger than {@link #MEMCHECK_MIN_ALARM} or else 3387 * the alarm to schedule the recheck will always appear within the 3388 * minimum "do not execute now" time. 3389 * @hide 3390 */ 3391 public static final String MEMCHECK_RECHECK_INTERVAL = "memcheck_recheck_interval"; 3392 3393 /** 3394 * How frequently (in DAYS) to reboot the device. If 0, no reboots 3395 * will occur. 3396 * @hide 3397 */ 3398 public static final String REBOOT_INTERVAL = "reboot_interval"; 3399 3400 /** 3401 * First time during the day it is okay to force a reboot of the 3402 * device (if REBOOT_INTERVAL is set). This number is 3403 * in seconds since midnight. 3404 * @hide 3405 */ 3406 public static final String REBOOT_START_TIME = "reboot_start_time"; 3407 3408 /** 3409 * The window of time (in seconds) after each REBOOT_INTERVAL in which 3410 * a reboot can be executed. If 0, a reboot will always be executed at 3411 * exactly the given time. Otherwise, it will only be executed if 3412 * the device is idle within the window. 3413 * @hide 3414 */ 3415 public static final String REBOOT_WINDOW = "reboot_window"; 3416 3417 /** 3418 * Threshold values for the duration and level of a discharge cycle, under 3419 * which we log discharge cycle info. 3420 * @hide 3421 */ 3422 public static final String BATTERY_DISCHARGE_DURATION_THRESHOLD = 3423 "battery_discharge_duration_threshold"; 3424 /** @hide */ 3425 public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold"; 3426 3427 /** 3428 * Flag for allowing ActivityManagerService to send ACTION_APP_ERROR intents 3429 * on application crashes and ANRs. If this is disabled, the crash/ANR dialog 3430 * will never display the "Report" button. 3431 * Type: int ( 0 = disallow, 1 = allow ) 3432 * @hide 3433 */ 3434 public static final String SEND_ACTION_APP_ERROR = "send_action_app_error"; 3435 3436 /** 3437 * Nonzero causes Log.wtf() to crash. 3438 * @hide 3439 */ 3440 public static final String WTF_IS_FATAL = "wtf_is_fatal"; 3441 3442 /** 3443 * Maximum age of entries kept by {@link com.android.internal.os.IDropBoxManagerService}. 3444 * @hide 3445 */ 3446 public static final String DROPBOX_AGE_SECONDS = 3447 "dropbox_age_seconds"; 3448 /** 3449 * Maximum number of entry files which {@link com.android.internal.os.IDropBoxManagerService} will keep around. 3450 * @hide 3451 */ 3452 public static final String DROPBOX_MAX_FILES = 3453 "dropbox_max_files"; 3454 /** 3455 * Maximum amount of disk space used by {@link com.android.internal.os.IDropBoxManagerService} no matter what. 3456 * @hide 3457 */ 3458 public static final String DROPBOX_QUOTA_KB = 3459 "dropbox_quota_kb"; 3460 /** 3461 * Percent of free disk (excluding reserve) which {@link com.android.internal.os.IDropBoxManagerService} will use. 3462 * @hide 3463 */ 3464 public static final String DROPBOX_QUOTA_PERCENT = 3465 "dropbox_quota_percent"; 3466 /** 3467 * Percent of total disk which {@link com.android.internal.os.IDropBoxManagerService} will never dip into. 3468 * @hide 3469 */ 3470 public static final String DROPBOX_RESERVE_PERCENT = 3471 "dropbox_reserve_percent"; 3472 /** 3473 * Prefix for per-tag dropbox disable/enable settings. 3474 * @hide 3475 */ 3476 public static final String DROPBOX_TAG_PREFIX = 3477 "dropbox:"; 3478 /** 3479 * Lines of logcat to include with system crash/ANR/etc. reports, 3480 * as a prefix of the dropbox tag of the report type. 3481 * For example, "logcat_for_system_server_anr" controls the lines 3482 * of logcat captured with system server ANR reports. 0 to disable. 3483 * @hide 3484 */ 3485 public static final String ERROR_LOGCAT_PREFIX = 3486 "logcat_for_"; 3487 3488 3489 /** 3490 * Screen timeout in milliseconds corresponding to the 3491 * PowerManager's POKE_LOCK_SHORT_TIMEOUT flag (i.e. the fastest 3492 * possible screen timeout behavior.) 3493 * @hide 3494 */ 3495 public static final String SHORT_KEYLIGHT_DELAY_MS = 3496 "short_keylight_delay_ms"; 3497 3498 /** 3499 * The interval in minutes after which the amount of free storage left on the 3500 * device is logged to the event log 3501 * @hide 3502 */ 3503 public static final String SYS_FREE_STORAGE_LOG_INTERVAL = 3504 "sys_free_storage_log_interval"; 3505 3506 /** 3507 * Threshold for the amount of change in disk free space required to report the amount of 3508 * free space. Used to prevent spamming the logs when the disk free space isn't changing 3509 * frequently. 3510 * @hide 3511 */ 3512 public static final String DISK_FREE_CHANGE_REPORTING_THRESHOLD = 3513 "disk_free_change_reporting_threshold"; 3514 3515 3516 /** 3517 * Minimum percentage of free storage on the device that is used to determine if 3518 * the device is running low on storage. The default is 10. 3519 * <p>Say this value is set to 10, the device is considered running low on storage 3520 * if 90% or more of the device storage is filled up. 3521 * @hide 3522 */ 3523 public static final String SYS_STORAGE_THRESHOLD_PERCENTAGE = 3524 "sys_storage_threshold_percentage"; 3525 3526 /** 3527 * Maximum byte size of the low storage threshold. This is to ensure 3528 * that {@link #SYS_STORAGE_THRESHOLD_PERCENTAGE} does not result in 3529 * an overly large threshold for large storage devices. Currently this 3530 * must be less than 2GB. This default is 500MB. 3531 * @hide 3532 */ 3533 public static final String SYS_STORAGE_THRESHOLD_MAX_BYTES = 3534 "sys_storage_threshold_max_bytes"; 3535 3536 /** 3537 * Minimum bytes of free storage on the device before the data 3538 * partition is considered full. By default, 1 MB is reserved 3539 * to avoid system-wide SQLite disk full exceptions. 3540 * @hide 3541 */ 3542 public static final String SYS_STORAGE_FULL_THRESHOLD_BYTES = 3543 "sys_storage_full_threshold_bytes"; 3544 3545 /** 3546 * The interval in milliseconds after which Wi-Fi is considered idle. 3547 * When idle, it is possible for the device to be switched from Wi-Fi to 3548 * the mobile data network. 3549 * @hide 3550 */ 3551 public static final String WIFI_IDLE_MS = "wifi_idle_ms"; 3552 3553 /** 3554 * The interval in milliseconds to issue wake up scans when wifi needs 3555 * to connect. This is necessary to connect to an access point when 3556 * device is on the move and the screen is off. 3557 * @hide 3558 */ 3559 public static final String WIFI_FRAMEWORK_SCAN_INTERVAL_MS = 3560 "wifi_framework_scan_interval_ms"; 3561 3562 /** 3563 * The interval in milliseconds to scan as used by the wifi supplicant 3564 * @hide 3565 */ 3566 public static final String WIFI_SUPPLICANT_SCAN_INTERVAL_MS = 3567 "wifi_supplicant_scan_interval_ms"; 3568 3569 /** 3570 * The interval in milliseconds at which to check packet counts on the 3571 * mobile data interface when screen is on, to detect possible data 3572 * connection problems. 3573 * @hide 3574 */ 3575 public static final String PDP_WATCHDOG_POLL_INTERVAL_MS = 3576 "pdp_watchdog_poll_interval_ms"; 3577 3578 /** 3579 * The interval in milliseconds at which to check packet counts on the 3580 * mobile data interface when screen is off, to detect possible data 3581 * connection problems. 3582 * @hide 3583 */ 3584 public static final String PDP_WATCHDOG_LONG_POLL_INTERVAL_MS = 3585 "pdp_watchdog_long_poll_interval_ms"; 3586 3587 /** 3588 * The interval in milliseconds at which to check packet counts on the 3589 * mobile data interface after {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} 3590 * outgoing packets has been reached without incoming packets. 3591 * @hide 3592 */ 3593 public static final String PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS = 3594 "pdp_watchdog_error_poll_interval_ms"; 3595 3596 /** 3597 * The number of outgoing packets sent without seeing an incoming packet 3598 * that triggers a countdown (of {@link #PDP_WATCHDOG_ERROR_POLL_COUNT} 3599 * device is logged to the event log 3600 * @hide 3601 */ 3602 public static final String PDP_WATCHDOG_TRIGGER_PACKET_COUNT = 3603 "pdp_watchdog_trigger_packet_count"; 3604 3605 /** 3606 * The number of polls to perform (at {@link #PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS}) 3607 * after hitting {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} before 3608 * attempting data connection recovery. 3609 * @hide 3610 */ 3611 public static final String PDP_WATCHDOG_ERROR_POLL_COUNT = 3612 "pdp_watchdog_error_poll_count"; 3613 3614 /** 3615 * The number of failed PDP reset attempts before moving to something more 3616 * drastic: re-registering to the network. 3617 * @hide 3618 */ 3619 public static final String PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT = 3620 "pdp_watchdog_max_pdp_reset_fail_count"; 3621 3622 /** 3623 * The interval in milliseconds at which to check gprs registration 3624 * after the first registration mismatch of gprs and voice service, 3625 * to detect possible data network registration problems. 3626 * 3627 * @hide 3628 */ 3629 public static final String GPRS_REGISTER_CHECK_PERIOD_MS = 3630 "gprs_register_check_period_ms"; 3631 3632 /** 3633 * The length of time in milli-seconds that automatic small adjustments to 3634 * SystemClock are ignored if NITZ_UPDATE_DIFF is not exceeded. 3635 * @hide 3636 */ 3637 public static final String NITZ_UPDATE_SPACING = "nitz_update_spacing"; 3638 3639 /** 3640 * If the NITZ_UPDATE_DIFF time is exceeded then an automatic adjustment 3641 * to SystemClock will be allowed even if NITZ_UPDATE_SPACING has not been 3642 * exceeded. 3643 * @hide 3644 */ 3645 public static final String NITZ_UPDATE_DIFF = "nitz_update_diff"; 3646 3647 /** 3648 * The maximum reconnect delay for short network outages or when the network is suspended 3649 * due to phone use. 3650 * @hide 3651 */ 3652 public static final String SYNC_MAX_RETRY_DELAY_IN_SECONDS = 3653 "sync_max_retry_delay_in_seconds"; 3654 3655 /** 3656 * The interval in milliseconds at which to check the number of SMS sent 3657 * out without asking for use permit, to limit the un-authorized SMS 3658 * usage. 3659 * @hide 3660 */ 3661 public static final String SMS_OUTGOING_CHECK_INTERVAL_MS = 3662 "sms_outgoing_check_interval_ms"; 3663 3664 /** 3665 * The number of outgoing SMS sent without asking for user permit 3666 * (of {@link #SMS_OUTGOING_CHECK_INTERVAL_MS} 3667 * @hide 3668 */ 3669 public static final String SMS_OUTGOING_CHECK_MAX_COUNT = 3670 "sms_outgoing_check_max_count"; 3671 3672 /** 3673 * The global search provider chosen by the user (if multiple global 3674 * search providers are installed). This will be the provider returned 3675 * by {@link SearchManager#getGlobalSearchActivity()} if it's still 3676 * installed. This setting is stored as a flattened component name as 3677 * per {@link ComponentName#flattenToString()}. 3678 * 3679 * @hide 3680 */ 3681 public static final String SEARCH_GLOBAL_SEARCH_ACTIVITY = 3682 "search_global_search_activity"; 3683 3684 /** 3685 * The number of promoted sources in GlobalSearch. 3686 * @hide 3687 */ 3688 public static final String SEARCH_NUM_PROMOTED_SOURCES = "search_num_promoted_sources"; 3689 /** 3690 * The maximum number of suggestions returned by GlobalSearch. 3691 * @hide 3692 */ 3693 public static final String SEARCH_MAX_RESULTS_TO_DISPLAY = "search_max_results_to_display"; 3694 /** 3695 * The number of suggestions GlobalSearch will ask each non-web search source for. 3696 * @hide 3697 */ 3698 public static final String SEARCH_MAX_RESULTS_PER_SOURCE = "search_max_results_per_source"; 3699 /** 3700 * The number of suggestions the GlobalSearch will ask the web search source for. 3701 * @hide 3702 */ 3703 public static final String SEARCH_WEB_RESULTS_OVERRIDE_LIMIT = 3704 "search_web_results_override_limit"; 3705 /** 3706 * The number of milliseconds that GlobalSearch will wait for suggestions from 3707 * promoted sources before continuing with all other sources. 3708 * @hide 3709 */ 3710 public static final String SEARCH_PROMOTED_SOURCE_DEADLINE_MILLIS = 3711 "search_promoted_source_deadline_millis"; 3712 /** 3713 * The number of milliseconds before GlobalSearch aborts search suggesiton queries. 3714 * @hide 3715 */ 3716 public static final String SEARCH_SOURCE_TIMEOUT_MILLIS = "search_source_timeout_millis"; 3717 /** 3718 * The maximum number of milliseconds that GlobalSearch shows the previous results 3719 * after receiving a new query. 3720 * @hide 3721 */ 3722 public static final String SEARCH_PREFILL_MILLIS = "search_prefill_millis"; 3723 /** 3724 * The maximum age of log data used for shortcuts in GlobalSearch. 3725 * @hide 3726 */ 3727 public static final String SEARCH_MAX_STAT_AGE_MILLIS = "search_max_stat_age_millis"; 3728 /** 3729 * The maximum age of log data used for source ranking in GlobalSearch. 3730 * @hide 3731 */ 3732 public static final String SEARCH_MAX_SOURCE_EVENT_AGE_MILLIS = 3733 "search_max_source_event_age_millis"; 3734 /** 3735 * The minimum number of impressions needed to rank a source in GlobalSearch. 3736 * @hide 3737 */ 3738 public static final String SEARCH_MIN_IMPRESSIONS_FOR_SOURCE_RANKING = 3739 "search_min_impressions_for_source_ranking"; 3740 /** 3741 * The minimum number of clicks needed to rank a source in GlobalSearch. 3742 * @hide 3743 */ 3744 public static final String SEARCH_MIN_CLICKS_FOR_SOURCE_RANKING = 3745 "search_min_clicks_for_source_ranking"; 3746 /** 3747 * The maximum number of shortcuts shown by GlobalSearch. 3748 * @hide 3749 */ 3750 public static final String SEARCH_MAX_SHORTCUTS_RETURNED = "search_max_shortcuts_returned"; 3751 /** 3752 * The size of the core thread pool for suggestion queries in GlobalSearch. 3753 * @hide 3754 */ 3755 public static final String SEARCH_QUERY_THREAD_CORE_POOL_SIZE = 3756 "search_query_thread_core_pool_size"; 3757 /** 3758 * The maximum size of the thread pool for suggestion queries in GlobalSearch. 3759 * @hide 3760 */ 3761 public static final String SEARCH_QUERY_THREAD_MAX_POOL_SIZE = 3762 "search_query_thread_max_pool_size"; 3763 /** 3764 * The size of the core thread pool for shortcut refreshing in GlobalSearch. 3765 * @hide 3766 */ 3767 public static final String SEARCH_SHORTCUT_REFRESH_CORE_POOL_SIZE = 3768 "search_shortcut_refresh_core_pool_size"; 3769 /** 3770 * The maximum size of the thread pool for shortcut refreshing in GlobalSearch. 3771 * @hide 3772 */ 3773 public static final String SEARCH_SHORTCUT_REFRESH_MAX_POOL_SIZE = 3774 "search_shortcut_refresh_max_pool_size"; 3775 /** 3776 * The maximun time that excess threads in the GlobalSeach thread pools will 3777 * wait before terminating. 3778 * @hide 3779 */ 3780 public static final String SEARCH_THREAD_KEEPALIVE_SECONDS = 3781 "search_thread_keepalive_seconds"; 3782 /** 3783 * The maximum number of concurrent suggestion queries to each source. 3784 * @hide 3785 */ 3786 public static final String SEARCH_PER_SOURCE_CONCURRENT_QUERY_LIMIT = 3787 "search_per_source_concurrent_query_limit"; 3788 3789 /** 3790 * Whether or not alert sounds are played on MountService events. (0 = false, 1 = true) 3791 * @hide 3792 */ 3793 public static final String MOUNT_PLAY_NOTIFICATION_SND = "mount_play_not_snd"; 3794 3795 /** 3796 * Whether or not UMS auto-starts on UMS host detection. (0 = false, 1 = true) 3797 * @hide 3798 */ 3799 public static final String MOUNT_UMS_AUTOSTART = "mount_ums_autostart"; 3800 3801 /** 3802 * Whether or not a notification is displayed on UMS host detection. (0 = false, 1 = true) 3803 * @hide 3804 */ 3805 public static final String MOUNT_UMS_PROMPT = "mount_ums_prompt"; 3806 3807 /** 3808 * Whether or not a notification is displayed while UMS is enabled. (0 = false, 1 = true) 3809 * @hide 3810 */ 3811 public static final String MOUNT_UMS_NOTIFY_ENABLED = "mount_ums_notify_enabled"; 3812 3813 /** 3814 * If nonzero, ANRs in invisible background processes bring up a dialog. 3815 * Otherwise, the process will be silently killed. 3816 * @hide 3817 */ 3818 public static final String ANR_SHOW_BACKGROUND = "anr_show_background"; 3819 3820 /** 3821 * The {@link ComponentName} string of the service to be used as the voice recognition 3822 * service. 3823 * 3824 * @hide 3825 */ 3826 public static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service"; 3827 3828 3829 /** 3830 * The {@link ComponentName} string of the selected spell checker service which is 3831 * one of the services managed by the text service manager. 3832 * 3833 * @hide 3834 */ 3835 public static final String SELECTED_SPELL_CHECKER = "selected_spell_checker"; 3836 3837 /** 3838 * The {@link ComponentName} string of the selected subtype of the selected spell checker 3839 * service which is one of the services managed by the text service manager. 3840 * 3841 * @hide 3842 */ 3843 public static final String SELECTED_SPELL_CHECKER_SUBTYPE = 3844 "selected_spell_checker_subtype"; 3845 3846 /** 3847 * The {@link ComponentName} string whether spell checker is enabled or not. 3848 * 3849 * @hide 3850 */ 3851 public static final String SPELL_CHECKER_ENABLED = "spell_checker_enabled"; 3852 3853 /** 3854 * What happens when the user presses the Power button while in-call 3855 * and the screen is on.<br/> 3856 * <b>Values:</b><br/> 3857 * 1 - The Power button turns off the screen and locks the device. (Default behavior)<br/> 3858 * 2 - The Power button hangs up the current call.<br/> 3859 * 3860 * @hide 3861 */ 3862 public static final String INCALL_POWER_BUTTON_BEHAVIOR = "incall_power_button_behavior"; 3863 3864 /** 3865 * INCALL_POWER_BUTTON_BEHAVIOR value for "turn off screen". 3866 * @hide 3867 */ 3868 public static final int INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF = 0x1; 3869 3870 /** 3871 * INCALL_POWER_BUTTON_BEHAVIOR value for "hang up". 3872 * @hide 3873 */ 3874 public static final int INCALL_POWER_BUTTON_BEHAVIOR_HANGUP = 0x2; 3875 3876 /** 3877 * INCALL_POWER_BUTTON_BEHAVIOR default value. 3878 * @hide 3879 */ 3880 public static final int INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT = 3881 INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF; 3882 3883 /** 3884 * The current night mode that has been selected by the user. Owned 3885 * and controlled by UiModeManagerService. Constants are as per 3886 * UiModeManager. 3887 * @hide 3888 */ 3889 public static final String UI_NIGHT_MODE = "ui_night_mode"; 3890 3891 /** 3892 * Let user pick default install location. 3893 * @hide 3894 */ 3895 public static final String SET_INSTALL_LOCATION = "set_install_location"; 3896 3897 /** 3898 * Default install location value. 3899 * 0 = auto, let system decide 3900 * 1 = internal 3901 * 2 = sdcard 3902 * @hide 3903 */ 3904 public static final String DEFAULT_INSTALL_LOCATION = "default_install_location"; 3905 3906 /** 3907 * The bandwidth throttle polling freqency in seconds 3908 * @hide 3909 */ 3910 public static final String THROTTLE_POLLING_SEC = "throttle_polling_sec"; 3911 3912 /** 3913 * The bandwidth throttle threshold (long) 3914 * @hide 3915 */ 3916 public static final String THROTTLE_THRESHOLD_BYTES = "throttle_threshold_bytes"; 3917 3918 /** 3919 * The bandwidth throttle value (kbps) 3920 * @hide 3921 */ 3922 public static final String THROTTLE_VALUE_KBITSPS = "throttle_value_kbitsps"; 3923 3924 /** 3925 * The bandwidth throttle reset calendar day (1-28) 3926 * @hide 3927 */ 3928 public static final String THROTTLE_RESET_DAY = "throttle_reset_day"; 3929 3930 /** 3931 * The throttling notifications we should send 3932 * @hide 3933 */ 3934 public static final String THROTTLE_NOTIFICATION_TYPE = "throttle_notification_type"; 3935 3936 /** 3937 * Help URI for data throttling policy 3938 * @hide 3939 */ 3940 public static final String THROTTLE_HELP_URI = "throttle_help_uri"; 3941 3942 /** 3943 * The length of time in Sec that we allow our notion of NTP time 3944 * to be cached before we refresh it 3945 * @hide 3946 */ 3947 public static final String THROTTLE_MAX_NTP_CACHE_AGE_SEC = 3948 "throttle_max_ntp_cache_age_sec"; 3949 3950 /** 3951 * The maximum size, in bytes, of a download that the download manager will transfer over 3952 * a non-wifi connection. 3953 * @hide 3954 */ 3955 public static final String DOWNLOAD_MAX_BYTES_OVER_MOBILE = 3956 "download_manager_max_bytes_over_mobile"; 3957 3958 /** 3959 * The recommended maximum size, in bytes, of a download that the download manager should 3960 * transfer over a non-wifi connection. Over this size, the use will be warned, but will 3961 * have the option to start the download over the mobile connection anyway. 3962 * @hide 3963 */ 3964 public static final String DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE = 3965 "download_manager_recommended_max_bytes_over_mobile"; 3966 3967 /** 3968 * ms during which to consume extra events related to Inet connection condition 3969 * after a transtion to fully-connected 3970 * @hide 3971 */ 3972 public static final String INET_CONDITION_DEBOUNCE_UP_DELAY = 3973 "inet_condition_debounce_up_delay"; 3974 3975 /** 3976 * ms during which to consume extra events related to Inet connection condtion 3977 * after a transtion to partly-connected 3978 * @hide 3979 */ 3980 public static final String INET_CONDITION_DEBOUNCE_DOWN_DELAY = 3981 "inet_condition_debounce_down_delay"; 3982 3983 /** 3984 * URL to open browser on to allow user to manage a prepay account 3985 * @hide 3986 */ 3987 public static final String SETUP_PREPAID_DATA_SERVICE_URL = 3988 "setup_prepaid_data_service_url"; 3989 3990 /** 3991 * URL to attempt a GET on to see if this is a prepay device 3992 * @hide 3993 */ 3994 public static final String SETUP_PREPAID_DETECTION_TARGET_URL = 3995 "setup_prepaid_detection_target_url"; 3996 3997 /** 3998 * Host to check for a redirect to after an attempt to GET 3999 * SETUP_PREPAID_DETECTION_TARGET_URL. (If we redirected there, 4000 * this is a prepaid device with zero balance.) 4001 * @hide 4002 */ 4003 public static final String SETUP_PREPAID_DETECTION_REDIR_HOST = 4004 "setup_prepaid_detection_redir_host"; 4005 4006 /** 4007 * The user's preferred "dream" (interactive screensaver) component. 4008 * 4009 * This component will be launched by the PhoneWindowManager after the user's chosen idle 4010 * timeout (specified by {@link #DREAM_TIMEOUT}). 4011 * @hide 4012 */ 4013 public static final String DREAM_COMPONENT = 4014 "dream_component"; 4015 4016 /** 4017 * The delay before a "dream" is started (set to 0 to disable). 4018 * @hide 4019 */ 4020 public static final String DREAM_TIMEOUT = 4021 "dream_timeout"; 4022 4023 /** {@hide} */ 4024 public static final String NETSTATS_ENABLED = "netstats_enabled"; 4025 /** {@hide} */ 4026 public static final String NETSTATS_POLL_INTERVAL = "netstats_poll_interval"; 4027 /** {@hide} */ 4028 public static final String NETSTATS_PERSIST_THRESHOLD = "netstats_persist_threshold"; 4029 /** {@hide} */ 4030 public static final String NETSTATS_NETWORK_BUCKET_DURATION = "netstats_network_bucket_duration"; 4031 /** {@hide} */ 4032 public static final String NETSTATS_NETWORK_MAX_HISTORY = "netstats_network_max_history"; 4033 /** {@hide} */ 4034 public static final String NETSTATS_UID_BUCKET_DURATION = "netstats_uid_bucket_duration"; 4035 /** {@hide} */ 4036 public static final String NETSTATS_UID_MAX_HISTORY = "netstats_uid_max_history"; 4037 /** {@hide} */ 4038 public static final String NETSTATS_TAG_MAX_HISTORY = "netstats_tag_max_history"; 4039 4040 /** Preferred NTP server. {@hide} */ 4041 public static final String NTP_SERVER = "ntp_server"; 4042 /** Timeout in milliseconds to wait for NTP server. {@hide} */ 4043 public static final String NTP_TIMEOUT = "ntp_timeout"; 4044 4045 /** Autofill server address (Used in WebView/browser). {@hide} */ 4046 public static final String WEB_AUTOFILL_QUERY_URL = 4047 "web_autofill_query_url"; 4048 4049 /** Whether package verification is enabled. {@hide} */ 4050 public static final String PACKAGE_VERIFIER_ENABLE = "verifier_enable"; 4051 4052 /** Timeout for package verification. {@hide} */ 4053 public static final String PACKAGE_VERIFIER_TIMEOUT = "verifier_timeout"; 4054 4055 /** 4056 * Duration in milliseconds before pre-authorized URIs for the contacts 4057 * provider should expire. 4058 * @hide 4059 */ 4060 public static final String CONTACTS_PREAUTH_URI_EXPIRATION = 4061 "contacts_preauth_uri_expiration"; 4062 4063 /** 4064 * This are the settings to be backed up. 4065 * 4066 * NOTE: Settings are backed up and restored in the order they appear 4067 * in this array. If you have one setting depending on another, 4068 * make sure that they are ordered appropriately. 4069 * 4070 * @hide 4071 */ 4072 public static final String[] SETTINGS_TO_BACKUP = { 4073 ADB_ENABLED, 4074 ALLOW_MOCK_LOCATION, 4075 PARENTAL_CONTROL_ENABLED, 4076 PARENTAL_CONTROL_REDIRECT_URL, 4077 USB_MASS_STORAGE_ENABLED, 4078 ACCESSIBILITY_SCRIPT_INJECTION, 4079 BACKUP_AUTO_RESTORE, 4080 ENABLED_ACCESSIBILITY_SERVICES, 4081 TOUCH_EXPLORATION_ENABLED, 4082 ACCESSIBILITY_ENABLED, 4083 TTS_USE_DEFAULTS, 4084 TTS_DEFAULT_RATE, 4085 TTS_DEFAULT_PITCH, 4086 TTS_DEFAULT_SYNTH, 4087 TTS_DEFAULT_LANG, 4088 TTS_DEFAULT_COUNTRY, 4089 TTS_ENABLED_PLUGINS, 4090 TTS_DEFAULT_LOCALE, 4091 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 4092 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 4093 WIFI_NUM_OPEN_NETWORKS_KEPT, 4094 MOUNT_PLAY_NOTIFICATION_SND, 4095 MOUNT_UMS_AUTOSTART, 4096 MOUNT_UMS_PROMPT, 4097 MOUNT_UMS_NOTIFY_ENABLED, 4098 UI_NIGHT_MODE, 4099 LOCK_SCREEN_OWNER_INFO, 4100 LOCK_SCREEN_OWNER_INFO_ENABLED 4101 }; 4102 4103 /** 4104 * Helper method for determining if a location provider is enabled. 4105 * @param cr the content resolver to use 4106 * @param provider the location provider to query 4107 * @return true if the provider is enabled 4108 */ isLocationProviderEnabled(ContentResolver cr, String provider)4109 public static final boolean isLocationProviderEnabled(ContentResolver cr, String provider) { 4110 String allowedProviders = Settings.Secure.getString(cr, LOCATION_PROVIDERS_ALLOWED); 4111 return TextUtils.delimitedStringContains(allowedProviders, ',', provider); 4112 } 4113 4114 /** 4115 * Thread-safe method for enabling or disabling a single location provider. 4116 * @param cr the content resolver to use 4117 * @param provider the location provider to enable or disable 4118 * @param enabled true if the provider should be enabled 4119 */ setLocationProviderEnabled(ContentResolver cr, String provider, boolean enabled)4120 public static final void setLocationProviderEnabled(ContentResolver cr, 4121 String provider, boolean enabled) { 4122 // to ensure thread safety, we write the provider name with a '+' or '-' 4123 // and let the SettingsProvider handle it rather than reading and modifying 4124 // the list of enabled providers. 4125 if (enabled) { 4126 provider = "+" + provider; 4127 } else { 4128 provider = "-" + provider; 4129 } 4130 putString(cr, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, provider); 4131 } 4132 } 4133 4134 /** 4135 * User-defined bookmarks and shortcuts. The target of each bookmark is an 4136 * Intent URL, allowing it to be either a web page or a particular 4137 * application activity. 4138 * 4139 * @hide 4140 */ 4141 public static final class Bookmarks implements BaseColumns 4142 { 4143 private static final String TAG = "Bookmarks"; 4144 4145 /** 4146 * The content:// style URL for this table 4147 */ 4148 public static final Uri CONTENT_URI = 4149 Uri.parse("content://" + AUTHORITY + "/bookmarks"); 4150 4151 /** 4152 * The row ID. 4153 * <p>Type: INTEGER</p> 4154 */ 4155 public static final String ID = "_id"; 4156 4157 /** 4158 * Descriptive name of the bookmark that can be displayed to the user. 4159 * If this is empty, the title should be resolved at display time (use 4160 * {@link #getTitle(Context, Cursor)} any time you want to display the 4161 * title of a bookmark.) 4162 * <P> 4163 * Type: TEXT 4164 * </P> 4165 */ 4166 public static final String TITLE = "title"; 4167 4168 /** 4169 * Arbitrary string (displayed to the user) that allows bookmarks to be 4170 * organized into categories. There are some special names for 4171 * standard folders, which all start with '@'. The label displayed for 4172 * the folder changes with the locale (via {@link #getLabelForFolder}) but 4173 * the folder name does not change so you can consistently query for 4174 * the folder regardless of the current locale. 4175 * 4176 * <P>Type: TEXT</P> 4177 * 4178 */ 4179 public static final String FOLDER = "folder"; 4180 4181 /** 4182 * The Intent URL of the bookmark, describing what it points to. This 4183 * value is given to {@link android.content.Intent#getIntent} to create 4184 * an Intent that can be launched. 4185 * <P>Type: TEXT</P> 4186 */ 4187 public static final String INTENT = "intent"; 4188 4189 /** 4190 * Optional shortcut character associated with this bookmark. 4191 * <P>Type: INTEGER</P> 4192 */ 4193 public static final String SHORTCUT = "shortcut"; 4194 4195 /** 4196 * The order in which the bookmark should be displayed 4197 * <P>Type: INTEGER</P> 4198 */ 4199 public static final String ORDERING = "ordering"; 4200 4201 private static final String[] sIntentProjection = { INTENT }; 4202 private static final String[] sShortcutProjection = { ID, SHORTCUT }; 4203 private static final String sShortcutSelection = SHORTCUT + "=?"; 4204 4205 /** 4206 * Convenience function to retrieve the bookmarked Intent for a 4207 * particular shortcut key. 4208 * 4209 * @param cr The ContentResolver to query. 4210 * @param shortcut The shortcut key. 4211 * 4212 * @return Intent The bookmarked URL, or null if there is no bookmark 4213 * matching the given shortcut. 4214 */ getIntentForShortcut(ContentResolver cr, char shortcut)4215 public static Intent getIntentForShortcut(ContentResolver cr, char shortcut) 4216 { 4217 Intent intent = null; 4218 4219 Cursor c = cr.query(CONTENT_URI, 4220 sIntentProjection, sShortcutSelection, 4221 new String[] { String.valueOf((int) shortcut) }, ORDERING); 4222 // Keep trying until we find a valid shortcut 4223 try { 4224 while (intent == null && c.moveToNext()) { 4225 try { 4226 String intentURI = c.getString(c.getColumnIndexOrThrow(INTENT)); 4227 intent = Intent.parseUri(intentURI, 0); 4228 } catch (java.net.URISyntaxException e) { 4229 // The stored URL is bad... ignore it. 4230 } catch (IllegalArgumentException e) { 4231 // Column not found 4232 Log.w(TAG, "Intent column not found", e); 4233 } 4234 } 4235 } finally { 4236 if (c != null) c.close(); 4237 } 4238 4239 return intent; 4240 } 4241 4242 /** 4243 * Add a new bookmark to the system. 4244 * 4245 * @param cr The ContentResolver to query. 4246 * @param intent The desired target of the bookmark. 4247 * @param title Bookmark title that is shown to the user; null if none 4248 * or it should be resolved to the intent's title. 4249 * @param folder Folder in which to place the bookmark; null if none. 4250 * @param shortcut Shortcut that will invoke the bookmark; 0 if none. If 4251 * this is non-zero and there is an existing bookmark entry 4252 * with this same shortcut, then that existing shortcut is 4253 * cleared (the bookmark is not removed). 4254 * @return The unique content URL for the new bookmark entry. 4255 */ add(ContentResolver cr, Intent intent, String title, String folder, char shortcut, int ordering)4256 public static Uri add(ContentResolver cr, 4257 Intent intent, 4258 String title, 4259 String folder, 4260 char shortcut, 4261 int ordering) 4262 { 4263 // If a shortcut is supplied, and it is already defined for 4264 // another bookmark, then remove the old definition. 4265 if (shortcut != 0) { 4266 cr.delete(CONTENT_URI, sShortcutSelection, 4267 new String[] { String.valueOf((int) shortcut) }); 4268 } 4269 4270 ContentValues values = new ContentValues(); 4271 if (title != null) values.put(TITLE, title); 4272 if (folder != null) values.put(FOLDER, folder); 4273 values.put(INTENT, intent.toUri(0)); 4274 if (shortcut != 0) values.put(SHORTCUT, (int) shortcut); 4275 values.put(ORDERING, ordering); 4276 return cr.insert(CONTENT_URI, values); 4277 } 4278 4279 /** 4280 * Return the folder name as it should be displayed to the user. This 4281 * takes care of localizing special folders. 4282 * 4283 * @param r Resources object for current locale; only need access to 4284 * system resources. 4285 * @param folder The value found in the {@link #FOLDER} column. 4286 * 4287 * @return CharSequence The label for this folder that should be shown 4288 * to the user. 4289 */ getLabelForFolder(Resources r, String folder)4290 public static CharSequence getLabelForFolder(Resources r, String folder) { 4291 return folder; 4292 } 4293 4294 /** 4295 * Return the title as it should be displayed to the user. This takes 4296 * care of localizing bookmarks that point to activities. 4297 * 4298 * @param context A context. 4299 * @param cursor A cursor pointing to the row whose title should be 4300 * returned. The cursor must contain at least the {@link #TITLE} 4301 * and {@link #INTENT} columns. 4302 * @return A title that is localized and can be displayed to the user, 4303 * or the empty string if one could not be found. 4304 */ getTitle(Context context, Cursor cursor)4305 public static CharSequence getTitle(Context context, Cursor cursor) { 4306 int titleColumn = cursor.getColumnIndex(TITLE); 4307 int intentColumn = cursor.getColumnIndex(INTENT); 4308 if (titleColumn == -1 || intentColumn == -1) { 4309 throw new IllegalArgumentException( 4310 "The cursor must contain the TITLE and INTENT columns."); 4311 } 4312 4313 String title = cursor.getString(titleColumn); 4314 if (!TextUtils.isEmpty(title)) { 4315 return title; 4316 } 4317 4318 String intentUri = cursor.getString(intentColumn); 4319 if (TextUtils.isEmpty(intentUri)) { 4320 return ""; 4321 } 4322 4323 Intent intent; 4324 try { 4325 intent = Intent.parseUri(intentUri, 0); 4326 } catch (URISyntaxException e) { 4327 return ""; 4328 } 4329 4330 PackageManager packageManager = context.getPackageManager(); 4331 ResolveInfo info = packageManager.resolveActivity(intent, 0); 4332 return info != null ? info.loadLabel(packageManager) : ""; 4333 } 4334 } 4335 4336 /** 4337 * Returns the device ID that we should use when connecting to the mobile gtalk server. 4338 * This is a string like "android-0x1242", where the hex string is the Android ID obtained 4339 * from the GoogleLoginService. 4340 * 4341 * @param androidId The Android ID for this device. 4342 * @return The device ID that should be used when connecting to the mobile gtalk server. 4343 * @hide 4344 */ getGTalkDeviceId(long androidId)4345 public static String getGTalkDeviceId(long androidId) { 4346 return "android-" + Long.toHexString(androidId); 4347 } 4348 } 4349