/** * Write all modified screens to the data stream. * * @param data output stream for key/value pairs * @throws IOException */ private void backupScreens(BackupDataOutput data) throws IOException { // persist things that have changed since the last backup ContentResolver cr = mContext.getContentResolver(); Cursor cursor = cr.query(WorkspaceScreens.CONTENT_URI, SCREEN_PROJECTION, null, null, null); try { cursor.moveToPosition(-1); if (DEBUG) Log.d(TAG, "dumping screens after: " + mLastBackupRestoreTime); while(cursor.moveToNext()) { final long id = cursor.getLong(ID_INDEX); final long updateTime = cursor.getLong(ID_MODIFIED); Key key = getKey(Key.SCREEN, id); mKeys.add(key); final String backupKey = keyToBackupKey(key); if (!mExistingKeys.contains(backupKey) || updateTime >= mLastBackupRestoreTime) { writeRowToBackup(key, packScreen(cursor), data); } else { if (VERBOSE) Log.v(TAG, "screen already backup up " + id); } } } finally { cursor.close(); } }
public void onBackup(ParcelFileDescriptor paramParcelFileDescriptor1, BackupDataOutput paramBackupDataOutput, ParcelFileDescriptor paramParcelFileDescriptor2) throws IOException { ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream(); DataOutputStream localDataOutputStream = new DataOutputStream(localByteArrayOutputStream); long l = ((Long)DfeApiConfig.androidId.get()).longValue(); Object[] arrayOfObject = new Object[1]; arrayOfObject[0] = FinskyLog.scrubPii(Long.toHexString(l)); FinskyLog.d("Backing up aid: %s", arrayOfObject); localDataOutputStream.writeLong(l); flushBufferData(paramBackupDataOutput, localByteArrayOutputStream, "vending"); writeData(paramBackupDataOutput, localByteArrayOutputStream, localDataOutputStream, "auto_update_enabled", ((Boolean)FinskyPreferences.autoUpdateEnabled.get()).booleanValue()); writeData(paramBackupDataOutput, localByteArrayOutputStream, localDataOutputStream, "update_over_wifi_only", ((Boolean)FinskyPreferences.autoUpdateWifiOnly.get()).booleanValue()); writeData(paramBackupDataOutput, localByteArrayOutputStream, localDataOutputStream, "auto_add_shortcuts", ((Boolean)VendingPreferences.AUTO_ADD_SHORTCUTS.get()).booleanValue()); writeData(paramBackupDataOutput, localByteArrayOutputStream, localDataOutputStream, "notify_updates", ((Boolean)VendingPreferences.NOTIFY_UPDATES.get()).booleanValue()); writeData(paramBackupDataOutput, localByteArrayOutputStream, localDataOutputStream, "notify_updates_completion", ((Boolean)VendingPreferences.NOTIFY_UPDATES_COMPLETION.get()).booleanValue()); localDataOutputStream.writeInt(((Integer)FinskyPreferences.contentFilterLevel.get()).intValue()); flushBufferData(paramBackupDataOutput, localByteArrayOutputStream, "content-filter-level"); VendingPreferences.BACKED_UP.put(Boolean.valueOf(true)); }
private void writeRowToBackup(Key key, byte[] blob, Journal out, BackupDataOutput data) throws IOException { String backupKey = keyToBackupKey(key); data.writeEntityHeader(backupKey, blob.length); data.writeEntityData(blob, blob.length); out.rows++; out.bytes += blob.length; if (VERBOSE) Log.v(TAG, "saving " + geKeyType(key) + " " + backupKey + ": " + getKeyName(key) + "/" + blob.length); if(DEBUG_PAYLOAD) { String encoded = Base64.encodeToString(blob, 0, blob.length, Base64.NO_WRAP); final int chunkSize = 1024; for (int offset = 0; offset < encoded.length(); offset += chunkSize) { int end = offset + chunkSize; end = Math.min(end, encoded.length()); Log.w(TAG, "wrote " + encoded.substring(offset, end)); } } }
/** * Write all modified favorites to the data stream. * * @param data output stream for key/value pairs * @throws IOException */ private void backupFavorites(BackupDataOutput data) throws IOException { // persist things that have changed since the last backup ContentResolver cr = mContext.getContentResolver(); // Don't backup apps in other profiles for now. Cursor cursor = cr.query(Favorites.CONTENT_URI, FAVORITE_PROJECTION, getUserSelectionArg(), null, null); try { cursor.moveToPosition(-1); while(cursor.moveToNext()) { final long id = cursor.getLong(ID_INDEX); final long updateTime = cursor.getLong(ID_MODIFIED); Key key = getKey(Key.FAVORITE, id); mKeys.add(key); final String backupKey = keyToBackupKey(key); if (!mExistingKeys.contains(backupKey) || updateTime >= mLastBackupRestoreTime) { writeRowToBackup(key, packFavorite(cursor), data); } else { if (DEBUG) Log.d(TAG, "favorite already backup up: " + id); } } } finally { cursor.close(); } }
@Override public void onCreate() { // The name of the SharedPreferences file final String prefs = getPackageName() + "_preferences"; // getPackageName() cannot be used in final SharedPreferencesBackupHelper prefsHelper = new SharedPreferencesBackupHelper(this, prefs) { @Override public void performBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) { if (new WorkTimeTrackerBackupManager(WorkTimeTrackerBackupAgentHelper.this).isEnabled()) { super.performBackup(oldState, data, newState); } } }; addHelper(PREFS_BACKUP_KEY, prefsHelper); DbBackupHelper dbHelper = new DbBackupHelper(this); addHelper(DB_BACKUP_KEY, dbHelper); }
private void backupCursor(BackupDataOutput data, ContentResolver contentResolver, Cursor cursor) { StringBuilder backedUp = new StringBuilder(); int idColumn = cursor.getColumnIndex(ID_COLUMN); while (cursor.moveToNext()) { int id = cursor.getInt(idColumn); byte[] serialized = mAdaptor.Serialize(cursor); try { data.writeEntityHeader("row_" + id, serialized.length); data.writeEntityData(serialized, serialized.length); if (backedUp.length() != 0) backedUp.append(','); backedUp.append(id); } catch (IOException e) { Log.e("AltidroidBackup", "cannot backup: " + id); e.printStackTrace(); } } // Mark all entries that were just backed up as such if (backedUp.length() > 0) { ContentValues values = new ContentValues(); values.put("backed_up", true); contentResolver.update(mUri, values, "_id IN (" + backedUp.toString() + ")", null); } }
private void writeData(BackupDataOutput data, String value) throws IOException { // Create buffer stream and data output stream for our data ByteArrayOutputStream bufStream = new ByteArrayOutputStream(); DataOutputStream outWriter = new DataOutputStream(bufStream); // Write structured data outWriter.writeUTF(value); // Send the data to the Backup Manager via the BackupDataOutput byte[] buffer = bufStream.toByteArray(); int len = buffer.length; data.writeEntityHeader(ACCOUNTS_BACKUP_KEY, len); data.writeEntityData(buffer, len); }
private void writeData(BackupDataOutput data, String value) throws IOException { // Create buffer stream and data output stream for our data ByteArrayOutputStream bufStream = new ByteArrayOutputStream(); DataOutputStream outWriter = new DataOutputStream(bufStream); // Write structured data outWriter.writeUTF(value); // Send the data to the Backup Manager via the BackupDataOutput byte[] buffer = bufStream.toByteArray(); int len = buffer.length; data.writeEntityHeader(SETTINGS_BACKUP_KEY, len); data.writeEntityData(buffer, len); }
private int transferIncrementalRestoreData(String packageName, ParcelFileDescriptor outputFileDescriptor) throws IOException, InvalidAlgorithmParameterException, InvalidKeyException { ParcelFileDescriptor inputFileDescriptor = buildInputFileDescriptor(); ZipInputStream inputStream = buildInputStream(inputFileDescriptor); BackupDataOutput backupDataOutput = new BackupDataOutput(outputFileDescriptor.getFileDescriptor()); Optional<ZipEntry> zipEntryOptional = seekToEntry(inputStream, configuration.getIncrementalBackupDirectory() + packageName); while (zipEntryOptional.isPresent()) { String fileName = new File(zipEntryOptional.get().getName()).getName(); String blobKey = new String(Base64.decode(fileName, Base64.DEFAULT)); byte[] backupData = Streams.readFullyNoClose(inputStream); backupDataOutput.writeEntityHeader(blobKey, backupData.length); backupDataOutput.writeEntityData(backupData, backupData.length); inputStream.closeEntry(); zipEntryOptional = seekToEntry(inputStream, configuration.getIncrementalBackupDirectory() + packageName); } IoUtils.closeQuietly(inputFileDescriptor); IoUtils.closeQuietly(outputFileDescriptor); return TRANSPORT_OK; }
/** * We want to ensure that the UI is not trying to rewrite the data file * while we're reading it for backup, so we override this method to * supply the necessary locking. */ @Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { // Hold the lock while the FileBackupHelper performs the backup operation synchronized (BackupRestoreActivity.sDataLock) { super.onBackup(oldState, data, newState); } }
/** * Write all modified favorites to the data stream. * * @param data output stream for key/value pairs * @throws IOException */ private void backupFavorites(BackupDataOutput data) throws IOException { // persist things that have changed since the last backup ContentResolver cr = mContext.getContentResolver(); // Don't backup apps in other profiles for now. Cursor cursor = cr.query(Favorites.CONTENT_URI, FAVORITE_PROJECTION, getUserSelectionArg(), null, null); try { cursor.moveToPosition(-1); while(cursor.moveToNext()) { final long id = cursor.getLong(ID_INDEX); final long updateTime = cursor.getLong(ID_MODIFIED); Key key = getKey(Key.FAVORITE, id); mKeys.add(key); final String backupKey = keyToBackupKey(key); // Favorite proto changed in v4. Backup again if the version is old. if (!mExistingKeys.contains(backupKey) || updateTime >= mLastBackupRestoreTime || restoredBackupVersion < 4) { writeRowToBackup(key, packFavorite(cursor), data); } else { if (DEBUG) Log.d(TAG, "favorite already backup up: " + id); } } } finally { cursor.close(); } }
private void writeRowToBackup(String backupKey, MessageNano proto, BackupDataOutput data) throws IOException { byte[] blob = writeCheckedBytes(proto); data.writeEntityHeader(backupKey, blob.length); data.writeEntityData(blob, blob.length); mBackupDataWasUpdated = true; if (VERBOSE) Log.v(TAG, "Writing New entry " + backupKey); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { synchronized(FlavordexProvider.class) { super.onBackup(oldState, data, newState); } }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { Log.i(TAG, "Performing backup"); SharedPreferences preferences = this.getSharedPreferences( Constants.SETTINGS_NAME, Context.MODE_PRIVATE); backupPreferences(data, preferences); Log.i(TAG, "Backup complete"); }
private void backupPreferences(BackupDataOutput data, SharedPreferences preferences) throws IOException { PreferenceBackupHelper preferenceDumper = createPreferenceBackupHelper(); byte[] dumpedContents = preferenceDumper.exportPreferences(preferences); data.writeEntityHeader(PREFERENCES_ENTITY, dumpedContents.length); data.writeEntityData(dumpedContents, dumpedContents.length); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { synchronized (HostDatabase.dbLock) { super.onBackup(oldState, data, newState); } }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { Log.d(LOG_TAG, "onBackup called"); synchronized (DbHelper.dbLock) { super.onBackup(oldState, data, newState); } }
private static void flushBufferData(BackupDataOutput paramBackupDataOutput, ByteArrayOutputStream paramByteArrayOutputStream, String paramString) throws IOException { byte[] arrayOfByte = paramByteArrayOutputStream.toByteArray(); paramBackupDataOutput.writeEntityHeader(paramString, arrayOfByte.length); paramBackupDataOutput.writeEntityData(arrayOfByte, arrayOfByte.length); paramByteArrayOutputStream.reset(); }
/** * Back up launcher data so we can restore the user's state on a new device. * * <P>The journal is a timestamp and a list of keys that were saved as of that time. * * <P>Keys may come back in any order, so each key/value is one complete row of the database. * * @param oldState notes from the last backup * @param data incremental key/value pairs to persist off-device * @param newState notes for the next backup * @throws IOException */ @Override public void performBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) { if (VERBOSE) Log.v(TAG, "onBackup"); Journal in = readJournal(oldState); Journal out = new Journal(); long lastBackupTime = in.t; out.t = System.currentTimeMillis(); out.rows = 0; out.bytes = 0; Log.v(TAG, "lastBackupTime = " + lastBackupTime); ArrayList<Key> keys = new ArrayList<Key>(); if (launcherIsReady()) { try { backupFavorites(in, data, out, keys); backupScreens(in, data, out, keys); backupIcons(in, data, out, keys); backupWidgets(in, data, out, keys); } catch (IOException e) { Log.e(TAG, "launcher backup has failed", e); } out.key = keys.toArray(new BackupProtos.Key[keys.size()]); } else { out = in; } writeJournal(newState, out); Log.v(TAG, "onBackup: wrote " + out.bytes + "b in " + out.rows + " rows."); }
/** * Write all modified favorites to the data stream. * * * @param in notes from last backup * @param data output stream for key/value pairs * @param out notes about this backup * @param keys keys to mark as clean in the notes for next backup * @throws IOException */ private void backupFavorites(Journal in, BackupDataOutput data, Journal out, ArrayList<Key> keys) throws IOException { // read the old ID set Set<String> savedIds = getSavedIdsByType(Key.FAVORITE, in); if (DEBUG) Log.d(TAG, "favorite savedIds.size()=" + savedIds.size()); // persist things that have changed since the last backup ContentResolver cr = mContext.getContentResolver(); Cursor cursor = cr.query(Favorites.CONTENT_URI, FAVORITE_PROJECTION, null, null, null); Set<String> currentIds = new HashSet<String>(cursor.getCount()); try { cursor.moveToPosition(-1); while(cursor.moveToNext()) { final long id = cursor.getLong(ID_INDEX); final long updateTime = cursor.getLong(ID_MODIFIED); Key key = getKey(Key.FAVORITE, id); keys.add(key); final String backupKey = keyToBackupKey(key); currentIds.add(backupKey); if (!savedIds.contains(backupKey) || updateTime >= in.t) { byte[] blob = packFavorite(cursor); writeRowToBackup(key, blob, out, data); } else { if (VERBOSE) Log.v(TAG, "favorite " + id + " was too old: " + updateTime); } } } finally { cursor.close(); } if (DEBUG) Log.d(TAG, "favorite currentIds.size()=" + currentIds.size()); // these IDs must have been deleted savedIds.removeAll(currentIds); out.rows += removeDeletedKeysFromBackup(savedIds, data); }
/** * Write all modified screens to the data stream. * * * @param in notes from last backup * @param data output stream for key/value pairs * @param out notes about this backup * @param keys keys to mark as clean in the notes for next backup * @throws IOException */ private void backupScreens(Journal in, BackupDataOutput data, Journal out, ArrayList<Key> keys) throws IOException { // read the old ID set Set<String> savedIds = getSavedIdsByType(Key.SCREEN, in); if (DEBUG) Log.d(TAG, "screen savedIds.size()=" + savedIds.size()); // persist things that have changed since the last backup ContentResolver cr = mContext.getContentResolver(); Cursor cursor = cr.query(WorkspaceScreens.CONTENT_URI, SCREEN_PROJECTION, null, null, null); Set<String> currentIds = new HashSet<String>(cursor.getCount()); try { cursor.moveToPosition(-1); if (DEBUG) Log.d(TAG, "dumping screens after: " + in.t); while(cursor.moveToNext()) { final long id = cursor.getLong(ID_INDEX); final long updateTime = cursor.getLong(ID_MODIFIED); Key key = getKey(Key.SCREEN, id); keys.add(key); final String backupKey = keyToBackupKey(key); currentIds.add(backupKey); if (!savedIds.contains(backupKey) || updateTime >= in.t) { byte[] blob = packScreen(cursor); writeRowToBackup(key, blob, out, data); } else { if (VERBOSE) Log.v(TAG, "screen " + id + " was too old: " + updateTime); } } } finally { cursor.close(); } if (DEBUG) Log.d(TAG, "screen currentIds.size()=" + currentIds.size()); // these IDs must have been deleted savedIds.removeAll(currentIds); out.rows += removeDeletedKeysFromBackup(savedIds, data); }
private int removeDeletedKeysFromBackup(Set<String> deletedIds, BackupDataOutput data) throws IOException { int rows = 0; for(String deleted: deletedIds) { if (VERBOSE) Log.v(TAG, "dropping deleted item " + deleted); data.writeEntityHeader(deleted, -1); rows++; } return rows; }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { // TODO Auto-generated method stub /* synchronized (HostDatabase.dbLock) { super.onBackup(oldState, data, newState); }*/ super.onBackup(oldState, data, newState); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { Log.v(TAG, "onBackup called"); // Hold the lock while the FileBackupHelper performs backup synchronized (StreamDatabase.dbLock) { super.onBackup(oldState, data, newState); } }
private void writeRowToBackup(String backupKey, MessageNano proto, BackupDataOutput data) throws IOException { byte[] blob = writeCheckedBytes(proto); data.writeEntityHeader(backupKey, blob.length); data.writeEntityData(blob, blob.length); if (VERBOSE) Log.v(TAG, "Writing New entry " + backupKey); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { Timber.i("onBackup"); lock.lock(); try { super.onBackup(oldState, data, newState); } finally { lock.unlock(); } }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { if (isAvailable) { instance.onBackup(oldState, data, newState); } }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { // Hold the lock while the BackupHelper performs backup synchronized (SafeSlinger.sDataLock) { super.onBackup(oldState, data, newState); } // store backup time and cancel pending notifications... SafeSlingerPrefs.setBackupCompleteDate(new Date().getTime()); String ns = Context.NOTIFICATION_SERVICE; NotificationManager nm = (NotificationManager) getSystemService(ns); nm.cancel(HomeActivity.NOTIFY_BACKUP_DELAY_ID); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { Log.d(LOG_TAG, "on backup"); super.onBackup(oldState, data, newState); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { synchronized (GeoPingBackupAgent.sDataLock) { Log.i(TAG, "----- ----- ----- ----- ----- ----- ----- ----- ----- "); Log.i(TAG, "----- ----- ----- ----- ----- ----- ----- ----- ----- "); Log.i(TAG, "----- onBackup GeoPing Backup --- Begin"); super.onBackup(oldState, data, newState); Log.i(TAG, "----- onBackup GeoPing Backup --- End"); Log.i(TAG, "----- ----- ----- ----- ----- ----- ----- ----- ----- "); Log.i(TAG, "----- ----- ----- ----- ----- ----- ----- ----- ----- "); } }
/** * Backs up the configured {@link android.content.SharedPreferences} groups. */ public void performBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) { String backupKey = GeoPingBackupAgent.BACKUP_KEY_PREFS; Log.i(TAG, "-------------------------------------------------"); Log.i(TAG, "--- performBackup : key = " + backupKey); super.performBackup(oldState, data, newState); Log.i(TAG, "----- performBackup End : key = " + backupKey); Log.i(TAG, "-------------------------------------------------"); }
@Override public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) throws IOException { // Hold the lock while the FileBackupHelper performs backup synchronized (UserData.sFileBackupLock) { super.onBackup(oldState, data, newState); } }
