DatabaseHelper.java revision 9219874be99cc07660807cc5dc94b0d157ef8808
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.PackageManager; 25import android.content.res.XmlResourceParser; 26import android.database.Cursor; 27import android.database.sqlite.SQLiteDatabase; 28import android.database.sqlite.SQLiteOpenHelper; 29import android.database.sqlite.SQLiteStatement; 30import android.media.AudioManager; 31import android.media.AudioService; 32import android.net.ConnectivityManager; 33import android.os.Environment; 34import android.os.SystemProperties; 35import android.os.UserHandle; 36import android.provider.Settings; 37import android.provider.Settings.Secure; 38import android.telephony.TelephonyManager; 39import android.text.TextUtils; 40import android.util.Log; 41 42import com.android.internal.content.PackageHelper; 43import com.android.internal.telephony.Phone; 44import com.android.internal.telephony.PhoneConstants; 45import com.android.internal.telephony.RILConstants; 46import com.android.internal.util.XmlUtils; 47import com.android.internal.widget.LockPatternUtils; 48import com.android.internal.widget.LockPatternView; 49 50import org.xmlpull.v1.XmlPullParser; 51import org.xmlpull.v1.XmlPullParserException; 52 53import java.io.File; 54import java.io.IOException; 55import java.util.HashSet; 56import java.util.List; 57 58/** 59 * Database helper class for {@link SettingsProvider}. 60 * Mostly just has a bit {@link #onCreate} to initialize the database. 61 */ 62public class DatabaseHelper extends SQLiteOpenHelper { 63 private static final String TAG = "SettingsProvider"; 64 private static final String DATABASE_NAME = "settings.db"; 65 66 // Please, please please. If you update the database version, check to make sure the 67 // database gets upgraded properly. At a minimum, please confirm that 'upgradeVersion' 68 // is properly propagated through your change. Not doing so will result in a loss of user 69 // settings. 70 private static final int DATABASE_VERSION = 86; 71 72 private Context mContext; 73 private int mUserHandle; 74 75 private static final HashSet<String> mValidTables = new HashSet<String>(); 76 77 private static final String TABLE_SYSTEM = "system"; 78 private static final String TABLE_SECURE = "secure"; 79 private static final String TABLE_GLOBAL = "global"; 80 81 static { 82 mValidTables.add(TABLE_SYSTEM); 83 mValidTables.add(TABLE_SECURE); 84 mValidTables.add(TABLE_GLOBAL); 85 mValidTables.add("bluetooth_devices"); 86 mValidTables.add("bookmarks"); 87 88 // These are old. 89 mValidTables.add("favorites"); 90 mValidTables.add("gservices"); 91 mValidTables.add("old_favorites"); 92 } 93 94 static String dbNameForUser(final int userHandle) { 95 // The owner gets the unadorned db name; 96 if (userHandle == UserHandle.USER_OWNER) { 97 return DATABASE_NAME; 98 } else { 99 // Place the database in the user-specific data tree so that it's 100 // cleaned up automatically when the user is deleted. 101 File databaseFile = new File( 102 Environment.getUserSystemDirectory(userHandle), DATABASE_NAME); 103 return databaseFile.getPath(); 104 } 105 } 106 107 public DatabaseHelper(Context context, int userHandle) { 108 super(context, dbNameForUser(userHandle), null, DATABASE_VERSION); 109 mContext = context; 110 mUserHandle = userHandle; 111 setWriteAheadLoggingEnabled(true); 112 } 113 114 public static boolean isValidTable(String name) { 115 return mValidTables.contains(name); 116 } 117 118 private void createSecureTable(SQLiteDatabase db) { 119 db.execSQL("CREATE TABLE secure (" + 120 "_id INTEGER PRIMARY KEY AUTOINCREMENT," + 121 "name TEXT UNIQUE ON CONFLICT REPLACE," + 122 "value TEXT" + 123 ");"); 124 db.execSQL("CREATE INDEX secureIndex1 ON secure (name);"); 125 } 126 127 private void createGlobalTable(SQLiteDatabase db) { 128 db.execSQL("CREATE TABLE global (" + 129 "_id INTEGER PRIMARY KEY AUTOINCREMENT," + 130 "name TEXT UNIQUE ON CONFLICT REPLACE," + 131 "value TEXT" + 132 ");"); 133 db.execSQL("CREATE INDEX globalIndex1 ON global (name);"); 134 } 135 136 @Override 137 public void onCreate(SQLiteDatabase db) { 138 db.execSQL("CREATE TABLE system (" + 139 "_id INTEGER PRIMARY KEY AUTOINCREMENT," + 140 "name TEXT UNIQUE ON CONFLICT REPLACE," + 141 "value TEXT" + 142 ");"); 143 db.execSQL("CREATE INDEX systemIndex1 ON system (name);"); 144 145 createSecureTable(db); 146 147 // Only create the global table for the singleton 'owner' user 148 if (mUserHandle == UserHandle.USER_OWNER) { 149 createGlobalTable(db); 150 } 151 152 db.execSQL("CREATE TABLE bluetooth_devices (" + 153 "_id INTEGER PRIMARY KEY," + 154 "name TEXT," + 155 "addr TEXT," + 156 "channel INTEGER," + 157 "type INTEGER" + 158 ");"); 159 160 db.execSQL("CREATE TABLE bookmarks (" + 161 "_id INTEGER PRIMARY KEY," + 162 "title TEXT," + 163 "folder TEXT," + 164 "intent TEXT," + 165 "shortcut INTEGER," + 166 "ordering INTEGER" + 167 ");"); 168 169 db.execSQL("CREATE INDEX bookmarksIndex1 ON bookmarks (folder);"); 170 db.execSQL("CREATE INDEX bookmarksIndex2 ON bookmarks (shortcut);"); 171 172 // Populate bookmarks table with initial bookmarks 173 loadBookmarks(db); 174 175 // Load initial volume levels into DB 176 loadVolumeLevels(db); 177 178 // Load inital settings values 179 loadSettings(db); 180 } 181 182 @Override 183 public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) { 184 Log.w(TAG, "Upgrading settings database from version " + oldVersion + " to " 185 + currentVersion); 186 187 int upgradeVersion = oldVersion; 188 189 // Pattern for upgrade blocks: 190 // 191 // if (upgradeVersion == [the DATABASE_VERSION you set] - 1) { 192 // .. your upgrade logic.. 193 // upgradeVersion = [the DATABASE_VERSION you set] 194 // } 195 196 if (upgradeVersion == 20) { 197 /* 198 * Version 21 is part of the volume control refresh. There is no 199 * longer a UI-visible for setting notification vibrate on/off (in 200 * our design), but the functionality still exists. Force the 201 * notification vibrate to on. 202 */ 203 loadVibrateSetting(db, true); 204 205 upgradeVersion = 21; 206 } 207 208 if (upgradeVersion < 22) { 209 upgradeVersion = 22; 210 // Upgrade the lock gesture storage location and format 211 upgradeLockPatternLocation(db); 212 } 213 214 if (upgradeVersion < 23) { 215 db.execSQL("UPDATE favorites SET iconResource=0 WHERE iconType=0"); 216 upgradeVersion = 23; 217 } 218 219 if (upgradeVersion == 23) { 220 db.beginTransaction(); 221 try { 222 db.execSQL("ALTER TABLE favorites ADD spanX INTEGER"); 223 db.execSQL("ALTER TABLE favorites ADD spanY INTEGER"); 224 // Shortcuts, applications, folders 225 db.execSQL("UPDATE favorites SET spanX=1, spanY=1 WHERE itemType<=0"); 226 // Photo frames, clocks 227 db.execSQL( 228 "UPDATE favorites SET spanX=2, spanY=2 WHERE itemType=1000 or itemType=1002"); 229 // Search boxes 230 db.execSQL("UPDATE favorites SET spanX=4, spanY=1 WHERE itemType=1001"); 231 db.setTransactionSuccessful(); 232 } finally { 233 db.endTransaction(); 234 } 235 upgradeVersion = 24; 236 } 237 238 if (upgradeVersion == 24) { 239 db.beginTransaction(); 240 try { 241 // The value of the constants for preferring wifi or preferring mobile have been 242 // swapped, so reload the default. 243 db.execSQL("DELETE FROM system WHERE name='network_preference'"); 244 db.execSQL("INSERT INTO system ('name', 'value') values ('network_preference', '" + 245 ConnectivityManager.DEFAULT_NETWORK_PREFERENCE + "')"); 246 db.setTransactionSuccessful(); 247 } finally { 248 db.endTransaction(); 249 } 250 upgradeVersion = 25; 251 } 252 253 if (upgradeVersion == 25) { 254 db.beginTransaction(); 255 try { 256 db.execSQL("ALTER TABLE favorites ADD uri TEXT"); 257 db.execSQL("ALTER TABLE favorites ADD displayMode INTEGER"); 258 db.setTransactionSuccessful(); 259 } finally { 260 db.endTransaction(); 261 } 262 upgradeVersion = 26; 263 } 264 265 if (upgradeVersion == 26) { 266 // This introduces the new secure settings table. 267 db.beginTransaction(); 268 try { 269 createSecureTable(db); 270 db.setTransactionSuccessful(); 271 } finally { 272 db.endTransaction(); 273 } 274 upgradeVersion = 27; 275 } 276 277 if (upgradeVersion == 27) { 278 String[] settingsToMove = { 279 Settings.Secure.ADB_ENABLED, 280 Settings.Secure.ANDROID_ID, 281 Settings.Secure.BLUETOOTH_ON, 282 Settings.Secure.DATA_ROAMING, 283 Settings.Secure.DEVICE_PROVISIONED, 284 Settings.Secure.HTTP_PROXY, 285 Settings.Secure.INSTALL_NON_MARKET_APPS, 286 Settings.Secure.LOCATION_PROVIDERS_ALLOWED, 287 Settings.Secure.LOGGING_ID, 288 Settings.Secure.NETWORK_PREFERENCE, 289 Settings.Secure.PARENTAL_CONTROL_ENABLED, 290 Settings.Secure.PARENTAL_CONTROL_LAST_UPDATE, 291 Settings.Secure.PARENTAL_CONTROL_REDIRECT_URL, 292 Settings.Secure.SETTINGS_CLASSNAME, 293 Settings.Secure.USB_MASS_STORAGE_ENABLED, 294 Settings.Secure.USE_GOOGLE_MAIL, 295 Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 296 Settings.Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 297 Settings.Secure.WIFI_NUM_OPEN_NETWORKS_KEPT, 298 Settings.Secure.WIFI_ON, 299 Settings.Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE, 300 Settings.Secure.WIFI_WATCHDOG_AP_COUNT, 301 Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS, 302 Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED, 303 Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS, 304 Settings.Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT, 305 Settings.Secure.WIFI_WATCHDOG_MAX_AP_CHECKS, 306 Settings.Secure.WIFI_WATCHDOG_ON, 307 Settings.Secure.WIFI_WATCHDOG_PING_COUNT, 308 Settings.Secure.WIFI_WATCHDOG_PING_DELAY_MS, 309 Settings.Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS, 310 }; 311 moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_SECURE, settingsToMove, false); 312 upgradeVersion = 28; 313 } 314 315 if (upgradeVersion == 28 || upgradeVersion == 29) { 316 // Note: The upgrade to 28 was flawed since it didn't delete the old 317 // setting first before inserting. Combining 28 and 29 with the 318 // fixed version. 319 320 // This upgrade adds the STREAM_NOTIFICATION type to the list of 321 // types affected by ringer modes (silent, vibrate, etc.) 322 db.beginTransaction(); 323 try { 324 db.execSQL("DELETE FROM system WHERE name='" 325 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'"); 326 int newValue = (1 << AudioManager.STREAM_RING) 327 | (1 << AudioManager.STREAM_NOTIFICATION) 328 | (1 << AudioManager.STREAM_SYSTEM); 329 db.execSQL("INSERT INTO system ('name', 'value') values ('" 330 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '" 331 + String.valueOf(newValue) + "')"); 332 db.setTransactionSuccessful(); 333 } finally { 334 db.endTransaction(); 335 } 336 337 upgradeVersion = 30; 338 } 339 340 if (upgradeVersion == 30) { 341 /* 342 * Upgrade 31 clears the title for all quick launch shortcuts so the 343 * activities' titles will be resolved at display time. Also, the 344 * folder is changed to '@quicklaunch'. 345 */ 346 db.beginTransaction(); 347 try { 348 db.execSQL("UPDATE bookmarks SET folder = '@quicklaunch'"); 349 db.execSQL("UPDATE bookmarks SET title = ''"); 350 db.setTransactionSuccessful(); 351 } finally { 352 db.endTransaction(); 353 } 354 upgradeVersion = 31; 355 } 356 357 if (upgradeVersion == 31) { 358 /* 359 * Animations are now managed in preferences, and may be 360 * enabled or disabled based on product resources. 361 */ 362 db.beginTransaction(); 363 SQLiteStatement stmt = null; 364 try { 365 db.execSQL("DELETE FROM system WHERE name='" 366 + Settings.System.WINDOW_ANIMATION_SCALE + "'"); 367 db.execSQL("DELETE FROM system WHERE name='" 368 + Settings.System.TRANSITION_ANIMATION_SCALE + "'"); 369 stmt = db.compileStatement("INSERT INTO system(name,value)" 370 + " VALUES(?,?);"); 371 loadDefaultAnimationSettings(stmt); 372 db.setTransactionSuccessful(); 373 } finally { 374 db.endTransaction(); 375 if (stmt != null) stmt.close(); 376 } 377 upgradeVersion = 32; 378 } 379 380 if (upgradeVersion == 32) { 381 // The Wi-Fi watchdog SSID list is now seeded with the value of 382 // the property ro.com.android.wifi-watchlist 383 String wifiWatchList = SystemProperties.get("ro.com.android.wifi-watchlist"); 384 if (!TextUtils.isEmpty(wifiWatchList)) { 385 db.beginTransaction(); 386 try { 387 db.execSQL("INSERT OR IGNORE INTO secure(name,value) values('" + 388 Settings.Secure.WIFI_WATCHDOG_WATCH_LIST + "','" + 389 wifiWatchList + "');"); 390 db.setTransactionSuccessful(); 391 } finally { 392 db.endTransaction(); 393 } 394 } 395 upgradeVersion = 33; 396 } 397 398 if (upgradeVersion == 33) { 399 // Set the default zoom controls to: tap-twice to bring up +/- 400 db.beginTransaction(); 401 try { 402 db.execSQL("INSERT INTO system(name,value) values('zoom','2');"); 403 db.setTransactionSuccessful(); 404 } finally { 405 db.endTransaction(); 406 } 407 upgradeVersion = 34; 408 } 409 410 if (upgradeVersion == 34) { 411 db.beginTransaction(); 412 SQLiteStatement stmt = null; 413 try { 414 stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)" 415 + " VALUES(?,?);"); 416 loadSecure35Settings(stmt); 417 db.setTransactionSuccessful(); 418 } finally { 419 db.endTransaction(); 420 if (stmt != null) stmt.close(); 421 } 422 upgradeVersion = 35; 423 } 424 // due to a botched merge from donut to eclair, the initialization of ASSISTED_GPS_ENABLED 425 // was accidentally done out of order here. 426 // to fix this, ASSISTED_GPS_ENABLED is now initialized while upgrading from 38 to 39, 427 // and we intentionally do nothing from 35 to 36 now. 428 if (upgradeVersion == 35) { 429 upgradeVersion = 36; 430 } 431 432 if (upgradeVersion == 36) { 433 // This upgrade adds the STREAM_SYSTEM_ENFORCED type to the list of 434 // types affected by ringer modes (silent, vibrate, etc.) 435 db.beginTransaction(); 436 try { 437 db.execSQL("DELETE FROM system WHERE name='" 438 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'"); 439 int newValue = (1 << AudioManager.STREAM_RING) 440 | (1 << AudioManager.STREAM_NOTIFICATION) 441 | (1 << AudioManager.STREAM_SYSTEM) 442 | (1 << AudioManager.STREAM_SYSTEM_ENFORCED); 443 db.execSQL("INSERT INTO system ('name', 'value') values ('" 444 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '" 445 + String.valueOf(newValue) + "')"); 446 db.setTransactionSuccessful(); 447 } finally { 448 db.endTransaction(); 449 } 450 upgradeVersion = 37; 451 } 452 453 if (upgradeVersion == 37) { 454 db.beginTransaction(); 455 SQLiteStatement stmt = null; 456 try { 457 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 458 + " VALUES(?,?);"); 459 loadStringSetting(stmt, Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS, 460 R.string.airplane_mode_toggleable_radios); 461 db.setTransactionSuccessful(); 462 } finally { 463 db.endTransaction(); 464 if (stmt != null) stmt.close(); 465 } 466 upgradeVersion = 38; 467 } 468 469 if (upgradeVersion == 38) { 470 db.beginTransaction(); 471 try { 472 String value = 473 mContext.getResources().getBoolean(R.bool.assisted_gps_enabled) ? "1" : "0"; 474 db.execSQL("INSERT OR IGNORE INTO secure(name,value) values('" + 475 Settings.Secure.ASSISTED_GPS_ENABLED + "','" + value + "');"); 476 db.setTransactionSuccessful(); 477 } finally { 478 db.endTransaction(); 479 } 480 481 upgradeVersion = 39; 482 } 483 484 if (upgradeVersion == 39) { 485 upgradeAutoBrightness(db); 486 upgradeVersion = 40; 487 } 488 489 if (upgradeVersion == 40) { 490 /* 491 * All animations are now turned on by default! 492 */ 493 db.beginTransaction(); 494 SQLiteStatement stmt = null; 495 try { 496 db.execSQL("DELETE FROM system WHERE name='" 497 + Settings.System.WINDOW_ANIMATION_SCALE + "'"); 498 db.execSQL("DELETE FROM system WHERE name='" 499 + Settings.System.TRANSITION_ANIMATION_SCALE + "'"); 500 stmt = db.compileStatement("INSERT INTO system(name,value)" 501 + " VALUES(?,?);"); 502 loadDefaultAnimationSettings(stmt); 503 db.setTransactionSuccessful(); 504 } finally { 505 db.endTransaction(); 506 if (stmt != null) stmt.close(); 507 } 508 upgradeVersion = 41; 509 } 510 511 if (upgradeVersion == 41) { 512 /* 513 * Initialize newly public haptic feedback setting 514 */ 515 db.beginTransaction(); 516 SQLiteStatement stmt = null; 517 try { 518 db.execSQL("DELETE FROM system WHERE name='" 519 + Settings.System.HAPTIC_FEEDBACK_ENABLED + "'"); 520 stmt = db.compileStatement("INSERT INTO system(name,value)" 521 + " VALUES(?,?);"); 522 loadDefaultHapticSettings(stmt); 523 db.setTransactionSuccessful(); 524 } finally { 525 db.endTransaction(); 526 if (stmt != null) stmt.close(); 527 } 528 upgradeVersion = 42; 529 } 530 531 if (upgradeVersion == 42) { 532 /* 533 * Initialize new notification pulse setting 534 */ 535 db.beginTransaction(); 536 SQLiteStatement stmt = null; 537 try { 538 stmt = db.compileStatement("INSERT INTO system(name,value)" 539 + " VALUES(?,?);"); 540 loadBooleanSetting(stmt, Settings.System.NOTIFICATION_LIGHT_PULSE, 541 R.bool.def_notification_pulse); 542 db.setTransactionSuccessful(); 543 } finally { 544 db.endTransaction(); 545 if (stmt != null) stmt.close(); 546 } 547 upgradeVersion = 43; 548 } 549 550 if (upgradeVersion == 43) { 551 /* 552 * This upgrade stores bluetooth volume separately from voice volume 553 */ 554 db.beginTransaction(); 555 SQLiteStatement stmt = null; 556 try { 557 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 558 + " VALUES(?,?);"); 559 loadSetting(stmt, Settings.System.VOLUME_BLUETOOTH_SCO, 560 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_BLUETOOTH_SCO]); 561 db.setTransactionSuccessful(); 562 } finally { 563 db.endTransaction(); 564 if (stmt != null) stmt.close(); 565 } 566 upgradeVersion = 44; 567 } 568 569 if (upgradeVersion == 44) { 570 /* 571 * Gservices was moved into vendor/google. 572 */ 573 db.execSQL("DROP TABLE IF EXISTS gservices"); 574 db.execSQL("DROP INDEX IF EXISTS gservicesIndex1"); 575 upgradeVersion = 45; 576 } 577 578 if (upgradeVersion == 45) { 579 /* 580 * New settings for MountService 581 */ 582 db.beginTransaction(); 583 try { 584 db.execSQL("INSERT INTO secure(name,value) values('" + 585 Settings.Secure.MOUNT_PLAY_NOTIFICATION_SND + "','1');"); 586 db.execSQL("INSERT INTO secure(name,value) values('" + 587 Settings.Secure.MOUNT_UMS_AUTOSTART + "','0');"); 588 db.execSQL("INSERT INTO secure(name,value) values('" + 589 Settings.Secure.MOUNT_UMS_PROMPT + "','1');"); 590 db.execSQL("INSERT INTO secure(name,value) values('" + 591 Settings.Secure.MOUNT_UMS_NOTIFY_ENABLED + "','1');"); 592 db.setTransactionSuccessful(); 593 } finally { 594 db.endTransaction(); 595 } 596 upgradeVersion = 46; 597 } 598 599 if (upgradeVersion == 46) { 600 /* 601 * The password mode constants have changed; reset back to no 602 * password. 603 */ 604 db.beginTransaction(); 605 try { 606 db.execSQL("DELETE FROM system WHERE name='lockscreen.password_type';"); 607 db.setTransactionSuccessful(); 608 } finally { 609 db.endTransaction(); 610 } 611 upgradeVersion = 47; 612 } 613 614 615 if (upgradeVersion == 47) { 616 /* 617 * The password mode constants have changed again; reset back to no 618 * password. 619 */ 620 db.beginTransaction(); 621 try { 622 db.execSQL("DELETE FROM system WHERE name='lockscreen.password_type';"); 623 db.setTransactionSuccessful(); 624 } finally { 625 db.endTransaction(); 626 } 627 upgradeVersion = 48; 628 } 629 630 if (upgradeVersion == 48) { 631 /* 632 * Default recognition service no longer initialized here, 633 * moved to RecognitionManagerService. 634 */ 635 upgradeVersion = 49; 636 } 637 638 if (upgradeVersion == 49) { 639 /* 640 * New settings for new user interface noises. 641 */ 642 db.beginTransaction(); 643 SQLiteStatement stmt = null; 644 try { 645 stmt = db.compileStatement("INSERT INTO system(name,value)" 646 + " VALUES(?,?);"); 647 loadUISoundEffectsSettings(stmt); 648 db.setTransactionSuccessful(); 649 } finally { 650 db.endTransaction(); 651 if (stmt != null) stmt.close(); 652 } 653 654 upgradeVersion = 50; 655 } 656 657 if (upgradeVersion == 50) { 658 /* 659 * Install location no longer initiated here. 660 */ 661 upgradeVersion = 51; 662 } 663 664 if (upgradeVersion == 51) { 665 /* Move the lockscreen related settings to Secure, including some private ones. */ 666 String[] settingsToMove = { 667 Secure.LOCK_PATTERN_ENABLED, 668 Secure.LOCK_PATTERN_VISIBLE, 669 Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED, 670 "lockscreen.password_type", 671 "lockscreen.lockoutattemptdeadline", 672 "lockscreen.patterneverchosen", 673 "lock_pattern_autolock", 674 "lockscreen.lockedoutpermanently", 675 "lockscreen.password_salt" 676 }; 677 moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_SECURE, settingsToMove, false); 678 upgradeVersion = 52; 679 } 680 681 if (upgradeVersion == 52) { 682 // new vibration/silent mode settings 683 db.beginTransaction(); 684 SQLiteStatement stmt = null; 685 try { 686 stmt = db.compileStatement("INSERT INTO system(name,value)" 687 + " VALUES(?,?);"); 688 loadBooleanSetting(stmt, Settings.System.VIBRATE_IN_SILENT, 689 R.bool.def_vibrate_in_silent); 690 db.setTransactionSuccessful(); 691 } finally { 692 db.endTransaction(); 693 if (stmt != null) stmt.close(); 694 } 695 696 upgradeVersion = 53; 697 } 698 699 if (upgradeVersion == 53) { 700 /* 701 * New settings for set install location UI no longer initiated here. 702 */ 703 upgradeVersion = 54; 704 } 705 706 if (upgradeVersion == 54) { 707 /* 708 * Update the screen timeout value if set to never 709 */ 710 db.beginTransaction(); 711 try { 712 upgradeScreenTimeoutFromNever(db); 713 db.setTransactionSuccessful(); 714 } finally { 715 db.endTransaction(); 716 } 717 718 upgradeVersion = 55; 719 } 720 721 if (upgradeVersion == 55) { 722 /* Move the install location settings. */ 723 String[] settingsToMove = { 724 Secure.SET_INSTALL_LOCATION, 725 Secure.DEFAULT_INSTALL_LOCATION 726 }; 727 moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_SECURE, settingsToMove, false); 728 db.beginTransaction(); 729 SQLiteStatement stmt = null; 730 try { 731 stmt = db.compileStatement("INSERT INTO system(name,value)" 732 + " VALUES(?,?);"); 733 loadSetting(stmt, Secure.SET_INSTALL_LOCATION, 0); 734 loadSetting(stmt, Secure.DEFAULT_INSTALL_LOCATION, 735 PackageHelper.APP_INSTALL_AUTO); 736 db.setTransactionSuccessful(); 737 } finally { 738 db.endTransaction(); 739 if (stmt != null) stmt.close(); 740 } 741 upgradeVersion = 56; 742 } 743 744 if (upgradeVersion == 56) { 745 /* 746 * Add Bluetooth to list of toggleable radios in airplane mode 747 */ 748 db.beginTransaction(); 749 SQLiteStatement stmt = null; 750 try { 751 db.execSQL("DELETE FROM system WHERE name='" 752 + Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS + "'"); 753 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 754 + " VALUES(?,?);"); 755 loadStringSetting(stmt, Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS, 756 R.string.airplane_mode_toggleable_radios); 757 db.setTransactionSuccessful(); 758 } finally { 759 db.endTransaction(); 760 if (stmt != null) stmt.close(); 761 } 762 upgradeVersion = 57; 763 } 764 765 /************* The following are Honeycomb changes ************/ 766 767 if (upgradeVersion == 57) { 768 /* 769 * New settings to: 770 * 1. Enable injection of accessibility scripts in WebViews. 771 * 2. Define the key bindings for traversing web content in WebViews. 772 */ 773 db.beginTransaction(); 774 SQLiteStatement stmt = null; 775 try { 776 stmt = db.compileStatement("INSERT INTO secure(name,value)" 777 + " VALUES(?,?);"); 778 loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SCRIPT_INJECTION, 779 R.bool.def_accessibility_script_injection); 780 stmt.close(); 781 stmt = db.compileStatement("INSERT INTO secure(name,value)" 782 + " VALUES(?,?);"); 783 loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS, 784 R.string.def_accessibility_web_content_key_bindings); 785 db.setTransactionSuccessful(); 786 } finally { 787 db.endTransaction(); 788 if (stmt != null) stmt.close(); 789 } 790 upgradeVersion = 58; 791 } 792 793 if (upgradeVersion == 58) { 794 /* Add default for new Auto Time Zone */ 795 int autoTimeValue = getIntValueFromSystem(db, Settings.System.AUTO_TIME, 0); 796 db.beginTransaction(); 797 SQLiteStatement stmt = null; 798 try { 799 stmt = db.compileStatement("INSERT INTO system(name,value)" + " VALUES(?,?);"); 800 loadSetting(stmt, Settings.System.AUTO_TIME_ZONE, 801 autoTimeValue); // Sync timezone to NITZ if auto_time was enabled 802 db.setTransactionSuccessful(); 803 } finally { 804 db.endTransaction(); 805 if (stmt != null) stmt.close(); 806 } 807 upgradeVersion = 59; 808 } 809 810 if (upgradeVersion == 59) { 811 // Persistence for the rotation lock feature. 812 db.beginTransaction(); 813 SQLiteStatement stmt = null; 814 try { 815 stmt = db.compileStatement("INSERT INTO system(name,value)" 816 + " VALUES(?,?);"); 817 loadBooleanSetting(stmt, Settings.System.USER_ROTATION, 818 R.integer.def_user_rotation); // should be zero degrees 819 db.setTransactionSuccessful(); 820 } finally { 821 db.endTransaction(); 822 if (stmt != null) stmt.close(); 823 } 824 upgradeVersion = 60; 825 } 826 827 if (upgradeVersion == 60) { 828 // Don't do this for upgrades from Gingerbread 829 // Were only required for intra-Honeycomb upgrades for testing 830 // upgradeScreenTimeout(db); 831 upgradeVersion = 61; 832 } 833 834 if (upgradeVersion == 61) { 835 // Don't do this for upgrades from Gingerbread 836 // Were only required for intra-Honeycomb upgrades for testing 837 // upgradeScreenTimeout(db); 838 upgradeVersion = 62; 839 } 840 841 // Change the default for screen auto-brightness mode 842 if (upgradeVersion == 62) { 843 // Don't do this for upgrades from Gingerbread 844 // Were only required for intra-Honeycomb upgrades for testing 845 // upgradeAutoBrightness(db); 846 upgradeVersion = 63; 847 } 848 849 if (upgradeVersion == 63) { 850 // This upgrade adds the STREAM_MUSIC type to the list of 851 // types affected by ringer modes (silent, vibrate, etc.) 852 db.beginTransaction(); 853 try { 854 db.execSQL("DELETE FROM system WHERE name='" 855 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'"); 856 int newValue = (1 << AudioManager.STREAM_RING) 857 | (1 << AudioManager.STREAM_NOTIFICATION) 858 | (1 << AudioManager.STREAM_SYSTEM) 859 | (1 << AudioManager.STREAM_SYSTEM_ENFORCED) 860 | (1 << AudioManager.STREAM_MUSIC); 861 db.execSQL("INSERT INTO system ('name', 'value') values ('" 862 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '" 863 + String.valueOf(newValue) + "')"); 864 db.setTransactionSuccessful(); 865 } finally { 866 db.endTransaction(); 867 } 868 upgradeVersion = 64; 869 } 870 871 if (upgradeVersion == 64) { 872 // New setting to configure the long press timeout. 873 db.beginTransaction(); 874 SQLiteStatement stmt = null; 875 try { 876 stmt = db.compileStatement("INSERT INTO secure(name,value)" 877 + " VALUES(?,?);"); 878 loadIntegerSetting(stmt, Settings.Secure.LONG_PRESS_TIMEOUT, 879 R.integer.def_long_press_timeout_millis); 880 stmt.close(); 881 db.setTransactionSuccessful(); 882 } finally { 883 db.endTransaction(); 884 if (stmt != null) stmt.close(); 885 } 886 upgradeVersion = 65; 887 } 888 889 /************* The following are Ice Cream Sandwich changes ************/ 890 891 if (upgradeVersion == 65) { 892 /* 893 * Animations are removed from Settings. Turned on by default 894 */ 895 db.beginTransaction(); 896 SQLiteStatement stmt = null; 897 try { 898 db.execSQL("DELETE FROM system WHERE name='" 899 + Settings.System.WINDOW_ANIMATION_SCALE + "'"); 900 db.execSQL("DELETE FROM system WHERE name='" 901 + Settings.System.TRANSITION_ANIMATION_SCALE + "'"); 902 stmt = db.compileStatement("INSERT INTO system(name,value)" 903 + " VALUES(?,?);"); 904 loadDefaultAnimationSettings(stmt); 905 db.setTransactionSuccessful(); 906 } finally { 907 db.endTransaction(); 908 if (stmt != null) stmt.close(); 909 } 910 upgradeVersion = 66; 911 } 912 913 if (upgradeVersion == 66) { 914 // This upgrade makes sure that MODE_RINGER_STREAMS_AFFECTED is set 915 // according to device voice capability 916 db.beginTransaction(); 917 try { 918 int ringerModeAffectedStreams = (1 << AudioManager.STREAM_RING) | 919 (1 << AudioManager.STREAM_NOTIFICATION) | 920 (1 << AudioManager.STREAM_SYSTEM) | 921 (1 << AudioManager.STREAM_SYSTEM_ENFORCED); 922 if (!mContext.getResources().getBoolean( 923 com.android.internal.R.bool.config_voice_capable)) { 924 ringerModeAffectedStreams |= (1 << AudioManager.STREAM_MUSIC); 925 } 926 db.execSQL("DELETE FROM system WHERE name='" 927 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "'"); 928 db.execSQL("INSERT INTO system ('name', 'value') values ('" 929 + Settings.System.MODE_RINGER_STREAMS_AFFECTED + "', '" 930 + String.valueOf(ringerModeAffectedStreams) + "')"); 931 db.setTransactionSuccessful(); 932 } finally { 933 db.endTransaction(); 934 } 935 upgradeVersion = 67; 936 } 937 938 if (upgradeVersion == 67) { 939 // New setting to enable touch exploration. 940 db.beginTransaction(); 941 SQLiteStatement stmt = null; 942 try { 943 stmt = db.compileStatement("INSERT INTO secure(name,value)" 944 + " VALUES(?,?);"); 945 loadBooleanSetting(stmt, Settings.Secure.TOUCH_EXPLORATION_ENABLED, 946 R.bool.def_touch_exploration_enabled); 947 stmt.close(); 948 db.setTransactionSuccessful(); 949 } finally { 950 db.endTransaction(); 951 if (stmt != null) stmt.close(); 952 } 953 upgradeVersion = 68; 954 } 955 956 if (upgradeVersion == 68) { 957 // Enable all system sounds by default 958 db.beginTransaction(); 959 try { 960 db.execSQL("DELETE FROM system WHERE name='" 961 + Settings.System.NOTIFICATIONS_USE_RING_VOLUME + "'"); 962 db.setTransactionSuccessful(); 963 } finally { 964 db.endTransaction(); 965 } 966 upgradeVersion = 69; 967 } 968 969 if (upgradeVersion == 69) { 970 // Add RADIO_NFC to AIRPLANE_MODE_RADIO and AIRPLANE_MODE_TOGGLEABLE_RADIOS 971 String airplaneRadios = mContext.getResources().getString( 972 R.string.def_airplane_mode_radios); 973 String toggleableRadios = mContext.getResources().getString( 974 R.string.airplane_mode_toggleable_radios); 975 db.beginTransaction(); 976 try { 977 db.execSQL("UPDATE system SET value='" + airplaneRadios + "' " + 978 "WHERE name='" + Settings.System.AIRPLANE_MODE_RADIOS + "'"); 979 db.execSQL("UPDATE system SET value='" + toggleableRadios + "' " + 980 "WHERE name='" + Settings.System.AIRPLANE_MODE_TOGGLEABLE_RADIOS + "'"); 981 db.setTransactionSuccessful(); 982 } finally { 983 db.endTransaction(); 984 } 985 upgradeVersion = 70; 986 } 987 988 if (upgradeVersion == 70) { 989 // Update all built-in bookmarks. Some of the package names have changed. 990 loadBookmarks(db); 991 upgradeVersion = 71; 992 } 993 994 if (upgradeVersion == 71) { 995 // New setting to specify whether to speak passwords in accessibility mode. 996 db.beginTransaction(); 997 SQLiteStatement stmt = null; 998 try { 999 stmt = db.compileStatement("INSERT INTO secure(name,value)" 1000 + " VALUES(?,?);"); 1001 loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD, 1002 R.bool.def_accessibility_speak_password); 1003 db.setTransactionSuccessful(); 1004 } finally { 1005 db.endTransaction(); 1006 if (stmt != null) stmt.close(); 1007 } 1008 upgradeVersion = 72; 1009 } 1010 1011 if (upgradeVersion == 72) { 1012 // update vibration settings 1013 db.beginTransaction(); 1014 SQLiteStatement stmt = null; 1015 try { 1016 stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)" 1017 + " VALUES(?,?);"); 1018 loadBooleanSetting(stmt, Settings.System.VIBRATE_IN_SILENT, 1019 R.bool.def_vibrate_in_silent); 1020 db.setTransactionSuccessful(); 1021 } finally { 1022 db.endTransaction(); 1023 if (stmt != null) stmt.close(); 1024 } 1025 upgradeVersion = 73; 1026 } 1027 1028 if (upgradeVersion == 73) { 1029 upgradeVibrateSettingFromNone(db); 1030 upgradeVersion = 74; 1031 } 1032 1033 if (upgradeVersion == 74) { 1034 // URL from which WebView loads a JavaScript based screen-reader. 1035 db.beginTransaction(); 1036 SQLiteStatement stmt = null; 1037 try { 1038 stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);"); 1039 loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL, 1040 R.string.def_accessibility_screen_reader_url); 1041 db.setTransactionSuccessful(); 1042 } finally { 1043 db.endTransaction(); 1044 if (stmt != null) stmt.close(); 1045 } 1046 upgradeVersion = 75; 1047 } 1048 if (upgradeVersion == 75) { 1049 db.beginTransaction(); 1050 SQLiteStatement stmt = null; 1051 Cursor c = null; 1052 try { 1053 c = db.query(TABLE_SECURE, new String[] {"_id", "value"}, 1054 "name='lockscreen.disabled'", 1055 null, null, null, null); 1056 // only set default if it has not yet been set 1057 if (c == null || c.getCount() == 0) { 1058 stmt = db.compileStatement("INSERT INTO system(name,value)" 1059 + " VALUES(?,?);"); 1060 loadBooleanSetting(stmt, Settings.System.LOCKSCREEN_DISABLED, 1061 R.bool.def_lockscreen_disabled); 1062 } 1063 db.setTransactionSuccessful(); 1064 } finally { 1065 db.endTransaction(); 1066 if (c != null) c.close(); 1067 if (stmt != null) stmt.close(); 1068 } 1069 upgradeVersion = 76; 1070 } 1071 1072 /************* The following are Jelly Bean changes ************/ 1073 1074 if (upgradeVersion == 76) { 1075 // Removed VIBRATE_IN_SILENT setting 1076 db.beginTransaction(); 1077 try { 1078 db.execSQL("DELETE FROM system WHERE name='" 1079 + Settings.System.VIBRATE_IN_SILENT + "'"); 1080 db.setTransactionSuccessful(); 1081 } finally { 1082 db.endTransaction(); 1083 } 1084 1085 upgradeVersion = 77; 1086 } 1087 1088 if (upgradeVersion == 77) { 1089 // Introduce "vibrate when ringing" setting 1090 loadVibrateWhenRingingSetting(db); 1091 1092 upgradeVersion = 78; 1093 } 1094 1095 if (upgradeVersion == 78) { 1096 // The JavaScript based screen-reader URL changes in JellyBean. 1097 db.beginTransaction(); 1098 SQLiteStatement stmt = null; 1099 try { 1100 stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)" 1101 + " VALUES(?,?);"); 1102 loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL, 1103 R.string.def_accessibility_screen_reader_url); 1104 db.setTransactionSuccessful(); 1105 } finally { 1106 db.endTransaction(); 1107 if (stmt != null) stmt.close(); 1108 } 1109 upgradeVersion = 79; 1110 } 1111 1112 if (upgradeVersion == 79) { 1113 // Before touch exploration was a global setting controlled by the user 1114 // via the UI. However, if the enabled accessibility services do not 1115 // handle touch exploration mode, enabling it makes no sense. Therefore, 1116 // now the services request touch exploration mode and the user is 1117 // presented with a dialog to allow that and if she does we store that 1118 // in the database. As a result of this change a user that has enabled 1119 // accessibility, touch exploration, and some accessibility services 1120 // may lose touch exploration state, thus rendering the device useless 1121 // unless sighted help is provided, since the enabled service(s) are 1122 // not in the list of services to which the user granted a permission 1123 // to put the device in touch explore mode. Here we are allowing all 1124 // enabled accessibility services to toggle touch exploration provided 1125 // accessibility and touch exploration are enabled and no services can 1126 // toggle touch exploration. Note that the user has already manually 1127 // enabled the services and touch exploration which means the she has 1128 // given consent to have these services work in touch exploration mode. 1129 final boolean accessibilityEnabled = getIntValueFromTable(db, TABLE_SECURE, 1130 Settings.Secure.ACCESSIBILITY_ENABLED, 0) == 1; 1131 final boolean touchExplorationEnabled = getIntValueFromTable(db, TABLE_SECURE, 1132 Settings.Secure.TOUCH_EXPLORATION_ENABLED, 0) == 1; 1133 if (accessibilityEnabled && touchExplorationEnabled) { 1134 String enabledServices = getStringValueFromTable(db, TABLE_SECURE, 1135 Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, ""); 1136 String touchExplorationGrantedServices = getStringValueFromTable(db, TABLE_SECURE, 1137 Settings.Secure.TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, ""); 1138 if (TextUtils.isEmpty(touchExplorationGrantedServices) 1139 && !TextUtils.isEmpty(enabledServices)) { 1140 SQLiteStatement stmt = null; 1141 try { 1142 db.beginTransaction(); 1143 stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)" 1144 + " VALUES(?,?);"); 1145 loadSetting(stmt, 1146 Settings.Secure.TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, 1147 enabledServices); 1148 db.setTransactionSuccessful(); 1149 } finally { 1150 db.endTransaction(); 1151 if (stmt != null) stmt.close(); 1152 } 1153 } 1154 } 1155 upgradeVersion = 80; 1156 } 1157 1158 // vvv Jelly Bean MR1 changes begin here vvv 1159 1160 if (upgradeVersion == 80) { 1161 // update screensaver settings 1162 db.beginTransaction(); 1163 SQLiteStatement stmt = null; 1164 try { 1165 stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)" 1166 + " VALUES(?,?);"); 1167 loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ENABLED, 1168 R.bool.def_screensaver_enabled); 1169 loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK, 1170 R.bool.def_screensaver_activate_on_dock); 1171 loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP, 1172 R.bool.def_screensaver_activate_on_sleep); 1173 loadStringSetting(stmt, Settings.Secure.SCREENSAVER_DEFAULT_COMPONENT, 1174 R.string.def_screensaver_component); 1175 loadStringSetting(stmt, Settings.Secure.SCREENSAVER_COMPONENTS, 1176 R.string.def_screensaver_component); 1177 1178 db.setTransactionSuccessful(); 1179 } finally { 1180 db.endTransaction(); 1181 if (stmt != null) stmt.close(); 1182 } 1183 upgradeVersion = 81; 1184 } 1185 1186 if (upgradeVersion == 81) { 1187 // Add package verification setting 1188 db.beginTransaction(); 1189 SQLiteStatement stmt = null; 1190 try { 1191 stmt = db.compileStatement("INSERT OR REPLACE INTO secure(name,value)" 1192 + " VALUES(?,?);"); 1193 loadBooleanSetting(stmt, Settings.Secure.PACKAGE_VERIFIER_ENABLE, 1194 R.bool.def_package_verifier_enable); 1195 db.setTransactionSuccessful(); 1196 } finally { 1197 db.endTransaction(); 1198 if (stmt != null) stmt.close(); 1199 } 1200 upgradeVersion = 82; 1201 } 1202 1203 if (upgradeVersion == 82) { 1204 // Move to per-user settings dbs 1205 db.beginTransaction(); 1206 SQLiteStatement stmt = null; 1207 try { 1208 // Migrate now-global settings. Note that this happens before 1209 // new users can be created. 1210 createGlobalTable(db); 1211 String[] settingsToMove = hashsetToStringArray(SettingsProvider.sSystemGlobalKeys); 1212 moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, settingsToMove, false); 1213 settingsToMove = hashsetToStringArray(SettingsProvider.sSecureGlobalKeys); 1214 moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, false); 1215 1216 db.setTransactionSuccessful(); 1217 } finally { 1218 db.endTransaction(); 1219 if (stmt != null) stmt.close(); 1220 } 1221 upgradeVersion = 83; 1222 } 1223 1224 if (upgradeVersion == 83) { 1225 // 1. Setting whether screen magnification is enabled. 1226 // 2. Setting for screen magnification scale. 1227 // 3. Setting for screen magnification auto update. 1228 db.beginTransaction(); 1229 SQLiteStatement stmt = null; 1230 try { 1231 stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);"); 1232 loadBooleanSetting(stmt, 1233 Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 1234 R.bool.def_accessibility_display_magnification_enabled); 1235 stmt.close(); 1236 stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);"); 1237 loadFractionSetting(stmt, Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE, 1238 R.fraction.def_accessibility_display_magnification_scale, 1); 1239 stmt.close(); 1240 stmt = db.compileStatement("INSERT INTO secure(name,value) VALUES(?,?);"); 1241 loadBooleanSetting(stmt, 1242 Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE, 1243 R.bool.def_accessibility_display_magnification_auto_update); 1244 1245 db.setTransactionSuccessful(); 1246 } finally { 1247 db.endTransaction(); 1248 if (stmt != null) stmt.close(); 1249 } 1250 upgradeVersion = 84; 1251 } 1252 1253 if (upgradeVersion == 84) { 1254 db.beginTransaction(); 1255 SQLiteStatement stmt = null; 1256 try { 1257 // Patch up the slightly-wrong key migration from 82 -> 83 for those 1258 // devices that missed it, ignoring if the move is redundant 1259 String[] settingsToMove = { 1260 Settings.Secure.ADB_ENABLED, 1261 Settings.Secure.BLUETOOTH_ON, 1262 Settings.Secure.DATA_ROAMING, 1263 Settings.Secure.DEVICE_PROVISIONED, 1264 Settings.Secure.INSTALL_NON_MARKET_APPS, 1265 Settings.Secure.USB_MASS_STORAGE_ENABLED 1266 }; 1267 moveSettingsToNewTable(db, TABLE_SECURE, TABLE_GLOBAL, settingsToMove, true); 1268 db.setTransactionSuccessful(); 1269 } finally { 1270 db.endTransaction(); 1271 if (stmt != null) stmt.close(); 1272 } 1273 upgradeVersion = 85; 1274 } 1275 1276 if (upgradeVersion == 85) { 1277 db.beginTransaction(); 1278 try { 1279 // Fix up the migration, ignoring already-migrated elements, to snap up to 1280 // date with new changes to the set of global versus system/secure settings 1281 String[] settingsToMove = { Settings.System.STAY_ON_WHILE_PLUGGED_IN }; 1282 moveSettingsToNewTable(db, TABLE_SYSTEM, TABLE_GLOBAL, settingsToMove, true); 1283 1284 db.setTransactionSuccessful(); 1285 } finally { 1286 db.endTransaction(); 1287 } 1288 upgradeVersion = 86; 1289 } 1290 1291 // *** Remember to update DATABASE_VERSION above! 1292 1293 if (upgradeVersion != currentVersion) { 1294 Log.w(TAG, "Got stuck trying to upgrade from version " + upgradeVersion 1295 + ", must wipe the settings provider"); 1296 db.execSQL("DROP TABLE IF EXISTS global"); 1297 db.execSQL("DROP TABLE IF EXISTS globalIndex1"); 1298 db.execSQL("DROP TABLE IF EXISTS system"); 1299 db.execSQL("DROP INDEX IF EXISTS systemIndex1"); 1300 db.execSQL("DROP TABLE IF EXISTS secure"); 1301 db.execSQL("DROP INDEX IF EXISTS secureIndex1"); 1302 db.execSQL("DROP TABLE IF EXISTS gservices"); 1303 db.execSQL("DROP INDEX IF EXISTS gservicesIndex1"); 1304 db.execSQL("DROP TABLE IF EXISTS bluetooth_devices"); 1305 db.execSQL("DROP TABLE IF EXISTS bookmarks"); 1306 db.execSQL("DROP INDEX IF EXISTS bookmarksIndex1"); 1307 db.execSQL("DROP INDEX IF EXISTS bookmarksIndex2"); 1308 db.execSQL("DROP TABLE IF EXISTS favorites"); 1309 onCreate(db); 1310 1311 // Added for diagnosing settings.db wipes after the fact 1312 String wipeReason = oldVersion + "/" + upgradeVersion + "/" + currentVersion; 1313 db.execSQL("INSERT INTO secure(name,value) values('" + 1314 "wiped_db_reason" + "','" + wipeReason + "');"); 1315 } 1316 } 1317 1318 private String[] hashsetToStringArray(HashSet<String> set) { 1319 String[] array = new String[set.size()]; 1320 return set.toArray(array); 1321 } 1322 1323 private void moveSettingsToNewTable(SQLiteDatabase db, 1324 String sourceTable, String destTable, 1325 String[] settingsToMove, boolean doIgnore) { 1326 // Copy settings values from the source table to the dest, and remove from the source 1327 SQLiteStatement insertStmt = null; 1328 SQLiteStatement deleteStmt = null; 1329 1330 db.beginTransaction(); 1331 try { 1332 insertStmt = db.compileStatement("INSERT " 1333 + (doIgnore ? " OR IGNORE " : "") 1334 + " INTO " + destTable + " (name,value) SELECT name,value FROM " 1335 + sourceTable + " WHERE name=?"); 1336 deleteStmt = db.compileStatement("DELETE FROM " + sourceTable + " WHERE name=?"); 1337 1338 for (String setting : settingsToMove) { 1339 insertStmt.bindString(1, setting); 1340 insertStmt.execute(); 1341 1342 deleteStmt.bindString(1, setting); 1343 deleteStmt.execute(); 1344 } 1345 db.setTransactionSuccessful(); 1346 } finally { 1347 db.endTransaction(); 1348 if (insertStmt != null) { 1349 insertStmt.close(); 1350 } 1351 if (deleteStmt != null) { 1352 deleteStmt.close(); 1353 } 1354 } 1355 } 1356 1357 private void upgradeLockPatternLocation(SQLiteDatabase db) { 1358 Cursor c = db.query(TABLE_SYSTEM, new String[] {"_id", "value"}, "name='lock_pattern'", 1359 null, null, null, null); 1360 if (c.getCount() > 0) { 1361 c.moveToFirst(); 1362 String lockPattern = c.getString(1); 1363 if (!TextUtils.isEmpty(lockPattern)) { 1364 // Convert lock pattern 1365 try { 1366 LockPatternUtils lpu = new LockPatternUtils(mContext); 1367 List<LockPatternView.Cell> cellPattern = 1368 LockPatternUtils.stringToPattern(lockPattern); 1369 lpu.saveLockPattern(cellPattern); 1370 } catch (IllegalArgumentException e) { 1371 // Don't want corrupted lock pattern to hang the reboot process 1372 } 1373 } 1374 c.close(); 1375 db.delete(TABLE_SYSTEM, "name='lock_pattern'", null); 1376 } else { 1377 c.close(); 1378 } 1379 } 1380 1381 private void upgradeScreenTimeoutFromNever(SQLiteDatabase db) { 1382 // See if the timeout is -1 (for "Never"). 1383 Cursor c = db.query(TABLE_SYSTEM, new String[] { "_id", "value" }, "name=? AND value=?", 1384 new String[] { Settings.System.SCREEN_OFF_TIMEOUT, "-1" }, 1385 null, null, null); 1386 1387 SQLiteStatement stmt = null; 1388 if (c.getCount() > 0) { 1389 c.close(); 1390 try { 1391 stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)" 1392 + " VALUES(?,?);"); 1393 1394 // Set the timeout to 30 minutes in milliseconds 1395 loadSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT, 1396 Integer.toString(30 * 60 * 1000)); 1397 } finally { 1398 if (stmt != null) stmt.close(); 1399 } 1400 } else { 1401 c.close(); 1402 } 1403 } 1404 1405 private void upgradeVibrateSettingFromNone(SQLiteDatabase db) { 1406 int vibrateSetting = getIntValueFromSystem(db, Settings.System.VIBRATE_ON, 0); 1407 // If the ringer vibrate value is invalid, set it to the default 1408 if ((vibrateSetting & 3) == AudioManager.VIBRATE_SETTING_OFF) { 1409 vibrateSetting = AudioService.getValueForVibrateSetting(0, 1410 AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_ONLY_SILENT); 1411 } 1412 // Apply the same setting to the notification vibrate value 1413 vibrateSetting = AudioService.getValueForVibrateSetting(vibrateSetting, 1414 AudioManager.VIBRATE_TYPE_NOTIFICATION, vibrateSetting); 1415 1416 SQLiteStatement stmt = null; 1417 try { 1418 stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)" 1419 + " VALUES(?,?);"); 1420 loadSetting(stmt, Settings.System.VIBRATE_ON, vibrateSetting); 1421 } finally { 1422 if (stmt != null) 1423 stmt.close(); 1424 } 1425 } 1426 1427 private void upgradeScreenTimeout(SQLiteDatabase db) { 1428 // Change screen timeout to current default 1429 db.beginTransaction(); 1430 SQLiteStatement stmt = null; 1431 try { 1432 stmt = db.compileStatement("INSERT OR REPLACE INTO system(name,value)" 1433 + " VALUES(?,?);"); 1434 loadIntegerSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT, 1435 R.integer.def_screen_off_timeout); 1436 db.setTransactionSuccessful(); 1437 } finally { 1438 db.endTransaction(); 1439 if (stmt != null) 1440 stmt.close(); 1441 } 1442 } 1443 1444 private void upgradeAutoBrightness(SQLiteDatabase db) { 1445 db.beginTransaction(); 1446 try { 1447 String value = 1448 mContext.getResources().getBoolean( 1449 R.bool.def_screen_brightness_automatic_mode) ? "1" : "0"; 1450 db.execSQL("INSERT OR REPLACE INTO system(name,value) values('" + 1451 Settings.System.SCREEN_BRIGHTNESS_MODE + "','" + value + "');"); 1452 db.setTransactionSuccessful(); 1453 } finally { 1454 db.endTransaction(); 1455 } 1456 } 1457 1458 /** 1459 * Loads the default set of bookmarked shortcuts from an xml file. 1460 * 1461 * @param db The database to write the values into 1462 */ 1463 private void loadBookmarks(SQLiteDatabase db) { 1464 ContentValues values = new ContentValues(); 1465 1466 PackageManager packageManager = mContext.getPackageManager(); 1467 try { 1468 XmlResourceParser parser = mContext.getResources().getXml(R.xml.bookmarks); 1469 XmlUtils.beginDocument(parser, "bookmarks"); 1470 1471 final int depth = parser.getDepth(); 1472 int type; 1473 1474 while (((type = parser.next()) != XmlPullParser.END_TAG || 1475 parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) { 1476 1477 if (type != XmlPullParser.START_TAG) { 1478 continue; 1479 } 1480 1481 String name = parser.getName(); 1482 if (!"bookmark".equals(name)) { 1483 break; 1484 } 1485 1486 String pkg = parser.getAttributeValue(null, "package"); 1487 String cls = parser.getAttributeValue(null, "class"); 1488 String shortcutStr = parser.getAttributeValue(null, "shortcut"); 1489 String category = parser.getAttributeValue(null, "category"); 1490 1491 int shortcutValue = shortcutStr.charAt(0); 1492 if (TextUtils.isEmpty(shortcutStr)) { 1493 Log.w(TAG, "Unable to get shortcut for: " + pkg + "/" + cls); 1494 continue; 1495 } 1496 1497 final Intent intent; 1498 final String title; 1499 if (pkg != null && cls != null) { 1500 ActivityInfo info = null; 1501 ComponentName cn = new ComponentName(pkg, cls); 1502 try { 1503 info = packageManager.getActivityInfo(cn, 0); 1504 } catch (PackageManager.NameNotFoundException e) { 1505 String[] packages = packageManager.canonicalToCurrentPackageNames( 1506 new String[] { pkg }); 1507 cn = new ComponentName(packages[0], cls); 1508 try { 1509 info = packageManager.getActivityInfo(cn, 0); 1510 } catch (PackageManager.NameNotFoundException e1) { 1511 Log.w(TAG, "Unable to add bookmark: " + pkg + "/" + cls, e); 1512 continue; 1513 } 1514 } 1515 1516 intent = new Intent(Intent.ACTION_MAIN, null); 1517 intent.addCategory(Intent.CATEGORY_LAUNCHER); 1518 intent.setComponent(cn); 1519 title = info.loadLabel(packageManager).toString(); 1520 } else if (category != null) { 1521 intent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN, category); 1522 title = ""; 1523 } else { 1524 Log.w(TAG, "Unable to add bookmark for shortcut " + shortcutStr 1525 + ": missing package/class or category attributes"); 1526 continue; 1527 } 1528 1529 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 1530 values.put(Settings.Bookmarks.INTENT, intent.toUri(0)); 1531 values.put(Settings.Bookmarks.TITLE, title); 1532 values.put(Settings.Bookmarks.SHORTCUT, shortcutValue); 1533 db.delete("bookmarks", "shortcut = ?", 1534 new String[] { Integer.toString(shortcutValue) }); 1535 db.insert("bookmarks", null, values); 1536 } 1537 } catch (XmlPullParserException e) { 1538 Log.w(TAG, "Got execption parsing bookmarks.", e); 1539 } catch (IOException e) { 1540 Log.w(TAG, "Got execption parsing bookmarks.", e); 1541 } 1542 } 1543 1544 /** 1545 * Loads the default volume levels. It is actually inserting the index of 1546 * the volume array for each of the volume controls. 1547 * 1548 * @param db the database to insert the volume levels into 1549 */ 1550 private void loadVolumeLevels(SQLiteDatabase db) { 1551 SQLiteStatement stmt = null; 1552 try { 1553 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 1554 + " VALUES(?,?);"); 1555 1556 loadSetting(stmt, Settings.System.VOLUME_MUSIC, 1557 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_MUSIC]); 1558 loadSetting(stmt, Settings.System.VOLUME_RING, 1559 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_RING]); 1560 loadSetting(stmt, Settings.System.VOLUME_SYSTEM, 1561 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_SYSTEM]); 1562 loadSetting( 1563 stmt, 1564 Settings.System.VOLUME_VOICE, 1565 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_VOICE_CALL]); 1566 loadSetting(stmt, Settings.System.VOLUME_ALARM, 1567 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_ALARM]); 1568 loadSetting( 1569 stmt, 1570 Settings.System.VOLUME_NOTIFICATION, 1571 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_NOTIFICATION]); 1572 loadSetting( 1573 stmt, 1574 Settings.System.VOLUME_BLUETOOTH_SCO, 1575 AudioManager.DEFAULT_STREAM_VOLUME[AudioManager.STREAM_BLUETOOTH_SCO]); 1576 1577 loadSetting(stmt, Settings.System.MODE_RINGER, 1578 AudioManager.RINGER_MODE_NORMAL); 1579 1580 // By default: 1581 // - ringtones, notification, system and music streams are affected by ringer mode 1582 // on non voice capable devices (tablets) 1583 // - ringtones, notification and system streams are affected by ringer mode 1584 // on voice capable devices (phones) 1585 int ringerModeAffectedStreams = (1 << AudioManager.STREAM_RING) | 1586 (1 << AudioManager.STREAM_NOTIFICATION) | 1587 (1 << AudioManager.STREAM_SYSTEM) | 1588 (1 << AudioManager.STREAM_SYSTEM_ENFORCED); 1589 if (!mContext.getResources().getBoolean( 1590 com.android.internal.R.bool.config_voice_capable)) { 1591 ringerModeAffectedStreams |= (1 << AudioManager.STREAM_MUSIC); 1592 } 1593 loadSetting(stmt, Settings.System.MODE_RINGER_STREAMS_AFFECTED, 1594 ringerModeAffectedStreams); 1595 1596 loadSetting(stmt, Settings.System.MUTE_STREAMS_AFFECTED, 1597 ((1 << AudioManager.STREAM_MUSIC) | 1598 (1 << AudioManager.STREAM_RING) | 1599 (1 << AudioManager.STREAM_NOTIFICATION) | 1600 (1 << AudioManager.STREAM_SYSTEM))); 1601 } finally { 1602 if (stmt != null) stmt.close(); 1603 } 1604 1605 loadVibrateWhenRingingSetting(db); 1606 } 1607 1608 private void loadVibrateSetting(SQLiteDatabase db, boolean deleteOld) { 1609 if (deleteOld) { 1610 db.execSQL("DELETE FROM system WHERE name='" + Settings.System.VIBRATE_ON + "'"); 1611 } 1612 1613 SQLiteStatement stmt = null; 1614 try { 1615 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 1616 + " VALUES(?,?);"); 1617 1618 // Vibrate on by default for ringer, on for notification 1619 int vibrate = 0; 1620 vibrate = AudioService.getValueForVibrateSetting(vibrate, 1621 AudioManager.VIBRATE_TYPE_NOTIFICATION, 1622 AudioManager.VIBRATE_SETTING_ONLY_SILENT); 1623 vibrate |= AudioService.getValueForVibrateSetting(vibrate, 1624 AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_ONLY_SILENT); 1625 loadSetting(stmt, Settings.System.VIBRATE_ON, vibrate); 1626 } finally { 1627 if (stmt != null) stmt.close(); 1628 } 1629 } 1630 1631 private void loadVibrateWhenRingingSetting(SQLiteDatabase db) { 1632 // The default should be off. VIBRATE_SETTING_ONLY_SILENT should also be ignored here. 1633 // Phone app should separately check whether AudioManager#getRingerMode() returns 1634 // RINGER_MODE_VIBRATE, with which the device should vibrate anyway. 1635 int vibrateSetting = getIntValueFromSystem(db, Settings.System.VIBRATE_ON, 1636 AudioManager.VIBRATE_SETTING_OFF); 1637 boolean vibrateWhenRinging = ((vibrateSetting & 3) == AudioManager.VIBRATE_SETTING_ON); 1638 1639 SQLiteStatement stmt = null; 1640 try { 1641 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 1642 + " VALUES(?,?);"); 1643 loadSetting(stmt, Settings.System.VIBRATE_WHEN_RINGING, vibrateWhenRinging ? 1 : 0); 1644 } finally { 1645 if (stmt != null) stmt.close(); 1646 } 1647 } 1648 1649 private void loadSettings(SQLiteDatabase db) { 1650 loadSystemSettings(db); 1651 loadSecureSettings(db); 1652 // The global table only exists for the 'owner' user 1653 if (mUserHandle == UserHandle.USER_OWNER) { 1654 loadGlobalSettings(db); 1655 } 1656 } 1657 1658 private void loadSystemSettings(SQLiteDatabase db) { 1659 SQLiteStatement stmt = null; 1660 try { 1661 stmt = db.compileStatement("INSERT OR IGNORE INTO system(name,value)" 1662 + " VALUES(?,?);"); 1663 1664 loadBooleanSetting(stmt, Settings.System.DIM_SCREEN, 1665 R.bool.def_dim_screen); 1666 loadIntegerSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT, 1667 R.integer.def_screen_off_timeout); 1668 1669 // Set default cdma emergency tone 1670 loadSetting(stmt, Settings.System.EMERGENCY_TONE, 0); 1671 1672 // Set default cdma call auto retry 1673 loadSetting(stmt, Settings.System.CALL_AUTO_RETRY, 0); 1674 1675 // Set default cdma DTMF type 1676 loadSetting(stmt, Settings.System.DTMF_TONE_TYPE_WHEN_DIALING, 0); 1677 1678 // Set default hearing aid 1679 loadSetting(stmt, Settings.System.HEARING_AID, 0); 1680 1681 // Set default tty mode 1682 loadSetting(stmt, Settings.System.TTY_MODE, 0); 1683 1684 loadIntegerSetting(stmt, Settings.System.SCREEN_BRIGHTNESS, 1685 R.integer.def_screen_brightness); 1686 1687 loadBooleanSetting(stmt, Settings.System.SCREEN_BRIGHTNESS_MODE, 1688 R.bool.def_screen_brightness_automatic_mode); 1689 1690 loadDefaultAnimationSettings(stmt); 1691 1692 loadBooleanSetting(stmt, Settings.System.ACCELEROMETER_ROTATION, 1693 R.bool.def_accelerometer_rotation); 1694 1695 loadDefaultHapticSettings(stmt); 1696 1697 loadBooleanSetting(stmt, Settings.System.NOTIFICATION_LIGHT_PULSE, 1698 R.bool.def_notification_pulse); 1699 loadSetting(stmt, Settings.Secure.SET_INSTALL_LOCATION, 0); 1700 loadSetting(stmt, Settings.Secure.DEFAULT_INSTALL_LOCATION, 1701 PackageHelper.APP_INSTALL_AUTO); 1702 1703 loadUISoundEffectsSettings(stmt); 1704 1705 loadIntegerSetting(stmt, Settings.System.POINTER_SPEED, 1706 R.integer.def_pointer_speed); 1707 } finally { 1708 if (stmt != null) stmt.close(); 1709 } 1710 } 1711 1712 private void loadUISoundEffectsSettings(SQLiteStatement stmt) { 1713 loadIntegerSetting(stmt, Settings.System.POWER_SOUNDS_ENABLED, 1714 R.integer.def_power_sounds_enabled); 1715 loadStringSetting(stmt, Settings.System.LOW_BATTERY_SOUND, 1716 R.string.def_low_battery_sound); 1717 loadBooleanSetting(stmt, Settings.System.DTMF_TONE_WHEN_DIALING, 1718 R.bool.def_dtmf_tones_enabled); 1719 loadBooleanSetting(stmt, Settings.System.SOUND_EFFECTS_ENABLED, 1720 R.bool.def_sound_effects_enabled); 1721 loadBooleanSetting(stmt, Settings.System.HAPTIC_FEEDBACK_ENABLED, 1722 R.bool.def_haptic_feedback); 1723 1724 loadIntegerSetting(stmt, Settings.System.DOCK_SOUNDS_ENABLED, 1725 R.integer.def_dock_sounds_enabled); 1726 loadStringSetting(stmt, Settings.System.DESK_DOCK_SOUND, 1727 R.string.def_desk_dock_sound); 1728 loadStringSetting(stmt, Settings.System.DESK_UNDOCK_SOUND, 1729 R.string.def_desk_undock_sound); 1730 loadStringSetting(stmt, Settings.System.CAR_DOCK_SOUND, 1731 R.string.def_car_dock_sound); 1732 loadStringSetting(stmt, Settings.System.CAR_UNDOCK_SOUND, 1733 R.string.def_car_undock_sound); 1734 1735 loadIntegerSetting(stmt, Settings.System.LOCKSCREEN_SOUNDS_ENABLED, 1736 R.integer.def_lockscreen_sounds_enabled); 1737 loadStringSetting(stmt, Settings.System.LOCK_SOUND, 1738 R.string.def_lock_sound); 1739 loadStringSetting(stmt, Settings.System.UNLOCK_SOUND, 1740 R.string.def_unlock_sound); 1741 } 1742 1743 private void loadDefaultAnimationSettings(SQLiteStatement stmt) { 1744 loadFractionSetting(stmt, Settings.System.WINDOW_ANIMATION_SCALE, 1745 R.fraction.def_window_animation_scale, 1); 1746 loadFractionSetting(stmt, Settings.System.TRANSITION_ANIMATION_SCALE, 1747 R.fraction.def_window_transition_scale, 1); 1748 } 1749 1750 private void loadDefaultHapticSettings(SQLiteStatement stmt) { 1751 loadBooleanSetting(stmt, Settings.System.HAPTIC_FEEDBACK_ENABLED, 1752 R.bool.def_haptic_feedback); 1753 } 1754 1755 private void loadSecureSettings(SQLiteDatabase db) { 1756 SQLiteStatement stmt = null; 1757 try { 1758 stmt = db.compileStatement("INSERT OR IGNORE INTO secure(name,value)" 1759 + " VALUES(?,?);"); 1760 1761 loadBooleanSetting(stmt, Settings.Secure.PACKAGE_VERIFIER_ENABLE, 1762 R.bool.def_package_verifier_enable); 1763 1764 loadStringSetting(stmt, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, 1765 R.string.def_location_providers_allowed); 1766 1767 loadBooleanSetting(stmt, Settings.Secure.WIFI_ON, 1768 R.bool.def_wifi_on); 1769 loadBooleanSetting(stmt, Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1770 R.bool.def_networks_available_notification_on); 1771 1772 String wifiWatchList = SystemProperties.get("ro.com.android.wifi-watchlist"); 1773 if (!TextUtils.isEmpty(wifiWatchList)) { 1774 loadSetting(stmt, Settings.Secure.WIFI_WATCHDOG_WATCH_LIST, wifiWatchList); 1775 } 1776 1777 // Set the preferred network mode to 0 = Global, CDMA default 1778 int type; 1779 if (TelephonyManager.getLteOnCdmaModeStatic() == PhoneConstants.LTE_ON_CDMA_TRUE) { 1780 type = Phone.NT_MODE_GLOBAL; 1781 } else { 1782 type = SystemProperties.getInt("ro.telephony.default_network", 1783 RILConstants.PREFERRED_NETWORK_MODE); 1784 } 1785 loadSetting(stmt, Settings.Secure.PREFERRED_NETWORK_MODE, type); 1786 1787 // Don't do this. The SystemServer will initialize ADB_ENABLED from a 1788 // persistent system property instead. 1789 //loadSetting(stmt, Settings.Secure.ADB_ENABLED, 0); 1790 1791 // Allow mock locations default, based on build 1792 loadSetting(stmt, Settings.Secure.ALLOW_MOCK_LOCATION, 1793 "1".equals(SystemProperties.get("ro.allow.mock.location")) ? 1 : 0); 1794 1795 loadSecure35Settings(stmt); 1796 1797 loadBooleanSetting(stmt, Settings.Secure.MOUNT_PLAY_NOTIFICATION_SND, 1798 R.bool.def_mount_play_notification_snd); 1799 1800 loadBooleanSetting(stmt, Settings.Secure.MOUNT_UMS_AUTOSTART, 1801 R.bool.def_mount_ums_autostart); 1802 1803 loadBooleanSetting(stmt, Settings.Secure.MOUNT_UMS_PROMPT, 1804 R.bool.def_mount_ums_prompt); 1805 1806 loadBooleanSetting(stmt, Settings.Secure.MOUNT_UMS_NOTIFY_ENABLED, 1807 R.bool.def_mount_ums_notify_enabled); 1808 1809 loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SCRIPT_INJECTION, 1810 R.bool.def_accessibility_script_injection); 1811 1812 loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS, 1813 R.string.def_accessibility_web_content_key_bindings); 1814 1815 loadIntegerSetting(stmt, Settings.Secure.LONG_PRESS_TIMEOUT, 1816 R.integer.def_long_press_timeout_millis); 1817 1818 loadBooleanSetting(stmt, Settings.Secure.TOUCH_EXPLORATION_ENABLED, 1819 R.bool.def_touch_exploration_enabled); 1820 1821 loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD, 1822 R.bool.def_accessibility_speak_password); 1823 1824 loadStringSetting(stmt, Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL, 1825 R.string.def_accessibility_screen_reader_url); 1826 1827 if (SystemProperties.getBoolean("ro.lockscreen.disable.default", false) == true) { 1828 loadSetting(stmt, Settings.System.LOCKSCREEN_DISABLED, "1"); 1829 } else { 1830 loadBooleanSetting(stmt, Settings.System.LOCKSCREEN_DISABLED, 1831 R.bool.def_lockscreen_disabled); 1832 } 1833 1834 loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ENABLED, 1835 R.bool.def_screensaver_enabled); 1836 loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK, 1837 R.bool.def_screensaver_activate_on_dock); 1838 loadBooleanSetting(stmt, Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP, 1839 R.bool.def_screensaver_activate_on_sleep); 1840 loadStringSetting(stmt, Settings.Secure.SCREENSAVER_COMPONENTS, 1841 R.string.def_screensaver_component); 1842 loadStringSetting(stmt, Settings.Secure.SCREENSAVER_DEFAULT_COMPONENT, 1843 R.string.def_screensaver_component); 1844 1845 loadBooleanSetting(stmt, Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 1846 R.bool.def_accessibility_display_magnification_enabled); 1847 1848 loadFractionSetting(stmt, Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE, 1849 R.fraction.def_accessibility_display_magnification_scale, 1); 1850 1851 loadBooleanSetting(stmt, 1852 Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE, 1853 R.bool.def_accessibility_display_magnification_auto_update); 1854 } finally { 1855 if (stmt != null) stmt.close(); 1856 } 1857 } 1858 1859 private void loadSecure35Settings(SQLiteStatement stmt) { 1860 loadBooleanSetting(stmt, Settings.Secure.BACKUP_ENABLED, 1861 R.bool.def_backup_enabled); 1862 1863 loadStringSetting(stmt, Settings.Secure.BACKUP_TRANSPORT, 1864 R.string.def_backup_transport); 1865 } 1866 1867 private void loadGlobalSettings(SQLiteDatabase db) { 1868 SQLiteStatement stmt = null; 1869 try { 1870 stmt = db.compileStatement("INSERT OR IGNORE INTO global(name,value)" 1871 + " VALUES(?,?);"); 1872 1873 // --- Previously in 'system' 1874 loadBooleanSetting(stmt, Settings.Global.AIRPLANE_MODE_ON, 1875 R.bool.def_airplane_mode_on); 1876 1877 loadStringSetting(stmt, Settings.Global.AIRPLANE_MODE_RADIOS, 1878 R.string.def_airplane_mode_radios); 1879 1880 loadStringSetting(stmt, Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS, 1881 R.string.airplane_mode_toggleable_radios); 1882 1883 loadBooleanSetting(stmt, Settings.Global.ASSISTED_GPS_ENABLED, 1884 R.bool.assisted_gps_enabled); 1885 1886 loadBooleanSetting(stmt, Settings.Global.AUTO_TIME, 1887 R.bool.def_auto_time); // Sync time to NITZ 1888 1889 loadBooleanSetting(stmt, Settings.Global.AUTO_TIME_ZONE, 1890 R.bool.def_auto_time_zone); // Sync timezone to NITZ 1891 1892 loadSetting(stmt, Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 1893 ("1".equals(SystemProperties.get("ro.kernel.qemu")) || 1894 mContext.getResources().getBoolean(R.bool.def_stay_on_while_plugged_in)) 1895 ? 1 : 0); 1896 1897 loadIntegerSetting(stmt, Settings.Global.WIFI_SLEEP_POLICY, 1898 R.integer.def_wifi_sleep_policy); 1899 1900 // --- Previously in 'secure' 1901 loadBooleanSetting(stmt, Settings.Global.BLUETOOTH_ON, 1902 R.bool.def_bluetooth_on); 1903 1904 // Enable or disable Cell Broadcast SMS 1905 loadSetting(stmt, Settings.Global.CDMA_CELL_BROADCAST_SMS, 1906 RILConstants.CDMA_CELL_BROADCAST_SMS_DISABLED); 1907 1908 // Data roaming default, based on build 1909 loadSetting(stmt, Settings.Global.DATA_ROAMING, 1910 "true".equalsIgnoreCase( 1911 SystemProperties.get("ro.com.android.dataroaming", 1912 "false")) ? 1 : 0); 1913 1914 loadBooleanSetting(stmt, Settings.Global.DEVICE_PROVISIONED, 1915 R.bool.def_device_provisioned); 1916 1917 final int maxBytes = mContext.getResources().getInteger( 1918 R.integer.def_download_manager_max_bytes_over_mobile); 1919 if (maxBytes > 0) { 1920 loadSetting(stmt, Settings.Global.DOWNLOAD_MAX_BYTES_OVER_MOBILE, 1921 Integer.toString(maxBytes)); 1922 } 1923 1924 final int recommendedMaxBytes = mContext.getResources().getInteger( 1925 R.integer.def_download_manager_recommended_max_bytes_over_mobile); 1926 if (recommendedMaxBytes > 0) { 1927 loadSetting(stmt, Settings.Global.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE, 1928 Integer.toString(recommendedMaxBytes)); 1929 } 1930 1931 // Mobile Data default, based on build 1932 loadSetting(stmt, Settings.Global.MOBILE_DATA, 1933 "true".equalsIgnoreCase( 1934 SystemProperties.get("ro.com.android.mobiledata", 1935 "true")) ? 1 : 0); 1936 1937 loadBooleanSetting(stmt, Settings.Global.NETSTATS_ENABLED, 1938 R.bool.def_netstats_enabled); 1939 1940 loadBooleanSetting(stmt, Settings.Global.INSTALL_NON_MARKET_APPS, 1941 R.bool.def_install_non_market_apps); 1942 1943 loadIntegerSetting(stmt, Settings.Global.NETWORK_PREFERENCE, 1944 R.integer.def_network_preference); 1945 1946 loadBooleanSetting(stmt, Settings.Global.USB_MASS_STORAGE_ENABLED, 1947 R.bool.def_usb_mass_storage_enabled); 1948 1949 loadIntegerSetting(stmt, Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT, 1950 R.integer.def_max_dhcp_retries); 1951 1952 // --- New global settings start here 1953 } finally { 1954 if (stmt != null) stmt.close(); 1955 } 1956 } 1957 1958 private void loadSetting(SQLiteStatement stmt, String key, Object value) { 1959 stmt.bindString(1, key); 1960 stmt.bindString(2, value.toString()); 1961 stmt.execute(); 1962 } 1963 1964 private void loadStringSetting(SQLiteStatement stmt, String key, int resid) { 1965 loadSetting(stmt, key, mContext.getResources().getString(resid)); 1966 } 1967 1968 private void loadBooleanSetting(SQLiteStatement stmt, String key, int resid) { 1969 loadSetting(stmt, key, 1970 mContext.getResources().getBoolean(resid) ? "1" : "0"); 1971 } 1972 1973 private void loadIntegerSetting(SQLiteStatement stmt, String key, int resid) { 1974 loadSetting(stmt, key, 1975 Integer.toString(mContext.getResources().getInteger(resid))); 1976 } 1977 1978 private void loadFractionSetting(SQLiteStatement stmt, String key, int resid, int base) { 1979 loadSetting(stmt, key, 1980 Float.toString(mContext.getResources().getFraction(resid, base, base))); 1981 } 1982 1983 private int getIntValueFromSystem(SQLiteDatabase db, String name, int defaultValue) { 1984 return getIntValueFromTable(db, TABLE_SYSTEM, name, defaultValue); 1985 } 1986 1987 private int getIntValueFromTable(SQLiteDatabase db, String table, String name, 1988 int defaultValue) { 1989 String value = getStringValueFromTable(db, table, name, null); 1990 return (value != null) ? Integer.parseInt(value) : defaultValue; 1991 } 1992 1993 private String getStringValueFromTable(SQLiteDatabase db, String table, String name, 1994 String defaultValue) { 1995 Cursor c = null; 1996 try { 1997 c = db.query(table, new String[] { Settings.System.VALUE }, "name='" + name + "'", 1998 null, null, null, null); 1999 if (c != null && c.moveToFirst()) { 2000 String val = c.getString(0); 2001 return val == null ? defaultValue : val; 2002 } 2003 } finally { 2004 if (c != null) c.close(); 2005 } 2006 return defaultValue; 2007 } 2008} 2009