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