1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/*
* Copyright (C) 2009 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 com.android.browser;
import java.io.IOException;
import android.app.BackupAgent;
import android.backup.BackupDataInput;
import android.backup.BackupDataOutput;
import android.database.Cursor;
import android.os.ParcelFileDescriptor;
import android.provider.Browser;
import android.provider.Browser.BookmarkColumns;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.CRC32;
/**
* Settings backup agent for the Android browser. Currently the only thing
* stored is the set of bookmarks. It's okay if I/O exceptions are thrown
* out of the agent; the calling code handles it and the backup operation
* simply fails.
*/
public class BrowserBackupAgent extends BackupAgent {
static final String BOOKMARK_KEY = "_bookmarks_";
/**
* In order to determine whether the bookmark set has changed since the
* last time we did a backup, we store the following bits of info in the
* state file after a backup:
*
* 1. the size of the flattened bookmark file
* 2. the CRC32 of that file
*
* After we flatten the bookmarks file here in onBackup, we compare its
* metrics with the values from the saved state. If they match, it means
* the bookmarks didn't really change and we don't need to send the data.
* (If they don't match, of course, then they've changed and we do indeed
* send the new flattened file to be backed up.)
*/
@Override
public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data,
ParcelFileDescriptor newState) throws IOException {
long savedFileSize = -1;
long savedCrc = -1;
// Extract the previous bookmark file size & CRC from the saved state
DataInputStream in = new DataInputStream(
new FileInputStream(oldState.getFileDescriptor()));
try {
savedFileSize = in.readLong();
savedCrc = in.readLong();
} catch (EOFException e) {
// It means we had no previous state; that's fine
}
// TODO: BUILD THE FLATTENED BOOKMARK FILE FROM THE DB (into tmpfile)
File tmpfile = getFilesDir().createTempFile("bkp", null);
CRC32 crc = new CRC32();
try {
Cursor cursor = getContentResolver().query(Browser.BOOKMARKS_URI,
new String[] { BookmarkColumns.URL, BookmarkColumns.VISITS,
BookmarkColumns.DATE, BookmarkColumns.CREATED,
BookmarkColumns.TITLE },
BookmarkColumns.BOOKMARK + " == 1 ", null, null);
int count = cursor.getCount();
FileOutputStream out = new FileOutputStream(tmpfile);
for (int i = 0; i < count; i++) {
StringBuilder sb = new StringBuilder();
// URL
sb.append("'");
sb.append(cursor.getString(0));
sb.append("','");
// VISITS
sb.append(cursor.getInt(1));
sb.append("','");
// DATE
sb.append(cursor.getLong(2));
sb.append("','");
// CREATED
sb.append(cursor.getLong(3));
sb.append("','");
// TITLE
sb.append(cursor.getString(4));
sb.append("'");
out.write(sb.toString().getBytes());
cursor.moveToNext();
}
out.close();
/*
android.util.Log.d("s", "backing up data" +
getContentResolver().openFileDescriptor(Browser.BOOKMARKS_URI, "r").toString());
*/
// NOTE: feed the flattened data through the crc engine on the fly
// to save re-reading it later just to checksum it
// Once the file is built, compare its metrics with the saved ones
if ((crc.getValue() != savedCrc) || (tmpfile.length() != savedFileSize)) {
// Different checksum or different size, so we need to back it up
copyFileToBackup(BOOKMARK_KEY, tmpfile, data);
}
// Last, record the metrics of the bookmark file that we just stored
writeBackupState(tmpfile.length(), crc.getValue(), newState);
} finally {
// Make sure to tidy up when we're done
tmpfile.delete();
}
}
/**
* Restore from backup -- reads in the flattened bookmark file as supplied from
* the backup service, parses that out, and rebuilds the bookmarks table in the
* browser database from it.
*/
@Override
public void onRestore(BackupDataInput data, int appVersionCode,
ParcelFileDescriptor newState) throws IOException {
long crc = -1;
File tmpfile = getFilesDir().createTempFile("rst", null);
try {
while (data.readNextHeader()) {
if (BOOKMARK_KEY.equals(data.getKey())) {
// Read the flattened bookmark data into a temp file
crc = copyBackupToFile(data, tmpfile, data.getDataSize());
// TODO: READ THE FLAT BOOKMARKS FILE 'tmpfile' AND REBUILD THE DB TABLE
}
// Last, write the state we just restored from so we can discern
// changes whenever we get invoked for backup in the future
writeBackupState(tmpfile.length(), crc, newState);
}
} finally {
// Whatever happens, delete the temp file
tmpfile.delete();
}
}
/*
* Utility functions
*/
// Write the file to backup as a single record under the given key
private void copyFileToBackup(String key, File file, BackupDataOutput data)
throws IOException {
final int CHUNK = 8192;
byte[] buf = new byte[CHUNK];
int toCopy = (int) file.length();
data.writeEntityHeader(key, toCopy);
FileInputStream in = new FileInputStream(file);
int nRead;
while (toCopy > 0) {
nRead = in.read(buf, 0, CHUNK);
data.writeEntityData(buf, nRead);
toCopy -= nRead;
}
in.close();
}
// Read the given file from backup to a file, calculating a CRC32 along the way
private long copyBackupToFile(BackupDataInput data, File file, int toRead)
throws IOException {
final int CHUNK = 8192;
byte[] buf = new byte[CHUNK];
CRC32 crc = new CRC32();
while (toRead > 0) {
int numRead = data.readEntityData(buf, 0, CHUNK);
crc.update(buf, 0, numRead);
toRead -= numRead;
}
return crc.getValue();
}
// Write the given metrics to the new state file
private void writeBackupState(long fileSize, long crc, ParcelFileDescriptor stateFile)
throws IOException {
DataOutputStream out = new DataOutputStream(
new FileOutputStream(stateFile.getFileDescriptor()));
out.writeLong(fileSize);
out.writeLong(crc);
}
}
|
