Fix telephony backup creating diff when there is none.
The telephony provider recreates the message files for each
backup. This has the unfortunate side effect of making the
file modified time the time of the backup, which means the
diffing algorithm used for backups things the files have
changed.
To avoid this happening when there's no data change this CL
changes the backup agent to use the date from the most recent
message in a file as the file mtime, which should maintain
consistency between backup generations.
Bug: 140995339
Test: atest TelephonyProviderTests
Change-Id: I28753f2d92ef842d7ab4612913109a82d64d4d0a
diff --git a/src/com/android/providers/telephony/TelephonyBackupAgent.java b/src/com/android/providers/telephony/TelephonyBackupAgent.java
index b88cd6b..3d32bef 100644
--- a/src/com/android/providers/telephony/TelephonyBackupAgent.java
+++ b/src/com/android/providers/telephony/TelephonyBackupAgent.java
@@ -16,6 +16,7 @@
package com.android.providers.telephony;
+import android.annotation.NonNull;
import android.annotation.TargetApi;
import android.app.AlarmManager;
import android.app.IntentService;
@@ -443,48 +444,54 @@
return;
}
- int messagesWritten = 0;
+ // Backups consist of multiple chunks; each chunk consists of a set of messages
+ // of the same type in a chronological order.
+ BackupChunkInformation chunk;
try (JsonWriter jsonWriter = getJsonWriter(fileName)) {
if (fileName.endsWith(SMS_BACKUP_FILE_SUFFIX)) {
- messagesWritten = putSmsMessagesToJson(cursor, jsonWriter);
+ chunk = putSmsMessagesToJson(cursor, jsonWriter);
} else {
- messagesWritten = putMmsMessagesToJson(cursor, jsonWriter);
+ chunk = putMmsMessagesToJson(cursor, jsonWriter);
}
}
- backupFile(messagesWritten, fileName, data);
+ backupFile(chunk, fileName, data);
}
@VisibleForTesting
- int putMmsMessagesToJson(Cursor cursor,
+ @NonNull
+ BackupChunkInformation putMmsMessagesToJson(Cursor cursor,
JsonWriter jsonWriter) throws IOException {
+ BackupChunkInformation results = new BackupChunkInformation();
jsonWriter.beginArray();
- int msgCount;
- for (msgCount = 0; msgCount < mMaxMsgPerFile && !cursor.isAfterLast();
+ for (; results.count < mMaxMsgPerFile && !cursor.isAfterLast();
cursor.moveToNext()) {
- msgCount += writeMmsToWriter(jsonWriter, cursor);
+ writeMmsToWriter(jsonWriter, cursor, results);
}
jsonWriter.endArray();
- return msgCount;
+ return results;
}
@VisibleForTesting
- int putSmsMessagesToJson(Cursor cursor, JsonWriter jsonWriter) throws IOException {
-
+ @NonNull
+ BackupChunkInformation putSmsMessagesToJson(Cursor cursor, JsonWriter jsonWriter)
+ throws IOException {
+ BackupChunkInformation results = new BackupChunkInformation();
jsonWriter.beginArray();
- int msgCount;
- for (msgCount = 0; msgCount < mMaxMsgPerFile && !cursor.isAfterLast();
- ++msgCount, cursor.moveToNext()) {
- writeSmsToWriter(jsonWriter, cursor);
+ for (; results.count < mMaxMsgPerFile && !cursor.isAfterLast();
+ ++results.count, cursor.moveToNext()) {
+ writeSmsToWriter(jsonWriter, cursor, results);
}
jsonWriter.endArray();
- return msgCount;
+ return results;
}
- private void backupFile(int messagesWritten, String fileName, FullBackupDataOutput data)
+ private void backupFile(BackupChunkInformation chunkInformation, String fileName,
+ FullBackupDataOutput data)
throws IOException {
final File file = new File(getFilesDir().getPath() + "/" + fileName);
+ file.setLastModified(chunkInformation.timestamp);
try {
- if (messagesWritten > 0) {
+ if (chunkInformation.count > 0) {
if (mBytesOverQuota > 0) {
mBytesOverQuota -= file.length();
return;
@@ -703,7 +710,8 @@
subscriptionInfo.getCountryIso().toUpperCase(Locale.US));
}
- private void writeSmsToWriter(JsonWriter jsonWriter, Cursor cursor) throws IOException {
+ private void writeSmsToWriter(JsonWriter jsonWriter, Cursor cursor,
+ BackupChunkInformation chunk) throws IOException {
jsonWriter.beginObject();
for (int i=0; i<cursor.getColumnCount(); ++i) {
@@ -726,12 +734,31 @@
break;
case Telephony.Sms._ID:
break;
+ case Telephony.Sms.DATE:
+ case Telephony.Sms.DATE_SENT:
+ chunk.timestamp = findNewestValue(chunk.timestamp, value);
+ jsonWriter.name(name).value(value);
+ break;
default:
jsonWriter.name(name).value(value);
break;
}
}
jsonWriter.endObject();
+ }
+
+ private long findNewestValue(long current, String latest) {
+ if(latest == null) {
+ return current;
+ }
+
+ try {
+ long latestLong = Long.valueOf(latest);
+ return Math.max(current, latestLong);
+ } catch (NumberFormatException e) {
+ Log.d(TAG, "Unable to parse value "+latest);
+ return current;
+ }
}
@@ -838,12 +865,13 @@
return recipients;
}
- private int writeMmsToWriter(JsonWriter jsonWriter, Cursor cursor) throws IOException {
+ private void writeMmsToWriter(JsonWriter jsonWriter, Cursor cursor,
+ BackupChunkInformation chunk) throws IOException {
final int mmsId = cursor.getInt(ID_IDX);
final MmsBody body = getMmsBody(mmsId);
// We backup any message that contains text, but only backup the text part.
if (body == null || body.text == null) {
- return 0;
+ return;
}
boolean subjectNull = true;
@@ -872,6 +900,11 @@
case Telephony.Mms._ID:
case Telephony.Mms.SUBJECT_CHARSET:
break;
+ case Telephony.Mms.DATE:
+ case Telephony.Mms.DATE_SENT:
+ chunk.timestamp = findNewestValue(chunk.timestamp, value);
+ jsonWriter.name(name).value(value);
+ break;
case Telephony.Mms.SUBJECT:
subjectNull = false;
default:
@@ -891,7 +924,7 @@
writeStringToWriter(jsonWriter, cursor, Telephony.Mms.SUBJECT_CHARSET);
}
jsonWriter.endObject();
- return 1;
+ chunk.count++;
}
private Mms readMmsFromReader(JsonReader jsonReader) throws IOException {
@@ -1407,4 +1440,12 @@
public static boolean getIsRestoring() {
return sIsRestoring;
}
+
+ private static class BackupChunkInformation {
+ // Timestamp of the recent message in the file
+ private long timestamp;
+
+ // The number of messages in the backup file
+ private int count = 0;
+ }
}
diff --git a/tests/src/com/android/providers/telephony/TelephonyBackupAgentTest.java b/tests/src/com/android/providers/telephony/TelephonyBackupAgentTest.java
index 37cf6e3..b1cd5e4 100644
--- a/tests/src/com/android/providers/telephony/TelephonyBackupAgentTest.java
+++ b/tests/src/com/android/providers/telephony/TelephonyBackupAgentTest.java
@@ -16,7 +16,10 @@
package com.android.providers.telephony;
+import static org.junit.Assert.assertArrayEquals;
+
import android.annotation.TargetApi;
+import android.app.backup.BackupDataOutput;
import android.app.backup.FullBackupDataOutput;
import android.content.ContentProvider;
import android.content.ContentResolver;
@@ -26,6 +29,7 @@
import android.database.Cursor;
import android.net.Uri;
import android.os.Build;
+import android.os.ParcelFileDescriptor;
import android.provider.BaseColumns;
import android.provider.Telephony;
import android.test.AndroidTestCase;
@@ -40,22 +44,29 @@
import android.util.Log;
import android.util.SparseArray;
+import libcore.io.IoUtils;
+
import com.google.android.mms.pdu.CharacterSets;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
+import java.util.concurrent.TimeUnit;
/**
* Tests for testing backup/restore of SMS and text MMS messages.
@@ -684,6 +695,44 @@
assertEquals(backupSizeAfterSecondQuotaHit, fullBackupDataOutput.getSize());
}
+ /**
+ * Test backups are consistent between runs. This ensures that when no data
+ * has changed between backup runs we don't generate a diff which needs to
+ * be sent to the server.
+ * @throws Exception
+ */
+ public void testBackup_WithoutChanges_DoesNotChangeOutput() throws Exception {
+ mSmsTable.addAll(Arrays.asList(mSmsRows));
+ mMmsTable.addAll(Arrays.asList(mMmsRows));
+
+ byte[] firstBackup = getBackup("1");
+ // Ensure there is some time between backup runs. This is the way to identify
+ // time dependent backup contents.
+ Thread.sleep(TimeUnit.MILLISECONDS.convert(1, TimeUnit.SECONDS));
+ byte[] secondBackup = getBackup("2");
+
+ // Make sure something has been backed up.
+ assertFalse(firstBackup == null || firstBackup.length == 0);
+
+ // Make sure the two backups are the same.
+ assertArrayEquals(firstBackup, secondBackup);
+ }
+
+ private byte[] getBackup(String runId) throws IOException {
+ File cacheDir = getContext().getCacheDir();
+ File backupOutput = File.createTempFile("backup", runId, cacheDir);
+ ParcelFileDescriptor outputFd =
+ ParcelFileDescriptor.open(backupOutput, ParcelFileDescriptor.MODE_WRITE_ONLY);
+ try {
+ FullBackupDataOutput fullBackupDataOutput = new FullBackupDataOutput(outputFd);
+ mTelephonyBackupAgent.onFullBackup(fullBackupDataOutput);
+ return IoUtils.readFileAsByteArray(backupOutput.getAbsolutePath());
+ } finally {
+ outputFd.close();
+ backupOutput.delete();
+ }
+ }
+
// Adding random keys to JSON to test handling it by the BackupAgent on restore.
private String addRandomDataToJson(String jsonString) throws JSONException {
JSONArray jsonArray = new JSONArray(jsonString);