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