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