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