This does not force an immediate backup. * * @param context application context */ public static void dataChanged(Context context) { if (sBackupManager == null) { sBackupManager = new BackupManager(context); } sBackupManager.dataChanged(); } /** * Back up launcher data so we can restore the user's state on a new device. * *
The journal is a timestamp and a list of keys that were saved as of that time. * *
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 onBackup(ParcelFileDescriptor oldState, BackupDataOutput data,
ParcelFileDescriptor newState)
throws IOException {
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 Keys may arrive in any order.
*
* @param data the key/value pairs from the server
* @param versionCode the version of the app that generated the data
* @param newState notes for the next backup
* @throws IOException
*/
@Override
public void onRestore(BackupDataInput data, int versionCode, ParcelFileDescriptor newState)
throws IOException {
Log.v(TAG, "onRestore");
int numRows = 0;
Journal out = new Journal();
ArrayList Keys arrive in any order, so screens and containers may not exist yet.
*
* @param key identifier for the row
* @param buffer the serialized proto from the stream, may be larger than dataSize
* @param dataSize the size of the proto from the stream
* @param keys keys to mark as clean in the notes for next backup
*/
private void restoreFavorite(Key key, byte[] buffer, int dataSize, ArrayList Keys arrive in any order, so children of this screen may already exist.
*
* @param key identifier for the row
* @param buffer the serialized proto from the stream, may be larger than dataSize
* @param dataSize the size of the proto from the stream
* @param keys keys to mark as clean in the notes for next backup
*/
private void restoreScreen(Key key, byte[] buffer, int dataSize, ArrayList Keys contain their own checksum instead of using
* the heavy-weight CheckedMessage wrapper.
*/
private Key getKey(int type, long id) {
Key key = new Key();
key.type = type;
key.id = id;
key.checksum = checkKey(key);
return key;
}
/** keys need to be strings, serialize and encode. */
private String keyToBackupKey(Key key) {
return Base64.encodeToString(Key.toByteArray(key), Base64.NO_WRAP | Base64.NO_PADDING);
}
/** keys need to be strings, decode and parse. */
private Key backupKeyToKey(String backupKey) throws KeyParsingException {
try {
Key key = Key.parseFrom(Base64.decode(backupKey, Base64.DEFAULT));
if (key.checksum != checkKey(key)) {
key = null;
throw new KeyParsingException("invalid key read from stream" + backupKey);
}
return key;
} catch (InvalidProtocolBufferNanoException e) {
throw new KeyParsingException(e);
} catch (IllegalArgumentException e) {
throw new KeyParsingException(e);
}
}
/** Compute the checksum over the important bits of a key. */
private long checkKey(Key key) {
CRC32 checksum = new CRC32();
checksum.update(key.type);
checksum.update((int) (key.id & 0xffff));
checksum.update((int) ((key.id >> 32) & 0xffff));
if (!TextUtils.isEmpty(key.name)) {
checksum.update(key.name.getBytes());
}
return checksum.getValue();
}
/** Serialize a Favorite for persistence, including a checksum wrapper. */
private byte[] packFavorite(Cursor c) {
Favorite favorite = new Favorite();
favorite.id = c.getLong(ID_INDEX);
favorite.screen = c.getInt(SCREEN_INDEX);
favorite.container = c.getInt(CONTAINER_INDEX);
favorite.cellX = c.getInt(CELLX_INDEX);
favorite.cellY = c.getInt(CELLY_INDEX);
favorite.spanX = c.getInt(SPANX_INDEX);
favorite.spanY = c.getInt(SPANY_INDEX);
favorite.iconType = c.getInt(ICON_TYPE_INDEX);
if (favorite.iconType == Favorites.ICON_TYPE_RESOURCE) {
String iconPackage = c.getString(ICON_PACKAGE_INDEX);
if (!TextUtils.isEmpty(iconPackage)) {
favorite.iconPackage = iconPackage;
}
String iconResource = c.getString(ICON_RESOURCE_INDEX);
if (!TextUtils.isEmpty(iconResource)) {
favorite.iconResource = iconResource;
}
}
if (favorite.iconType == Favorites.ICON_TYPE_BITMAP) {
byte[] blob = c.getBlob(ICON_INDEX);
if (blob != null && blob.length > 0) {
favorite.icon = blob;
}
}
String title = c.getString(TITLE_INDEX);
if (!TextUtils.isEmpty(title)) {
favorite.title = title;
}
String intent = c.getString(INTENT_INDEX);
if (!TextUtils.isEmpty(intent)) {
favorite.intent = intent;
}
favorite.itemType = c.getInt(ITEM_TYPE_INDEX);
if (favorite.itemType == Favorites.ITEM_TYPE_APPWIDGET) {
favorite.appWidgetId = c.getInt(APPWIDGET_ID_INDEX);
String appWidgetProvider = c.getString(APPWIDGET_PROVIDER_INDEX);
if (!TextUtils.isEmpty(appWidgetProvider)) {
favorite.appWidgetProvider = appWidgetProvider;
}
}
return writeCheckedBytes(favorite);
}
/** Deserialize a Favorite from persistence, after verifying checksum wrapper. */
private Favorite unpackFavorite(byte[] buffer, int offset, int dataSize)
throws InvalidProtocolBufferNanoException {
Favorite favorite = new Favorite();
MessageNano.mergeFrom(favorite, readCheckedBytes(buffer, offset, dataSize));
return favorite;
}
/** Serialize a Screen for persistence, including a checksum wrapper. */
private byte[] packScreen(Cursor c) {
Screen screen = new Screen();
screen.id = c.getLong(ID_INDEX);
screen.rank = c.getInt(SCREEN_RANK_INDEX);
return writeCheckedBytes(screen);
}
/** Deserialize a Screen from persistence, after verifying checksum wrapper. */
private Screen unpackScreen(byte[] buffer, int offset, int dataSize)
throws InvalidProtocolBufferNanoException {
Screen screen = new Screen();
MessageNano.mergeFrom(screen, readCheckedBytes(buffer, offset, dataSize));
return screen;
}
/**
* Read the old journal from the input file.
*
* In the event of any error, just pretend we didn't have a journal,
* in that case, do a full backup.
*
* @param oldState the read-0only file descriptor pointing to the old journal
* @return a Journal protocol bugffer
*/
private Journal readJournal(ParcelFileDescriptor oldState) {
int fileSize = (int) oldState.getStatSize();
int remaining = fileSize;
byte[] buffer = null;
Journal journal = new Journal();
if (remaining < MAX_JOURNAL_SIZE) {
FileInputStream inStream = new FileInputStream(oldState.getFileDescriptor());
int offset = 0;
buffer = new byte[remaining];
while (remaining > 0) {
int bytesRead = 0;
try {
bytesRead = inStream.read(buffer, offset, remaining);
} catch (IOException e) {
Log.w(TAG, "failed to read the journal", e);
buffer = null;
remaining = 0;
}
if (bytesRead > 0) {
remaining -= bytesRead;
} else {
// act like there is not journal
Log.w(TAG, "failed to read the journal");
buffer = null;
remaining = 0;
}
}
if (buffer != null) {
try {
MessageNano.mergeFrom(journal, readCheckedBytes(buffer, 0, fileSize));
} catch (InvalidProtocolBufferNanoException e) {
Log.d(TAG, "failed to read the journal", e);
journal.clear();
}
}
try {
inStream.close();
} catch (IOException e) {
Log.d(TAG, "failed to close the journal", e);
}
}
return journal;
}
/**
* Write the new journal to the output file.
*
* In the event of any error, just pretend we didn't have a journal,
* in that case, do a full backup.
* @param newState the write-only file descriptor pointing to the new journal
* @param journal a Journal protocol buffer
*/
private void writeJournal(ParcelFileDescriptor newState, Journal journal) {
FileOutputStream outStream = null;
try {
outStream = new FileOutputStream(newState.getFileDescriptor());
outStream.write(writeCheckedBytes(journal));
outStream.close();
} catch (IOException e) {
Log.d(TAG, "failed to write backup journal", e);
}
}
/** Wrap a proto in a CheckedMessage and compute the checksum. */
private byte[] writeCheckedBytes(MessageNano proto) {
CheckedMessage wrapper = new CheckedMessage();
wrapper.payload = MessageNano.toByteArray(proto);
CRC32 checksum = new CRC32();
checksum.update(wrapper.payload);
wrapper.checksum = checksum.getValue();
return MessageNano.toByteArray(wrapper);
}
/** Unwrap a proto message from a CheckedMessage, verifying the checksum. */
private byte[] readCheckedBytes(byte[] buffer, int offset, int dataSize)
throws InvalidProtocolBufferNanoException {
CheckedMessage wrapper = new CheckedMessage();
MessageNano.mergeFrom(wrapper, buffer, offset, dataSize);
CRC32 checksum = new CRC32();
checksum.update(wrapper.payload);
if (wrapper.checksum != checksum.getValue()) {
throw new InvalidProtocolBufferNanoException("checksum does not match");
}
return wrapper.payload;
}
private class KeyParsingException extends Throwable {
private KeyParsingException(Throwable cause) {
super(cause);
}
public KeyParsingException(String reason) {
super(reason);
}
}
}