/* * Copyright (C) 2010 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.app.backup; import android.app.WallpaperManager; import android.content.Context; import android.graphics.BitmapFactory; import android.graphics.Point; import android.os.Environment; import android.os.ParcelFileDescriptor; import android.os.UserHandle; import android.util.Slog; import android.view.Display; import android.view.WindowManager; import java.io.File; /** * Helper for backing up / restoring wallpapers. Basically an AbsoluteFileBackupHelper, * but with logic for deciding what to do with restored wallpaper images. * * @hide */ public class WallpaperBackupHelper extends FileBackupHelperBase implements BackupHelper { private static final String TAG = "WallpaperBackupHelper"; private static final boolean DEBUG = false; // If 'true', then apply an acceptable-size heuristic at restore time, dropping back // to the factory default wallpaper if the restored one differs "too much" from the // device's preferred wallpaper image dimensions. private static final boolean REJECT_OUTSIZED_RESTORE = true; // When outsized restore rejection is enabled, this is the maximum ratio between the // source and target image heights that will be permitted. The ratio is checked both // ways (i.e. >= MAX, or <= 1/MAX) to validate restores from both largeer-than-target // and smaller-than-target sources. private static final double MAX_HEIGHT_RATIO = 1.35; // The height ratio check when applying larger images on smaller screens is separate; // in current policy we accept any such restore regardless of the relative dimensions. private static final double MIN_HEIGHT_RATIO = 0; // This path must match what the WallpaperManagerService uses // TODO: Will need to change if backing up non-primary user's wallpaper public static final String WALLPAPER_IMAGE = new File(Environment.getUserSystemDirectory(UserHandle.USER_OWNER), "wallpaper").getAbsolutePath(); public static final String WALLPAPER_INFO = new File(Environment.getUserSystemDirectory(UserHandle.USER_OWNER), "wallpaper_info.xml").getAbsolutePath(); // Use old keys to keep legacy data compatibility and avoid writing two wallpapers public static final String WALLPAPER_IMAGE_KEY = "/data/data/com.android.settings/files/wallpaper"; public static final String WALLPAPER_INFO_KEY = "/data/system/wallpaper_info.xml"; // Stage file - should be adjacent to the WALLPAPER_IMAGE location. The wallpapers // will be saved to this file from the restore stream, then renamed to the proper // location if it's deemed suitable. // TODO: Will need to change if backing up non-primary user's wallpaper private static final String STAGE_FILE = new File(Environment.getUserSystemDirectory(UserHandle.USER_OWNER), "wallpaper-tmp").getAbsolutePath(); Context mContext; String[] mFiles; String[] mKeys; double mDesiredMinWidth; double mDesiredMinHeight; /** * Construct a helper for backing up / restoring the files at the given absolute locations * within the file system. * * @param context * @param files */ public WallpaperBackupHelper(Context context, String[] files, String[] keys) { 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); } } /** * 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. */ public void performBackup(ParcelFileDescriptor oldState, BackupDataOutput data, ParcelFileDescriptor newState) { performBackup_checked(oldState, data, newState, mFiles, mKeys); } /** * 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. */ public void restoreEntity(BackupDataInputStream data) { 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); } } } }