@Override public void onCreate(final Bundle savedInstanceState) { super.onCreate(savedInstanceState); mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() { @Override public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) { final SubScreenFragment fragment = SubScreenFragment.this; final Context context = fragment.getActivity(); if (context == null || fragment.getPreferenceScreen() == null) { final String tag = fragment.getClass().getSimpleName(); // TODO: Introduce a static function to register this class and ensure that // onCreate must be called before "onSharedPreferenceChanged" is called. Log.w(tag, "onSharedPreferenceChanged called before activity starts."); return; } new BackupManager(context).dataChanged(); fragment.onSharedPreferenceChanged(prefs, key); } }; getSharedPreferences().registerOnSharedPreferenceChangeListener( mSharedPreferenceChangeListener); }
/** Set up the activity and populate its UI from the persistent data. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); /** Establish the activity's UI */ setContentView(R.layout.backup_restore); /** Once the UI has been inflated, cache the controls for later */ mFillingGroup = (RadioGroup) findViewById(R.id.filling_group); mAddMayoCheckbox = (CheckBox) findViewById(R.id.mayo); mAddTomatoCheckbox = (CheckBox) findViewById(R.id.tomato); /** Set up our file bookkeeping */ mDataFile = new File(getFilesDir(), BackupRestoreActivity.DATA_FILE_NAME); /** It is handy to keep a BackupManager cached */ mBackupManager = new BackupManager(this); /** * Finally, build the UI from the persistent store */ populateUI(); }
/** * Replaces the set of active extensions with the given list. */ public void setInternalActiveExtensions(List<ComponentName> extensions) { StringBuilder sb = new StringBuilder(); for (ComponentName extension : extensions) { if (sb.length() > 0) { sb.append(","); } sb.append(extension.flattenToString()); } mDefaultPreferences.edit() .putString(PREF_ACTIVE_EXTENSIONS, sb.toString()) .apply(); new BackupManager(mApplicationContext).dataChanged(); mInternalActiveExtensions.clear(); mInternalActiveExtensions.addAll(extensions); setActiveExtensions(getActiveExtensionNames()); }
@Override public void onSharedPreferenceChanged(SharedPreferences sp, String key) { new BackupManager(getActivity()).dataChanged(); // Potentially enable/disable the launcher activity if the settings button // preference has changed. if (isAdded() && AppearanceConfig.PREF_SETTINGS_BUTTON.equals(key)) { boolean enableLauncher = AppearanceConfig.PREF_SETTINGS_BUTTON_IN_LAUNCHER.equals( sp.getString(AppearanceConfig.PREF_SETTINGS_BUTTON, null)); getActivity().getPackageManager().setComponentEnabledSetting( new ComponentName( getActivity().getPackageName(), ConfigurationActivity.LAUNCHER_ACTIVITY_NAME), enableLauncher ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED : PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); } }
@Override public void onStop() { // If something changed, tell WikiService to kick back in. Don't // worry; if WikiService isn't paused, this won't do anything, and // if it's stopped for any other reason, it'll stop again when this // comes in. if(mHasChanged) { mHasChanged = false; Intent i = new Intent(getActivity(), WikiService.class); i.putExtra(QueueService.COMMAND_EXTRA, QueueService.COMMAND_RESUME); getActivity().startService(i); } BackupManager bm = new BackupManager(getActivity()); bm.dataChanged(); super.onStop(); }
/** * <p> * Sets whether or not the app is in night mode. * </p> * * <p> * <b>NOTE:</b> If the state of night mode changes, <b>the Activity WILL be * recreated</b>, as that's the only way you can change themes on-the-fly. * Make sure you've done whatever you need to BEFORE calling this, as there * is NO guarantee execution will meaningfully continue past this! * </p> * * @param night true to be night, false to be not night */ protected void setNightMode(boolean night) { SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); // Remember, ONLY act on this if this changed at all! if(prefs.getBoolean(GHDConstants.PREF_NIGHT_MODE, false) != night) { SharedPreferences.Editor edit = prefs.edit(); edit.putBoolean(GHDConstants.PREF_NIGHT_MODE, night); edit.apply(); BackupManager bm = new BackupManager(this); bm.dataChanged(); recreate(); } }
private void updateLastGraticule(@NonNull Info info) { // This'll just stash the last Graticule away in preferences so we can // start with the last-used one if preferences demand it as such. SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); SharedPreferences.Editor edit = prefs.edit(); edit.putBoolean(GHDConstants.PREF_DEFAULT_GRATICULE_GLOBALHASH, info.isGlobalHash()); Graticule g = info.getGraticule(); if(g != null) { edit.putString(GHDConstants.PREF_DEFAULT_GRATICULE_LATITUDE, g.getLatitudeString(true)); edit.putString(GHDConstants.PREF_DEFAULT_GRATICULE_LONGITUDE, g.getLongitudeString(true)); } edit.apply(); BackupManager bm = new BackupManager(this); bm.dataChanged(); }
/** * Stores a bunch of KnownLocations to preferences. Note that this <b>replaces</b> * all currently-stored KnownLocations. * * @param c a Context * @param locations a List of KnownLocations */ public static void storeKnownLocations(@NonNull Context c, @NonNull List<KnownLocation> locations) { SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(c); SharedPreferences.Editor edit = prefs.edit(); JSONArray arr = new JSONArray(); for(KnownLocation kl : locations) { arr.put(kl.serialize()); } // Man, that's easy. edit.putString(GHDConstants.PREF_KNOWN_LOCATIONS, arr.toString()); edit.apply(); BackupManager bm = new BackupManager(c); bm.dataChanged(); }
@Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String s) { new BackupManager(getActivity()).dataChanged(); // Potentially enable/disable the launcher activity if the settings button // preference has changed. final String launcherIntentKey = getString(R.string.pref_key_launcher_intent); if (isAdded() && launcherIntentKey.equals(s)) { final boolean hideLauncher = sharedPreferences.getBoolean(launcherIntentKey, false); getActivity().getPackageManager().setComponentEnabledSetting( new ComponentName( getActivity().getPackageName(), LAUNCHER_ACTIVITY_NAME), hideLauncher ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED : PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); } }
@Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String s) { new BackupManager(getActivity()).dataChanged(); // Potentially enable/disable the launcher activity if the settings button // preference has changed. final String launcherIntentKey = getString(R.string.pref_key_launcher_intent); if (isAdded() && launcherIntentKey.equals(s)) { final boolean hideLauncher = sharedPreferences.getBoolean(launcherIntentKey, false); packageManager.setComponentEnabledSetting( new ComponentName( getActivity().getPackageName(), LAUNCHER_ACTIVITY_NAME), hideLauncher ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED : PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); } }
public static String getUserID(Context context) { if (uniqueID == null) { SharedPreferences sharedPrefs = context.getSharedPreferences(SimpleBackupAgent.PREFS, Context.MODE_PRIVATE); uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null); if (uniqueID == null) { uniqueID = UUID.randomUUID().toString(); SharedPreferences.Editor editor = sharedPrefs.edit(); editor.putString(PREF_UNIQUE_ID, uniqueID); editor.commit(); //backup the changes BackupManager mBackupManager = new BackupManager(context); mBackupManager.dataChanged(); } } return uniqueID; }
@Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { LOGI(TAG, "onSharedPreferenceChanged(" + key + ')'); Context context = getApplicationContext(); if (null != context) { (new BackupManager(context)).dataChanged(); } if (Constants.PREF_VOLUME_PANEL.equals(key)) { // TRACK: what theme is being used. String panel = sharedPreferences.getString(key, StatusBarVolumePanel.TAG); VolumeAccessibilityService.VolumePanelChangeEvent event = new VolumeAccessibilityService.VolumePanelChangeEvent(panel, Utils.supportsMediaPlayback(panel)); onVolumePanelChangeEvent(event); } else if (Constants.PREF_REPORTING.equals(key)) { // TRACK: when the user opts out of being tracked. } }
@Override public int delete(Uri uri, String selection, String[] selectionArgs) { ContentConstants.ProtocolURLs vrUrl = convertURIToProtocolURL(uri); int count = 0; switch (vrUrl) { case URLProtocol: count = db.getWritableDatabase().delete(Protocol.TABLE_NAME, selection, selectionArgs); if (count > 0) { new BackupManager(getContext()).dataChanged(); } break; } getContext().getContentResolver().notifyChange(uri, null); // Returns the number of rows deleted. return count; }
@Override public Uri insert(Uri uri, ContentValues values) { ContentConstants.ProtocolURLs vrUrl = convertURIToProtocolURL(uri); long rowId = -1; switch (vrUrl) { case URLProtocol: rowId = db.getWritableDatabase().insert(Protocol.TABLE_NAME, null, values); new BackupManager(getContext()).dataChanged(); break; default: throw new SQLiteConstraintException("Failed to switch insert protocol " + uri); } // If the insert succeeded, the row ID exists. if (rowId > 0) { // Creates a URI with the note ID pattern and the new row ID appended to it. Uri noteUri = ContentConstants.getUriFor(vrUrl, rowId); // Notifies observers registered against this provider that the data changed. getContext().getContentResolver().notifyChange(noteUri, null); return noteUri; } else { throw new SQLiteConstraintException("Failed to insert row into " + uri); } }
@Override public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { int count = 0; ContentConstants.ProtocolURLs vrUrl = convertURIToProtocolURL(uri); switch (vrUrl) { case URLProtocol: SQLiteDatabase sql = db.getWritableDatabase(); count = sql.update(Protocol.TABLE_NAME, values, selection, selectionArgs); if (count > 0) { new BackupManager(getContext()).dataChanged(); } break; } getContext().getContentResolver().notifyChange(uri, null); return count; }
/** * Called when the application is starting, before any activity, service, or * receiver objects (excluding content providers) have been created. */ @Override public void onCreate() { super.onCreate(); checkApplicationResources(); mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this); mBackupManager = new BackupManager(this); initLocale(); mSdkInt = android.os.Build.VERSION.SDK_INT; int serviceType = getServiceType(); if (DSCApplication.SERVICE_TYPE_DISABLED != serviceType) { checkRegisteredServiceType(false); } mFolderObserverMap = new HashMap<>(); if (SERVICE_TYPE_FILE_OBSERVER == serviceType) { initVolumes(); initFolderObserverList(false); } }
@Override protected void onPause() { super.onPause(); // If the equalizer is silent, stop the service. // This makes it harder to leave running accidentally. if (mServiceActive && mUiState.getPhonon().isSilent()) { NoiseService.stopNow(getApplication(), R.string.stop_reason_silent); } SharedPreferences.Editor pref = getSharedPreferences(PREF_NAME, MODE_PRIVATE).edit(); pref.clear(); mUiState.saveState(pref); pref.commit(); new BackupManager(this).dataChanged(); // Stop receiving progress events. NoiseService.removePercentListener(this); mUiState.removeLockListener(this); }
@Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.create: createTestFiles(); break; case R.id.restore: new BackupManager(this).requestRestore(new RestoreObserver() { @Override public void restoreFinished(int error) { if (error == 0) { Toast.makeText(MainActivity.this, R.string.files_restored, Toast.LENGTH_SHORT).show(); } else { Toast.makeText(MainActivity.this, getString(R.string.restore_failed, error), Toast.LENGTH_SHORT).show(); } } }); break; } return super.onOptionsItemSelected(item); }
@Override public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { SQLiteDatabase dbWritable = mOpenHelper.getWritableDatabase(); dbWritable.beginTransaction(); int count = dbWritable.update(getTableName(uri), values, selection, selectionArgs); dbWritable.setTransactionSuccessful(); dbWritable.endTransaction(); // Log.i(TAG, "Updated rows: " + count); if (count > 0) { BackupManager.dataChanged(getContext().getPackageName()); } return count; }
/** * {@inheritDoc} */ @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); sharedPrefs = PreferenceManager.getDefaultSharedPreferences(getApplication()); sharedPrefs.registerOnSharedPreferenceChangeListener(new OnSharedPreferenceChangeListener() { @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { BackupManager.dataChanged(getPackageName()); } }); Utils.setStrictMode(true); setContentView(getLayoutResource()); initUI(); }
/** * Requests the system to update the system locale. Note that the system looks halted * for a while during the Locale migration, so the caller need to take care of it. * <p/> * Requires android.permission.CHANGE_CONFIGURATION */ public static void updateLocale(Locale locale) { try { IActivityManager am = ActivityManagerNative.getDefault(); Configuration config = am.getConfiguration(); // Will set userSetLocale to indicate this isn't some passing default - the user // wants this remembered config.setLocale(locale); am.updateConfiguration(config); // Trigger the dirty bit for the Settings Provider. BackupManager.dataChanged("com.android.providers.settings"); } catch (RemoteException e) { // Intentionally left blank } }
@Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { // Ask Backup BackupManager.dataChanged(getPackageName()); // Recompute Change Sumaries Log.d(TAG, "### onSharedPreferenceChanged key : " + key); Preference pref = findPreference(key); Log.d(TAG, "### onSharedPreferenceChanged findPreference : " + pref); setSummary(this, pref); // Tracker // GeoPingApplication.getInstance().tracker().trackPageView("/Pref/" + // key); Tracker tracker = tracker = GeoPingApplication.getGeoPingApplication(this).getTracker(); tracker.send(new HitBuilders.EventBuilder()// .setCategory("ui_pref") // Category .setAction("changed") // Action .setLabel(key) // Label .build()); }
/** * Click handler, designated in the layout, that runs a restore of the app's * most recent data when the button is pressed. */ public void onRestoreButtonClick(View v) { Log.v(TAG, "Requesting restore of our most recent data"); BackupManager mBackupManager = new BackupManager(this); mBackupManager.requestRestore(new RestoreObserver() { public void restoreFinished(int error) { /** Done with the restore! Now draw the new state of our data */ if (error == 0) { Log.v(TAG, "Restore finished, error = " + error); NotifToasts.showBackupRestored(GeoPingPrefActivity.this); } else { Log.e(TAG, "Restore finished with error = " + error); } } }); }
@Override public Uri insert(Uri uri, ContentValues values) { switch (sURIMatcher.match(uri)) { case PERSONS: long personId = personDatabase.insertEntity(values); Uri personUri = null; if (personId > -1) { personUri = Uri.withAppendedPath(Constants.CONTENT_URI, String.valueOf(personId)); getContext().getContentResolver().notifyChange(uri, null); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return personUri; default: throw new IllegalArgumentException("Unknown Uri: " + uri); } }
@Override public int delete(Uri uri, String selection, String[] selectionArgs) { int count = 0; switch (sURIMatcher.match(uri)) { case PERSON_ID: String entityId = uri.getLastPathSegment(); String[] args = new String[] { entityId }; count = personDatabase.deleteEntity(PersonColumns.SELECT_BY_ENTITY_ID, args); break; case PERSONS: count = personDatabase.deleteEntity(selection, selectionArgs); break; default: throw new IllegalArgumentException("Unknown Uri: " + uri); } if (count > 0) { getContext().getContentResolver().notifyChange(uri, null); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return count; }
@Override public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { int count = 0; switch (sURIMatcher.match(uri)) { case PERSON_ID: String entityId = uri.getLastPathSegment(); String[] args = new String[] { entityId }; count = personDatabase.updateEntity(values, PersonColumns.SELECT_BY_ENTITY_ID, args); break; case PERSONS: count = personDatabase.updateEntity(values, selection, selectionArgs); break; default: throw new IllegalArgumentException("Unknown Uri: " + uri); } if (count > 0) { getContext().getContentResolver().notifyChange(uri, null); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return count; }
@Override public Uri insert(Uri uri, ContentValues values) { switch (sURIMatcher.match(uri)) { case PAIRINGS: long pairingId = pairingDatabase.insertEntity(values); Uri pairingUri = null; if (pairingId > -1) { pairingUri = Uri.withAppendedPath(Constants.CONTENT_URI, String.valueOf(pairingId)); getContext().getContentResolver().notifyChange(uri, null); Log.i(TAG, String.format("Insert Pairing %s : %s", pairingUri, values)); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return pairingUri; default: throw new IllegalArgumentException("Unknown Uri: " + uri); } }
@Override public int delete(Uri uri, String selection, String[] selectionArgs) { int count = 0; switch (sURIMatcher.match(uri)) { case PAIRING_ID: String entityId = uri.getLastPathSegment(); String[] args = new String[] { entityId }; count = pairingDatabase.deleteEntity(PairingColumns.SELECT_BY_ENTITY_ID, args); break; case PAIRINGS: count = pairingDatabase.deleteEntity(selection, selectionArgs); break; default: throw new IllegalArgumentException("Unknown Uri: " + uri); } if (count > 0) { getContext().getContentResolver().notifyChange(uri, null); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return count; }
@Override public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { int count = 0; switch (sURIMatcher.match(uri)) { case PAIRING_ID: String entityId = uri.getLastPathSegment(); String[] args = new String[] { entityId }; count = pairingDatabase.updateEntity(values, PairingColumns.SELECT_BY_ENTITY_ID, args); break; case PAIRINGS: count = pairingDatabase.updateEntity(values, selection, selectionArgs); break; default: throw new IllegalArgumentException("Unknown Uri: " + uri); } if (count > 0) { getContext().getContentResolver().notifyChange(uri, null); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return count; }
@Override public Uri insert(Uri uri, ContentValues values) { switch (sURIMatcher.match(uri)) { case GEOFENCES: long geofenceId = geofenceDatabase.insertEntity(values); Uri geofenceUri = null; if (geofenceId > -1) { geofenceUri = Constants.getContentUri(geofenceId); getContext().getContentResolver().notifyChange(uri, null); Log.i(TAG, String.format("Insert GeoFence %s : %s", geofenceUri, values)); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return geofenceUri; default: throw new IllegalArgumentException("Unknown insert Uri: " + uri); } }
@Override public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { int count = 0; switch (sURIMatcher.match(uri)) { case GEOFENCE_ID: String entityId = uri.getLastPathSegment(); String[] args = new String[]{entityId}; count = geofenceDatabase.updateEntity(values, GeoFenceColumns.SELECT_BY_ENTITY_ID, args); break; case GEOFENCES: count = geofenceDatabase.updateEntity(values, selection, selectionArgs); break; default: throw new IllegalArgumentException("Unknown update Uri: " + uri); } if (count > 0) { getContext().getContentResolver().notifyChange(uri, null); // Backup BackupManager.dataChanged(getContext().getPackageName()); } return count; }
@Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { Activity a = getActivity(); if (key.equals(KEY_ALERTS)) { updateChildPreferences(); if (a != null) { Intent intent = new Intent(); intent.setClass(a, AlertReceiver.class); if (mAlert.isChecked()) { intent.setAction(AlertReceiver.ACTION_DISMISS_OLD_REMINDERS); } else { intent.setAction(CalendarContract.ACTION_EVENT_REMINDER); } a.sendBroadcast(intent); } } if (a != null) { BackupManager.dataChanged(a.getPackageName()); } }
private void saveActiveExtensionList() { StringBuilder sb = new StringBuilder(); synchronized (mActiveExtensions) { for (ExtensionWithData ci : mActiveExtensions) { if (sb.length() > 0) { sb.append(","); } sb.append(ci.listing.componentName.flattenToString()); } } mDefaultPreferences.edit() .putString(PREF_ACTIVE_EXTENSIONS, sb.toString()) .commit(); new BackupManager(mApplicationContext).dataChanged(); }
@Override public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) { (new BackupManager(getActivity())).dataChanged(); final Resources res = getResources(); if (key.equals(Settings.PREF_POPUP_ON)) { setPreferenceEnabled(Settings.PREF_KEY_PREVIEW_POPUP_DISMISS_DELAY, Settings.readKeyPreviewPopupEnabled(prefs, res)); } else if (key.equals(Settings.PREF_SHOW_LANGUAGE_SWITCH_KEY)) { setPreferenceEnabled(Settings.PREF_INCLUDE_OTHER_IMES_IN_LANGUAGE_SWITCH_LIST, Settings.readShowsLanguageSwitchKey(prefs)); } else if (key.equals(Settings.PREF_SHOW_SETUP_WIZARD_ICON)) { LauncherIconVisibilityManager.updateSetupWizardIconVisibility(getActivity()); } ensureConsistencyOfAutoCorrectionSettings(); updateVoiceModeSummary(); updateShowCorrectionSuggestionsSummary(); updateKeyPreviewPopupDelaySummary(); refreshEnablingsOfKeypressSoundAndVibrationSettings(prefs, getResources()); }
/** * Insert new item into favorites * * @param context */ @SuppressLint("NewApi") public static void insertFavorite(Context context, String code, String title, String location) { synchronized (DBHelper.sDataLock) { SQLiteDatabase db = getDatabase(context); ContentValues values = new ContentValues(); values.put("code", code); values.put("title", title); values.put("location", location); db.insert("favorites", null, values); db.close(); } favCodes.add(code); new BackupManager(context).dataChanged(); }
