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