FileDocCategorySizeDatePackage
WallpaperBackupHelper.javaAPI DocAndroid 5.1 API8784Thu Mar 12 22:22:10 GMT 2015android.app.backup

WallpaperBackupHelper

public class WallpaperBackupHelper extends FileBackupHelperBase implements BackupHelper
Helper for backing up / restoring wallpapers. Basically an AbsoluteFileBackupHelper, but with logic for deciding what to do with restored wallpaper images.
hide

Fields Summary
private static final String
TAG
private static final boolean
DEBUG
private static final boolean
REJECT_OUTSIZED_RESTORE
private static final double
MAX_HEIGHT_RATIO
private static final double
MIN_HEIGHT_RATIO
public static final String
WALLPAPER_IMAGE
public static final String
WALLPAPER_INFO
public static final String
WALLPAPER_IMAGE_KEY
public static final String
WALLPAPER_INFO_KEY
private static final String
STAGE_FILE
android.content.Context
mContext
String[]
mFiles
String[]
mKeys
double
mDesiredMinWidth
double
mDesiredMinHeight
Constructors Summary
public WallpaperBackupHelper(android.content.Context context, String[] files, String[] keys)
Construct a helper for backing up / restoring the files at the given absolute locations within the file system.

param
context
param
files


                                
           
        super(context);

        mContext = context;
        mFiles = files;
        mKeys = keys;

        final WindowManager wm =
                (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        final WallpaperManager wpm =
                (WallpaperManager) context.getSystemService(Context.WALLPAPER_SERVICE);
        final Display d = wm.getDefaultDisplay();
        final Point size = new Point();
        d.getSize(size);
        mDesiredMinWidth = Math.min(size.x, size.y);
        mDesiredMinHeight = (double) wpm.getDesiredMinimumHeight();
        if (mDesiredMinHeight <= 0) {
            mDesiredMinHeight = size.y;
        }

        if (DEBUG) {
            Slog.d(TAG, "dmW=" + mDesiredMinWidth + " dmH=" + mDesiredMinHeight);
        }
Methods Summary
public voidperformBackup(android.os.ParcelFileDescriptor oldState, BackupDataOutput data, android.os.ParcelFileDescriptor newState)
Based on oldState, determine which of the files from the application's data directory need to be backed up, write them to the data stream, and fill in newState with the state as it exists now.

        performBackup_checked(oldState, data, newState, mFiles, mKeys);
public voidrestoreEntity(BackupDataInputStream data)
Restore one absolute file entity from the restore stream. If we're restoring the magic wallpaper file, take specific action to determine whether it is suitable for the current device.

        final String key = data.getKey();
        if (isKeyInList(key, mKeys)) {
            if (key.equals(WALLPAPER_IMAGE_KEY)) {
                // restore the file to the stage for inspection
                File f = new File(STAGE_FILE);
                if (writeFile(f, data)) {

                    // Preflight the restored image's dimensions without loading it
                    BitmapFactory.Options options = new BitmapFactory.Options();
                    options.inJustDecodeBounds = true;
                    BitmapFactory.decodeFile(STAGE_FILE, options);

                    if (DEBUG) Slog.d(TAG, "Restoring wallpaper image w=" + options.outWidth
                            + " h=" + options.outHeight);

                    if (REJECT_OUTSIZED_RESTORE) {
                        // We accept any wallpaper that is at least as wide as our preference
                        // (i.e. wide enough to fill the screen), and is within a comfortable
                        // factor of the target height, to avoid significant clipping/scaling/
                        // letterboxing.  At this point we know that mDesiredMinWidth is the
                        // smallest dimension, regardless of current orientation, so we can
                        // safely require that the candidate's width and height both exceed
                        // that hard minimum.
                        final double heightRatio = mDesiredMinHeight / options.outHeight;
                        if (options.outWidth < mDesiredMinWidth
                                || options.outHeight < mDesiredMinWidth
                                || heightRatio >= MAX_HEIGHT_RATIO
                                || heightRatio <= MIN_HEIGHT_RATIO) {
                            // Not wide enough for the screen, or too short/tall to be a good fit
                            // for the height of the screen, broken image file, or the system's
                            // desires for wallpaper size are in a bad state.  Probably one of the
                            // first two.
                            Slog.i(TAG, "Restored image dimensions (w="
                                    + options.outWidth + ", h=" + options.outHeight
                                    + ") too far off target (tw="
                                    + mDesiredMinWidth + ", th=" + mDesiredMinHeight
                                    + "); falling back to default wallpaper.");
                            f.delete();
                            return;
                        }
                    }

                    // We passed the acceptable-dimensions test (if any), so we're going to
                    // use the restored image.
                    // TODO: spin a service to copy the restored image to sd/usb storage,
                    // since it does not exist anywhere other than the private wallpaper
                    // file.
                    Slog.d(TAG, "Applying restored wallpaper image.");
                    f.renameTo(new File(WALLPAPER_IMAGE));
                }
            } else if (key.equals(WALLPAPER_INFO_KEY)) {
                // XML file containing wallpaper info
                File f = new File(WALLPAPER_INFO);
                writeFile(f, data);
            }
        }