Java tutorial
/* * Copyright (C) 2009 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; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.RawRes; import android.annotation.RequiresPermission; import android.annotation.SdkConstant; import android.annotation.SdkConstant.SdkConstantType; import android.annotation.SystemApi; import android.annotation.SystemService; import android.annotation.UnsupportedAppUsage; import android.content.ComponentName; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.content.res.Resources; import android.content.res.Resources.NotFoundException; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.BitmapRegionDecoder; import android.graphics.Canvas; import android.graphics.ColorFilter; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.PixelFormat; import android.graphics.PorterDuff; import android.graphics.PorterDuffXfermode; import android.graphics.Rect; import android.graphics.RectF; import android.graphics.drawable.BitmapDrawable; import android.graphics.drawable.Drawable; import android.net.Uri; import android.os.Build; import android.os.Bundle; import android.os.DeadSystemException; import android.os.FileUtils; import android.os.Handler; import android.os.IBinder; import android.os.Looper; import android.os.ParcelFileDescriptor; import android.os.RemoteException; import android.os.SystemProperties; import android.text.TextUtils; import android.util.Log; import android.util.Pair; import android.view.WindowManagerGlobal; import libcore.io.IoUtils; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; /** * Provides access to the system wallpaper. With WallpaperManager, you can * get the current wallpaper, get the desired dimensions for the wallpaper, set * the wallpaper, and more. * * <p> An app can check whether wallpapers are supported for the current user, by calling * {@link #isWallpaperSupported()}, and whether setting of wallpapers is allowed, by calling * {@link #isSetWallpaperAllowed()}. */ @SystemService(Context.WALLPAPER_SERVICE) public class WallpaperManager { private static String TAG = "WallpaperManager"; private static boolean DEBUG = false; private float mWallpaperXStep = -1; private float mWallpaperYStep = -1; /** {@hide} */ private static final String PROP_WALLPAPER = "ro.config.wallpaper"; /** {@hide} */ private static final String PROP_LOCK_WALLPAPER = "ro.config.lock_wallpaper"; /** {@hide} */ private static final String PROP_WALLPAPER_COMPONENT = "ro.config.wallpaper_component"; /** * Activity Action: Show settings for choosing wallpaper. Do not use directly to construct * an intent; instead, use {@link #getCropAndSetWallpaperIntent}. * <p>Input: {@link Intent#getData} is the URI of the image to crop and set as wallpaper. * <p>Output: RESULT_OK if user decided to crop/set the wallpaper, RESULT_CANCEL otherwise * Activities that support this intent should specify a MIME filter of "image/*" */ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_CROP_AND_SET_WALLPAPER = "android.service.wallpaper.CROP_AND_SET_WALLPAPER"; /** * Launch an activity for the user to pick the current global live * wallpaper. */ public static final String ACTION_LIVE_WALLPAPER_CHOOSER = "android.service.wallpaper.LIVE_WALLPAPER_CHOOSER"; /** * Directly launch live wallpaper preview, allowing the user to immediately * confirm to switch to a specific live wallpaper. You must specify * {@link #EXTRA_LIVE_WALLPAPER_COMPONENT} with the ComponentName of * a live wallpaper component that is to be shown. */ public static final String ACTION_CHANGE_LIVE_WALLPAPER = "android.service.wallpaper.CHANGE_LIVE_WALLPAPER"; /** * Extra in {@link #ACTION_CHANGE_LIVE_WALLPAPER} that specifies the * ComponentName of a live wallpaper that should be shown as a preview, * for the user to confirm. */ public static final String EXTRA_LIVE_WALLPAPER_COMPONENT = "android.service.wallpaper.extra.LIVE_WALLPAPER_COMPONENT"; /** * Manifest entry for activities that respond to {@link Intent#ACTION_SET_WALLPAPER} * which allows them to provide a custom large icon associated with this action. */ public static final String WALLPAPER_PREVIEW_META_DATA = "android.wallpaper.preview"; /** * Command for {@link #sendWallpaperCommand}: reported by the wallpaper * host when the user taps on an empty area (not performing an action * in the host). The x and y arguments are the location of the tap in * screen coordinates. */ public static final String COMMAND_TAP = "android.wallpaper.tap"; /** * Command for {@link #sendWallpaperCommand}: reported by the wallpaper * host when the user releases a secondary pointer on an empty area * (not performing an action in the host). The x and y arguments are * the location of the secondary tap in screen coordinates. */ public static final String COMMAND_SECONDARY_TAP = "android.wallpaper.secondaryTap"; /** * Command for {@link #sendWallpaperCommand}: reported by the wallpaper * host when the user drops an object into an area of the host. The x * and y arguments are the location of the drop. */ public static final String COMMAND_DROP = "android.home.drop"; /** * Extra passed back from setWallpaper() giving the new wallpaper's assigned ID. * @hide */ public static final String EXTRA_NEW_WALLPAPER_ID = "android.service.wallpaper.extra.ID"; // flags for which kind of wallpaper to act on /** @hide */ @IntDef(flag = true, prefix = { "FLAG_" }, value = { FLAG_SYSTEM, FLAG_LOCK }) @Retention(RetentionPolicy.SOURCE) public @interface SetWallpaperFlags { } /** * Flag: set or retrieve the general system wallpaper. */ public static final int FLAG_SYSTEM = 1 << 0; /** * Flag: set or retrieve the lock-screen-specific wallpaper. */ public static final int FLAG_LOCK = 1 << 1; private final Context mContext; /** * Special drawable that draws a wallpaper as fast as possible. Assumes * no scaling or placement off (0,0) of the wallpaper (this should be done * at the time the bitmap is loaded). */ static class FastBitmapDrawable extends Drawable { private final Bitmap mBitmap; private final int mWidth; private final int mHeight; private int mDrawLeft; private int mDrawTop; private final Paint mPaint; private FastBitmapDrawable(Bitmap bitmap) { mBitmap = bitmap; mWidth = bitmap.getWidth(); mHeight = bitmap.getHeight(); setBounds(0, 0, mWidth, mHeight); mPaint = new Paint(); mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC)); } @Override public void draw(Canvas canvas) { canvas.drawBitmap(mBitmap, mDrawLeft, mDrawTop, mPaint); } @Override public int getOpacity() { return PixelFormat.OPAQUE; } @Override public void setBounds(int left, int top, int right, int bottom) { mDrawLeft = left + (right - left - mWidth) / 2; mDrawTop = top + (bottom - top - mHeight) / 2; } @Override public void setAlpha(int alpha) { throw new UnsupportedOperationException("Not supported with this drawable"); } @Override public void setColorFilter(ColorFilter colorFilter) { throw new UnsupportedOperationException("Not supported with this drawable"); } @Override public void setDither(boolean dither) { throw new UnsupportedOperationException("Not supported with this drawable"); } @Override public void setFilterBitmap(boolean filter) { throw new UnsupportedOperationException("Not supported with this drawable"); } @Override public int getIntrinsicWidth() { return mWidth; } @Override public int getIntrinsicHeight() { return mHeight; } @Override public int getMinimumWidth() { return mWidth; } @Override public int getMinimumHeight() { return mHeight; } } private static class Globals extends IWallpaperManagerCallback.Stub { private final IWallpaperManager mService; private boolean mColorCallbackRegistered; private final ArrayList<Pair<OnColorsChangedListener, Handler>> mColorListeners = new ArrayList<>(); private Bitmap mCachedWallpaper; private int mCachedWallpaperUserId; private Bitmap mDefaultWallpaper; private Handler mMainLooperHandler; Globals(IWallpaperManager service, Looper looper) { mService = service; mMainLooperHandler = new Handler(looper); forgetLoadedWallpaper(); } public void onWallpaperChanged() { /* The wallpaper has changed but we shouldn't eagerly load the * wallpaper as that would be inefficient. Reset the cached wallpaper * to null so if the user requests the wallpaper again then we'll * fetch it. */ forgetLoadedWallpaper(); } /** * Start listening to wallpaper color events. * Will be called whenever someone changes their wallpaper or if a live wallpaper * changes its colors. * @param callback Listener * @param handler Thread to call it from. Main thread if null. * @param userId Owner of the wallpaper or UserHandle.USER_ALL */ public void addOnColorsChangedListener(@NonNull OnColorsChangedListener callback, @Nullable Handler handler, int userId) { synchronized (this) { if (!mColorCallbackRegistered) { try { mService.registerWallpaperColorsCallback(this, userId); mColorCallbackRegistered = true; } catch (RemoteException e) { // Failed, service is gone Log.w(TAG, "Can't register for color updates", e); } } mColorListeners.add(new Pair<>(callback, handler)); } } /** * Stop listening to wallpaper color events. * * @param callback listener * @param userId Owner of the wallpaper or UserHandle.USER_ALL */ public void removeOnColorsChangedListener(@NonNull OnColorsChangedListener callback, int userId) { synchronized (this) { mColorListeners.removeIf(pair -> pair.first == callback); if (mColorListeners.size() == 0 && mColorCallbackRegistered) { mColorCallbackRegistered = false; try { mService.unregisterWallpaperColorsCallback(this, userId); } catch (RemoteException e) { // Failed, service is gone Log.w(TAG, "Can't unregister color updates", e); } } } } @Override public void onWallpaperColorsChanged(WallpaperColors colors, int which, int userId) { synchronized (this) { for (Pair<OnColorsChangedListener, Handler> listener : mColorListeners) { Handler handler = listener.second; if (listener.second == null) { handler = mMainLooperHandler; } handler.post(() -> { // Dealing with race conditions between posting a callback and // removeOnColorsChangedListener being called. boolean stillExists; synchronized (sGlobals) { stillExists = mColorListeners.contains(listener); } if (stillExists) { listener.first.onColorsChanged(colors, which, userId); } }); } } } WallpaperColors getWallpaperColors(int which, int userId) { if (which != FLAG_LOCK && which != FLAG_SYSTEM) { throw new IllegalArgumentException("Must request colors for exactly one kind of wallpaper"); } try { return mService.getWallpaperColors(which, userId); } catch (RemoteException e) { // Can't get colors, connection lost. } return null; } public Bitmap peekWallpaperBitmap(Context context, boolean returnDefault, @SetWallpaperFlags int which) { return peekWallpaperBitmap(context, returnDefault, which, context.getUserId(), false /* hardware */); } public Bitmap peekWallpaperBitmap(Context context, boolean returnDefault, @SetWallpaperFlags int which, int userId, boolean hardware) { if (mService != null) { try { if (!mService.isWallpaperSupported(context.getOpPackageName())) { return null; } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } synchronized (this) { if (mCachedWallpaper != null && mCachedWallpaperUserId == userId && !mCachedWallpaper.isRecycled()) { return mCachedWallpaper; } mCachedWallpaper = null; mCachedWallpaperUserId = 0; try { mCachedWallpaper = getCurrentWallpaperLocked(context, userId, hardware); mCachedWallpaperUserId = userId; } catch (OutOfMemoryError e) { Log.w(TAG, "Out of memory loading the current wallpaper: " + e); } catch (SecurityException e) { if (context.getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.O_MR1) { Log.w(TAG, "No permission to access wallpaper, suppressing" + " exception to avoid crashing legacy app."); } else { // Post-O apps really most sincerely need the permission. throw e; } } if (mCachedWallpaper != null) { return mCachedWallpaper; } } if (returnDefault) { Bitmap defaultWallpaper = mDefaultWallpaper; if (defaultWallpaper == null) { defaultWallpaper = getDefaultWallpaper(context, which); synchronized (this) { mDefaultWallpaper = defaultWallpaper; } } return defaultWallpaper; } return null; } void forgetLoadedWallpaper() { synchronized (this) { mCachedWallpaper = null; mCachedWallpaperUserId = 0; mDefaultWallpaper = null; } } private Bitmap getCurrentWallpaperLocked(Context context, int userId, boolean hardware) { if (mService == null) { Log.w(TAG, "WallpaperService not running"); return null; } try { Bundle params = new Bundle(); ParcelFileDescriptor fd = mService.getWallpaper(context.getOpPackageName(), this, FLAG_SYSTEM, params, userId); if (fd != null) { try { BitmapFactory.Options options = new BitmapFactory.Options(); if (hardware) { options.inPreferredConfig = Bitmap.Config.HARDWARE; } return BitmapFactory.decodeFileDescriptor(fd.getFileDescriptor(), null, options); } catch (OutOfMemoryError e) { Log.w(TAG, "Can't decode file", e); } finally { IoUtils.closeQuietly(fd); } } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } return null; } private Bitmap getDefaultWallpaper(Context context, @SetWallpaperFlags int which) { InputStream is = openDefaultWallpaper(context, which); if (is != null) { try { BitmapFactory.Options options = new BitmapFactory.Options(); return BitmapFactory.decodeStream(is, null, options); } catch (OutOfMemoryError e) { Log.w(TAG, "Can't decode stream", e); } finally { IoUtils.closeQuietly(is); } } return null; } } private static final Object sSync = new Object[0]; @UnsupportedAppUsage private static Globals sGlobals; static void initGlobals(IWallpaperManager service, Looper looper) { synchronized (sSync) { if (sGlobals == null) { sGlobals = new Globals(service, looper); } } } /*package*/ WallpaperManager(IWallpaperManager service, Context context, Handler handler) { mContext = context; initGlobals(service, context.getMainLooper()); } /** * Retrieve a WallpaperManager associated with the given Context. */ public static WallpaperManager getInstance(Context context) { return (WallpaperManager) context.getSystemService(Context.WALLPAPER_SERVICE); } /** @hide */ @UnsupportedAppUsage public IWallpaperManager getIWallpaperManager() { return sGlobals.mService; } /** * Retrieve the current system wallpaper; if * no wallpaper is set, the system built-in static wallpaper is returned. * This is returned as an * abstract Drawable that you can install in a View to display whatever * wallpaper the user has currently set. * <p> * This method can return null if there is no system wallpaper available, if * wallpapers are not supported in the current user, or if the calling app is not * permitted to access the system wallpaper. * * @return Returns a Drawable object that will draw the system wallpaper, * or {@code null} if no system wallpaper exists or if the calling application * is not able to access the wallpaper. */ public Drawable getDrawable() { Bitmap bm = sGlobals.peekWallpaperBitmap(mContext, true, FLAG_SYSTEM); if (bm != null) { Drawable dr = new BitmapDrawable(mContext.getResources(), bm); dr.setDither(false); return dr; } return null; } /** * Obtain a drawable for the built-in static system wallpaper. */ public Drawable getBuiltInDrawable() { return getBuiltInDrawable(0, 0, false, 0, 0, FLAG_SYSTEM); } /** * Obtain a drawable for the specified built-in static system wallpaper. * * @param which The {@code FLAG_*} identifier of a valid wallpaper type. Throws * IllegalArgumentException if an invalid wallpaper is requested. * @return A Drawable presenting the specified wallpaper image, or {@code null} * if no built-in default image for that wallpaper type exists. */ public Drawable getBuiltInDrawable(@SetWallpaperFlags int which) { return getBuiltInDrawable(0, 0, false, 0, 0, which); } /** * Returns a drawable for the system built-in static wallpaper. Based on the parameters, the * drawable can be cropped and scaled * * @param outWidth The width of the returned drawable * @param outWidth The height of the returned drawable * @param scaleToFit If true, scale the wallpaper down rather than just cropping it * @param horizontalAlignment A float value between 0 and 1 specifying where to crop the image; * 0 for left-aligned, 0.5 for horizontal center-aligned, and 1 for right-aligned * @param verticalAlignment A float value between 0 and 1 specifying where to crop the image; * 0 for top-aligned, 0.5 for vertical center-aligned, and 1 for bottom-aligned * @return A Drawable presenting the built-in default system wallpaper image, * or {@code null} if no such default image is defined on this device. */ public Drawable getBuiltInDrawable(int outWidth, int outHeight, boolean scaleToFit, float horizontalAlignment, float verticalAlignment) { return getBuiltInDrawable(outWidth, outHeight, scaleToFit, horizontalAlignment, verticalAlignment, FLAG_SYSTEM); } /** * Returns a drawable for the built-in static wallpaper of the specified type. Based on the * parameters, the drawable can be cropped and scaled. * * @param outWidth The width of the returned drawable * @param outWidth The height of the returned drawable * @param scaleToFit If true, scale the wallpaper down rather than just cropping it * @param horizontalAlignment A float value between 0 and 1 specifying where to crop the image; * 0 for left-aligned, 0.5 for horizontal center-aligned, and 1 for right-aligned * @param verticalAlignment A float value between 0 and 1 specifying where to crop the image; * 0 for top-aligned, 0.5 for vertical center-aligned, and 1 for bottom-aligned * @param which The {@code FLAG_*} identifier of a valid wallpaper type. Throws * IllegalArgumentException if an invalid wallpaper is requested. * @return A Drawable presenting the built-in default wallpaper image of the given type, * or {@code null} if no default image of that type is defined on this device. */ public Drawable getBuiltInDrawable(int outWidth, int outHeight, boolean scaleToFit, float horizontalAlignment, float verticalAlignment, @SetWallpaperFlags int which) { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } if (which != FLAG_SYSTEM && which != FLAG_LOCK) { throw new IllegalArgumentException("Must request exactly one kind of wallpaper"); } Resources resources = mContext.getResources(); horizontalAlignment = Math.max(0, Math.min(1, horizontalAlignment)); verticalAlignment = Math.max(0, Math.min(1, verticalAlignment)); InputStream wpStream = openDefaultWallpaper(mContext, which); if (wpStream == null) { if (DEBUG) { Log.w(TAG, "default wallpaper stream " + which + " is null"); } return null; } else { InputStream is = new BufferedInputStream(wpStream); if (outWidth <= 0 || outHeight <= 0) { Bitmap fullSize = BitmapFactory.decodeStream(is, null, null); return new BitmapDrawable(resources, fullSize); } else { int inWidth; int inHeight; // Just measure this time through... { BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; BitmapFactory.decodeStream(is, null, options); if (options.outWidth != 0 && options.outHeight != 0) { inWidth = options.outWidth; inHeight = options.outHeight; } else { Log.e(TAG, "default wallpaper dimensions are 0"); return null; } } // Reopen the stream to do the full decode. We know at this point // that openDefaultWallpaper() will return non-null. is = new BufferedInputStream(openDefaultWallpaper(mContext, which)); RectF cropRectF; outWidth = Math.min(inWidth, outWidth); outHeight = Math.min(inHeight, outHeight); if (scaleToFit) { cropRectF = getMaxCropRect(inWidth, inHeight, outWidth, outHeight, horizontalAlignment, verticalAlignment); } else { float left = (inWidth - outWidth) * horizontalAlignment; float right = left + outWidth; float top = (inHeight - outHeight) * verticalAlignment; float bottom = top + outHeight; cropRectF = new RectF(left, top, right, bottom); } Rect roundedTrueCrop = new Rect(); cropRectF.roundOut(roundedTrueCrop); if (roundedTrueCrop.width() <= 0 || roundedTrueCrop.height() <= 0) { Log.w(TAG, "crop has bad values for full size image"); return null; } // See how much we're reducing the size of the image int scaleDownSampleSize = Math.min(roundedTrueCrop.width() / outWidth, roundedTrueCrop.height() / outHeight); // Attempt to open a region decoder BitmapRegionDecoder decoder = null; try { decoder = BitmapRegionDecoder.newInstance(is, true); } catch (IOException e) { Log.w(TAG, "cannot open region decoder for default wallpaper"); } Bitmap crop = null; if (decoder != null) { // Do region decoding to get crop bitmap BitmapFactory.Options options = new BitmapFactory.Options(); if (scaleDownSampleSize > 1) { options.inSampleSize = scaleDownSampleSize; } crop = decoder.decodeRegion(roundedTrueCrop, options); decoder.recycle(); } if (crop == null) { // BitmapRegionDecoder has failed, try to crop in-memory. We know at // this point that openDefaultWallpaper() will return non-null. is = new BufferedInputStream(openDefaultWallpaper(mContext, which)); Bitmap fullSize = null; BitmapFactory.Options options = new BitmapFactory.Options(); if (scaleDownSampleSize > 1) { options.inSampleSize = scaleDownSampleSize; } fullSize = BitmapFactory.decodeStream(is, null, options); if (fullSize != null) { crop = Bitmap.createBitmap(fullSize, roundedTrueCrop.left, roundedTrueCrop.top, roundedTrueCrop.width(), roundedTrueCrop.height()); } } if (crop == null) { Log.w(TAG, "cannot decode default wallpaper"); return null; } // Scale down if necessary if (outWidth > 0 && outHeight > 0 && (crop.getWidth() != outWidth || crop.getHeight() != outHeight)) { Matrix m = new Matrix(); RectF cropRect = new RectF(0, 0, crop.getWidth(), crop.getHeight()); RectF returnRect = new RectF(0, 0, outWidth, outHeight); m.setRectToRect(cropRect, returnRect, Matrix.ScaleToFit.FILL); Bitmap tmp = Bitmap.createBitmap((int) returnRect.width(), (int) returnRect.height(), Bitmap.Config.ARGB_8888); if (tmp != null) { Canvas c = new Canvas(tmp); Paint p = new Paint(); p.setFilterBitmap(true); c.drawBitmap(crop, m, p); crop = tmp; } } return new BitmapDrawable(resources, crop); } } } private static RectF getMaxCropRect(int inWidth, int inHeight, int outWidth, int outHeight, float horizontalAlignment, float verticalAlignment) { RectF cropRect = new RectF(); // Get a crop rect that will fit this if (inWidth / (float) inHeight > outWidth / (float) outHeight) { cropRect.top = 0; cropRect.bottom = inHeight; float cropWidth = outWidth * (inHeight / (float) outHeight); cropRect.left = (inWidth - cropWidth) * horizontalAlignment; cropRect.right = cropRect.left + cropWidth; } else { cropRect.left = 0; cropRect.right = inWidth; float cropHeight = outHeight * (inWidth / (float) outWidth); cropRect.top = (inHeight - cropHeight) * verticalAlignment; cropRect.bottom = cropRect.top + cropHeight; } return cropRect; } /** * Retrieve the current system wallpaper; if there is no wallpaper set, * a null pointer is returned. This is returned as an * abstract Drawable that you can install in a View to display whatever * wallpaper the user has currently set. * * @return Returns a Drawable object that will draw the wallpaper or a * null pointer if these is none. */ public Drawable peekDrawable() { Bitmap bm = sGlobals.peekWallpaperBitmap(mContext, false, FLAG_SYSTEM); if (bm != null) { Drawable dr = new BitmapDrawable(mContext.getResources(), bm); dr.setDither(false); return dr; } return null; } /** * Like {@link #getDrawable()}, but the returned Drawable has a number * of limitations to reduce its overhead as much as possible. It will * never scale the wallpaper (only centering it if the requested bounds * do match the bitmap bounds, which should not be typical), doesn't * allow setting an alpha, color filter, or other attributes, etc. The * bounds of the returned drawable will be initialized to the same bounds * as the wallpaper, so normally you will not need to touch it. The * drawable also assumes that it will be used in a context running in * the same density as the screen (not in density compatibility mode). * * @return Returns a Drawable object that will draw the wallpaper. */ @RequiresPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE) public Drawable getFastDrawable() { Bitmap bm = sGlobals.peekWallpaperBitmap(mContext, true, FLAG_SYSTEM); if (bm != null) { return new FastBitmapDrawable(bm); } return null; } /** * Like {@link #getFastDrawable()}, but if there is no wallpaper set, * a null pointer is returned. * * @return Returns an optimized Drawable object that will draw the * wallpaper or a null pointer if these is none. */ @RequiresPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE) public Drawable peekFastDrawable() { Bitmap bm = sGlobals.peekWallpaperBitmap(mContext, false, FLAG_SYSTEM); if (bm != null) { return new FastBitmapDrawable(bm); } return null; } /** * Like {@link #getDrawable()} but returns a Bitmap with default {@link Bitmap.Config}. * * @hide */ @UnsupportedAppUsage public Bitmap getBitmap() { return getBitmap(false); } /** * Like {@link #getDrawable()} but returns a Bitmap. * * @param hardware Asks for a hardware backed bitmap. * @see Bitmap.Config#HARDWARE * @hide */ @UnsupportedAppUsage public Bitmap getBitmap(boolean hardware) { return getBitmapAsUser(mContext.getUserId(), hardware); } /** * Like {@link #getDrawable()} but returns a Bitmap for the provided user. * * @hide */ public Bitmap getBitmapAsUser(int userId, boolean hardware) { return sGlobals.peekWallpaperBitmap(mContext, true, FLAG_SYSTEM, userId, hardware); } /** * Get an open, readable file descriptor to the given wallpaper image file. * The caller is responsible for closing the file descriptor when done ingesting the file. * * <p>If no lock-specific wallpaper has been configured for the given user, then * this method will return {@code null} when requesting {@link #FLAG_LOCK} rather than * returning the system wallpaper's image file. * * @param which The wallpaper whose image file is to be retrieved. Must be a single * defined kind of wallpaper, either {@link #FLAG_SYSTEM} or * {@link #FLAG_LOCK}. * @return An open, readable file desriptor to the requested wallpaper image file; * or {@code null} if no such wallpaper is configured or if the calling app does * not have permission to read the current wallpaper. * * @see #FLAG_LOCK * @see #FLAG_SYSTEM */ @RequiresPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE) public ParcelFileDescriptor getWallpaperFile(@SetWallpaperFlags int which) { return getWallpaperFile(which, mContext.getUserId()); } /** * Registers a listener to get notified when the wallpaper colors change. * @param listener A listener to register * @param handler Where to call it from. Will be called from the main thread * if null. */ public void addOnColorsChangedListener(@NonNull OnColorsChangedListener listener, @NonNull Handler handler) { addOnColorsChangedListener(listener, handler, mContext.getUserId()); } /** * Registers a listener to get notified when the wallpaper colors change * @param listener A listener to register * @param handler Where to call it from. Will be called from the main thread * if null. * @param userId Owner of the wallpaper or UserHandle.USER_ALL. * @hide */ @UnsupportedAppUsage public void addOnColorsChangedListener(@NonNull OnColorsChangedListener listener, @NonNull Handler handler, int userId) { sGlobals.addOnColorsChangedListener(listener, handler, userId); } /** * Stop listening to color updates. * @param callback A callback to unsubscribe. */ public void removeOnColorsChangedListener(@NonNull OnColorsChangedListener callback) { removeOnColorsChangedListener(callback, mContext.getUserId()); } /** * Stop listening to color updates. * @param callback A callback to unsubscribe. * @param userId Owner of the wallpaper or UserHandle.USER_ALL. * @hide */ public void removeOnColorsChangedListener(@NonNull OnColorsChangedListener callback, int userId) { sGlobals.removeOnColorsChangedListener(callback, userId); } /** * Get the primary colors of a wallpaper. * * <p>This method can return {@code null} when: * <ul> * <li>Colors are still being processed by the system.</li> * <li>The user has chosen to use a live wallpaper: live wallpapers might not * implement * {@link android.service.wallpaper.WallpaperService.Engine#onComputeColors() * WallpaperService.Engine#onComputeColors()}.</li> * </ul> * * @param which Wallpaper type. Must be either {@link #FLAG_SYSTEM} or * {@link #FLAG_LOCK}. * @return Current {@link WallpaperColors} or null if colors are unknown. * @see #addOnColorsChangedListener(OnColorsChangedListener, Handler) */ public @Nullable WallpaperColors getWallpaperColors(int which) { return getWallpaperColors(which, mContext.getUserId()); } /** * Get the primary colors of the wallpaper configured in the given user. * @param which wallpaper type. Must be either {@link #FLAG_SYSTEM} or * {@link #FLAG_LOCK} * @param userId Owner of the wallpaper. * @return {@link WallpaperColors} or null if colors are unknown. * @hide */ @UnsupportedAppUsage public @Nullable WallpaperColors getWallpaperColors(int which, int userId) { return sGlobals.getWallpaperColors(which, userId); } /** * Version of {@link #getWallpaperFile(int)} that can access the wallpaper data * for a given user. The caller must hold the INTERACT_ACROSS_USERS_FULL * permission to access another user's wallpaper data. * * @param which The wallpaper whose image file is to be retrieved. Must be a single * defined kind of wallpaper, either {@link #FLAG_SYSTEM} or * {@link #FLAG_LOCK}. * @param userId The user or profile whose imagery is to be retrieved * * @see #FLAG_LOCK * @see #FLAG_SYSTEM * * @hide */ @UnsupportedAppUsage public ParcelFileDescriptor getWallpaperFile(@SetWallpaperFlags int which, int userId) { if (which != FLAG_SYSTEM && which != FLAG_LOCK) { throw new IllegalArgumentException("Must request exactly one kind of wallpaper"); } if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { try { Bundle outParams = new Bundle(); return sGlobals.mService.getWallpaper(mContext.getOpPackageName(), null, which, outParams, userId); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } catch (SecurityException e) { if (mContext.getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.O_MR1) { Log.w(TAG, "No permission to access wallpaper, suppressing" + " exception to avoid crashing legacy app."); return null; } else { throw e; } } } } /** * Remove all internal references to the last loaded wallpaper. Useful * for apps that want to reduce memory usage when they only temporarily * need to have the wallpaper. After calling, the next request for the * wallpaper will require reloading it again from disk. */ public void forgetLoadedWallpaper() { sGlobals.forgetLoadedWallpaper(); } /** * If the current wallpaper is a live wallpaper component, return the * information about that wallpaper. Otherwise, if it is a static image, * simply return null. */ public WallpaperInfo getWallpaperInfo() { try { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { return sGlobals.mService.getWallpaperInfo(mContext.getUserId()); } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Get the ID of the current wallpaper of the given kind. If there is no * such wallpaper configured, returns a negative number. * * <p>Every time the wallpaper image is set, a new ID is assigned to it. * This method allows the caller to determine whether the wallpaper imagery * has changed, regardless of how that change happened. * * @param which The wallpaper whose ID is to be returned. Must be a single * defined kind of wallpaper, either {@link #FLAG_SYSTEM} or * {@link #FLAG_LOCK}. * @return The positive numeric ID of the current wallpaper of the given kind, * or a negative value if no such wallpaper is configured. */ public int getWallpaperId(@SetWallpaperFlags int which) { return getWallpaperIdForUser(which, mContext.getUserId()); } /** * Get the ID of the given user's current wallpaper of the given kind. If there * is no such wallpaper configured, returns a negative number. * @hide */ public int getWallpaperIdForUser(@SetWallpaperFlags int which, int userId) { try { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { return sGlobals.mService.getWallpaperIdForUser(which, userId); } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Gets an Intent that will launch an activity that crops the given * image and sets the device's wallpaper. If there is a default HOME activity * that supports cropping wallpapers, it will be preferred as the default. * Use this method instead of directly creating a {@link #ACTION_CROP_AND_SET_WALLPAPER} * intent. * * @param imageUri The image URI that will be set in the intent. The must be a content * URI and its provider must resolve its type to "image/*" * * @throws IllegalArgumentException if the URI is not a content URI or its MIME type is * not "image/*" */ public Intent getCropAndSetWallpaperIntent(Uri imageUri) { if (imageUri == null) { throw new IllegalArgumentException("Image URI must not be null"); } if (!ContentResolver.SCHEME_CONTENT.equals(imageUri.getScheme())) { throw new IllegalArgumentException( "Image URI must be of the " + ContentResolver.SCHEME_CONTENT + " scheme type"); } final PackageManager packageManager = mContext.getPackageManager(); Intent cropAndSetWallpaperIntent = new Intent(ACTION_CROP_AND_SET_WALLPAPER, imageUri); cropAndSetWallpaperIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); // Find out if the default HOME activity supports CROP_AND_SET_WALLPAPER Intent homeIntent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_HOME); ResolveInfo resolvedHome = packageManager.resolveActivity(homeIntent, PackageManager.MATCH_DEFAULT_ONLY); if (resolvedHome != null) { cropAndSetWallpaperIntent.setPackage(resolvedHome.activityInfo.packageName); List<ResolveInfo> cropAppList = packageManager.queryIntentActivities(cropAndSetWallpaperIntent, 0); if (cropAppList.size() > 0) { return cropAndSetWallpaperIntent; } } // fallback crop activity final String cropperPackage = mContext .getString(com.android.internal.R.string.config_wallpaperCropperPackage); cropAndSetWallpaperIntent.setPackage(cropperPackage); List<ResolveInfo> cropAppList = packageManager.queryIntentActivities(cropAndSetWallpaperIntent, 0); if (cropAppList.size() > 0) { return cropAndSetWallpaperIntent; } // If the URI is not of the right type, or for some reason the system wallpaper // cropper doesn't exist, return null throw new IllegalArgumentException("Cannot use passed URI to set wallpaper; " + "check that the type returned by ContentProvider matches image/*"); } /** * Change the current system wallpaper to the bitmap in the given resource. * The resource is opened as a raw data stream and copied into the * wallpaper; it must be a valid PNG or JPEG image. On success, the intent * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. * * @param resid The resource ID of the bitmap to be used as the wallpaper image * * @throws IOException If an error occurs reverting to the built-in * wallpaper. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public void setResource(@RawRes int resid) throws IOException { setResource(resid, FLAG_SYSTEM | FLAG_LOCK); } /** * Version of {@link #setResource(int)} that allows the caller to specify which * of the supported wallpaper categories to set. * * @param resid The resource ID of the bitmap to be used as the wallpaper image * @param which Flags indicating which wallpaper(s) to configure with the new imagery * * @see #FLAG_LOCK * @see #FLAG_SYSTEM * * @return An integer ID assigned to the newly active wallpaper; or zero on failure. * * @throws IOException */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public int setResource(@RawRes int resid, @SetWallpaperFlags int which) throws IOException { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } final Bundle result = new Bundle(); final WallpaperSetCompletion completion = new WallpaperSetCompletion(); try { Resources resources = mContext.getResources(); /* Set the wallpaper to the default values */ ParcelFileDescriptor fd = sGlobals.mService.setWallpaper("res:" + resources.getResourceName(resid), mContext.getOpPackageName(), null, false, result, which, completion, mContext.getUserId()); if (fd != null) { FileOutputStream fos = null; boolean ok = false; try { fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); copyStreamToWallpaperFile(resources.openRawResource(resid), fos); // The 'close()' is the trigger for any server-side image manipulation, // so we must do that before waiting for completion. fos.close(); completion.waitForCompletion(); } finally { // Might be redundant but completion shouldn't wait unless the write // succeeded; this is a fallback if it threw past the close+wait. IoUtils.closeQuietly(fos); } } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } return result.getInt(EXTRA_NEW_WALLPAPER_ID, 0); } /** * Change the current system wallpaper to a bitmap. The given bitmap is * converted to a PNG and stored as the wallpaper. On success, the intent * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. * * <p>This method is equivalent to calling * {@link #setBitmap(Bitmap, Rect, boolean)} and passing {@code null} for the * {@code visibleCrop} rectangle and {@code true} for the {@code allowBackup} * parameter. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. * * @param bitmap The bitmap to be used as the new system wallpaper. * * @throws IOException If an error occurs when attempting to set the wallpaper * to the provided image. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public void setBitmap(Bitmap bitmap) throws IOException { setBitmap(bitmap, null, true); } /** * Change the current system wallpaper to a bitmap, specifying a hint about * which subrectangle of the full image is to be visible. The OS will then * try to best present the given portion of the full image as the static system * wallpaper image. On success, the intent * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. * * <p>Passing {@code null} as the {@code visibleHint} parameter is equivalent to * passing (0, 0, {@code fullImage.getWidth()}, {@code fullImage.getHeight()}). * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. * * @param fullImage A bitmap that will supply the wallpaper imagery. * @param visibleCropHint The rectangular subregion of {@code fullImage} that should be * displayed as wallpaper. Passing {@code null} for this parameter means that * the full image should be displayed if possible given the image's and device's * aspect ratios, etc. * @param allowBackup {@code true} if the OS is permitted to back up this wallpaper * image for restore to a future device; {@code false} otherwise. * * @return An integer ID assigned to the newly active wallpaper; or zero on failure. * * @throws IOException If an error occurs when attempting to set the wallpaper * to the provided image. * @throws IllegalArgumentException If the {@code visibleCropHint} rectangle is * empty or invalid. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public int setBitmap(Bitmap fullImage, Rect visibleCropHint, boolean allowBackup) throws IOException { return setBitmap(fullImage, visibleCropHint, allowBackup, FLAG_SYSTEM | FLAG_LOCK); } /** * Version of {@link #setBitmap(Bitmap, Rect, boolean)} that allows the caller * to specify which of the supported wallpaper categories to set. * * @param fullImage A bitmap that will supply the wallpaper imagery. * @param visibleCropHint The rectangular subregion of {@code fullImage} that should be * displayed as wallpaper. Passing {@code null} for this parameter means that * the full image should be displayed if possible given the image's and device's * aspect ratios, etc. * @param allowBackup {@code true} if the OS is permitted to back up this wallpaper * image for restore to a future device; {@code false} otherwise. * @param which Flags indicating which wallpaper(s) to configure with the new imagery. * * @see #FLAG_LOCK * @see #FLAG_SYSTEM * * @return An integer ID assigned to the newly active wallpaper; or zero on failure. * * @throws IOException */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public int setBitmap(Bitmap fullImage, Rect visibleCropHint, boolean allowBackup, @SetWallpaperFlags int which) throws IOException { return setBitmap(fullImage, visibleCropHint, allowBackup, which, mContext.getUserId()); } /** * Like {@link #setBitmap(Bitmap, Rect, boolean, int)}, but allows to pass in an explicit user * id. If the user id doesn't match the user id the process is running under, calling this * requires permission {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL}. * @hide */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) public int setBitmap(Bitmap fullImage, Rect visibleCropHint, boolean allowBackup, @SetWallpaperFlags int which, int userId) throws IOException { validateRect(visibleCropHint); if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } final Bundle result = new Bundle(); final WallpaperSetCompletion completion = new WallpaperSetCompletion(); try { ParcelFileDescriptor fd = sGlobals.mService.setWallpaper(null, mContext.getOpPackageName(), visibleCropHint, allowBackup, result, which, completion, userId); if (fd != null) { FileOutputStream fos = null; try { fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); fullImage.compress(Bitmap.CompressFormat.PNG, 90, fos); fos.close(); completion.waitForCompletion(); } finally { IoUtils.closeQuietly(fos); } } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } return result.getInt(EXTRA_NEW_WALLPAPER_ID, 0); } private final void validateRect(Rect rect) { if (rect != null && rect.isEmpty()) { throw new IllegalArgumentException("visibleCrop rectangle must be valid and non-empty"); } } /** * Change the current system wallpaper to a specific byte stream. The * give InputStream is copied into persistent storage and will now be * used as the wallpaper. Currently it must be either a JPEG or PNG * image. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} * is broadcast. * * <p>This method is equivalent to calling * {@link #setStream(InputStream, Rect, boolean)} and passing {@code null} for the * {@code visibleCrop} rectangle and {@code true} for the {@code allowBackup} * parameter. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. * * @param bitmapData A stream containing the raw data to install as a wallpaper. This * data can be in any format handled by {@link BitmapRegionDecoder}. * * @throws IOException If an error occurs when attempting to set the wallpaper * based on the provided image data. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public void setStream(InputStream bitmapData) throws IOException { setStream(bitmapData, null, true); } private void copyStreamToWallpaperFile(InputStream data, FileOutputStream fos) throws IOException { FileUtils.copy(data, fos); } /** * Change the current system wallpaper to a specific byte stream, specifying a * hint about which subrectangle of the full image is to be visible. The OS will * then try to best present the given portion of the full image as the static system * wallpaper image. The data from the given InputStream is copied into persistent * storage and will then be used as the system wallpaper. Currently the data must * be either a JPEG or PNG image. On success, the intent * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. * * @param bitmapData A stream containing the raw data to install as a wallpaper. This * data can be in any format handled by {@link BitmapRegionDecoder}. * @param visibleCropHint The rectangular subregion of the streamed image that should be * displayed as wallpaper. Passing {@code null} for this parameter means that * the full image should be displayed if possible given the image's and device's * aspect ratios, etc. * @param allowBackup {@code true} if the OS is permitted to back up this wallpaper * image for restore to a future device; {@code false} otherwise. * @return An integer ID assigned to the newly active wallpaper; or zero on failure. * * @see #getWallpaperId(int) * * @throws IOException If an error occurs when attempting to set the wallpaper * based on the provided image data. * @throws IllegalArgumentException If the {@code visibleCropHint} rectangle is * empty or invalid. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public int setStream(InputStream bitmapData, Rect visibleCropHint, boolean allowBackup) throws IOException { return setStream(bitmapData, visibleCropHint, allowBackup, FLAG_SYSTEM | FLAG_LOCK); } /** * Version of {@link #setStream(InputStream, Rect, boolean)} that allows the caller * to specify which of the supported wallpaper categories to set. * * @param bitmapData A stream containing the raw data to install as a wallpaper. This * data can be in any format handled by {@link BitmapRegionDecoder}. * @param visibleCropHint The rectangular subregion of the streamed image that should be * displayed as wallpaper. Passing {@code null} for this parameter means that * the full image should be displayed if possible given the image's and device's * aspect ratios, etc. * @param allowBackup {@code true} if the OS is permitted to back up this wallpaper * image for restore to a future device; {@code false} otherwise. * @param which Flags indicating which wallpaper(s) to configure with the new imagery. * @return An integer ID assigned to the newly active wallpaper; or zero on failure. * * @see #getWallpaperId(int) * @see #FLAG_LOCK * @see #FLAG_SYSTEM * * @throws IOException */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public int setStream(InputStream bitmapData, Rect visibleCropHint, boolean allowBackup, @SetWallpaperFlags int which) throws IOException { validateRect(visibleCropHint); if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } final Bundle result = new Bundle(); final WallpaperSetCompletion completion = new WallpaperSetCompletion(); try { ParcelFileDescriptor fd = sGlobals.mService.setWallpaper(null, mContext.getOpPackageName(), visibleCropHint, allowBackup, result, which, completion, mContext.getUserId()); if (fd != null) { FileOutputStream fos = null; try { fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); copyStreamToWallpaperFile(bitmapData, fos); fos.close(); completion.waitForCompletion(); } finally { IoUtils.closeQuietly(fos); } } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } return result.getInt(EXTRA_NEW_WALLPAPER_ID, 0); } /** * Return whether any users are currently set to use the wallpaper * with the given resource ID. That is, their wallpaper has been * set through {@link #setResource(int)} with the same resource id. */ public boolean hasResourceWallpaper(@RawRes int resid) { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { Resources resources = mContext.getResources(); String name = "res:" + resources.getResourceName(resid); return sGlobals.mService.hasNamedWallpaper(name); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Returns the desired minimum width for the wallpaper. Callers of * {@link #setBitmap(android.graphics.Bitmap)} or * {@link #setStream(java.io.InputStream)} should check this value * beforehand to make sure the supplied wallpaper respects the desired * minimum width. * * If the returned value is <= 0, the caller should use the width of * the default display instead. * * @return The desired minimum width for the wallpaper. This value should * be honored by applications that set the wallpaper but it is not * mandatory. */ public int getDesiredMinimumWidth() { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { return sGlobals.mService.getWidthHint(); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Returns the desired minimum height for the wallpaper. Callers of * {@link #setBitmap(android.graphics.Bitmap)} or * {@link #setStream(java.io.InputStream)} should check this value * beforehand to make sure the supplied wallpaper respects the desired * minimum height. * * If the returned value is <= 0, the caller should use the height of * the default display instead. * * @return The desired minimum height for the wallpaper. This value should * be honored by applications that set the wallpaper but it is not * mandatory. */ public int getDesiredMinimumHeight() { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { return sGlobals.mService.getHeightHint(); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * For use only by the current home application, to specify the size of * wallpaper it would like to use. This allows such applications to have * a virtual wallpaper that is larger than the physical screen, matching * the size of their workspace. * * <p>Note developers, who don't seem to be reading this. This is * for <em>home apps</em> to tell what size wallpaper they would like. * Nobody else should be calling this! Certainly not other non-home * apps that change the wallpaper. Those apps are supposed to * <b>retrieve</b> the suggested size so they can construct a wallpaper * that matches it. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER_HINTS}. * * @param minimumWidth Desired minimum width * @param minimumHeight Desired minimum height */ public void suggestDesiredDimensions(int minimumWidth, int minimumHeight) { try { /** * The framework makes no attempt to limit the window size * to the maximum texture size. Any window larger than this * cannot be composited. * * Read maximum texture size from system property and scale down * minimumWidth and minimumHeight accordingly. */ int maximumTextureSize; try { maximumTextureSize = SystemProperties.getInt("sys.max_texture_size", 0); } catch (Exception e) { maximumTextureSize = 0; } if (maximumTextureSize > 0) { if ((minimumWidth > maximumTextureSize) || (minimumHeight > maximumTextureSize)) { float aspect = (float) minimumHeight / (float) minimumWidth; if (minimumWidth > minimumHeight) { minimumWidth = maximumTextureSize; minimumHeight = (int) ((minimumWidth * aspect) + 0.5); } else { minimumHeight = maximumTextureSize; minimumWidth = (int) ((minimumHeight / aspect) + 0.5); } } } if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { sGlobals.mService.setDimensionHints(minimumWidth, minimumHeight, mContext.getOpPackageName()); } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Specify extra padding that the wallpaper should have outside of the display. * That is, the given padding supplies additional pixels the wallpaper should extend * outside of the display itself. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER_HINTS}. * * @param padding The number of pixels the wallpaper should extend beyond the display, * on its left, top, right, and bottom sides. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER_HINTS) public void setDisplayPadding(Rect padding) { try { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { sGlobals.mService.setDisplayPadding(padding, mContext.getOpPackageName()); } } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Apply a raw offset to the wallpaper window. Should only be used in * combination with {@link #setDisplayPadding(android.graphics.Rect)} when you * have ensured that the wallpaper will extend outside of the display area so that * it can be moved without leaving part of the display uncovered. * @param x The offset, in pixels, to apply to the left edge. * @param y The offset, in pixels, to apply to the top edge. * @hide */ @SystemApi public void setDisplayOffset(IBinder windowToken, int x, int y) { try { //Log.v(TAG, "Sending new wallpaper display offsets from app..."); WindowManagerGlobal.getWindowSession().setWallpaperDisplayOffset(windowToken, x, y); //Log.v(TAG, "...app returning after sending display offset!"); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Reset all wallpaper to the factory default. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public void clearWallpaper() { clearWallpaper(FLAG_LOCK, mContext.getUserId()); clearWallpaper(FLAG_SYSTEM, mContext.getUserId()); } /** * Clear the wallpaper for a specific user. The caller must hold the * INTERACT_ACROSS_USERS_FULL permission to clear another user's * wallpaper, and must hold the SET_WALLPAPER permission in all * circumstances. * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS_FULL) public void clearWallpaper(@SetWallpaperFlags int which, int userId) { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { sGlobals.mService.clearWallpaper(mContext.getOpPackageName(), which, userId); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Set the live wallpaper. * * @hide */ @SystemApi @RequiresPermission(android.Manifest.permission.SET_WALLPAPER_COMPONENT) public boolean setWallpaperComponent(ComponentName name) { return setWallpaperComponent(name, mContext.getUserId()); } /** * Set the live wallpaper. * * This can only be called by packages with android.permission.SET_WALLPAPER_COMPONENT * permission. The caller must hold the INTERACT_ACROSS_USERS_FULL permission to change * another user's wallpaper. * * @hide */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER_COMPONENT) @UnsupportedAppUsage public boolean setWallpaperComponent(ComponentName name, int userId) { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { sGlobals.mService.setWallpaperComponentChecked(name, mContext.getOpPackageName(), userId); return true; } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Set the display position of the current wallpaper within any larger space, when * that wallpaper is visible behind the given window. The X and Y offsets * are floating point numbers ranging from 0 to 1, representing where the * wallpaper should be positioned within the screen space. These only * make sense when the wallpaper is larger than the display. * * @param windowToken The window who these offsets should be associated * with, as returned by {@link android.view.View#getWindowToken() * View.getWindowToken()}. * @param xOffset The offset along the X dimension, from 0 to 1. * @param yOffset The offset along the Y dimension, from 0 to 1. */ public void setWallpaperOffsets(IBinder windowToken, float xOffset, float yOffset) { try { //Log.v(TAG, "Sending new wallpaper offsets from app..."); WindowManagerGlobal.getWindowSession().setWallpaperPosition(windowToken, xOffset, yOffset, mWallpaperXStep, mWallpaperYStep); //Log.v(TAG, "...app returning after sending offsets!"); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * For applications that use multiple virtual screens showing a wallpaper, * specify the step size between virtual screens. For example, if the * launcher has 3 virtual screens, it would specify an xStep of 0.5, * since the X offset for those screens are 0.0, 0.5 and 1.0 * @param xStep The X offset delta from one screen to the next one * @param yStep The Y offset delta from one screen to the next one */ public void setWallpaperOffsetSteps(float xStep, float yStep) { mWallpaperXStep = xStep; mWallpaperYStep = yStep; } /** * Send an arbitrary command to the current active wallpaper. * * @param windowToken The window who these offsets should be associated * with, as returned by {@link android.view.View#getWindowToken() * View.getWindowToken()}. * @param action Name of the command to perform. This must be a scoped * name to avoid collisions, such as "com.mycompany.wallpaper.DOIT". * @param x Arbitrary integer argument based on command. * @param y Arbitrary integer argument based on command. * @param z Arbitrary integer argument based on command. * @param extras Optional additional information for the command, or null. */ public void sendWallpaperCommand(IBinder windowToken, String action, int x, int y, int z, Bundle extras) { try { //Log.v(TAG, "Sending new wallpaper offsets from app..."); WindowManagerGlobal.getWindowSession().sendWallpaperCommand(windowToken, action, x, y, z, extras, false); //Log.v(TAG, "...app returning after sending offsets!"); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Returns whether wallpapers are supported for the calling user. If this function returns * {@code false}, any attempts to changing the wallpaper will have no effect, * and any attempt to obtain of the wallpaper will return {@code null}. */ public boolean isWallpaperSupported() { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { try { return sGlobals.mService.isWallpaperSupported(mContext.getOpPackageName()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } } /** * Returns whether the calling package is allowed to set the wallpaper for the calling user. * If this function returns {@code false}, any attempts to change the wallpaper will have * no effect. Always returns {@code true} for device owner and profile owner. * * @see android.os.UserManager#DISALLOW_SET_WALLPAPER */ public boolean isSetWallpaperAllowed() { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } else { try { return sGlobals.mService.isSetWallpaperAllowed(mContext.getOpPackageName()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } } /** * Clear the offsets previously associated with this window through * {@link #setWallpaperOffsets(IBinder, float, float)}. This reverts * the window to its default state, where it does not cause the wallpaper * to scroll from whatever its last offsets were. * * @param windowToken The window who these offsets should be associated * with, as returned by {@link android.view.View#getWindowToken() * View.getWindowToken()}. */ public void clearWallpaperOffsets(IBinder windowToken) { try { WindowManagerGlobal.getWindowSession().setWallpaperPosition(windowToken, -1, -1, -1, -1); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Remove any currently set system wallpaper, reverting to the system's built-in * wallpaper. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} * is broadcast. * * <p>This method requires the caller to hold the permission * {@link android.Manifest.permission#SET_WALLPAPER}. * * @throws IOException If an error occurs reverting to the built-in * wallpaper. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public void clear() throws IOException { setStream(openDefaultWallpaper(mContext, FLAG_SYSTEM), null, false); } /** * Remove one or more currently set wallpapers, reverting to the system default * display for each one. If {@link #FLAG_SYSTEM} is set in the {@code which} * parameter, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} will be broadcast * upon success. * * @param which A bitwise combination of {@link #FLAG_SYSTEM} or * {@link #FLAG_LOCK} * @throws IOException If an error occurs reverting to the built-in wallpaper. */ @RequiresPermission(android.Manifest.permission.SET_WALLPAPER) public void clear(@SetWallpaperFlags int which) throws IOException { if ((which & FLAG_SYSTEM) != 0) { clear(); } if ((which & FLAG_LOCK) != 0) { clearWallpaper(FLAG_LOCK, mContext.getUserId()); } } /** * Open stream representing the default static image wallpaper. * * If the device defines no default wallpaper of the requested kind, * {@code null} is returned. * * @hide */ @UnsupportedAppUsage public static InputStream openDefaultWallpaper(Context context, @SetWallpaperFlags int which) { final String whichProp; final int defaultResId; if (which == FLAG_LOCK) { /* Factory-default lock wallpapers are not yet supported whichProp = PROP_LOCK_WALLPAPER; defaultResId = com.android.internal.R.drawable.default_lock_wallpaper; */ return null; } else { whichProp = PROP_WALLPAPER; defaultResId = com.android.internal.R.drawable.default_wallpaper; } final String path = SystemProperties.get(whichProp); if (!TextUtils.isEmpty(path)) { final File file = new File(path); if (file.exists()) { try { return new FileInputStream(file); } catch (IOException e) { // Ignored, fall back to platform default below } } } try { return context.getResources().openRawResource(defaultResId); } catch (NotFoundException e) { // no default defined for this device; this is not a failure } return null; } /** * Return {@link ComponentName} of the default live wallpaper, or * {@code null} if none is defined. * * @hide */ public static ComponentName getDefaultWallpaperComponent(Context context) { ComponentName cn = null; String flat = SystemProperties.get(PROP_WALLPAPER_COMPONENT); if (!TextUtils.isEmpty(flat)) { cn = ComponentName.unflattenFromString(flat); } if (cn == null) { flat = context.getString(com.android.internal.R.string.default_wallpaper_component); if (!TextUtils.isEmpty(flat)) { cn = ComponentName.unflattenFromString(flat); } } // Check if the package exists if (cn != null) { try { final PackageManager packageManager = context.getPackageManager(); packageManager.getPackageInfo(cn.getPackageName(), PackageManager.MATCH_DIRECT_BOOT_AWARE | PackageManager.MATCH_DIRECT_BOOT_UNAWARE); } catch (PackageManager.NameNotFoundException e) { cn = null; } } return cn; } /** * Register a callback for lock wallpaper observation. Only the OS may use this. * * @return true on success; false on error. * @hide */ public boolean setLockWallpaperCallback(IWallpaperManagerCallback callback) { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { return sGlobals.mService.setLockWallpaperCallback(callback); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Is the current system wallpaper eligible for backup? * * Only the OS itself may use this method. * @hide */ public boolean isWallpaperBackupEligible(int which) { if (sGlobals.mService == null) { Log.w(TAG, "WallpaperService not running"); throw new RuntimeException(new DeadSystemException()); } try { return sGlobals.mService.isWallpaperBackupEligible(which, mContext.getUserId()); } catch (RemoteException e) { Log.e(TAG, "Exception querying wallpaper backup eligibility: " + e.getMessage()); } return false; } // Private completion callback for setWallpaper() synchronization private class WallpaperSetCompletion extends IWallpaperManagerCallback.Stub { final CountDownLatch mLatch; public WallpaperSetCompletion() { mLatch = new CountDownLatch(1); } public void waitForCompletion() { try { mLatch.await(30, TimeUnit.SECONDS); } catch (InterruptedException e) { // This might be legit: the crop may take a very long time. Don't sweat // it in that case; we are okay with display lagging behind in order to // keep the caller from locking up indeterminately. } } @Override public void onWallpaperChanged() throws RemoteException { mLatch.countDown(); } @Override public void onWallpaperColorsChanged(WallpaperColors colors, int which, int userId) throws RemoteException { sGlobals.onWallpaperColorsChanged(colors, which, userId); } } /** * Interface definition for a callback to be invoked when colors change on a wallpaper. */ public interface OnColorsChangedListener { /** * Called when colors change. * A {@link android.app.WallpaperColors} object containing a simplified * color histogram will be given. * * @param colors Wallpaper color info * @param which A combination of {@link #FLAG_LOCK} and {@link #FLAG_SYSTEM} */ void onColorsChanged(WallpaperColors colors, int which); /** * Called when colors change. * A {@link android.app.WallpaperColors} object containing a simplified * color histogram will be given. * * @param colors Wallpaper color info * @param which A combination of {@link #FLAG_LOCK} and {@link #FLAG_SYSTEM} * @param userId Owner of the wallpaper * @hide */ default void onColorsChanged(WallpaperColors colors, int which, int userId) { onColorsChanged(colors, which); } } }