安卓壁纸机制

android之壁纸机制 
１.涉及核心类: 
１>ImageWallpaper.java(IW):继承WallpaperService主要负责静态壁纸的draw处理; 
２>WallpaperManager.java(WM):主要负责壁纸的存取方法管理(可能会多个实例); 
３>WallpaperManagerService(WMS).java:主要是对WalllpaperManager一些核心方法提供,及一些初始参数的保存(服务); 
４>iWallpaperManager.aidl(IWM):负责WallpaperManager与WallpaperManagerService之间的通信; 
５>IWallpaperManagerCallback(IMC).aidl:负责WallpaperManager与WallpaperManagerService之间的通信,这是一个回调机制与前面不同; 
６>WallpaperService.java(WS):设置壁纸的引擎机制(包括动态与静态);//这类工作时没有修改过,所以个人了解不是很清楚,希望有朋友补充. 
7>launcher.java(LC)设置壁纸初始化值,带到壁纸机制的转屏. 

2. 壁纸从设置存到取流程: 
１>首先ＷＭ.setBitmap(bitmap) 
public void setBitmap(Bitmap bitmap) throws IOException { 
        try { 
            ParcelFileDescriptor fd = sGlobals.mService.setWallpaper(null); 
            if (fd == null) { 
                return; 
            } 
            FileOutputStream fos = null; 
            try { 
                fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); 
                bitmap.compress(Bitmap.CompressFormat.PNG, 90, fos); 
            } finally { 
                if (fos != null) { 
                    fos.close(); 
                } 
            } 
        } catch (RemoteException e) { 
        } 
    } 
2>然后ＷＭＳ.setWallpaper(null),设置成功会写入到壁纸相应文件里,文件监听类此时会触发 
private final FileObserver mWallpaperObserver = new FileObserver( 
            WALLPAPER_DIR.getAbsolutePath(), CREATE | CLOSE_WRITE | DELETE | DELETE_SELF) { 
                @Override 
                public void onEvent(int event, String path) { 
                    if (path == null) { 
                        return; 
                    } 
                    synchronized (mLock) { 
                        // changing the wallpaper means we'll need to back up the new one 
                        long origId = Binder.clearCallingIdentity(); 
                        BackupManager bm = new BackupManager(mContext); 
                        bm.dataChanged(); 
                        Binder.restoreCallingIdentity(origId); 

                        File changedFile = new File(WALLPAPER_DIR, path); 
                        if (WALLPAPER_FILE.equals(changedFile)) { 
                            notifyCallbacksLocked();//会发出广播与调用回调方法 
                        } 
                    } 
                } 
            }; 

//notifyCallbacksLocked()做两件事情 
   private void notifyCallbacksLocked() { 
        final int n = mCallbacks.beginBroadcast(); 
        for (int i = 0; i < n; i++) { 
            try { 
                mCallbacks.getBroadcastItem(i).onWallpaperChanged();//回调机制在ＷＭ实现onWallpaperChanged() 
            } catch (RemoteException e) { 

                // The RemoteCallbackList will take care of removing 
                // the dead object for us. 
            } 
        } 
        mCallbacks.finishBroadcast(); 
        final Intent intent = new Intent(Intent.ACTION_WALLPAPER_CHANGED);//壁纸变化的广播意图 
        mContext.sendBroadcast(intent);//ＩＷ会接收到此意图,ＩＷ.updateWallpaper()去获取新壁纸. 
    } 

３>ＷＭ.onWallpaperChanged()通过handler机制清除壁纸缓存 
   private final Handler mHandler; 
        
        Globals(Looper looper) { 
            IBinder b = ServiceManager.getService(Context.WALLPAPER_SERVICE); 
            mService = IWallpaperManager.Stub.asInterface(b); 
            mHandler = new Handler(looper) { 
                @Override 
                public void handleMessage(Message msg) { 
                    switch (msg.what) { 
                        case MSG_CLEAR_WALLPAPER: 
                            synchronized (this) { 
                                mWallpaper = null;//用户自定义壁纸 
                                mDefaultWallpaper = null;//系统默认壁纸 
                            } 
                            break; 
                    } 
                } 
            }; 
        } 
        
        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. 
             */ 
            mHandler.sendEmptyMessage(MSG_CLEAR_WALLPAPER); 
        } 

