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