DatabaseHelper.java revision 550021ec5a2c8d741506c3fe5d1ee85139bc794a 
1/*
2 * Copyright (C) 2007 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 com.android.providers.settings;
18
19import android.content.ComponentName;
20import android.content.ContentValues;
21import android.content.Context;
22import android.content.Intent;
23import android.content.pm.ActivityInfo;
24import android.content.pm.IPackageManager;
25import android.content.pm.PackageManager;
26import android.content.res.XmlResourceParser;
27import android.database.Cursor;
28import android.database.sqlite.SQLiteDatabase;
29import android.database.sqlite.SQLiteOpenHelper;
30import android.database.sqlite.SQLiteStatement;
31import android.media.AudioManager;
32import android.media.AudioService;
33import android.net.ConnectivityManager;
34import android.os.Build;
35import android.os.Environment;
36import android.os.RemoteException;
37import android.os.ServiceManager;
38import android.os.SystemProperties;
39import android.os.UserHandle;
40import android.provider.Settings;
41import android.provider.Settings.Global;
42import android.provider.Settings.Secure;
43import android.text.TextUtils;
44import android.util.Log;
45
46import com.android.internal.content.PackageHelper;
47import com.android.internal.telephony.RILConstants;
48import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager;
49import com.android.internal.util.XmlUtils;
50import com.android.internal.widget.LockPatternUtils;
51import com.android.internal.widget.LockPatternView;
52
53import org.xmlpull.v1.XmlPullParser;
54import org.xmlpull.v1.XmlPullParserException;
55
56import java.io.File;
57import java.io.IOException;
58import java.util.HashSet;
59import java.util.List;
60
61/**
62 * Database helper class for {@link SettingsProvider}.
63 * Mostly just has a bit {@link #onCreate} to initialize the database.
64 */
65public class DatabaseHelper extends SQLiteOpenHelper {
66    private static final String TAG = "SettingsProvider";
67    private static final String DATABASE_NAME = "settings.db";
68
69    // Please, please please. If you update the database version, check to make sure the
70    // database gets upgraded properly. At a minimum, please confirm that 'upgradeVersion'
71    // is properly propagated through your change.  Not doing so will result in a loss of user
72    // settings.
73    private static final int DATABASE_VERSION = 112;
74
75    private Context mContext;
76    private int mUserHandle;
77
78    private static final HashSet<String> mValidTables = new HashSet<String>();
79
80    private static final String TABLE_SYSTEM = "system";
81    private static final String TABLE_SECURE = "secure";
82    private static final String TABLE_GLOBAL = "global";
83
84    static {
85        mValidTables.add(TABLE_SYSTEM);
86        mValidTables.add(TABLE_SECURE);
87        mValidTables.add(TABLE_GLOBAL);
88        mValidTables.add("bluetooth_devices");
89        mValidTables.add("bookmarks");
90
91        // These are old.
92        mValidTables.add("favorites");
93        mValidTables.add("gservices");
94        mValidTables.add("old_favorites");
95    }
96
97    static String dbNameForUser(final int userHandle) {
98        // The owner gets the unadorned db name;
99        if (userHandle == UserHandle.USER_OWNER) {
100            return DATABASE_NAME;
101        } else {
102            // Place the database in the user-specific data tree so that it's
103            // cleaned up automatically when the user is deleted.
104            File databaseFile = new File(
105                    Environment.getUserSystemDirectory(userHandle), DATABASE_NAME);
106            return databaseFile.getPath();
107        }
108    }
109
110    public DatabaseHelper(Context context, int userHandle) {
111        super(context, dbNameForUser(userHandle), null, DATABASE_VERSION);
112        mContext = context;
113        mUserHandle = userHandle;
114    }
115
116    public static boolean isValidTable(String name) {
117        return mValidTables.contains(name);
118    }
119
120    private void createSecureTable(SQLiteDatabase db) {
121        db.execSQL("CREATE TABLE secure (" +
122                "_id INTEGER PRIMARY KEY AUTOINCREMENT," +
123                "name TEXT UNIQUE ON CONFLICT REPLACE," +
124                "value TEXT" +
125                ");");
126        db.execSQL("CREATE INDEX secureIndex1 ON secure (name);");
127    }
128
129    private void createGlobalTable(SQLiteDatabase db) {
130        db.execSQL("CREATE TABLE global (" +
131                "_id INTEGER PRIMARY KEY AUTOINCREMENT," +
132                "name TEXT UNIQUE ON CONFLICT REPLACE," +
133                "value TEXT" +
134                ");");
135        db.execSQL("CREATE INDEX globalIndex1 ON global (name);");
136    }
137
138    @Override
139    public void onCreate(SQLiteDatabase db) {
140        db.execSQL("CREATE TABLE system (" +
141                    "_id INTEGER PRIMARY KEY AUTOINCREMENT," +
142                    "name TEXT UNIQUE ON CONFLICT REPLACE," +
143                    "value TEXT" +
144                    ");");
145        db.execSQL("CREATE INDEX systemIndex1 ON system (name);");
146
147        createSecureTable(db);
148
149        // Only create the global table for the singleton 'owner' user
150        if (mUserHandle == UserHandle.USER_OWNER) {
151            createGlobalTable(db);
152        }
153
154        db.execSQL("CREATE TABLE bluetooth_devices (" +
155                    "_id INTEGER PRIMARY KEY," +
156                    "name TEXT," +
157                    "addr TEXT," +
158                    "channel INTEGER," +
159                    "type INTEGER" +
160                    ");");
161
162        db.execSQL("CREATE TABLE bookmarks (" +
163                    "_id INTEGER PRIMARY KEY," +
164                    "title TEXT," +
165                    "folder TEXT," +
166                    "intent TEXT," +
167                    "shortcut INTEGER," +
168                    "ordering INTEGER" +
169                    ");");
170
171        db.execSQL("CREATE INDEX bookmarksIndex1 ON bookmarks (folder);");
172        db.execSQL("CREATE INDEX bookmarksIndex2 ON bookmarks (shortcut);");
173
174        // Populate bookmarks table with initial bookmarks
175        boolean onlyCore = false;
176        try {
177            onlyCore = IPackageManager.Stub.asInterface(ServiceManager.getService(
178                    "package")).isOnlyCoreApps();
179        } catch (RemoteException e) {
180        }
181        if (!onlyCore) {
182            loadBookmarks(db);
183        }
184
185        // Load initial volume levels into DB
186        loadVolumeLevels(db);
187
188        // Load inital settings values
189        loadSettings(db);
190    }
191
192    @Override
193    public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) {
194        Log.w(TAG, "Upgrading settings database from version " + oldVersion + " to "
195                + currentVersion);
196
197        int upgradeVersion = oldVersion;
198
199        // Pattern for upgrade blocks:
200        //
201        //    if (upgradeVersion == [the DATABASE_VERSION you set] - 1) {
202        //        .. your upgrade logic..
203        //        upgradeVersion = [the DATABASE_VERSION you set]
204        //    }
205
206        if (upgradeVersion == 20) {
207            /*
208             * Version 21 is part of the volume control refresh. There is no
209             * longer a UI-visible for setting notification vibrate on/off (in
210             * our design), but the functionality still exists. Force the
211             * notification vibrate to on.
212             */
213            loadVibrateSetting(db, true);
214
215            upgradeVersion = 21;
216        }
217
218        if (upgradeVersion < 22) {
219            upgradeVersion = 22;
220            // Upgrade the lock gesture storage location and format
221            upgradeLockPatternLocation(db);
222        }
223
224        if (upgradeVersion < 23) {
225            db.execSQL("UPDATE favorites SET iconResource=0 WHERE iconType=0");
226            upgradeVersion = 23;
227        }
228
229        if (upgradeVersion == 23) {
230            db.beginTransaction();
231            try {
232                db.execSQL("ALTER TABLE favorites ADD spanX INTEGER");
233                db.execSQL("ALTER TABLE favorites ADD spanY INTEGER");
234                // Shortcuts, applications, folders
235                db.execSQL("UPDATE favorites SET spanX=1, spanY=1 WHERE itemType<=0");
236                // Photo frames, clocks
237                db.execSQL(
238                    "UPDATE favorites SET spanX=2, spanY=2 WHERE itemType=1000 or itemType=1002");
239                // Search boxes
240                db.execSQL("UPDATE favorites SET spanX=4, spanY=1 WHERE itemType=1001");
241                db.setTransactionSuccessful();
242            } finally {
243                db.endTransaction();
244            }
245            upgradeVersion = 24;
246        }
247
248        if (upgradeVersion == 24) {
249            db.beginTransaction();
250            try {
251                // The value of the constants for preferring wifi or preferring mobile have been
252                // swapped, so reload the default.
253                db.execSQL("DELETE FROM system WHERE name='network_preference'");
254                db.execSQL("INSERT INTO system ('name', 'value') values ('network_preference', '" +
255                        ConnectivityManager.DEFAULT_NETWORK_PREFERENCE + "')");
256                db.setTransactionSuccessful();
257            } finally {
258                db.endTransaction();
259            }
260            upgradeVersion = 25;
261        }
262
263        if (upgradeVersion == 25) {
264            db.beginTransaction();
265            try {
266                db.execSQL("ALTER TABLE favorites ADD uri TEXT");
267                db.execSQL("ALTER TABLE favorites ADD displayMode INTEGER");
268                db.setTransactionSuccessful();
269            } finally {
270                db.endTransaction();
271            }
272            upgradeVersion = 26;
273        }
274
275        if (upgradeVersion == 26) {
276            // This introduces the new secure settings table.
277            db.beginTransaction();
278            try {
279                createSecureTable(db);
280                db.setTransactionSuccessful();
281            } finally {
282                db.endTransaction();
283            }
284            upgradeVersion = 27;
285        }
286
287        if (upgradeVersion == 27) {
288            String[] settingsToMove = {
289                    Settings.Secure.ADB_ENABLED,
290                    Settings.Secure.ANDROID_ID,
291                    Settings.Secure.BLUETOOTH_ON,
292                    Settings.Secure.DATA_ROAMING,
293                    Settings.Secure.DEVICE_PROVISIONED,
294                    Settings.Secure.HTTP_PROXY,
295                    Settings.Secure.INSTALL_NON_MARKET_APPS,
296                    Settings.Secure.LOCATION_PROVIDERS_ALLOWED,
297                    Settings.Secure.LOGGING_ID,
298                    Settings.Secure.NETWORK_PREFERENCE,
299                    Settings.Secure.PARENTAL_CONTROL_ENABLED,
300                    Settings.Secure.PARENTAL_CONTROL_LAST_UPDATE,
301                    Settings.Secure.PARENTAL_CONTROL_REDIRECT_URL,
302                    Settings.Secure.SETTINGS_CLASSNAME,
303                    Settings.Secure.USB_MASS_STORAGE_ENABLED,
304                    Settings.Secure.USE_GOOGLE_MAIL,
305                    Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
306                    Settings.Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY,
307                    Settings.Secure.WIFI_NUM_OPEN_NETWORKS_KEPT,
308                    Settings.Secure.WIFI_ON,
309                    Settings.Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE,
310                    Settings.Secure.WIFI_WATCHDOG_AP_COUNT,
311                    Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS,
312                    Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED,
313                    Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS,
314                    Settings.Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT,
315                    Settings.Secure.WIFI_WATCHDOG_MAX_AP_CHECKS,
316                    Settings.Secure.WIFI_WATCHDOG_ON,
317                    Settings.Secure.WIFI_WATCHDOG_PING_COUNT,
318                    Settings.Secure.WIFI_WATCHDOG_PING_DELAY_MS,
319                    Settings.Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS,
320                };
321            moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_SECURE, settingsToMove, false);
322            upgradeVersion = 28;
323        }
324
325        if (upgradeVersion == 28 || upgradeVersion == 29) {
326            // Note: The upgrade to 28 was flawed since it didn't delete the old
327            // setting first before inserting. Combining 28 and 29 with the
328            // fixed version.
329
330            // This upgrade adds the STREAM_NOTIFICATION type to the list of
331            // types affected by ringer modes (silent, vibrate, etc.)
332            db.beginTransaction();
333            try {
334                db.execSQL("DELETE FROM system WHERE name='"
335                        + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'");
336                int newValue = (1 << AudioManager.STREAM_RING)
337                        | (1 << AudioManager.STREAM_NOTIFICATION)
338                        | (1 << AudioManager.STREAM_SYSTEM);
339                db.execSQL("INSERT INTO system ('name', 'value') values ('"
340                        + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '"
341                        + String.valueOf(newValue) + "')");
342                db.setTransactionSuccessful();
343            } finally {
344                db.endTransaction();
345            }
346
347            upgradeVersion = 30;
348        }
349
350        if (upgradeVersion == 30) {
351            /*
352             * Upgrade 31 clears the title for all quick launch shortcuts so the
353             * activities' titles will be resolved at display time. Also, the
354             * folder is changed to '@quicklaunch'.
355             */
356            db.beginTransaction();
357            try {
358                db.execSQL("UPDATE bookmarks SET folder = '@quicklaunch'");
359                db.execSQL("UPDATE bookmarks SET title = ''");
360                db.setTransactionSuccessful();
361            } finally {
362                db.endTransaction();
363            }
364            upgradeVersion = 31;
365        }
366
367        if (upgradeVersion == 31) {
368            /*
369             * Animations are now managed in preferences, and may be
370             * enabled or disabled based on product resources.
371             */
372            db.beginTransaction();
373            SQLiteStatement stmt = null;
374            try {
375                db.execSQL("DELETE FROM system WHERE name='"
376                        + Settings.System.WINDOW_ANIMATION_SCALE + "'");
377                db.execSQL("DELETE FROM system WHERE name='"
378                        + Settings.System.TRANSITION_ANIMATION_SCALE + "'");
379                stmt = db.compileStatement("INSERT INTO system(name,value)"
380                        + " VALUES(?,?);");
381                loadDefaultAnimationSettings(stmt);
382                db.setTransactionSuccessful();
383            } finally {
384                db.endTransaction();
385                if (stmt != null) stmt.close();
386            }
387            upgradeVersion = 32;
388        }
389
390        if (upgradeVersion == 32) {
391            // The Wi-Fi watchdog SSID list is now seeded with the value of
392            // the property ro.com.android.wifi-watchlist
393            String wifiWatchList = SystemProperties.get("ro.com.android.wifi-watchlist");
394            if (!TextUtils.isEmpty(wifiWatchList)) {
395                db.beginTransaction();
396                try {
397                    db.execSQL("INSERT OR IGNORE INTO secure(name,value) values('" +
398                            Settings.Secure.WIFI_WATCHDOG_WATCH_LIST + "','" +
399                            wifiWatchList + "');");
400                    db.setTransactionSuccessful();
401                } finally {
402                    db.endTransaction();
403                }
404            }
405            upgradeVersion = 33;
406        }
407
408        if (upgradeVersion == 33) {
409            // Set the default zoom controls to: tap-twice to bring up +/-
410            db.beginTransaction();
411            try {
412                db.execSQL("INSERT INTO system(name,value) values('zoom','2');");
413                db.setTransactionSuccessful();
414            } finally {
415                db.endTransaction();
416            }
417            upgradeVersion = 34;
418        }
419
420        if (upgradeVersion == 34) {
421            db.beginTransaction();
422            SQLiteStatement stmt = null;
423            try {
424                stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)"
425                        + " VALUES(?,?);");
426                loadSecure35Settings(stmt);
427                db.setTransactionSuccessful();
428            } finally {
429                db.endTransaction();
430                if (stmt != null) stmt.close();
431            }
432            upgradeVersion = 35;
433        }
434            // due to a botched merge from donut to eclair, the initialization of ASSISTED_GPS_ENABLED
435            // was accidentally done out of order here.
436            // to fix this, ASSISTED_GPS_ENABLED is now initialized while upgrading from 38 to 39,
437            // and we intentionally do nothing from 35 to 36 now.
438        if (upgradeVersion == 35) {
439            upgradeVersion = 36;
440        }
441
442        if (upgradeVersion == 36) {
443           // This upgrade adds the STREAM_SYSTEM_ENFORCED type to the list of
444            // types affected by ringer modes (silent, vibrate, etc.)
445            db.beginTransaction();
446            try {
447                db.execSQL("DELETE FROM system WHERE name='"
448                        + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'");
449                int newValue = (1 << AudioManager.STREAM_RING)
450                        | (1 << AudioManager.STREAM_NOTIFICATION)
451                        | (1 << AudioManager.STREAM_SYSTEM)
452                        | (1 << AudioManager.STREAM_SYSTEM_ENFORCED);
453                db.execSQL("INSERT INTO system ('name', 'value') values ('"
454                        + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '"
455                        + String.valueOf(newValue) + "')");
456                db.setTransactionSuccessful();
457            } finally {
458                db.endTransaction();
459            }
460            upgradeVersion = 37;
461        }
462
463        if (upgradeVersion == 37) {
464            db.beginTransaction();
465            SQLiteStatement stmt = null;
466            try {
467                stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
468                        + " VALUES(?,?);");
469                loadStringSetting(stmt, Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS,
470                        R.string.airplane_mode_toggleable_radios);
471                db.setTransactionSuccessful();
472            } finally {
473                db.endTransaction();
474                if (stmt != null) stmt.close();
475            }
476            upgradeVersion = 38;
477        }
478
479        if (upgradeVersion == 38) {
480            db.beginTransaction();
481            try {
482                String value =
483                        mContext.getResources().getBoolean(R.bool.assisted_gps_enabled) ? "1" : "0";
484                db.execSQL("INSERT OR IGNORE INTO secure(name,value) values('" +
485                        Settings.Global.ASSISTED_GPS_ENABLED + "','" + value + "');");
486                db.setTransactionSuccessful();
487            } finally {
488                db.endTransaction();
489            }
490
491            upgradeVersion = 39;
492        }
493
494        if (upgradeVersion == 39) {
495            upgradeAutoBrightness(db);
496            upgradeVersion = 40;
497        }
498
499        if (upgradeVersion == 40) {
500            /*
501             * All animations are now turned on by default!
502             */
503            db.beginTransaction();
504            SQLiteStatement stmt = null;
505            try {
506                db.execSQL("DELETE FROM system WHERE name='"
507                        + Settings.System.WINDOW_ANIMATION_SCALE + "'");
508                db.execSQL("DELETE FROM system WHERE name='"
509                        + Settings.System.TRANSITION_ANIMATION_SCALE + "'");
510                stmt = db.compileStatement("INSERT INTO system(name,value)"
511                        + " VALUES(?,?);");
512                loadDefaultAnimationSettings(stmt);
513                db.setTransactionSuccessful();
514            } finally {
515                db.endTransaction();
516                if (stmt != null) stmt.close();
517            }
518            upgradeVersion = 41;
519        }
520
521        if (upgradeVersion == 41) {
522            /*
523             * Initialize newly public haptic feedback setting
524             */
525            db.beginTransaction();
526            SQLiteStatement stmt = null;
527            try {
528                db.execSQL("DELETE FROM system WHERE name='"
529                        + Settings.System.HAPTIC_FEEDBACK_ENABLED + "'");
530                stmt = db.compileStatement("INSERT INTO system(name,value)"
531                        + " VALUES(?,?);");
532                loadDefaultHapticSettings(stmt);
533                db.setTransactionSuccessful();
534            } finally {
535                db.endTransaction();
536                if (stmt != null) stmt.close();
537            }
538            upgradeVersion = 42;
539        }
540
541        if (upgradeVersion == 42) {
542            /*
543             * Initialize new notification pulse setting
544             */
545            db.beginTransaction();
546            SQLiteStatement stmt = null;
547            try {
548                stmt = db.compileStatement("INSERT INTO system(name,value)"
549                        + " VALUES(?,?);");
550                loadBooleanSetting(stmt, Settings.System.NOTIFICATION_LIGHT_PULSE,
551                        R.bool.def_notification_pulse);
552                db.setTransactionSuccessful();
553            } finally {
554                db.endTransaction();
555                if (stmt != null) stmt.close();
556            }
557            upgradeVersion = 43;
558        }
559
560        if (upgradeVersion == 43) {
561            /*
562             * This upgrade stores bluetooth volume separately from voice volume
563             */
564            db.beginTransaction();
565            SQLiteStatement stmt = null;
566            try {
567                stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
568                        + " VALUES(?,?);");
569                loadSetting(stmt, Settings.System.VOLUME_BLUETOOTH_SCO,
570                        AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_BLUETOOTH_SCO]);
571                db.setTransactionSuccessful();
572            } finally {
573                db.endTransaction();
574                if (stmt != null) stmt.close();
575            }
576            upgradeVersion = 44;
577        }
578
579        if (upgradeVersion == 44) {
580            /*
581             * Gservices was moved into vendor/google.
582             */
583            db.execSQL("DROP TABLE IF EXISTS gservices");
584            db.execSQL("DROP INDEX IF EXISTS gservicesIndex1");
585            upgradeVersion = 45;
586        }
587
588        if (upgradeVersion == 45) {
589             /*
590              * New settings for MountService
591              */
592            db.beginTransaction();
593            try {
594                db.execSQL("INSERT INTO secure(name,value) values('" +
595                        Settings.Secure.MOUNT_PLAY_NOTIFICATION_SND + "','1');");
596                db.execSQL("INSERT INTO secure(name,value) values('" +
597                        Settings.Secure.MOUNT_UMS_AUTOSTART + "','0');");
598                db.execSQL("INSERT INTO secure(name,value) values('" +
599                        Settings.Secure.MOUNT_UMS_PROMPT + "','1');");
600                db.execSQL("INSERT INTO secure(name,value) values('" +
601                        Settings.Secure.MOUNT_UMS_NOTIFY_ENABLED + "','1');");
602                db.setTransactionSuccessful();
603            } finally {
604                db.endTransaction();
605            }
606            upgradeVersion = 46;
607        }
608
609        if (upgradeVersion == 46) {
610            /*
611             * The password mode constants have changed; reset back to no
612             * password.
613             */
614            db.beginTransaction();
615            try {
616                db.execSQL("DELETE FROM system WHERE name='lockscreen.password_type';");
617                db.setTransactionSuccessful();
618            } finally {
619                db.endTransaction();
620            }
621           upgradeVersion = 47;
622       }
623
624
625        if (upgradeVersion == 47) {
626            /*
627             * The password mode constants have changed again; reset back to no
628             * password.
629             */
630            db.beginTransaction();
631            try {
632                db.execSQL("DELETE FROM system WHERE name='lockscreen.password_type';");
633                db.setTransactionSuccessful();
634            } finally {
635                db.endTransaction();
636            }
637           upgradeVersion = 48;
638       }
639
640       if (upgradeVersion == 48) {
641           /*
642            * Default recognition service no longer initialized here,
643            * moved to RecognitionManagerService.
644            */
645           upgradeVersion = 49;
646       }
647
648       if (upgradeVersion == 49) {
649           /*
650            * New settings for new user interface noises.
651            */
652           db.beginTransaction();
653           SQLiteStatement stmt = null;
654           try {
655                stmt = db.compileStatement("INSERT INTO system(name,value)"
656                        + " VALUES(?,?);");
657                loadUISoundEffectsSettings(stmt);
658                db.setTransactionSuccessful();
659            } finally {
660                db.endTransaction();
661                if (stmt != null) stmt.close();
662            }
663
664           upgradeVersion = 50;
665       }
666
667       if (upgradeVersion == 50) {
668           /*
669            * Install location no longer initiated here.
670            */
671           upgradeVersion = 51;
672       }
673
674       if (upgradeVersion == 51) {
675           /* Move the lockscreen related settings to Secure, including some private ones. */
676           String[] settingsToMove = {
677                   Secure.LOCK_PATTERN_ENABLED,
678                   Secure.LOCK_PATTERN_VISIBLE,
679                   Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED,
680                   "lockscreen.password_type",
681                   "lockscreen.lockoutattemptdeadline",
682                   "lockscreen.patterneverchosen",
683                   "lock_pattern_autolock",
684                   "lockscreen.lockedoutpermanently",
685                   "lockscreen.password_salt"
686           };
687           moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_SECURE, settingsToMove, false);
688           upgradeVersion = 52;
689       }
690
691        if (upgradeVersion == 52) {
692            // new vibration/silent mode settings
693            db.beginTransaction();
694            SQLiteStatement stmt = null;
695            try {
696                stmt = db.compileStatement("INSERT INTO system(name,value)"
697                        + " VALUES(?,?);");
698                loadBooleanSetting(stmt, Settings.System.VIBRATE_IN_SILENT,
699                        R.bool.def_vibrate_in_silent);
700                db.setTransactionSuccessful();
701            } finally {
702                db.endTransaction();
703                if (stmt != null) stmt.close();
704            }
705
706            upgradeVersion = 53;
707        }
708
709        if (upgradeVersion == 53) {
710            /*
711             * New settings for set install location UI no longer initiated here.
712             */
713            upgradeVersion = 54;
714        }
715
716        if (upgradeVersion == 54) {
717            /*
718             * Update the screen timeout value if set to never
719             */
720            db.beginTransaction();
721            try {
722                upgradeScreenTimeoutFromNever(db);
723                db.setTransactionSuccessful();
724            } finally {
725                db.endTransaction();
726            }
727
728            upgradeVersion = 55;
729        }
730
731        if (upgradeVersion == 55) {
732            /* Move the install location settings. */
733            String[] settingsToMove = {
734                    Global.SET_INSTALL_LOCATION,
735                    Global.DEFAULT_INSTALL_LOCATION
736            };
737            moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_SECURE, settingsToMove, false);
738            db.beginTransaction();
739            SQLiteStatement stmt = null;
740            try {
741                stmt = db.compileStatement("INSERT INTO system(name,value)"
742                        + " VALUES(?,?);");
743                loadSetting(stmt, Global.SET_INSTALL_LOCATION, 0);
744                loadSetting(stmt, Global.DEFAULT_INSTALL_LOCATION,
745                        PackageHelper.APP_INSTALL_AUTO);
746                db.setTransactionSuccessful();
747             } finally {
748                 db.endTransaction();
749                 if (stmt != null) stmt.close();
750             }
751            upgradeVersion = 56;
752        }
753
754        if (upgradeVersion == 56) {
755            /*
756             * Add Bluetooth to list of toggleable radios in airplane mode
757             */
758            db.beginTransaction();
759            SQLiteStatement stmt = null;
760            try {
761                db.execSQL("DELETE FROM system WHERE name='"
762                        + Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS + "'");
763                stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
764                        + " VALUES(?,?);");
765                loadStringSetting(stmt, Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS,
766                        R.string.airplane_mode_toggleable_radios);
767                db.setTransactionSuccessful();
768            } finally {
769                db.endTransaction();
770                if (stmt != null) stmt.close();
771            }
772            upgradeVersion = 57;
773        }
774
775        /************* The following are Honeycomb changes ************/
776
777        if (upgradeVersion == 57) {
778            /*
779             * New settings to:
780             *  1. Enable injection of accessibility scripts in WebViews.
781             *  2. Define the key bindings for traversing web content in WebViews.
782             */
783            db.beginTransaction();
784            SQLiteStatement stmt = null;
785            try {
786                stmt = db.compileStatement("INSERT INTO secure(name,value)"
787                        + " VALUES(?,?);");
788                loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SCRIPT_INJECTION,
789                        R.bool.def_accessibility_script_injection);
790                stmt.close();
791                stmt = db.compileStatement("INSERT INTO secure(name,value)"
792                        + " VALUES(?,?);");
793                loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS,
794                        R.string.def_accessibility_web_content_key_bindings);
795                db.setTransactionSuccessful();
796            } finally {
797                db.endTransaction();
798                if (stmt != null) stmt.close();
799            }
800            upgradeVersion = 58;
801        }
802
803        if (upgradeVersion == 58) {
804            /* Add default for new Auto Time Zone */
805            int autoTimeValue = getIntValueFromSystem(db, Settings.System.AUTO_TIME, 0);
806            db.beginTransaction();
807            SQLiteStatement stmt = null;
808            try {
809                stmt = db.compileStatement("INSERT INTO system(name,value)" + " VALUES(?,?);");
810                loadSetting(stmt, Settings.System.AUTO_TIME_ZONE,
811                        autoTimeValue); // Sync timezone to NITZ if auto_time was enabled
812                db.setTransactionSuccessful();
813            } finally {
814                db.endTransaction();
815                if (stmt != null) stmt.close();
816            }
817            upgradeVersion = 59;
818        }
819
820        if (upgradeVersion == 59) {
821            // Persistence for the rotation lock feature.
822            db.beginTransaction();
823            SQLiteStatement stmt = null;
824            try {
825                stmt = db.compileStatement("INSERT INTO system(name,value)"
826                        + " VALUES(?,?);");
827                loadBooleanSetting(stmt, Settings.System.USER_ROTATION,
828                        R.integer.def_user_rotation); // should be zero degrees
829                db.setTransactionSuccessful();
830            } finally {
831                db.endTransaction();
832                if (stmt != null) stmt.close();
833            }
834            upgradeVersion = 60;
835        }
836
837        if (upgradeVersion == 60) {
838            // Don't do this for upgrades from Gingerbread
839            // Were only required for intra-Honeycomb upgrades for testing
840            // upgradeScreenTimeout(db);
841            upgradeVersion = 61;
842        }
843
844        if (upgradeVersion == 61) {
845            // Don't do this for upgrades from Gingerbread
846            // Were only required for intra-Honeycomb upgrades for testing
847            // upgradeScreenTimeout(db);
848            upgradeVersion = 62;
849        }
850
851        // Change the default for screen auto-brightness mode
852        if (upgradeVersion == 62) {
853            // Don't do this for upgrades from Gingerbread
854            // Were only required for intra-Honeycomb upgrades for testing
855            // upgradeAutoBrightness(db);
856            upgradeVersion = 63;
857        }
858
859        if (upgradeVersion == 63) {
860            // This upgrade adds the STREAM_MUSIC type to the list of
861             // types affected by ringer modes (silent, vibrate, etc.)
862             db.beginTransaction();
863             try {
864                 db.execSQL("DELETE FROM system WHERE name='"
865                         + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'");
866                 int newValue = (1 << AudioManager.STREAM_RING)
867                         | (1 << AudioManager.STREAM_NOTIFICATION)
868                         | (1 << AudioManager.STREAM_SYSTEM)
869                         | (1 << AudioManager.STREAM_SYSTEM_ENFORCED)
870                         | (1 << AudioManager.STREAM_MUSIC);
871                 db.execSQL("INSERT INTO system ('name', 'value') values ('"
872                         + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '"
873                         + String.valueOf(newValue) + "')");
874                 db.setTransactionSuccessful();
875             } finally {
876                 db.endTransaction();
877             }
878             upgradeVersion = 64;
879         }
880
881        if (upgradeVersion == 64) {
882            // New setting to configure the long press timeout.
883            db.beginTransaction();
884            SQLiteStatement stmt = null;
885            try {
886                stmt = db.compileStatement("INSERT INTO secure(name,value)"
887                        + " VALUES(?,?);");
888                loadIntegerSetting(stmt, Settings.Secure.LONG_PRESS_TIMEOUT,
889                        R.integer.def_long_press_timeout_millis);
890                stmt.close();
891                db.setTransactionSuccessful();
892            } finally {
893                db.endTransaction();
894                if (stmt != null) stmt.close();
895            }
896            upgradeVersion = 65;
897        }
898
899        /************* The following are Ice Cream Sandwich changes ************/
900
901        if (upgradeVersion == 65) {
902            /*
903             * Animations are removed from Settings. Turned on by default
904             */
905            db.beginTransaction();
906            SQLiteStatement stmt = null;
907            try {
908                db.execSQL("DELETE FROM system WHERE name='"
909                        + Settings.System.WINDOW_ANIMATION_SCALE + "'");
910                db.execSQL("DELETE FROM system WHERE name='"
911                        + Settings.System.TRANSITION_ANIMATION_SCALE + "'");
912                stmt = db.compileStatement("INSERT INTO system(name,value)"
913                        + " VALUES(?,?);");
914                loadDefaultAnimationSettings(stmt);
915                db.setTransactionSuccessful();
916            } finally {
917                db.endTransaction();
918                if (stmt != null) stmt.close();
919            }
920            upgradeVersion = 66;
921        }
922
923        if (upgradeVersion == 66) {
924            // This upgrade makes sure that MODE_RINGER_STREAMS_AFFECTED is set
925            // according to device voice capability
926            db.beginTransaction();
927            try {
928                int ringerModeAffectedStreams = (1 << AudioManager.STREAM_RING) |
929                                                (1 << AudioManager.STREAM_NOTIFICATION) |
930                                                (1 << AudioManager.STREAM_SYSTEM) |
931                                                (1 << AudioManager.STREAM_SYSTEM_ENFORCED);
932                if (!mContext.getResources().getBoolean(
933                        com.android.internal.R.bool.config_voice_capable)) {
934                    ringerModeAffectedStreams |= (1 << AudioManager.STREAM_MUSIC);
935                }
936                db.execSQL("DELETE FROM system WHERE name='"
937                        + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'");
938                db.execSQL("INSERT INTO system ('name', 'value') values ('"
939                        + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '"
940                        + String.valueOf(ringerModeAffectedStreams) + "')");
941                db.setTransactionSuccessful();
942            } finally {
943                db.endTransaction();
944            }
945            upgradeVersion = 67;
946        }
947
948        if (upgradeVersion == 67) {
949            // New setting to enable touch exploration.
950            db.beginTransaction();
951            SQLiteStatement stmt = null;
952            try {
953                stmt = db.compileStatement("INSERT INTO secure(name,value)"
954                        + " VALUES(?,?);");
955                loadBooleanSetting(stmt, Settings.Secure.TOUCH_EXPLORATION_ENABLED,
956                        R.bool.def_touch_exploration_enabled);
957                stmt.close();
958                db.setTransactionSuccessful();
959            } finally {
960                db.endTransaction();
961                if (stmt != null) stmt.close();
962            }
963            upgradeVersion = 68;
964        }
965
966        if (upgradeVersion == 68) {
967            // Enable all system sounds by default
968            db.beginTransaction();
969            try {
970                db.execSQL("DELETE FROM system WHERE name='"
971                        + Settings.System.NOTIFICATIONS_USE_RING_VOLUME + "'");
972                db.setTransactionSuccessful();
973            } finally {
974                db.endTransaction();
975            }
976            upgradeVersion = 69;
977        }
978
979        if (upgradeVersion == 69) {
980            // Add RADIO_NFC to AIRPLANE_MODE_RADIO and AIRPLANE_MODE_TOGGLEABLE_RADIOS
981            String airplaneRadios = mContext.getResources().getString(
982                    R.string.def_airplane_mode_radios);
983            String toggleableRadios = mContext.getResources().getString(
984                    R.string.airplane_mode_toggleable_radios);
985            db.beginTransaction();
986            try {
987                db.execSQL("UPDATE system SET value='" + airplaneRadios + "' " +
988                        "WHERE name='" + Settings.System.AIRPLANE_MODE_RADIOS + "'");
989                db.execSQL("UPDATE system SET value='" + toggleableRadios + "' " +
990                        "WHERE name='" + Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS + "'");
991                db.setTransactionSuccessful();
992            } finally {
993                db.endTransaction();
994            }
995            upgradeVersion = 70;
996        }
997
998        if (upgradeVersion == 70) {
999            // Update all built-in bookmarks.  Some of the package names have changed.
1000            loadBookmarks(db);
1001            upgradeVersion = 71;
1002        }
1003
1004        if (upgradeVersion == 71) {
1005             // New setting to specify whether to speak passwords in accessibility mode.
1006            db.beginTransaction();
1007            SQLiteStatement stmt = null;
1008            try {
1009                stmt = db.compileStatement("INSERT INTO secure(name,value)"
1010                        + " VALUES(?,?);");
1011                loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD,
1012                        R.bool.def_accessibility_speak_password);
1013                db.setTransactionSuccessful();
1014            } finally {
1015                db.endTransaction();
1016                if (stmt != null) stmt.close();
1017            }
1018            upgradeVersion = 72;
1019        }
1020
1021        if (upgradeVersion == 72) {
1022            // update vibration settings
1023            db.beginTransaction();
1024            SQLiteStatement stmt = null;
1025            try {
1026                stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)"
1027                        + " VALUES(?,?);");
1028                loadBooleanSetting(stmt, Settings.System.VIBRATE_IN_SILENT,
1029                        R.bool.def_vibrate_in_silent);
1030                db.setTransactionSuccessful();
1031            } finally {
1032                db.endTransaction();
1033                if (stmt != null) stmt.close();
1034            }
1035            upgradeVersion = 73;
1036        }
1037
1038        if (upgradeVersion == 73) {
1039            upgradeVibrateSettingFromNone(db);
1040            upgradeVersion = 74;
1041        }
1042
1043        if (upgradeVersion == 74) {
1044            // URL from which WebView loads a JavaScript based screen-reader.
1045            db.beginTransaction();
1046            SQLiteStatement stmt = null;
1047            try {
1048                stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);");
1049                loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL,
1050                        R.string.def_accessibility_screen_reader_url);
1051                db.setTransactionSuccessful();
1052            } finally {
1053                db.endTransaction();
1054                if (stmt != null) stmt.close();
1055            }
1056            upgradeVersion = 75;
1057        }
1058        if (upgradeVersion == 75) {
1059            db.beginTransaction();
1060            SQLiteStatement stmt = null;
1061            Cursor c = null;
1062            try {
1063                c = db.query(TABLE_SECURE, new String[] {"_id", "value"},
1064                        "name='lockscreen.disabled'",
1065                        null, null, null, null);
1066                // only set default if it has not yet been set
1067                if (c == null || c.getCount() == 0) {
1068                    stmt = db.compileStatement("INSERT INTO system(name,value)"
1069                            + " VALUES(?,?);");
1070                    loadBooleanSetting(stmt, Settings.System.LOCKSCREEN_DISABLED,
1071                            R.bool.def_lockscreen_disabled);
1072                }
1073                db.setTransactionSuccessful();
1074            } finally {
1075                db.endTransaction();
1076                if (c != null) c.close();
1077                if (stmt != null) stmt.close();
1078            }
1079            upgradeVersion = 76;
1080        }
1081
1082        /************* The following are Jelly Bean changes ************/
1083
1084        if (upgradeVersion == 76) {
1085            // Removed VIBRATE_IN_SILENT setting
1086            db.beginTransaction();
1087            try {
1088                db.execSQL("DELETE FROM system WHERE name='"
1089                                + Settings.System.VIBRATE_IN_SILENT + "'");
1090                db.setTransactionSuccessful();
1091            } finally {
1092                db.endTransaction();
1093            }
1094
1095            upgradeVersion = 77;
1096        }
1097
1098        if (upgradeVersion == 77) {
1099            // Introduce "vibrate when ringing" setting
1100            loadVibrateWhenRingingSetting(db);
1101
1102            upgradeVersion = 78;
1103        }
1104
1105        if (upgradeVersion == 78) {
1106            // The JavaScript based screen-reader URL changes in JellyBean.
1107            db.beginTransaction();
1108            SQLiteStatement stmt = null;
1109            try {
1110                stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)"
1111                        + " VALUES(?,?);");
1112                loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL,
1113                        R.string.def_accessibility_screen_reader_url);
1114                db.setTransactionSuccessful();
1115            } finally {
1116                db.endTransaction();
1117                if (stmt != null) stmt.close();
1118            }
1119            upgradeVersion = 79;
1120        }
1121
1122        if (upgradeVersion == 79) {
1123            // Before touch exploration was a global setting controlled by the user
1124            // via the UI. However, if the enabled accessibility services do not
1125            // handle touch exploration mode, enabling it makes no sense. Therefore,
1126            // now the services request touch exploration mode and the user is
1127            // presented with a dialog to allow that and if she does we store that
1128            // in the database. As a result of this change a user that has enabled
1129            // accessibility, touch exploration, and some accessibility services
1130            // may lose touch exploration state, thus rendering the device useless
1131            // unless sighted help is provided, since the enabled service(s) are
1132            // not in the list of services to which the user granted a permission
1133            // to put the device in touch explore mode. Here we are allowing all
1134            // enabled accessibility services to toggle touch exploration provided
1135            // accessibility and touch exploration are enabled and no services can
1136            // toggle touch exploration. Note that the user has already manually
1137            // enabled the services and touch exploration which means the she has
1138            // given consent to have these services work in touch exploration mode.
1139            final boolean accessibilityEnabled = getIntValueFromTable(db, TABLE_SECURE,
1140                    Settings.Secure.ACCESSIBILITY_ENABLED, 0) == 1;
1141            final boolean touchExplorationEnabled = getIntValueFromTable(db, TABLE_SECURE,
1142                    Settings.Secure.TOUCH_EXPLORATION_ENABLED, 0) == 1;
1143            if (accessibilityEnabled && touchExplorationEnabled) {
1144                String enabledServices = getStringValueFromTable(db, TABLE_SECURE,
1145                        Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, "");
1146                String touchExplorationGrantedServices = getStringValueFromTable(db, TABLE_SECURE,
1147                        Settings.Secure.TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, "");
1148                if (TextUtils.isEmpty(touchExplorationGrantedServices)
1149                        && !TextUtils.isEmpty(enabledServices)) {
1150                    SQLiteStatement stmt = null;
1151                    try {
1152                        db.beginTransaction();
1153                        stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)"
1154                                + " VALUES(?,?);");
1155                        loadSetting(stmt,
1156                                Settings.Secure.TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES,
1157                                enabledServices);
1158                        db.setTransactionSuccessful();
1159                    } finally {
1160                        db.endTransaction();
1161                        if (stmt != null) stmt.close();
1162                    }
1163                }
1164            }
1165            upgradeVersion = 80;
1166        }
1167
1168        // vvv Jelly Bean MR1 changes begin here vvv
1169
1170        if (upgradeVersion == 80) {
1171            // update screensaver settings
1172            db.beginTransaction();
1173            SQLiteStatement stmt = null;
1174            try {
1175                stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)"
1176                        + " VALUES(?,?);");
1177                loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ENABLED,
1178                        com.android.internal.R.bool.config_dreamsEnabledByDefault);
1179                loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK,
1180                        com.android.internal.R.bool.config_dreamsActivatedOnDockByDefault);
1181                loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP,
1182                        com.android.internal.R.bool.config_dreamsActivatedOnSleepByDefault);
1183                loadStringSetting(stmt, Settings.Secure.SCREENSAVER_COMPONENTS,
1184                        com.android.internal.R.string.config_dreamsDefaultComponent);
1185                loadStringSetting(stmt, Settings.Secure.SCREENSAVER_DEFAULT_COMPONENT,
1186                        com.android.internal.R.string.config_dreamsDefaultComponent);
1187
1188                db.setTransactionSuccessful();
1189            } finally {
1190                db.endTransaction();
1191                if (stmt != null) stmt.close();
1192            }
1193            upgradeVersion = 81;
1194        }
1195
1196        if (upgradeVersion == 81) {
1197            // Add package verification setting
1198            db.beginTransaction();
1199            SQLiteStatement stmt = null;
1200            try {
1201                stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)"
1202                        + " VALUES(?,?);");
1203                loadBooleanSetting(stmt, Settings.Global.PACKAGE_VERIFIER_ENABLE,
1204                        R.bool.def_package_verifier_enable);
1205                db.setTransactionSuccessful();
1206            } finally {
1207                db.endTransaction();
1208                if (stmt != null) stmt.close();
1209            }
1210            upgradeVersion = 82;
1211        }
1212
1213        if (upgradeVersion == 82) {
1214            // Move to per-user settings dbs
1215            if (mUserHandle == UserHandle.USER_OWNER) {
1216
1217                db.beginTransaction();
1218                SQLiteStatement stmt = null;
1219                try {
1220                    // Migrate now-global settings. Note that this happens before
1221                    // new users can be created.
1222                    createGlobalTable(db);
1223                    String[] settingsToMove = hashsetToStringArray(SettingsProvider.sSystemGlobalKeys);
1224                    moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, settingsToMove, false);
1225                    settingsToMove = hashsetToStringArray(SettingsProvider.sSecureGlobalKeys);
1226                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, false);
1227
1228                    db.setTransactionSuccessful();
1229                } finally {
1230                    db.endTransaction();
1231                    if (stmt != null) stmt.close();
1232                }
1233            }
1234            upgradeVersion = 83;
1235        }
1236
1237        if (upgradeVersion == 83) {
1238            // 1. Setting whether screen magnification is enabled.
1239            // 2. Setting for screen magnification scale.
1240            // 3. Setting for screen magnification auto update.
1241            db.beginTransaction();
1242            SQLiteStatement stmt = null;
1243            try {
1244                stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);");
1245                loadBooleanSetting(stmt,
1246                        Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
1247                        R.bool.def_accessibility_display_magnification_enabled);
1248                stmt.close();
1249                stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);");
1250                loadFractionSetting(stmt, Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE,
1251                        R.fraction.def_accessibility_display_magnification_scale, 1);
1252                stmt.close();
1253                stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);");
1254                loadBooleanSetting(stmt,
1255                        Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE,
1256                        R.bool.def_accessibility_display_magnification_auto_update);
1257
1258                db.setTransactionSuccessful();
1259            } finally {
1260                db.endTransaction();
1261                if (stmt != null) stmt.close();
1262            }
1263            upgradeVersion = 84;
1264        }
1265
1266        if (upgradeVersion == 84) {
1267            if (mUserHandle == UserHandle.USER_OWNER) {
1268                db.beginTransaction();
1269                SQLiteStatement stmt = null;
1270                try {
1271                    // Patch up the slightly-wrong key migration from 82 -> 83 for those
1272                    // devices that missed it, ignoring if the move is redundant
1273                    String[] settingsToMove = {
1274                            Settings.Secure.ADB_ENABLED,
1275                            Settings.Secure.BLUETOOTH_ON,
1276                            Settings.Secure.DATA_ROAMING,
1277                            Settings.Secure.DEVICE_PROVISIONED,
1278                            Settings.Secure.INSTALL_NON_MARKET_APPS,
1279                            Settings.Secure.USB_MASS_STORAGE_ENABLED
1280                    };
1281                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true);
1282                    db.setTransactionSuccessful();
1283                } finally {
1284                    db.endTransaction();
1285                    if (stmt != null) stmt.close();
1286                }
1287            }
1288            upgradeVersion = 85;
1289        }
1290
1291        if (upgradeVersion == 85) {
1292            if (mUserHandle == UserHandle.USER_OWNER) {
1293                db.beginTransaction();
1294                try {
1295                    // Fix up the migration, ignoring already-migrated elements, to snap up to
1296                    // date with new changes to the set of global versus system/secure settings
1297                    String[] settingsToMove = { Settings.System.STAY_ON_WHILE_PLUGGED_IN };
1298                    moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, settingsToMove, true);
1299
1300                    db.setTransactionSuccessful();
1301                } finally {
1302                    db.endTransaction();
1303                }
1304            }
1305            upgradeVersion = 86;
1306        }
1307
1308        if (upgradeVersion == 86) {
1309            if (mUserHandle == UserHandle.USER_OWNER) {
1310                db.beginTransaction();
1311                try {
1312                    String[] settingsToMove = {
1313                            Settings.Global.PACKAGE_VERIFIER_ENABLE,
1314                            Settings.Global.PACKAGE_VERIFIER_TIMEOUT,
1315                            Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE
1316                    };
1317                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true);
1318
1319                    db.setTransactionSuccessful();
1320                } finally {
1321                    db.endTransaction();
1322                }
1323            }
1324            upgradeVersion = 87;
1325        }
1326
1327        if (upgradeVersion == 87) {
1328            if (mUserHandle == UserHandle.USER_OWNER) {
1329                db.beginTransaction();
1330                try {
1331                    String[] settingsToMove = {
1332                            Settings.Global.DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS,
1333                            Settings.Global.DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS,
1334                            Settings.Global.GPRS_REGISTER_CHECK_PERIOD_MS
1335                    };
1336                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true);
1337
1338                    db.setTransactionSuccessful();
1339                } finally {
1340                    db.endTransaction();
1341                }
1342            }
1343            upgradeVersion = 88;
1344        }
1345
1346        if (upgradeVersion == 88) {
1347            if (mUserHandle == UserHandle.USER_OWNER) {
1348                db.beginTransaction();
1349                try {
1350                    String[] settingsToMove = {
1351                            Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD,
1352                            Settings.Global.BATTERY_DISCHARGE_THRESHOLD,
1353                            Settings.Global.SEND_ACTION_APP_ERROR,
1354                            Settings.Global.DROPBOX_AGE_SECONDS,
1355                            Settings.Global.DROPBOX_MAX_FILES,
1356                            Settings.Global.DROPBOX_QUOTA_KB,
1357                            Settings.Global.DROPBOX_QUOTA_PERCENT,
1358                            Settings.Global.DROPBOX_RESERVE_PERCENT,
1359                            Settings.Global.DROPBOX_TAG_PREFIX,
1360                            Settings.Global.ERROR_LOGCAT_PREFIX,
1361                            Settings.Global.SYS_FREE_STORAGE_LOG_INTERVAL,
1362                            Settings.Global.DISK_FREE_CHANGE_REPORTING_THRESHOLD,
1363                            Settings.Global.SYS_STORAGE_THRESHOLD_PERCENTAGE,
1364                            Settings.Global.SYS_STORAGE_THRESHOLD_MAX_BYTES,
1365                            Settings.Global.SYS_STORAGE_FULL_THRESHOLD_BYTES,
1366                            Settings.Global.SYNC_MAX_RETRY_DELAY_IN_SECONDS,
1367                            Settings.Global.CONNECTIVITY_CHANGE_DELAY,
1368                            Settings.Global.CAPTIVE_PORTAL_DETECTION_ENABLED,
1369                            Settings.Global.CAPTIVE_PORTAL_SERVER,
1370                            Settings.Global.NSD_ON,
1371                            Settings.Global.SET_INSTALL_LOCATION,
1372                            Settings.Global.DEFAULT_INSTALL_LOCATION,
1373                            Settings.Global.INET_CONDITION_DEBOUNCE_UP_DELAY,
1374                            Settings.Global.INET_CONDITION_DEBOUNCE_DOWN_DELAY,
1375                            Settings.Global.READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT,
1376                            Settings.Global.HTTP_PROXY,
1377                            Settings.Global.GLOBAL_HTTP_PROXY_HOST,
1378                            Settings.Global.GLOBAL_HTTP_PROXY_PORT,
1379                            Settings.Global.GLOBAL_HTTP_PROXY_EXCLUSION_LIST,
1380                            Settings.Global.SET_GLOBAL_HTTP_PROXY,
1381                            Settings.Global.DEFAULT_DNS_SERVER,
1382                    };
1383                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true);
1384                    db.setTransactionSuccessful();
1385                } finally {
1386                    db.endTransaction();
1387                }
1388            }
1389            upgradeVersion = 89;
1390        }
1391
1392        if (upgradeVersion == 89) {
1393            if (mUserHandle == UserHandle.USER_OWNER) {
1394                db.beginTransaction();
1395                try {
1396                    String[] prefixesToMove = {
1397                            Settings.Global.BLUETOOTH_HEADSET_PRIORITY_PREFIX,
1398                            Settings.Global.BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX,
1399                            Settings.Global.BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX,
1400                    };
1401
1402                    movePrefixedSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, prefixesToMove);
1403
1404                    db.setTransactionSuccessful();
1405                } finally {
1406                    db.endTransaction();
1407                }
1408            }
1409            upgradeVersion = 90;
1410        }
1411
1412        if (upgradeVersion == 90) {
1413            if (mUserHandle == UserHandle.USER_OWNER) {
1414                db.beginTransaction();
1415                try {
1416                    String[] systemToGlobal = {
1417                            Settings.Global.WINDOW_ANIMATION_SCALE,
1418                            Settings.Global.TRANSITION_ANIMATION_SCALE,
1419                            Settings.Global.ANIMATOR_DURATION_SCALE,
1420                            Settings.Global.FANCY_IME_ANIMATIONS,
1421                            Settings.Global.COMPATIBILITY_MODE,
1422                            Settings.Global.EMERGENCY_TONE,
1423                            Settings.Global.CALL_AUTO_RETRY,
1424                            Settings.Global.DEBUG_APP,
1425                            Settings.Global.WAIT_FOR_DEBUGGER,
1426                            Settings.Global.SHOW_PROCESSES,
1427                            Settings.Global.ALWAYS_FINISH_ACTIVITIES,
1428                    };
1429                    String[] secureToGlobal = {
1430                            Settings.Global.PREFERRED_NETWORK_MODE,
1431                            Settings.Global.CDMA_SUBSCRIPTION_MODE,
1432                    };
1433
1434                    moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, systemToGlobal, true);
1435                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, secureToGlobal, true);
1436
1437                    db.setTransactionSuccessful();
1438                } finally {
1439                    db.endTransaction();
1440                }
1441            }
1442            upgradeVersion = 91;
1443        }
1444
1445        if (upgradeVersion == 91) {
1446            if (mUserHandle == UserHandle.USER_OWNER) {
1447                db.beginTransaction();
1448                try {
1449                    // Move ringer mode from system to global settings
1450                    String[] settingsToMove = { Settings.Global.MODE_RINGER };
1451                    moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, settingsToMove, true);
1452
1453                    db.setTransactionSuccessful();
1454                } finally {
1455                    db.endTransaction();
1456                }
1457            }
1458            upgradeVersion = 92;
1459        }
1460
1461        if (upgradeVersion == 92) {
1462            SQLiteStatement stmt = null;
1463            try {
1464                stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)"
1465                        + " VALUES(?,?);");
1466                if (mUserHandle == UserHandle.USER_OWNER) {
1467                    // consider existing primary users to have made it through user setup
1468                    // if the globally-scoped device-provisioned bit is set
1469                    // (indicating they already made it through setup as primary)
1470                    int deviceProvisioned = getIntValueFromTable(db, TABLE_GLOBAL,
1471                            Settings.Global.DEVICE_PROVISIONED, 0);
1472                    loadSetting(stmt, Settings.Secure.USER_SETUP_COMPLETE,
1473                            deviceProvisioned);
1474                } else {
1475                    // otherwise use the default
1476                    loadBooleanSetting(stmt, Settings.Secure.USER_SETUP_COMPLETE,
1477                            R.bool.def_user_setup_complete);
1478                }
1479            } finally {
1480                if (stmt != null) stmt.close();
1481            }
1482            upgradeVersion = 93;
1483        }
1484
1485        if (upgradeVersion == 93) {
1486            // Redo this step, since somehow it didn't work the first time for some users
1487            if (mUserHandle == UserHandle.USER_OWNER) {
1488                db.beginTransaction();
1489                try {
1490                    // Migrate now-global settings
1491                    String[] settingsToMove = hashsetToStringArray(SettingsProvider.sSystemGlobalKeys);
1492                    moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, settingsToMove, true);
1493                    settingsToMove = hashsetToStringArray(SettingsProvider.sSecureGlobalKeys);
1494                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true);
1495
1496                    db.setTransactionSuccessful();
1497                } finally {
1498                    db.endTransaction();
1499                }
1500            }
1501            upgradeVersion = 94;
1502        }
1503
1504        if (upgradeVersion == 94) {
1505            // Add wireless charging started sound setting
1506            if (mUserHandle == UserHandle.USER_OWNER) {
1507                db.beginTransaction();
1508                SQLiteStatement stmt = null;
1509                try {
1510                    stmt = db.compileStatement("INSERT OR REPLACE INTO global(name,value)"
1511                            + " VALUES(?,?);");
1512                    loadStringSetting(stmt, Settings.Global.WIRELESS_CHARGING_STARTED_SOUND,
1513                            R.string.def_wireless_charging_started_sound);
1514                    db.setTransactionSuccessful();
1515                } finally {
1516                    db.endTransaction();
1517                    if (stmt != null) stmt.close();
1518                }
1519            }
1520            upgradeVersion = 95;
1521        }
1522
1523        if (upgradeVersion == 95) {
1524            if (mUserHandle == UserHandle.USER_OWNER) {
1525                db.beginTransaction();
1526                try {
1527                    String[] settingsToMove = { Settings.Global.BUGREPORT_IN_POWER_MENU };
1528                    moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true);
1529                    db.setTransactionSuccessful();
1530                } finally {
1531                    db.endTransaction();
1532                }
1533            }
1534            upgradeVersion = 96;
1535        }
1536
1537        if (upgradeVersion == 96) {
1538            // NOP bump due to a reverted change that some people got on upgrade.
1539            upgradeVersion = 97;
1540        }
1541
1542        if (upgradeVersion == 97) {
1543            if (mUserHandle == UserHandle.USER_OWNER) {
1544                db.beginTransaction();
1545                SQLiteStatement stmt = null;
1546                try {
1547                    stmt = db.compileStatement("INSERT OR REPLACE INTO global(name,value)"
1548                            + " VALUES(?,?);");
1549                    loadIntegerSetting(stmt, Settings.Global.LOW_BATTERY_SOUND_TIMEOUT,
1550                            R.integer.def_low_battery_sound_timeout);
1551                    db.setTransactionSuccessful();
1552                } finally {
1553                    db.endTransaction();
1554                    if (stmt != null) stmt.close();
1555                }
1556            }
1557            upgradeVersion = 98;
1558        }
1559
1560        if (upgradeVersion == 98) {
1561            // no-op; LOCK_SCREEN_SHOW_NOTIFICATIONS now handled in version 106
1562            upgradeVersion = 99;
1563        }
1564
1565        if (upgradeVersion == 99) {
1566            // no-op; HEADS_UP_NOTIFICATIONS_ENABLED now handled in version 100
1567            upgradeVersion = 100;
1568        }
1569
1570        if (upgradeVersion == 100) {
1571            // note: LOCK_SCREEN_SHOW_NOTIFICATIONS now handled in version 106
1572            if (mUserHandle == UserHandle.USER_OWNER) {
1573                db.beginTransaction();
1574                SQLiteStatement stmt = null;
1575                try {
1576                    stmt = db.compileStatement("INSERT OR REPLACE INTO global(name,value)"
1577                            + " VALUES(?,?);");
1578                    loadIntegerSetting(stmt, Global.HEADS_UP_NOTIFICATIONS_ENABLED,
1579                            R.integer.def_heads_up_enabled);
1580                    db.setTransactionSuccessful();
1581                } finally {
1582                    db.endTransaction();
1583                    if (stmt != null) stmt.close();
1584                }
1585            }
1586            upgradeVersion = 101;
1587        }
1588
1589        if (upgradeVersion == 101) {
1590            if (mUserHandle == UserHandle.USER_OWNER) {
1591                db.beginTransaction();
1592                SQLiteStatement stmt = null;
1593                try {
1594                    stmt = db.compileStatement("INSERT OR IGNORE INTO global(name,value)"
1595                            + " VALUES(?,?);");
1596                    loadSetting(stmt, Settings.Global.DEVICE_NAME, getDefaultDeviceName());
1597                    db.setTransactionSuccessful();
1598                } finally {
1599                    db.endTransaction();
1600                    if (stmt != null) stmt.close();
1601                }
1602            }
1603            upgradeVersion = 102;
1604        }
1605
1606        if (upgradeVersion == 102) {
1607            db.beginTransaction();
1608            SQLiteStatement stmt = null;
1609            try {
1610                // The INSTALL_NON_MARKET_APPS setting is becoming per-user rather
1611                // than device-global.
1612                if (mUserHandle == UserHandle.USER_OWNER) {
1613                    // In the owner user, the global table exists so we can migrate the
1614                    // entry from there to the secure table, preserving its value.
1615                    String[] globalToSecure = {
1616                            Settings.Secure.INSTALL_NON_MARKET_APPS
1617                    };
1618                    moveSettingsToNewTable(db, TABLE_GLOBAL, TABLE_SECURE, globalToSecure, true);
1619                } else {
1620                    // Secondary users' dbs don't have the global table, so institute the
1621                    // default.
1622                    stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)"
1623                            + " VALUES(?,?);");
1624                    loadBooleanSetting(stmt, Settings.Secure.INSTALL_NON_MARKET_APPS,
1625                            R.bool.def_install_non_market_apps);
1626                }
1627                db.setTransactionSuccessful();
1628            } finally {
1629                db.endTransaction();
1630                if (stmt != null) stmt.close();
1631            }
1632            upgradeVersion = 103;
1633        }
1634
1635        if (upgradeVersion == 103) {
1636            db.beginTransaction();
1637            SQLiteStatement stmt = null;
1638            try {
1639                stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)"
1640                        + " VALUES(?,?);");
1641                loadBooleanSetting(stmt, Settings.Secure.WAKE_GESTURE_ENABLED,
1642                        R.bool.def_wake_gesture_enabled);
1643                db.setTransactionSuccessful();
1644            } finally {
1645                db.endTransaction();
1646                if (stmt != null) stmt.close();
1647            }
1648            upgradeVersion = 104;
1649        }
1650
1651        if (upgradeVersion < 105) {
1652            if (mUserHandle == UserHandle.USER_OWNER) {
1653                db.beginTransaction();
1654                SQLiteStatement stmt = null;
1655                try {
1656                    stmt = db.compileStatement("INSERT OR IGNORE INTO global(name,value)"
1657                            + " VALUES(?,?);");
1658                    loadBooleanSetting(stmt, Settings.Global.GUEST_USER_ENABLED,
1659                            R.bool.def_guest_user_enabled);
1660                    db.setTransactionSuccessful();
1661                } finally {
1662                    db.endTransaction();
1663                    if (stmt != null) stmt.close();
1664                }
1665            }
1666            upgradeVersion = 105;
1667        }
1668
1669        if (upgradeVersion < 106) {
1670            // LOCK_SCREEN_SHOW_NOTIFICATIONS is now per-user.
1671            db.beginTransaction();
1672            SQLiteStatement stmt = null;
1673            try {
1674                stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)"
1675                        + " VALUES(?,?);");
1676                loadIntegerSetting(stmt, Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS,
1677                        R.integer.def_lock_screen_show_notifications);
1678                if (mUserHandle == UserHandle.USER_OWNER) {
1679                    final int oldShow = getIntValueFromTable(db,
1680                            TABLE_GLOBAL, Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, -1);
1681                    if (oldShow >= 0) {
1682                        // overwrite the default with whatever you had
1683                        loadSetting(stmt, Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, oldShow);
1684                        final SQLiteStatement deleteStmt
1685                                = db.compileStatement("DELETE FROM global WHERE name=?");
1686                        deleteStmt.bindString(1, Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS);
1687                        deleteStmt.execute();
1688                    }
1689                }
1690                db.setTransactionSuccessful();
1691            } finally {
1692                db.endTransaction();
1693                if (stmt != null) stmt.close();
1694            }
1695            upgradeVersion = 106;
1696        }
1697
1698        if (upgradeVersion < 107) {
1699            // Add trusted sound setting
1700            if (mUserHandle == UserHandle.USER_OWNER) {
1701                db.beginTransaction();
1702                SQLiteStatement stmt = null;
1703                try {
1704                    stmt = db.compileStatement("INSERT OR REPLACE INTO global(name,value)"
1705                            + " VALUES(?,?);");
1706                    loadStringSetting(stmt, Settings.Global.TRUSTED_SOUND,
1707                            R.string.def_trusted_sound);
1708                    db.setTransactionSuccessful();
1709                } finally {
1710                    db.endTransaction();
1711                    if (stmt != null) stmt.close();
1712                }
1713            }
1714            upgradeVersion = 107;
1715        }
1716
1717        if (upgradeVersion < 108) {
1718            // Reset the auto-brightness setting to default since the behavior
1719            // of the feature is now quite different and is being presented to
1720            // the user in a new way as "adaptive brightness".
1721            db.beginTransaction();
1722            SQLiteStatement stmt = null;
1723            try {
1724                stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)"
1725                        + " VALUES(?,?);");
1726                loadBooleanSetting(stmt, Settings.System.SCREEN_BRIGHTNESS_MODE,
1727                        R.bool.def_screen_brightness_automatic_mode);
1728                db.setTransactionSuccessful();
1729            } finally {
1730                db.endTransaction();
1731                if (stmt != null) stmt.close();
1732            }
1733            upgradeVersion = 108;
1734        }
1735
1736        if (upgradeVersion < 109) {
1737            db.beginTransaction();
1738            SQLiteStatement stmt = null;
1739            try {
1740                stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)"
1741                        + " VALUES(?,?);");
1742                loadBooleanSetting(stmt, Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
1743                        R.bool.def_lock_screen_allow_private_notifications);
1744                db.setTransactionSuccessful();
1745            } finally {
1746                db.endTransaction();
1747                if (stmt != null) stmt.close();
1748            }
1749            upgradeVersion = 109;
1750        }
1751
1752        if (upgradeVersion < 110) {
1753            // The SIP_CALL_OPTIONS value SIP_ASK_EACH_TIME is being deprecated.
1754            // If the SIP_CALL_OPTIONS setting is set to SIP_ASK_EACH_TIME, default to
1755            // SIP_ADDRESS_ONLY.
1756            db.beginTransaction();
1757            SQLiteStatement stmt = null;
1758            try {
1759                stmt = db.compileStatement("UPDATE system SET value = ? " +
1760                        "WHERE name = ? AND value = ?;");
1761                stmt.bindString(1, Settings.System.SIP_ADDRESS_ONLY);
1762                stmt.bindString(2, Settings.System.SIP_CALL_OPTIONS);
1763                stmt.bindString(3, Settings.System.SIP_ASK_ME_EACH_TIME);
1764                stmt.execute();
1765                db.setTransactionSuccessful();
1766            } finally {
1767                db.endTransaction();
1768                if (stmt != null) stmt.close();
1769            }
1770            upgradeVersion = 110;
1771        }
1772
1773        if (upgradeVersion < 111) {
1774            // reset ringer mode, so it doesn't force zen mode to follow
1775            if (mUserHandle == UserHandle.USER_OWNER) {
1776                db.beginTransaction();
1777                SQLiteStatement stmt = null;
1778                try {
1779                    stmt = db.compileStatement("INSERT OR REPLACE INTO global(name,value)"
1780                            + " VALUES(?,?);");
1781                    loadSetting(stmt, Settings.Global.MODE_RINGER, AudioManager.RINGER_MODE_NORMAL);
1782                    db.setTransactionSuccessful();
1783                } finally {
1784                    db.endTransaction();
1785                    if (stmt != null) stmt.close();
1786                }
1787            }
1788            upgradeVersion = 111;
1789        }
1790
1791        if (upgradeVersion < 112) {
1792            if (mUserHandle == UserHandle.USER_OWNER) {
1793                // When device name was added, we went with Manufacturer + Model, device name should
1794                // actually be Model only.
1795                // Update device name to Model if it wasn't modified by user.
1796                db.beginTransaction();
1797                SQLiteStatement stmt = null;
1798                try {
1799                    stmt = db.compileStatement("UPDATE global SET value = ? "
1800                        + " WHERE name = ? AND value = ?");
1801                    stmt.bindString(1, getDefaultDeviceName()); // new default device name
1802                    stmt.bindString(2, Settings.Global.DEVICE_NAME);
1803                    stmt.bindString(3, getOldDefaultDeviceName()); // old default device name
1804                    stmt.execute();
1805                    db.setTransactionSuccessful();
1806                } finally {
1807                    db.endTransaction();
1808                    if (stmt != null) stmt.close();
1809                }
1810            }
1811            upgradeVersion = 112;
1812        }
1813
1814        // *** Remember to update DATABASE_VERSION above!
1815
1816        if (upgradeVersion != currentVersion) {
1817            Log.w(TAG, "Got stuck trying to upgrade from version " + upgradeVersion
1818                    + ", must wipe the settings provider");
1819            db.execSQL("DROP TABLE IF EXISTS global");
1820            db.execSQL("DROP TABLE IF EXISTS globalIndex1");
1821            db.execSQL("DROP TABLE IF EXISTS system");
1822            db.execSQL("DROP INDEX IF EXISTS systemIndex1");
1823            db.execSQL("DROP TABLE IF EXISTS secure");
1824            db.execSQL("DROP INDEX IF EXISTS secureIndex1");
1825            db.execSQL("DROP TABLE IF EXISTS gservices");
1826            db.execSQL("DROP INDEX IF EXISTS gservicesIndex1");
1827            db.execSQL("DROP TABLE IF EXISTS bluetooth_devices");
1828            db.execSQL("DROP TABLE IF EXISTS bookmarks");
1829            db.execSQL("DROP INDEX IF EXISTS bookmarksIndex1");
1830            db.execSQL("DROP INDEX IF EXISTS bookmarksIndex2");
1831            db.execSQL("DROP TABLE IF EXISTS favorites");
1832            onCreate(db);
1833
1834            // Added for diagnosing settings.db wipes after the fact
1835            String wipeReason = oldVersion + "/" + upgradeVersion + "/" + currentVersion;
1836            db.execSQL("INSERT INTO secure(name,value) values('" +
1837                    "wiped_db_reason" + "','" + wipeReason + "');");
1838        }
1839    }
1840
1841    private String[] hashsetToStringArray(HashSet<String> set) {
1842        String[] array = new String[set.size()];
1843        return set.toArray(array);
1844    }
1845
1846    private void moveSettingsToNewTable(SQLiteDatabase db,
1847            String sourceTable, String destTable,
1848            String[] settingsToMove, boolean doIgnore) {
1849        // Copy settings values from the source table to the dest, and remove from the source
1850        SQLiteStatement insertStmt = null;
1851        SQLiteStatement deleteStmt = null;
1852
1853        db.beginTransaction();
1854        try {
1855            insertStmt = db.compileStatement("INSERT "
1856                    + (doIgnore ? " OR IGNORE " : "")
1857                    + " INTO " + destTable + " (name,value) SELECT name,value FROM "
1858                    + sourceTable + " WHERE name=?");
1859            deleteStmt = db.compileStatement("DELETE FROM " + sourceTable + " WHERE name=?");
1860
1861            for (String setting : settingsToMove) {
1862                insertStmt.bindString(1, setting);
1863                insertStmt.execute();
1864
1865                deleteStmt.bindString(1, setting);
1866                deleteStmt.execute();
1867            }
1868            db.setTransactionSuccessful();
1869        } finally {
1870            db.endTransaction();
1871            if (insertStmt != null) {
1872                insertStmt.close();
1873            }
1874            if (deleteStmt != null) {
1875                deleteStmt.close();
1876            }
1877        }
1878    }
1879
1880    /**
1881     * Move any settings with the given prefixes from the source table to the
1882     * destination table.
1883     */
1884    private void movePrefixedSettingsToNewTable(
1885            SQLiteDatabase db, String sourceTable, String destTable, String[] prefixesToMove) {
1886        SQLiteStatement insertStmt = null;
1887        SQLiteStatement deleteStmt = null;
1888
1889        db.beginTransaction();
1890        try {
1891            insertStmt = db.compileStatement("INSERT INTO " + destTable
1892                    + " (name,value) SELECT name,value FROM " + sourceTable
1893                    + " WHERE substr(name,0,?)=?");
1894            deleteStmt = db.compileStatement(
1895                    "DELETE FROM " + sourceTable + " WHERE substr(name,0,?)=?");
1896
1897            for (String prefix : prefixesToMove) {
1898                insertStmt.bindLong(1, prefix.length() + 1);
1899                insertStmt.bindString(2, prefix);
1900                insertStmt.execute();
1901
1902                deleteStmt.bindLong(1, prefix.length() + 1);
1903                deleteStmt.bindString(2, prefix);
1904                deleteStmt.execute();
1905            }
1906            db.setTransactionSuccessful();
1907        } finally {
1908            db.endTransaction();
1909            if (insertStmt != null) {
1910                insertStmt.close();
1911            }
1912            if (deleteStmt != null) {
1913                deleteStmt.close();
1914            }
1915        }
1916    }
1917
1918    private void upgradeLockPatternLocation(SQLiteDatabase db) {
1919        Cursor c = db.query(TABLE_SYSTEM, new String[] {"_id", "value"}, "name='lock_pattern'",
1920                null, null, null, null);
1921        if (c.getCount() > 0) {
1922            c.moveToFirst();
1923            String lockPattern = c.getString(1);
1924            if (!TextUtils.isEmpty(lockPattern)) {
1925                // Convert lock pattern
1926                try {
1927                    LockPatternUtils lpu = new LockPatternUtils(mContext);
1928                    List<LockPatternView.Cell> cellPattern =
1929                            LockPatternUtils.stringToPattern(lockPattern);
1930                    lpu.saveLockPattern(cellPattern);
1931                } catch (IllegalArgumentException e) {
1932                    // Don't want corrupted lock pattern to hang the reboot process
1933                }
1934            }
1935            c.close();
1936            db.delete(TABLE_SYSTEM, "name='lock_pattern'", null);
1937        } else {
1938            c.close();
1939        }
1940    }
1941
1942    private void upgradeScreenTimeoutFromNever(SQLiteDatabase db) {
1943        // See if the timeout is -1 (for "Never").
1944        Cursor c = db.query(TABLE_SYSTEM, new String[] { "_id", "value" }, "name=? AND value=?",
1945                new String[] { Settings.System.SCREEN_OFF_TIMEOUT, "-1" },
1946                null, null, null);
1947
1948        SQLiteStatement stmt = null;
1949        if (c.getCount() > 0) {
1950            c.close();
1951            try {
1952                stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)"
1953                        + " VALUES(?,?);");
1954
1955                // Set the timeout to 30 minutes in milliseconds
1956                loadSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT,
1957                        Integer.toString(30 * 60 * 1000));
1958            } finally {
1959                if (stmt != null) stmt.close();
1960            }
1961        } else {
1962            c.close();
1963        }
1964    }
1965
1966    private void upgradeVibrateSettingFromNone(SQLiteDatabase db) {
1967        int vibrateSetting = getIntValueFromSystem(db, Settings.System.VIBRATE_ON, 0);
1968        // If the ringer vibrate value is invalid, set it to the default
1969        if ((vibrateSetting & 3) == AudioManager.VIBRATE_SETTING_OFF) {
1970            vibrateSetting = AudioService.getValueForVibrateSetting(0,
1971                    AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_ONLY_SILENT);
1972        }
1973        // Apply the same setting to the notification vibrate value
1974        vibrateSetting = AudioService.getValueForVibrateSetting(vibrateSetting,
1975                AudioManager.VIBRATE_TYPE_NOTIFICATION, vibrateSetting);
1976
1977        SQLiteStatement stmt = null;
1978        try {
1979            stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)"
1980                    + " VALUES(?,?);");
1981            loadSetting(stmt, Settings.System.VIBRATE_ON, vibrateSetting);
1982        } finally {
1983            if (stmt != null)
1984                stmt.close();
1985        }
1986    }
1987
1988    private void upgradeScreenTimeout(SQLiteDatabase db) {
1989        // Change screen timeout to current default
1990        db.beginTransaction();
1991        SQLiteStatement stmt = null;
1992        try {
1993            stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)"
1994                    + " VALUES(?,?);");
1995            loadIntegerSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT,
1996                    R.integer.def_screen_off_timeout);
1997            db.setTransactionSuccessful();
1998        } finally {
1999            db.endTransaction();
2000            if (stmt != null)
2001                stmt.close();
2002        }
2003    }
2004
2005    private void upgradeAutoBrightness(SQLiteDatabase db) {
2006        db.beginTransaction();
2007        try {
2008            String value =
2009                    mContext.getResources().getBoolean(
2010                    R.bool.def_screen_brightness_automatic_mode) ? "1" : "0";
2011            db.execSQL("INSERT OR REPLACE INTO system(name,value) values('" +
2012                    Settings.System.SCREEN_BRIGHTNESS_MODE + "','" + value + "');");
2013            db.setTransactionSuccessful();
2014        } finally {
2015            db.endTransaction();
2016        }
2017    }
2018
2019    /**
2020     * Loads the default set of bookmarked shortcuts from an xml file.
2021     *
2022     * @param db The database to write the values into
2023     */
2024    private void loadBookmarks(SQLiteDatabase db) {
2025        ContentValues values = new ContentValues();
2026
2027        PackageManager packageManager = mContext.getPackageManager();
2028        try {
2029            XmlResourceParser parser = mContext.getResources().getXml(R.xml.bookmarks);
2030            XmlUtils.beginDocument(parser, "bookmarks");
2031
2032            final int depth = parser.getDepth();
2033            int type;
2034
2035            while (((type = parser.next()) != XmlPullParser.END_TAG ||
2036                    parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
2037
2038                if (type != XmlPullParser.START_TAG) {
2039                    continue;
2040                }
2041
2042                String name = parser.getName();
2043                if (!"bookmark".equals(name)) {
2044                    break;
2045                }
2046
2047                String pkg = parser.getAttributeValue(null, "package");
2048                String cls = parser.getAttributeValue(null, "class");
2049                String shortcutStr = parser.getAttributeValue(null, "shortcut");
2050                String category = parser.getAttributeValue(null, "category");
2051
2052                int shortcutValue = shortcutStr.charAt(0);
2053                if (TextUtils.isEmpty(shortcutStr)) {
2054                    Log.w(TAG, "Unable to get shortcut for: " + pkg + "/" + cls);
2055                    continue;
2056                }
2057
2058                final Intent intent;
2059                final String title;
2060                if (pkg != null && cls != null) {
2061                    ActivityInfo info = null;
2062                    ComponentName cn = new ComponentName(pkg, cls);
2063                    try {
2064                        info = packageManager.getActivityInfo(cn, 0);
2065                    } catch (PackageManager.NameNotFoundException e) {
2066                        String[] packages = packageManager.canonicalToCurrentPackageNames(
2067                                new String[] { pkg });
2068                        cn = new ComponentName(packages[0], cls);
2069                        try {
2070                            info = packageManager.getActivityInfo(cn, 0);
2071                        } catch (PackageManager.NameNotFoundException e1) {
2072                            Log.w(TAG, "Unable to add bookmark: " + pkg + "/" + cls, e);
2073                            continue;
2074                        }
2075                    }
2076
2077                    intent = new Intent(Intent.ACTION_MAIN, null);
2078                    intent.addCategory(Intent.CATEGORY_LAUNCHER);
2079                    intent.setComponent(cn);
2080                    title = info.loadLabel(packageManager).toString();
2081                } else if (category != null) {
2082                    intent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN, category);
2083                    title = "";
2084                } else {
2085                    Log.w(TAG, "Unable to add bookmark for shortcut " + shortcutStr
2086                            + ": missing package/class or category attributes");
2087                    continue;
2088                }
2089
2090                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2091                values.put(Settings.Bookmarks.INTENT, intent.toUri(0));
2092                values.put(Settings.Bookmarks.TITLE, title);
2093                values.put(Settings.Bookmarks.SHORTCUT, shortcutValue);
2094                db.delete("bookmarks", "shortcut = ?",
2095                        new String[] { Integer.toString(shortcutValue) });
2096                db.insert("bookmarks", null, values);
2097            }
2098        } catch (XmlPullParserException e) {
2099            Log.w(TAG, "Got execption parsing bookmarks.", e);
2100        } catch (IOException e) {
2101            Log.w(TAG, "Got execption parsing bookmarks.", e);
2102        }
2103    }
2104
2105    /**
2106     * Loads the default volume levels. It is actually inserting the index of
2107     * the volume array for each of the volume controls.
2108     *
2109     * @param db the database to insert the volume levels into
2110     */
2111    private void loadVolumeLevels(SQLiteDatabase db) {
2112        SQLiteStatement stmt = null;
2113        try {
2114            stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
2115                    + " VALUES(?,?);");
2116
2117            loadSetting(stmt, Settings.System.VOLUME_MUSIC,
2118                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_MUSIC]);
2119            loadSetting(stmt, Settings.System.VOLUME_RING,
2120                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_RING]);
2121            loadSetting(stmt, Settings.System.VOLUME_SYSTEM,
2122                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_SYSTEM]);
2123            loadSetting(
2124                    stmt,
2125                    Settings.System.VOLUME_VOICE,
2126                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_VOICE_CALL]);
2127            loadSetting(stmt, Settings.System.VOLUME_ALARM,
2128                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_ALARM]);
2129            loadSetting(
2130                    stmt,
2131                    Settings.System.VOLUME_NOTIFICATION,
2132                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_NOTIFICATION]);
2133            loadSetting(
2134                    stmt,
2135                    Settings.System.VOLUME_BLUETOOTH_SCO,
2136                    AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_BLUETOOTH_SCO]);
2137
2138            // By default:
2139            // - ringtones, notification, system and music streams are affected by ringer mode
2140            // on non voice capable devices (tablets)
2141            // - ringtones, notification and system streams are affected by ringer mode
2142            // on voice capable devices (phones)
2143            int ringerModeAffectedStreams = (1 << AudioManager.STREAM_RING) |
2144                                            (1 << AudioManager.STREAM_NOTIFICATION) |
2145                                            (1 << AudioManager.STREAM_SYSTEM) |
2146                                            (1 << AudioManager.STREAM_SYSTEM_ENFORCED);
2147            if (!mContext.getResources().getBoolean(
2148                    com.android.internal.R.bool.config_voice_capable)) {
2149                ringerModeAffectedStreams |= (1 << AudioManager.STREAM_MUSIC);
2150            }
2151            loadSetting(stmt, Settings.System.MODE_RINGER_STREAMS_AFFECTED,
2152                    ringerModeAffectedStreams);
2153
2154            loadSetting(stmt, Settings.System.MUTE_STREAMS_AFFECTED,
2155                    ((1 << AudioManager.STREAM_MUSIC) |
2156                     (1 << AudioManager.STREAM_RING) |
2157                     (1 << AudioManager.STREAM_NOTIFICATION) |
2158                     (1 << AudioManager.STREAM_SYSTEM)));
2159        } finally {
2160            if (stmt != null) stmt.close();
2161        }
2162
2163        loadVibrateWhenRingingSetting(db);
2164    }
2165
2166    private void loadVibrateSetting(SQLiteDatabase db, boolean deleteOld) {
2167        if (deleteOld) {
2168            db.execSQL("DELETE FROM system WHERE name='" + Settings.System.VIBRATE_ON + "'");
2169        }
2170
2171        SQLiteStatement stmt = null;
2172        try {
2173            stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
2174                    + " VALUES(?,?);");
2175
2176            // Vibrate on by default for ringer, on for notification
2177            int vibrate = 0;
2178            vibrate = AudioService.getValueForVibrateSetting(vibrate,
2179                    AudioManager.VIBRATE_TYPE_NOTIFICATION,
2180                    AudioManager.VIBRATE_SETTING_ONLY_SILENT);
2181            vibrate |= AudioService.getValueForVibrateSetting(vibrate,
2182                    AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_ONLY_SILENT);
2183            loadSetting(stmt, Settings.System.VIBRATE_ON, vibrate);
2184        } finally {
2185            if (stmt != null) stmt.close();
2186        }
2187    }
2188
2189    private void loadVibrateWhenRingingSetting(SQLiteDatabase db) {
2190        // The default should be off. VIBRATE_SETTING_ONLY_SILENT should also be ignored here.
2191        // Phone app should separately check whether AudioManager#getRingerMode() returns
2192        // RINGER_MODE_VIBRATE, with which the device should vibrate anyway.
2193        int vibrateSetting = getIntValueFromSystem(db, Settings.System.VIBRATE_ON,
2194                AudioManager.VIBRATE_SETTING_OFF);
2195        boolean vibrateWhenRinging = ((vibrateSetting & 3) == AudioManager.VIBRATE_SETTING_ON);
2196
2197        SQLiteStatement stmt = null;
2198        try {
2199            stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
2200                    + " VALUES(?,?);");
2201            loadSetting(stmt, Settings.System.VIBRATE_WHEN_RINGING, vibrateWhenRinging ? 1 : 0);
2202        } finally {
2203            if (stmt != null) stmt.close();
2204        }
2205    }
2206
2207    private void loadSettings(SQLiteDatabase db) {
2208        loadSystemSettings(db);
2209        loadSecureSettings(db);
2210        // The global table only exists for the 'owner' user
2211        if (mUserHandle == UserHandle.USER_OWNER) {
2212            loadGlobalSettings(db);
2213        }
2214    }
2215
2216    private void loadSystemSettings(SQLiteDatabase db) {
2217        SQLiteStatement stmt = null;
2218        try {
2219            stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)"
2220                    + " VALUES(?,?);");
2221
2222            loadBooleanSetting(stmt, Settings.System.DIM_SCREEN,
2223                    R.bool.def_dim_screen);
2224            loadIntegerSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT,
2225                    R.integer.def_screen_off_timeout);
2226
2227            // Set default cdma DTMF type
2228            loadSetting(stmt, Settings.System.DTMF_TONE_TYPE_WHEN_DIALING, 0);
2229
2230            // Set default hearing aid
2231            loadSetting(stmt, Settings.System.HEARING_AID, 0);
2232
2233            // Set default tty mode
2234            loadSetting(stmt, Settings.System.TTY_MODE, 0);
2235
2236            loadIntegerSetting(stmt, Settings.System.SCREEN_BRIGHTNESS,
2237                    R.integer.def_screen_brightness);
2238
2239            loadBooleanSetting(stmt, Settings.System.SCREEN_BRIGHTNESS_MODE,
2240                    R.bool.def_screen_brightness_automatic_mode);
2241
2242            loadDefaultAnimationSettings(stmt);
2243
2244            loadBooleanSetting(stmt, Settings.System.ACCELEROMETER_ROTATION,
2245                    R.bool.def_accelerometer_rotation);
2246
2247            loadDefaultHapticSettings(stmt);
2248
2249            loadBooleanSetting(stmt, Settings.System.NOTIFICATION_LIGHT_PULSE,
2250                    R.bool.def_notification_pulse);
2251
2252            loadUISoundEffectsSettings(stmt);
2253
2254            loadIntegerSetting(stmt, Settings.System.POINTER_SPEED,
2255                    R.integer.def_pointer_speed);
2256        } finally {
2257            if (stmt != null) stmt.close();
2258        }
2259    }
2260
2261    private void loadUISoundEffectsSettings(SQLiteStatement stmt) {
2262        loadBooleanSetting(stmt, Settings.System.DTMF_TONE_WHEN_DIALING,
2263                R.bool.def_dtmf_tones_enabled);
2264        loadBooleanSetting(stmt, Settings.System.SOUND_EFFECTS_ENABLED,
2265                R.bool.def_sound_effects_enabled);
2266        loadBooleanSetting(stmt, Settings.System.HAPTIC_FEEDBACK_ENABLED,
2267                R.bool.def_haptic_feedback);
2268
2269        loadIntegerSetting(stmt, Settings.System.LOCKSCREEN_SOUNDS_ENABLED,
2270            R.integer.def_lockscreen_sounds_enabled);
2271    }
2272
2273    private void loadDefaultAnimationSettings(SQLiteStatement stmt) {
2274        loadFractionSetting(stmt, Settings.System.WINDOW_ANIMATION_SCALE,
2275                R.fraction.def_window_animation_scale, 1);
2276        loadFractionSetting(stmt, Settings.System.TRANSITION_ANIMATION_SCALE,
2277                R.fraction.def_window_transition_scale, 1);
2278    }
2279
2280    private void loadDefaultHapticSettings(SQLiteStatement stmt) {
2281        loadBooleanSetting(stmt, Settings.System.HAPTIC_FEEDBACK_ENABLED,
2282                R.bool.def_haptic_feedback);
2283    }
2284
2285    private void loadSecureSettings(SQLiteDatabase db) {
2286        SQLiteStatement stmt = null;
2287        try {
2288            stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)"
2289                    + " VALUES(?,?);");
2290
2291            loadStringSetting(stmt, Settings.Secure.LOCATION_PROVIDERS_ALLOWED,
2292                    R.string.def_location_providers_allowed);
2293
2294            String wifiWatchList = SystemProperties.get("ro.com.android.wifi-watchlist");
2295            if (!TextUtils.isEmpty(wifiWatchList)) {
2296                loadSetting(stmt, Settings.Secure.WIFI_WATCHDOG_WATCH_LIST, wifiWatchList);
2297            }
2298
2299            // Don't do this.  The SystemServer will initialize ADB_ENABLED from a
2300            // persistent system property instead.
2301            //loadSetting(stmt, Settings.Secure.ADB_ENABLED, 0);
2302
2303            // Allow mock locations default, based on build
2304            loadSetting(stmt, Settings.Secure.ALLOW_MOCK_LOCATION,
2305                    "1".equals(SystemProperties.get("ro.allow.mock.location")) ? 1 : 0);
2306
2307            loadSecure35Settings(stmt);
2308
2309            loadBooleanSetting(stmt, Settings.Secure.MOUNT_PLAY_NOTIFICATION_SND,
2310                    R.bool.def_mount_play_notification_snd);
2311
2312            loadBooleanSetting(stmt, Settings.Secure.MOUNT_UMS_AUTOSTART,
2313                    R.bool.def_mount_ums_autostart);
2314
2315            loadBooleanSetting(stmt, Settings.Secure.MOUNT_UMS_PROMPT,
2316                    R.bool.def_mount_ums_prompt);
2317
2318            loadBooleanSetting(stmt, Settings.Secure.MOUNT_UMS_NOTIFY_ENABLED,
2319                    R.bool.def_mount_ums_notify_enabled);
2320
2321            loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SCRIPT_INJECTION,
2322                    R.bool.def_accessibility_script_injection);
2323
2324            loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS,
2325                    R.string.def_accessibility_web_content_key_bindings);
2326
2327            loadIntegerSetting(stmt, Settings.Secure.LONG_PRESS_TIMEOUT,
2328                    R.integer.def_long_press_timeout_millis);
2329
2330            loadBooleanSetting(stmt, Settings.Secure.TOUCH_EXPLORATION_ENABLED,
2331                    R.bool.def_touch_exploration_enabled);
2332
2333            loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD,
2334                    R.bool.def_accessibility_speak_password);
2335
2336            loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL,
2337                    R.string.def_accessibility_screen_reader_url);
2338
2339            if (SystemProperties.getBoolean("ro.lockscreen.disable.default", false) == true) {
2340                loadSetting(stmt, Settings.System.LOCKSCREEN_DISABLED, "1");
2341            } else {
2342                loadBooleanSetting(stmt, Settings.System.LOCKSCREEN_DISABLED,
2343                        R.bool.def_lockscreen_disabled);
2344            }
2345
2346            loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ENABLED,
2347                    com.android.internal.R.bool.config_dreamsEnabledByDefault);
2348            loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK,
2349                    com.android.internal.R.bool.config_dreamsActivatedOnDockByDefault);
2350            loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP,
2351                    com.android.internal.R.bool.config_dreamsActivatedOnSleepByDefault);
2352            loadStringSetting(stmt, Settings.Secure.SCREENSAVER_COMPONENTS,
2353                    com.android.internal.R.string.config_dreamsDefaultComponent);
2354            loadStringSetting(stmt, Settings.Secure.SCREENSAVER_DEFAULT_COMPONENT,
2355                    com.android.internal.R.string.config_dreamsDefaultComponent);
2356
2357            loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
2358                    R.bool.def_accessibility_display_magnification_enabled);
2359
2360            loadFractionSetting(stmt, Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE,
2361                    R.fraction.def_accessibility_display_magnification_scale, 1);
2362
2363            loadBooleanSetting(stmt,
2364                    Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE,
2365                    R.bool.def_accessibility_display_magnification_auto_update);
2366
2367            loadBooleanSetting(stmt, Settings.Secure.USER_SETUP_COMPLETE,
2368                    R.bool.def_user_setup_complete);
2369
2370            loadStringSetting(stmt, Settings.Secure.IMMERSIVE_MODE_CONFIRMATIONS,
2371                        R.string.def_immersive_mode_confirmations);
2372
2373            loadBooleanSetting(stmt, Settings.Secure.INSTALL_NON_MARKET_APPS,
2374                    R.bool.def_install_non_market_apps);
2375
2376            loadBooleanSetting(stmt, Settings.Secure.WAKE_GESTURE_ENABLED,
2377                    R.bool.def_wake_gesture_enabled);
2378
2379            loadIntegerSetting(stmt, Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS,
2380                    R.integer.def_lock_screen_show_notifications);
2381
2382            loadBooleanSetting(stmt, Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
2383                    R.bool.def_lock_screen_allow_private_notifications);
2384
2385        } finally {
2386            if (stmt != null) stmt.close();
2387        }
2388    }
2389
2390    private void loadSecure35Settings(SQLiteStatement stmt) {
2391        loadBooleanSetting(stmt, Settings.Secure.BACKUP_ENABLED,
2392                R.bool.def_backup_enabled);
2393
2394        loadStringSetting(stmt, Settings.Secure.BACKUP_TRANSPORT,
2395                R.string.def_backup_transport);
2396    }
2397
2398    private void loadGlobalSettings(SQLiteDatabase db) {
2399        SQLiteStatement stmt = null;
2400        try {
2401            stmt = db.compileStatement("INSERT OR IGNORE INTO global(name,value)"
2402                    + " VALUES(?,?);");
2403
2404            // --- Previously in 'system'
2405            loadBooleanSetting(stmt, Settings.Global.AIRPLANE_MODE_ON,
2406                    R.bool.def_airplane_mode_on);
2407
2408            loadStringSetting(stmt, Settings.Global.AIRPLANE_MODE_RADIOS,
2409                    R.string.def_airplane_mode_radios);
2410
2411            loadStringSetting(stmt, Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS,
2412                    R.string.airplane_mode_toggleable_radios);
2413
2414            loadBooleanSetting(stmt, Settings.Global.ASSISTED_GPS_ENABLED,
2415                    R.bool.assisted_gps_enabled);
2416
2417            loadBooleanSetting(stmt, Settings.Global.AUTO_TIME,
2418                    R.bool.def_auto_time); // Sync time to NITZ
2419
2420            loadBooleanSetting(stmt, Settings.Global.AUTO_TIME_ZONE,
2421                    R.bool.def_auto_time_zone); // Sync timezone to NITZ
2422
2423            loadSetting(stmt, Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
2424                    ("1".equals(SystemProperties.get("ro.kernel.qemu")) ||
2425                        mContext.getResources().getBoolean(R.bool.def_stay_on_while_plugged_in))
2426                     ? 1 : 0);
2427
2428            loadIntegerSetting(stmt, Settings.Global.WIFI_SLEEP_POLICY,
2429                    R.integer.def_wifi_sleep_policy);
2430
2431            loadSetting(stmt, Settings.Global.MODE_RINGER,
2432                    AudioManager.RINGER_MODE_NORMAL);
2433
2434            // --- Previously in 'secure'
2435            loadBooleanSetting(stmt, Settings.Global.PACKAGE_VERIFIER_ENABLE,
2436                    R.bool.def_package_verifier_enable);
2437
2438            loadBooleanSetting(stmt, Settings.Global.WIFI_ON,
2439                    R.bool.def_wifi_on);
2440
2441            loadBooleanSetting(stmt, Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
2442                    R.bool.def_networks_available_notification_on);
2443
2444            loadBooleanSetting(stmt, Settings.Global.BLUETOOTH_ON,
2445                    R.bool.def_bluetooth_on);
2446
2447            // Enable or disable Cell Broadcast SMS
2448            loadSetting(stmt, Settings.Global.CDMA_CELL_BROADCAST_SMS,
2449                    RILConstants.CDMA_CELL_BROADCAST_SMS_DISABLED);
2450
2451            // Data roaming default, based on build
2452            loadSetting(stmt, Settings.Global.DATA_ROAMING,
2453                    "true".equalsIgnoreCase(
2454                            SystemProperties.get("ro.com.android.dataroaming",
2455                                    "false")) ? 1 : 0);
2456
2457            loadBooleanSetting(stmt, Settings.Global.DEVICE_PROVISIONED,
2458                    R.bool.def_device_provisioned);
2459
2460            final int maxBytes = mContext.getResources().getInteger(
2461                    R.integer.def_download_manager_max_bytes_over_mobile);
2462            if (maxBytes > 0) {
2463                loadSetting(stmt, Settings.Global.DOWNLOAD_MAX_BYTES_OVER_MOBILE,
2464                        Integer.toString(maxBytes));
2465            }
2466
2467            final int recommendedMaxBytes = mContext.getResources().getInteger(
2468                    R.integer.def_download_manager_recommended_max_bytes_over_mobile);
2469            if (recommendedMaxBytes > 0) {
2470                loadSetting(stmt, Settings.Global.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE,
2471                        Integer.toString(recommendedMaxBytes));
2472            }
2473
2474            // Mobile Data default, based on build
2475            loadSetting(stmt, Settings.Global.MOBILE_DATA,
2476                    "true".equalsIgnoreCase(
2477                            SystemProperties.get("ro.com.android.mobiledata",
2478                                    "true")) ? 1 : 0);
2479
2480            loadBooleanSetting(stmt, Settings.Global.NETSTATS_ENABLED,
2481                    R.bool.def_netstats_enabled);
2482
2483            loadBooleanSetting(stmt, Settings.Global.USB_MASS_STORAGE_ENABLED,
2484                    R.bool.def_usb_mass_storage_enabled);
2485
2486            loadIntegerSetting(stmt, Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT,
2487                    R.integer.def_max_dhcp_retries);
2488
2489            loadBooleanSetting(stmt, Settings.Global.WIFI_DISPLAY_ON,
2490                    R.bool.def_wifi_display_on);
2491
2492            loadStringSetting(stmt, Settings.Global.LOCK_SOUND,
2493                    R.string.def_lock_sound);
2494            loadStringSetting(stmt, Settings.Global.UNLOCK_SOUND,
2495                    R.string.def_unlock_sound);
2496            loadStringSetting(stmt, Settings.Global.TRUSTED_SOUND,
2497                    R.string.def_trusted_sound);
2498            loadIntegerSetting(stmt, Settings.Global.POWER_SOUNDS_ENABLED,
2499                    R.integer.def_power_sounds_enabled);
2500            loadStringSetting(stmt, Settings.Global.LOW_BATTERY_SOUND,
2501                    R.string.def_low_battery_sound);
2502            loadIntegerSetting(stmt, Settings.Global.DOCK_SOUNDS_ENABLED,
2503                    R.integer.def_dock_sounds_enabled);
2504            loadStringSetting(stmt, Settings.Global.DESK_DOCK_SOUND,
2505                    R.string.def_desk_dock_sound);
2506            loadStringSetting(stmt, Settings.Global.DESK_UNDOCK_SOUND,
2507                    R.string.def_desk_undock_sound);
2508            loadStringSetting(stmt, Settings.Global.CAR_DOCK_SOUND,
2509                    R.string.def_car_dock_sound);
2510            loadStringSetting(stmt, Settings.Global.CAR_UNDOCK_SOUND,
2511                    R.string.def_car_undock_sound);
2512            loadStringSetting(stmt, Settings.Global.WIRELESS_CHARGING_STARTED_SOUND,
2513                    R.string.def_wireless_charging_started_sound);
2514
2515            loadIntegerSetting(stmt, Settings.Global.DOCK_AUDIO_MEDIA_ENABLED,
2516                    R.integer.def_dock_audio_media_enabled);
2517
2518            loadSetting(stmt, Settings.Global.SET_INSTALL_LOCATION, 0);
2519            loadSetting(stmt, Settings.Global.DEFAULT_INSTALL_LOCATION,
2520                    PackageHelper.APP_INSTALL_AUTO);
2521
2522            // Set default cdma emergency tone
2523            loadSetting(stmt, Settings.Global.EMERGENCY_TONE, 0);
2524
2525            // Set default cdma call auto retry
2526            loadSetting(stmt, Settings.Global.CALL_AUTO_RETRY, 0);
2527
2528            // Set the preferred network mode to target desired value or Default
2529            // value defined in RILConstants
2530            int type;
2531            type = SystemProperties.getInt("ro.telephony.default_network",
2532                        RILConstants.PREFERRED_NETWORK_MODE);
2533            loadSetting(stmt, Settings.Global.PREFERRED_NETWORK_MODE, type);
2534
2535            // Set the preferred cdma subscription source to target desired value or default
2536            // value defined in CdmaSubscriptionSourceManager
2537            type = SystemProperties.getInt("ro.telephony.default_cdma_sub",
2538                        CdmaSubscriptionSourceManager.PREFERRED_CDMA_SUBSCRIPTION);
2539            loadSetting(stmt, Settings.Global.CDMA_SUBSCRIPTION_MODE, type);
2540
2541            loadIntegerSetting(stmt, Settings.Global.LOW_BATTERY_SOUND_TIMEOUT,
2542                    R.integer.def_low_battery_sound_timeout);
2543
2544            loadIntegerSetting(stmt, Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE,
2545                    R.integer.def_wifi_scan_always_available);
2546
2547            loadIntegerSetting(stmt, Global.HEADS_UP_NOTIFICATIONS_ENABLED,
2548                    R.integer.def_heads_up_enabled);
2549
2550            loadSetting(stmt, Settings.Global.DEVICE_NAME, getDefaultDeviceName());
2551
2552            loadBooleanSetting(stmt, Settings.Global.GUEST_USER_ENABLED,
2553                    R.bool.def_guest_user_enabled);
2554            // --- New global settings start here
2555        } finally {
2556            if (stmt != null) stmt.close();
2557        }
2558    }
2559
2560    private void loadSetting(SQLiteStatement stmt, String key, Object value) {
2561        stmt.bindString(1, key);
2562        stmt.bindString(2, value.toString());
2563        stmt.execute();
2564    }
2565
2566    private void loadStringSetting(SQLiteStatement stmt, String key, int resid) {
2567        loadSetting(stmt, key, mContext.getResources().getString(resid));
2568    }
2569
2570    private void loadBooleanSetting(SQLiteStatement stmt, String key, int resid) {
2571        loadSetting(stmt, key,
2572                mContext.getResources().getBoolean(resid) ? "1" : "0");
2573    }
2574
2575    private void loadIntegerSetting(SQLiteStatement stmt, String key, int resid) {
2576        loadSetting(stmt, key,
2577                Integer.toString(mContext.getResources().getInteger(resid)));
2578    }
2579
2580    private void loadFractionSetting(SQLiteStatement stmt, String key, int resid, int base) {
2581        loadSetting(stmt, key,
2582                Float.toString(mContext.getResources().getFraction(resid, base, base)));
2583    }
2584
2585    private int getIntValueFromSystem(SQLiteDatabase db, String name, int defaultValue) {
2586        return getIntValueFromTable(db, TABLE_SYSTEM, name, defaultValue);
2587    }
2588
2589    private int getIntValueFromTable(SQLiteDatabase db, String table, String name,
2590            int defaultValue) {
2591        String value = getStringValueFromTable(db, table, name, null);
2592        return (value != null) ? Integer.parseInt(value) : defaultValue;
2593    }
2594
2595    private String getStringValueFromTable(SQLiteDatabase db, String table, String name,
2596            String defaultValue) {
2597        Cursor c = null;
2598        try {
2599            c = db.query(table, new String[] { Settings.System.VALUE }, "name='" + name + "'",
2600                    null, null, null, null);
2601            if (c != null && c.moveToFirst()) {
2602                String val = c.getString(0);
2603                return val == null ? defaultValue : val;
2604            }
2605        } finally {
2606            if (c != null) c.close();
2607        }
2608        return defaultValue;
2609    }
2610
2611    private String getOldDefaultDeviceName() {
2612        return mContext.getResources().getString(R.string.def_device_name_old,
2613                Build.MANUFACTURER, Build.MODEL);
2614    }
2615
2616    private String getDefaultDeviceName() {
2617        return mContext.getResources().getString(R.string.def_device_name, Build.MODEL);
2618    }
2619}
2620