//ＩＷ.updateWallpaper() 

  void updateWallpaper() { 
            synchronized (mLock) { 
                try { 
                    mBackground = mWallpaperManager.getFastDrawable();//ＷＭ去获取壁纸 
                } catch (RuntimeException e) { 
                    Log.w("ImageWallpaper", "Unable to load wallpaper!", e); 
                } 
            } 
        } 
//收到壁纸变换广播 
     class WallpaperObserver extends BroadcastReceiver { 
            public void onReceive(Context context, Intent intent) { 
                updateWallpaper();//调用 
                drawFrame(); 
                // Assume we are the only one using the wallpaper in this 
                // process, and force a GC now to release the old wallpaper. 
                System.gc(); 
            } 
        } 

        @Override 
        public void onCreate(SurfaceHolder surfaceHolder) { 
            super.onCreate(surfaceHolder); 
            IntentFilter filter = new IntentFilter(Intent.ACTION_WALLPAPER_CHANGED);// 
            mReceiver = new WallpaperObserver(); 
            registerReceiver(mReceiver, filter);//注册 
            updateWallpaper(); 
            surfaceHolder.setSizeFromLayout(); 
        } 

４>mWallpaperManager.getFastDrawable();//ＷＭ去获取壁纸 
a.  public Drawable getFastDrawable() { 
        Bitmap bm = sGlobals.peekWallpaperBitmap(mContext, true);//获取壁纸总方法 
        if (bm != null) { 
            Drawable dr = new FastBitmapDrawable(bm); 
            return dr; 
        } 
        return null; 
    } 

b. public Bitmap peekWallpaperBitmap(Context context, boolean returnDefault) { 
            synchronized (this) { 
                if (mWallpaper != null) { 
                    return mWallpaper; 
                } 
                if (mDefaultWallpaper != null) { 
                    return mDefaultWallpaper; 
                } 
                mWallpaper = null; 
                try { 
                    mWallpaper = getCurrentWallpaperLocked(context);//调用获取用户自定义壁纸方法 
                } catch (OutOfMemoryError e) { 
                    Log.w(TAG, "No memory load current wallpaper", e); 
                } 
                if (mWallpaper == null && returnDefault) { 
                    mDefaultWallpaper = getDefaultWallpaperLocked(context);调用默认壁纸方法 
                    return mDefaultWallpaper; 
                } 
                return mWallpaper; 
            } 
        } 

