/* Copyright (C) 2024 José Rebelo
|
|
This file is part of Gadgetbridge.
|
|
Gadgetbridge is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as published
|
by the Free Software Foundation, either version 3 of the License, or
|
(at your option) any later version.
|
|
Gadgetbridge is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
package nodomain.freeyourgadget.gadgetbridge.util.backup;
|
|
import android.content.Context;
|
import android.content.SharedPreferences;
|
import android.net.Uri;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.OutputStream;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.zip.ZipEntry;
|
import java.util.zip.ZipOutputStream;
|
|
import nodomain.freeyourgadget.gadgetbridge.BuildConfig;
|
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
|
import nodomain.freeyourgadget.gadgetbridge.R;
|
import nodomain.freeyourgadget.gadgetbridge.database.DBHandler;
|
import nodomain.freeyourgadget.gadgetbridge.database.DBHelper;
|
import nodomain.freeyourgadget.gadgetbridge.entities.Device;
|
import nodomain.freeyourgadget.gadgetbridge.util.FileUtils;
|
|
public class ZipBackupExportJob extends AbstractZipBackupJob {
|
private static final Logger LOG = LoggerFactory.getLogger(ZipBackupExportJob.class);
|
|
private final Uri mUri;
|
|
private final byte[] copyBuffer = new byte[8192];
|
|
public ZipBackupExportJob(final Context context, final ZipBackupCallback callback, final Uri uri) {
|
super(context, callback);
|
this.mUri = uri;
|
}
|
|
@Override
|
public void run() {
|
try (final OutputStream outputStream = getContext().getContentResolver().openOutputStream(mUri);
|
final ZipOutputStream zipOut = new ZipOutputStream(outputStream)) {
|
|
if (isAborted()) return;
|
|
// Preferences
|
updateProgress(0, R.string.backup_restore_exporting_preferences);
|
exportPreferences(zipOut);
|
|
if (isAborted()) return;
|
|
// Database
|
updateProgress(10, R.string.backup_restore_exporting_database);
|
exportDatabase(zipOut, getContext());
|
|
if (isAborted()) return;
|
|
// External files
|
updateProgress(25, R.string.backup_restore_exporting_files);
|
|
final File externalFilesDir = FileUtils.getExternalFilesDir();
|
LOG.debug("Exporting external files from {}", externalFilesDir);
|
|
final List<String> allExternalFiles = getAllRelativeFiles(externalFilesDir);
|
LOG.debug("Got {} files to export", allExternalFiles.size());
|
|
for (int i = 0; i < allExternalFiles.size() && !isAborted(); i++) {
|
final String child = allExternalFiles.get(i);
|
exportSingleExternalFile(zipOut, externalFilesDir, child);
|
|
final int progress = (int) Math.min(99, 50 + 49 * (i / (float) allExternalFiles.size()));
|
updateProgress(progress, R.string.backup_restore_exporting_files_i_of_n, i + 1, allExternalFiles.size());
|
}
|
|
// Metadata
|
updateProgress(99, R.string.backup_restore_exporting_finishing);
|
|
if (isAborted()) return;
|
|
addMetadata(zipOut);
|
|
zipOut.finish();
|
zipOut.flush();
|
|
if (isAborted()) return;
|
|
LOG.info("Export complete");
|
|
onSuccess(null);
|
} catch (final Exception e) {
|
LOG.error("Export failed", e);
|
|
if (!isAborted()) {
|
onFailure(e.getLocalizedMessage());
|
}
|
}
|
}
|
|
private static void exportPreferences(final ZipOutputStream zipOut) throws IOException {
|
LOG.debug("Exporting global preferences");
|
|
final SharedPreferences globalPreferences = GBApplication.getPrefs().getPreferences();
|
exportPreferences(zipOut, globalPreferences, PREFS_GLOBAL_FILENAME);
|
|
try (DBHandler dbHandler = GBApplication.acquireDB()) {
|
final List<Device> activeDevices = DBHelper.getActiveDevices(dbHandler.getDaoSession());
|
for (Device dbDevice : activeDevices) {
|
LOG.debug("Exporting device preferences for {}", dbDevice.getIdentifier());
|
final SharedPreferences devicePrefs = GBApplication.getDeviceSpecificSharedPrefs(dbDevice.getIdentifier());
|
if (devicePrefs != null) {
|
exportPreferences(zipOut, devicePrefs, String.format(Locale.ROOT, PREFS_DEVICE_FILENAME, dbDevice.getIdentifier()));
|
}
|
}
|
} catch (final Exception e) {
|
throw new IOException("Failed to export device preferences", e);
|
}
|
}
|
|
private static void exportPreferences(final ZipOutputStream zipOut,
|
final SharedPreferences sharedPreferences,
|
final String zipEntryName) throws IOException {
|
LOG.debug("Exporting preferences to {}", zipEntryName);
|
|
final JsonBackupPreferences jsonBackupPreferences = JsonBackupPreferences.exportFrom(sharedPreferences);
|
final String preferencesJson = jsonBackupPreferences.toJson();
|
|
final ZipEntry zipEntry = new ZipEntry(zipEntryName);
|
zipOut.putNextEntry(zipEntry);
|
zipOut.write(preferencesJson.getBytes(StandardCharsets.UTF_8));
|
}
|
|
private static void exportDatabase(final ZipOutputStream zipOut, final Context context) throws IOException {
|
LOG.debug("Exporting database");
|
|
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
try (DBHandler dbHandler = GBApplication.acquireDB()) {
|
final DBHelper helper = new DBHelper(context);
|
helper.exportDB(dbHandler, baos);
|
} catch (final Exception e) {
|
throw new IOException("Failed to export database", e);
|
}
|
|
final ZipEntry zipEntry = new ZipEntry(DATABASE_FILENAME);
|
zipOut.putNextEntry(zipEntry);
|
zipOut.write(baos.toByteArray());
|
}
|
|
/**
|
* Gets a list of the relative path of all files from a directory, recursively.
|
*/
|
private static List<String> getAllRelativeFiles(final File dir) {
|
final List<String> ret = new ArrayList<>();
|
|
final String[] childEntries = dir.list();
|
if (childEntries == null) {
|
LOG.warn("Files in external dir are null");
|
return ret;
|
}
|
|
for (final String child : childEntries) {
|
getAllRelativeFilesAux(ret, dir, child);
|
}
|
|
return ret;
|
}
|
|
private static void getAllRelativeFilesAux(final List<String> currentList,
|
final File externalFilesDir,
|
final String relativePath) {
|
final File file = new File(externalFilesDir, relativePath);
|
if (file.isDirectory()) {
|
final String[] childEntries = file.list();
|
if (childEntries == null) {
|
LOG.warn("Files in {} are null", file);
|
return;
|
}
|
|
for (final String child : childEntries) {
|
getAllRelativeFilesAux(currentList, externalFilesDir, relativePath + "/" + child);
|
}
|
} else if (file.isFile()) {
|
currentList.add(relativePath);
|
} else {
|
// Should never happen?
|
LOG.error("Unknown file type for {}", file);
|
}
|
}
|
|
private void exportSingleExternalFile(final ZipOutputStream zipOut,
|
final File externalFilesDir,
|
final String relativePath) throws IOException {
|
final File file = new File(externalFilesDir, relativePath);
|
if (!file.isFile()) {
|
throw new IOException("Not a file: " + file);
|
}
|
|
LOG.trace("Exporting file: {}", relativePath);
|
|
final ZipEntry zipEntry = new ZipEntry(EXTERNAL_FILES_FOLDER + "/" + relativePath);
|
zipOut.putNextEntry(zipEntry);
|
|
try (final InputStream in = new FileInputStream(new File(externalFilesDir, relativePath))) {
|
int read;
|
while ((read = in.read(copyBuffer)) > 0) {
|
zipOut.write(copyBuffer, 0, read);
|
}
|
} catch (final Exception e) {
|
throw new IOException("Failed to write " + relativePath, e);
|
}
|
}
|
|
private static void addMetadata(final ZipOutputStream zipOut) throws IOException {
|
LOG.debug("Adding metadata");
|
|
final ZipBackupMetadata metadata = new ZipBackupMetadata(
|
BuildConfig.APPLICATION_ID,
|
BuildConfig.VERSION_NAME,
|
BuildConfig.VERSION_CODE,
|
VERSION,
|
new Date()
|
);
|
final String metadataJson = GSON.toJson(metadata);
|
|
final ZipEntry zipEntry = new ZipEntry(METADATA_FILENAME);
|
zipOut.putNextEntry(zipEntry);
|
zipOut.write(metadataJson.getBytes(StandardCharsets.UTF_8));
|
}
|
}
|
