android.app.backup.BlobBackupHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.app.backup;
import android.os.ParcelFileDescriptor;
import android.util.ArrayMap;
import android.util.Log;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.CRC32;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;
/**
* Utility class for writing BackupHelpers whose underlying data is a
* fixed set of byte-array blobs. The helper manages diff detection
* and compression on the wire.
*
* @hide
*/
public abstract class BlobBackupHelper implements BackupHelper {
private static final String TAG = "BlobBackupHelper";
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
private final int mCurrentBlobVersion;
private final String[] mKeys;
public BlobBackupHelper(int currentBlobVersion, String... keys) {
mCurrentBlobVersion = currentBlobVersion;
mKeys = keys;
}
// Client interface
/**
* Generate and return the byte array containing the backup payload describing
* the current data state. During a backup operation this method is called once
* per key that was supplied to the helper's constructor.
*
* @return A byte array containing the data blob that the caller wishes to store,
* or {@code null} if the current state is empty or undefined.
*/
abstract protected byte[] getBackupPayload(String key);
/**
* Given a byte array that was restored from backup, do whatever is appropriate
* to apply that described state in the live system. This method is called once
* per key/value payload that was delivered for restore. Typically data is delivered
* for restore in lexical order by key, not in the order in which the keys
* were supplied in the constructor.
*
* @param payload The byte array that was passed to {@link #getBackupPayload()}
* on the ancestral device.
*/
abstract protected void applyRestoredPayload(String key, byte[] payload);
// Internal implementation
/*
* State on-disk format:
* [Int] : overall blob version number
* [Int=N] : number of keys represented in the state blob
* N* :
* [String] key
* [Long] blob checksum, calculated after compression
*/
@SuppressWarnings("resource")
private ArrayMap readOldState(ParcelFileDescriptor oldStateFd) {
final ArrayMap state = new ArrayMap();
FileInputStream fis = new FileInputStream(oldStateFd.getFileDescriptor());
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream in = new DataInputStream(bis);
try {
int version = in.readInt();
if (version <= mCurrentBlobVersion) {
final int numKeys = in.readInt();
for (int i = 0; i < numKeys; i++) {
String key = in.readUTF();
long checksum = in.readLong();
state.put(key, checksum);
}
} else {
Log.w(TAG, "Prior state from unrecognized version " + version);
}
} catch (EOFException e) {
// Empty file is expected on first backup, so carry on. If the state
// is truncated we just treat it the same way.
state.clear();
} catch (Exception e) {
Log.e(TAG, "Error examining prior backup state " + e.getMessage());
state.clear();
}
return state;
}
/**
* New overall state record
*/
private void writeBackupState(ArrayMap state, ParcelFileDescriptor stateFile) {
try {
FileOutputStream fos = new FileOutputStream(stateFile.getFileDescriptor());
// We explicitly don't close 'out' because we must not close the backing fd.
// The FileOutputStream will not close it implicitly.
@SuppressWarnings("resource")
DataOutputStream out = new DataOutputStream(fos);
out.writeInt(mCurrentBlobVersion);
final int N = (state != null) ? state.size() : 0;
out.writeInt(N);
for (int i = 0; i < N; i++) {
out.writeUTF(state.keyAt(i));
out.writeLong(state.valueAt(i).longValue());
}
} catch (IOException e) {
Log.e(TAG, "Unable to write updated state", e);
}
}
// Also versions the deflated blob internally in case we need to revise it
private byte[] deflate(byte[] data) {
byte[] result = null;
if (data != null) {
try {
ByteArrayOutputStream sink = new ByteArrayOutputStream();
DataOutputStream headerOut = new DataOutputStream(sink);
// write the header directly to the sink ahead of the deflated payload
headerOut.writeInt(mCurrentBlobVersion);
DeflaterOutputStream out = new DeflaterOutputStream(sink);
out.write(data);
out.close(); // finishes and commits the compression run
result = sink.toByteArray();
if (DEBUG) {
Log.v(TAG, "Deflated " + data.length + " bytes to " + result.length);
}
} catch (IOException e) {
Log.w(TAG, "Unable to process payload: " + e.getMessage());
}
}
return result;
}
// Returns null if inflation failed
private byte[] inflate(byte[] compressedData) {
byte[] result = null;
if (compressedData != null) {
try {
ByteArrayInputStream source = new ByteArrayInputStream(compressedData);
DataInputStream headerIn = new DataInputStream(source);
int version = headerIn.readInt();
if (version > mCurrentBlobVersion) {
Log.w(TAG, "Saved payload from unrecognized version " + version);
return null;
}
InflaterInputStream in = new InflaterInputStream(source);
ByteArrayOutputStream inflated = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int nRead;
while ((nRead = in.read(buffer)) > 0) {
inflated.write(buffer, 0, nRead);
}
in.close();
inflated.flush();
result = inflated.toByteArray();
if (DEBUG) {
Log.v(TAG, "Inflated " + compressedData.length + " bytes to " + result.length);
}
} catch (IOException e) {
// result is still null here
Log.w(TAG, "Unable to process restored payload: " + e.getMessage());
}
}
return result;
}
private long checksum(byte[] buffer) {
if (buffer != null) {
try {
CRC32 crc = new CRC32();
ByteArrayInputStream bis = new ByteArrayInputStream(buffer);
byte[] buf = new byte[4096];
int nRead = 0;
while ((nRead = bis.read(buf)) >= 0) {
crc.update(buf, 0, nRead);
}
return crc.getValue();
} catch (Exception e) {
// whoops; fall through with an explicitly bogus checksum
}
}
return -1;
}
// BackupHelper interface
@Override
public void performBackup(ParcelFileDescriptor oldStateFd, BackupDataOutput data,
ParcelFileDescriptor newStateFd) {
final ArrayMap oldState = readOldState(oldStateFd);
final ArrayMap newState = new ArrayMap();
try {
for (String key : mKeys) {
final byte[] payload = deflate(getBackupPayload(key));
final long checksum = checksum(payload);
newState.put(key, checksum);
Long oldChecksum = oldState.get(key);
if (oldChecksum == null || checksum != oldChecksum) {
if (DEBUG) {
Log.i(TAG, "State has changed for key " + key + ", writing");
}
if (payload != null) {
data.writeEntityHeader(key, payload.length);
data.writeEntityData(payload, payload.length);
} else {
// state's changed but there's no current payload => delete
data.writeEntityHeader(key, -1);
}
} else {
if (DEBUG) {
Log.i(TAG, "No change under key " + key + " => not writing");
}
}
}
} catch (Exception e) {
Log.w(TAG, "Unable to record notification state: " + e.getMessage());
newState.clear();
} finally {
// Always recommit the state even if nothing changed
writeBackupState(newState, newStateFd);
}
}
@Override
public void restoreEntity(BackupDataInputStream data) {
final String key = data.getKey();
try {
// known key?
int which;
for (which = 0; which < mKeys.length; which++) {
if (key.equals(mKeys[which])) {
break;
}
}
if (which >= mKeys.length) {
Log.e(TAG, "Unrecognized key " + key + ", ignoring");
return;
}
byte[] compressed = new byte[data.size()];
data.read(compressed);
byte[] payload = inflate(compressed);
applyRestoredPayload(key, payload);
} catch (Exception e) {
Log.e(TAG, "Exception restoring entity " + key + " : " + e.getMessage());
}
}
@Override
public void writeNewStateDescription(ParcelFileDescriptor newState) {
// Just ensure that we do a full backup the first time after a restore
writeBackupState(null, newState);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy