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; 

相關推薦