c. 两方法分析 
private Bitmap getCurrentWallpaperLocked(Context context) { 
            try { 
                Bundle params = new Bundle(); 
                ParcelFileDescriptor fd = mService.getWallpaper(this, params);//ＷＭＳ.getWallpaper(this, params),params是out型表示参数传送是从ＷＭＳ传到ＷＭ,是与平时java编码不合适习惯的这android一特性也是aidl机制的一部分;这里留个问题就ＷＭＳ是如何获取到的params参数呢? 
                if (fd != null) { 
                    int width = params.getInt("width", 0); 
                    int height = params.getInt("height", 0); 
                    
                    if (width <= 0 || height <= 0) { 
                        // Degenerate case: no size requested, just load 
                        // bitmap as-is. 
                        Bitmap bm = null; 
                        try { 
                            bm = BitmapFactory.decodeFileDescriptor( 
                                   fd.getFileDescriptor(), null, null); 
                        } catch (OutOfMemoryError e) { 
                            Log.w(TAG, "Can't decode file", e); 
                        } 
                        try { 
                            fd.close(); 
                        } catch (IOException e) { 
                        } 
                        if (bm != null) { 
                            bm.setDensity(DisplayMetrics.DENSITY_DEVICE); 
                        } 
                        return bm; 
                    } 
                    
                    // Load the bitmap with full color depth, to preserve 
                    // quality for later processing. 
                    BitmapFactory.Options options = new BitmapFactory.Options(); 
                    options.inDither = false; 
                    options.inPreferredConfig = Bitmap.Config.ARGB_8888; 
                    Bitmap bm = BitmapFactory.decodeFileDescriptor( 
                            fd.getFileDescriptor(), null, options); 
                    try { 
                        fd.close(); 
                    } catch (IOException e) { 
                    } 
                    
                    return generateBitmap(context, bm, width, height); 
                } 
            } catch (RemoteException e) { 
            } 
            return null; 
        } 
        
        private Bitmap getDefaultWallpaperLocked(Context context) { 
            try { 
                InputStream is = context.getResources().openRawResource( 
                        com.android.internal.R.drawable.default_wallpaper); 
                if (is != null) { 
                    int width = mService.getWidthHint(); 
                    int height = mService.getHeightHint(); 
                    
                    if (width <= 0 || height <= 0) { 
                        // Degenerate case: no size requested, just load 
                        // bitmap as-is. 
                        Bitmap bm = null; 
                        try { 
                            bm = BitmapFactory.decodeStream(is, null, null); 
                        } catch (OutOfMemoryError e) { 
                            Log.w(TAG, "Can't decode stream", e); 
                        } 
                        try { 
                            is.close(); 
                        } catch (IOException e) { 
                        } 
                        if (bm != null) { 
                            bm.setDensity(DisplayMetrics.DENSITY_DEVICE); 
                        } 
                        return bm; 
                    } 
５>ＷＭＳ.getWallpaper(this, params) 
    public ParcelFileDescriptor getWallpaper(IWallpaperManagerCallback cb, 
            Bundle outParams) { 
        synchronized (mLock) { 
            try { 
                if (outParams != null) { 
                    outParams.putInt("width", mWidth); 
                    outParams.putInt("height", mHeight); 
                } 
                mCallbacks.register(cb); 
                File f = WALLPAPER_FILE; 
                if (!f.exists()) { 
                    return null; 
                } 
                return ParcelFileDescriptor.open(f, MODE_READ_ONLY);//ParcelFileDescriptor是google自定义的句柄具有安全性,对它所属的流具体保护性,否会图像丢失出现花屏情况.我对它了解也不深,不遇到类似的bug. 
            } catch (FileNotFoundException e) { 
                /* Shouldn't happen as we check to see if the file exists */ 
                Slog.w(TAG, "Error getting wallpaper", e); 
            } 
            return null; 
        } 
    } 

６>呵呵呵,该画了ＩW.draw(),考虑有很多东西要跟大家分享下就把ＩＷ类粘贴出来 
package com.android.internal.service.wallpaper; 

import com.android.internal.view.WindowManagerPolicyThread; 

import android.app.WallpaperManager; 
import android.graphics.Canvas; 
import android.graphics.Rect; 
import android.graphics.Region.Op; 
import android.graphics.drawable.Drawable; 
import android.os.HandlerThread; 
import android.os.Looper; 
import android.os.Process; 
import android.service.wallpaper.WallpaperService; 
import android.util.Log; 
import android.view.MotionEvent; 
import android.view.SurfaceHolder; 
import android.content.Context; 
import android.content.IntentFilter; 
import android.content.Intent; 
import android.content.BroadcastReceiver; 

/** 
* Default built-in wallpaper that simply shows a static image. 
*/ 
public class ImageWallpaper extends WallpaperService { 
    WallpaperManager mWallpaperManager; 
    private HandlerThread mThread; 

    @Override 
    public void onCreate() { 
        super.onCreate(); 
        mWallpaperManager = (WallpaperManager) getSystemService(WALLPAPER_SERVICE); 
        Looper looper = WindowManagerPolicyThread.getLooper(); 
        if (looper != null) { 
            setCallbackLooper(looper); 
        } else { 
            mThread = new HandlerThread("Wallpaper", Process.THREAD_PRIORITY_FOREGROUND); 
            mThread.start(); 
            setCallbackLooper(mThread.getLooper()); 
        } 
    } 

    public Engine onCreateEngine() { 
        return new DrawableEngine(); 
    } 

    @Override 
    public void onDestroy() { 
        super.onDestroy(); 
        if (mThread != null) { 
            mThread.quit(); 
        } 
    } 

    class DrawableEngine extends Engine { 
        private final Object mLock = new Object(); 
        private WallpaperObserver mReceiver; 
        Drawable mBackground; 
        float mXOffset; 
        float mYOffset; 

        class WallpaperObserver extends BroadcastReceiver { 
            public void onReceive(Context context, Intent intent) { 
                updateWallpaper(); 
                drawFrame(); 
                // Assume we are the only one using the wallpaper in this 
                // process, and force a GC now to release the old wallpaper. 
                System.gc(); 
            } 
        } 

        @Override 
        public void onCreate(SurfaceHolder surfaceHolder) { 
            super.onCreate(surfaceHolder); 
            IntentFilter filter = new IntentFilter(Intent.ACTION_WALLPAPER_CHANGED); 
            mReceiver = new WallpaperObserver(); 
            registerReceiver(mReceiver, filter); 
            updateWallpaper(); 
            surfaceHolder.setSizeFromLayout(); 
        } 

        @Override 
        public void onDestroy() { 
            super.onDestroy(); 
            unregisterReceiver(mReceiver); 
        } 

        @Override 
        public void onVisibilityChanged(boolean visible) {//亮屏时会执行 
            drawFrame(); 
        } 
        
        @Override 
        public void onTouchEvent(MotionEvent event) { 
            super.onTouchEvent(event); 
        } 

        @Override 
        public void onOffsetsChanged(float xOffset, float yOffset, 
                float xOffsetStep, float yOffsetStep, 
                int xPixels, int yPixels) {//滑动壁纸时会执行 
            mXOffset = xOffset; 
            mYOffset = yOffset; 
            drawFrame(); 
        } 

        @Override 
        public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {//开机和转屏时会执行 
            super.onSurfaceChanged(holder, format, width, height); 
            drawFrame(); 
        } 

        @Override 
        public void onSurfaceCreated(SurfaceHolder holder) { 
            super.onSurfaceCreated(holder); 
        } 

        @Override 
        public void onSurfaceDestroyed(SurfaceHolder holder) { 
            super.onSurfaceDestroyed(holder); 
        } 
        
        void drawFrame() { 
            SurfaceHolder sh = getSurfaceHolder(); 
            Canvas c = sh.lockCanvas();//锁住canvas 
            if (c != null) { 
                final Rect frame = sh.getSurfaceFrame(); 
                synchronized (mLock) { 
                    final Drawable background = mBackground; 
                    final int dw = frame.width(); 
                    final int dh = frame.height(); 
                    final int bw = background != null ? background.getIntrinsicWidth() : 0; 
                    final int bh = background != null ? background.getIntrinsicHeight() : 0; 
                    final int availw = dw-bw; 
                    final int availh = dh-bh; 
                    int xPixels = availw < 0 ? (int)(availw*mXOffset+.5f) : (availw/2); 
                    int yPixels = availh < 0 ? (int)(availh*mYOffset+.5f) : (availh/2); 

                    c.translate(xPixels, yPixels);//滑动后计算到壁纸画起点位置 
                    if (availw<0 || availh<0) { 
                        c.save(Canvas.CLIP_SAVE_FLAG); 
                        c.clipRect(0, 0, bw, bh, Op.DIFFERENCE); 
                        c.drawColor(0xff000000);//出现壁纸尺寸异常或是转屏延迟就会画黑 
                        c.restore(); 
                    } 
                    if (background != null) { 
                        background.draw(c); 
                    } 
                } 
                sh.unlockCanvasAndPost(c);//解锁canvas并提交 
            } 
        } 

        void updateWallpaper() { 
            synchronized (mLock) { 
                try { 
                    mBackground = mWallpaperManager.getFastDrawable(); 
                } catch (RuntimeException e) { 
                    Log.w("ImageWallpaper", "Unable to load wallpaper!", e); 
                } 
            } 
        } 
    } 
} 

３.壁纸长宽初始化值及转屏处理 
1>LC.setWallpaperDimension() 
private void setWallpaperDimension() { 
        WallpaperManager wpm = (WallpaperManager)getSystemService(WALLPAPER_SERVICE); 

        Display display = getWindowManager().getDefaultDisplay(); 
        boolean isPortrait = display.getWidth() < display.getHeight(); 

        final int width = isPortrait ? display.getWidth() : display.getHeight(); 
        final int height = isPortrait ? display.getHeight() : display.getWidth(); 
        wpm.suggestDesiredDimensions(width * WALLPAPER_SCREENS_SPAN, height);//WM.setsuggestDesiredDimensions(width,height) 设置长宽 
    } 
２> 
   public void suggestDesiredDimensions(int minimumWidth, int minimumHeight) { 
        try { 
            sGlobals.mService.setDimensionHints(minimumWidth, minimumHeight);//WMS.setsetDimensionHints(..) 
        } catch (RemoteException e) { 
        } 
    } 
3> 
    public void setDimensionHints(int width, int height) throws RemoteException { 
        checkPermission(android.Manifest.permission.SET_WALLPAPER_HINTS); 

        if (width <= 0 || height <= 0) { 
            throw new IllegalArgumentException("width and height must be > 0"); 
        } 

        synchronized (mLock) { 
            if (width != mWidth || height != mHeight) { 
                mWidth = width; 
                mHeight = height; 
                saveSettingsLocked();//将值以xml形式存储,开机时候会调用loadSettingsLocked()读取 
                if (mWallpaperConnection != null) { 
                    if (mWallpaperConnection.mEngine != null) { 
                        try { 
                            mWallpaperConnection.mEngine.setDesiredSize( 
                                    width, height); 
                        } catch (RemoteException e) { 
                        } 
                        notifyCallbacksLocked();//通知壁纸有变化(包括换壁纸与横竖转换). 
                    } 
                } 
            } 
        } 
    } 

４>android的壁纸机制用得ＩＰＣ机制,aidl机制,广播机制,这里我们就不再介绍.不太清楚google吧.另外我将aidl内容贴出来,希望对大家的理解有帮助. 
/** @hide */ 
１>IWallpaperManager.aidl 
interface IWallpaperManager { 

    /** 
     * Set the wallpaper. 
     */ 
    ParcelFileDescriptor setWallpaper(String name); 
    
    /** 
     * Set the live wallpaper. 
     */ 
    void setWallpaperComponent(in ComponentName name); 
    
    /** 
     * Get the wallpaper. 
     */ 
    ParcelFileDescriptor getWallpaper(IWallpaperManagerCallback cb, 
            out Bundle outParams); 
    
    /** 
     * Get information about a live wallpaper. 
     */ 
    WallpaperInfo getWallpaperInfo(); 
    
    /** 
     * Clear the wallpaper. 
     */ 
    void clearWallpaper(); 

    /** 
     * Sets the dimension hint for the wallpaper. These hints indicate the desired 
     * minimum width and height for the wallpaper. 
     */ 
    void setDimensionHints(in int width, in int height); 

    /** 
     * Returns the desired minimum width for the wallpaper. 
     */ 
    int getWidthHint(); 

    /** 
     * Returns the desired minimum height for the wallpaper. 
     */ 
    int getHeightHint(); 
} 

２>IWallpaperManagerCallback.aidl 
oneway interface IWallpaperManagerCallback { 
    /** 
     * Called when the wallpaper has changed 
     */ 
    void onWallpaperChanged(); 
}