hostsidetests/backup/FullBackupOnly/src/FullBackupOnlyBackupAgent.java

/*
 * Copyright (C) 2017 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.cts.backup.fullbackuponlyapp;

import android.app.backup.BackupAgent;
import android.app.backup.BackupDataInput;
import android.app.backup.BackupDataOutput;

import android.os.ParcelFileDescriptor;
import android.util.Log;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * BackupAgent for test apps in {@link android.cts.backup.fullbackuponlyapp} package.
 * Performs backup/restore of the file provided by {@link FullBackupOnlyTest}.
 *
 * Implementation of key/value backup methods is based on the examples from
 * https://developer.android.com/guide/topics/data/keyvaluebackup.html
 */
public class FullBackupOnlyBackupAgent extends BackupAgent {
    private static final String TAG = "FullBackupOnlyBA";

    private static final String BACKUP_KEY = "full_backup_only_key";
    private static final int DEFAULT_VALUE = -1;

    /** Get the value saved in the shared preference and back it up. */
    @Override
    public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data,
            ParcelFileDescriptor newState) throws IOException {
        Log.i(TAG, "onBackup");

        File fileToBackup = FullBackupOnlyTest.getKeyValueBackupFile(this);
        byte[] buffer = readFileToBytes(fileToBackup);

        // Send the data to the Backup Manager via the BackupDataOutput
        int len = buffer.length;
        data.writeEntityHeader(BACKUP_KEY, len);
        data.writeEntityData(buffer, len);
    }

    /** Get the value from backup and save it in the shared preference. */
    @Override
    public void onRestore(BackupDataInput data, int appVersionCode, ParcelFileDescriptor newState)
            throws IOException {
        Log.i(TAG, "onRestore");
        int value = DEFAULT_VALUE;

        // There should be only one entity, but the safest
        // way to consume it is using a while loop
        while (data.readNextHeader()) {
            String key = data.getKey();
            int dataSize = data.getDataSize();

            // If the key is ours (for saving top score). Note this key was used when
            // we wrote the backup entity header
            if (BACKUP_KEY.equals(key)) {
                // Copy data from BackupDataInput and write it into the file.
                byte[] dataBuf = new byte[dataSize];
                data.readEntityData(dataBuf, 0, dataSize);

                File fileToRestore = FullBackupOnlyTest.getKeyValueBackupFile(this);

                try (BufferedOutputStream bos = new BufferedOutputStream(
                        new FileOutputStream(fileToRestore))) {
                    bos.write(dataBuf, 0, dataBuf.length);
                }
            } else {
                // We don't know this entity key. Shouldn't happen.
                throw new RuntimeException("Unexpected key in the backup data");
            }
        }

        // Finally, write to the state blob (newState) that describes the restored data
        FileOutputStream outstream = new FileOutputStream(newState.getFileDescriptor());
        DataOutputStream out = new DataOutputStream(outstream);
        out.writeInt(value);
    }


    private byte[] readFileToBytes(File file) {
        int size = (int) file.length();
        byte[] bytes = new byte[size];
        try {
            BufferedInputStream buf = new BufferedInputStream(new FileInputStream(file));
            buf.read(bytes, 0, bytes.length);
            buf.close();
        } catch (FileNotFoundException e) {
            throw new RuntimeException("Key/value file not found", e);
        } catch (IOException e) {
            throw new RuntimeException("Error reading key/value file", e);
        }
        return bytes;
    }
}