Home | History | Annotate | Download | only in app
      1 /*
      2  * Copyright 2009, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.app;
     18 
     19 import android.app.backup.IBackupManager;
     20 import android.os.ParcelFileDescriptor;
     21 
     22 /**
     23  * Interface presented by applications being asked to participate in the
     24  * backup & restore mechanism.  End user code will not typically implement
     25  * this interface directly; they subclass BackupAgent instead.
     26  *
     27  * {@hide}
     28  */
     29 oneway interface IBackupAgent {
     30     /**
     31      * Request that the app perform an incremental backup.
     32      *
     33      * @param oldState Read-only file containing the description blob of the
     34      *        app's data state as of the last backup operation's completion.
     35      *        This file is empty or invalid when a full backup is being
     36      *        requested.
     37      *
     38      * @param data Read-write file, empty when onBackup() is called, that
     39      *        is the data destination for this backup pass's incrementals.
     40      *
     41      * @param newState Read-write file, empty when onBackup() is called,
     42      *        where the new state blob is to be recorded.
     43      *
     44      * @param token Opaque token identifying this transaction.  This must
     45      *        be echoed back to the backup service binder once the new
     46      *        data has been written to the data and newState files.
     47      *
     48      * @param callbackBinder Binder on which to indicate operation completion,
     49      *        passed here as a convenience to the agent.
     50      */
     51     void doBackup(in ParcelFileDescriptor oldState,
     52             in ParcelFileDescriptor data,
     53             in ParcelFileDescriptor newState,
     54             int token, IBackupManager callbackBinder);
     55 
     56     /**
     57      * Restore an entire data snapshot to the application.
     58      *
     59      * @param data Read-only file containing the full data snapshot of the
     60      *        app's backup.  This is to be a <i>replacement</i> of the app's
     61      *        current data, not to be merged into it.
     62      *
     63      * @param appVersionCode The android:versionCode attribute of the application
     64      *        that created this data set.  This can help the agent distinguish among
     65      *        various historical backup content possibilities.
     66      *
     67      * @param newState Read-write file, empty when onRestore() is called,
     68      *        that is to be written with the state description that holds after
     69      *        the restore has been completed.
     70      *
     71      * @param token Opaque token identifying this transaction.  This must
     72      *        be echoed back to the backup service binder once the agent is
     73      *        finished restoring the application based on the restore data
     74      *        contents.
     75      *
     76      * @param callbackBinder Binder on which to indicate operation completion,
     77      *        passed here as a convenience to the agent.
     78      */
     79     void doRestore(in ParcelFileDescriptor data,
     80             int appVersionCode, in ParcelFileDescriptor newState,
     81             int token, IBackupManager callbackBinder);
     82 
     83     /**
     84      * Perform a "full" backup to the given file descriptor.  The output file is presumed
     85      * to be a socket or other non-seekable, write-only data sink.  When this method is
     86      * called, the app should write all of its files to the output.
     87      *
     88      * @param data Write-only file to receive the backed-up file content stream.
     89      *        The data must be formatted correctly for the resulting archive to be
     90      *        legitimate, so that will be tightly controlled by the available API.
     91      *
     92      * @param token Opaque token identifying this transaction.  This must
     93      *        be echoed back to the backup service binder once the agent is
     94      *        finished restoring the application based on the restore data
     95      *        contents.
     96      *
     97      * @param callbackBinder Binder on which to indicate operation completion,
     98      *        passed here as a convenience to the agent.
     99      */
    100     void doFullBackup(in ParcelFileDescriptor data, int token, IBackupManager callbackBinder);
    101 
    102     /**
    103      * Estimate how much data a full backup will deliver
    104      */
    105     void doMeasureFullBackup(int token, IBackupManager callbackBinder);
    106 
    107     /**
    108      * Tells the application agent that the backup data size exceeded current transport quota.
    109      * Later calls to {@link #onBackup(ParcelFileDescriptor, BackupDataOutput, ParcelFileDescriptor)}
    110      * and {@link #onFullBackup(FullBackupDataOutput)} could use this information
    111      * to reduce backup size under the limit.
    112      * However, the quota can change, so do not assume that the value passed in here is absolute,
    113      * similarly all subsequent backups should not be restricted to this size.
    114      * This callback will be invoked before data has been put onto the wire in a preflight check,
    115      * so it is relatively inexpensive to hit your quota.
    116      * Apps that hit quota repeatedly without dealing with it can be subject to having their backup
    117      * schedule reduced.
    118      * The {@code quotaBytes} is a loose guideline b/c of metadata added by the backupmanager
    119      * so apps should be more aggressive in trimming their backup set.
    120      *
    121      * @param backupDataBytes Expected or already processed amount of data.
    122      *                        Could be less than total backup size if backup process was interrupted
    123      *                        before finish of processing all backup data.
    124      * @param quotaBytes Current amount of backup data that is allowed for the app.
    125      */
    126     void doQuotaExceeded(long backupDataBytes, long quotaBytes);
    127 
    128     /**
    129      * Restore a single "file" to the application.  The file was typically obtained from
    130      * a full-backup dataset.  The agent reads 'size' bytes of file content
    131      * from the provided file descriptor.
    132      *
    133      * @param data Read-only pipe delivering the file content itself.
    134      *
    135      * @param size Size of the file being restored.
    136      * @param type Type of file system entity, e.g. FullBackup.TYPE_DIRECTORY.
    137      * @param domain Name of the file's semantic domain to which the 'path' argument is a
    138      *        relative path.  e.g. FullBackup.DATABASE_TREE_TOKEN.
    139      * @param path Relative path of the file within its semantic domain.
    140      * @param mode Access mode of the file system entity, e.g. 0660.
    141      * @param mtime Last modification time of the file system entity.
    142      * @param token Opaque token identifying this transaction.  This must
    143      *        be echoed back to the backup service binder once the agent is
    144      *        finished restoring the application based on the restore data
    145      *        contents.
    146      * @param callbackBinder Binder on which to indicate operation completion,
    147      *        passed here as a convenience to the agent.
    148      */
    149     void doRestoreFile(in ParcelFileDescriptor data, long size,
    150             int type, String domain, String path, long mode, long mtime,
    151             int token, IBackupManager callbackBinder);
    152 
    153     /**
    154      * Provide the app with a canonical "all data has been delivered" end-of-restore
    155      * callback so that it can do any postprocessing of the restored data that might
    156      * be appropriate.  This is issued after both key/value and full data restore
    157      * operations have completed.
    158      *
    159      * @param token Opaque token identifying this transaction.  This must
    160      *        be echoed back to the backup service binder once the agent is
    161      *        finished restoring the application based on the restore data
    162      *        contents.
    163      * @param callbackBinder Binder on which to indicate operation completion,
    164      *        passed here as a convenience to the agent.
    165      */
    166     void doRestoreFinished(int token, IBackupManager callbackBinder);
    167 
    168     /**
    169      * Out of band: instruct the agent to crash within the client process.  This is used
    170      * when the backup infrastructure detects a semantic error post-hoc and needs to
    171      * pass the problem back to the app.
    172      *
    173      * @param message The message to be passed to the agent's application in an exception.
    174      */
    175     void fail(String message);
    176 }
    177