壁紙服務的啟動程序-有解無憂

文章目錄

- 壁紙基礎
- 壁紙服務的兩種啟動場景
- - 非首次重啟壁紙服務啟動流程
  - 手動切換時壁紙服務的啟動流程
- 壁紙服務啟動程序
- - 1.校驗是否是壁紙服務
  - 2.系結壁紙服務
  - 3.引擎的創建和初始化
- 壁紙服務的啟動流程總結

壁紙基礎

android中的壁紙分為動態壁紙和靜態壁紙兩種，兩種型別的壁紙都以Service的型別運行在系統后臺，

靜態壁紙：僅以圖片的形式進行展示
對于靜態壁紙，可以使用WallpaperManager中的getDrawable()等介面獲取到當前的bitmap影像，
動態壁紙：顯示的內容為動態的內容，同時可以對用戶的操作做出回應
對于動態壁紙的實時影像，是沒辦法通過android中原生的介面獲取到，需要獲取到動態壁紙的影像得自己修改原始碼，

壁紙實作時涉及的幾個主要的類：

WallpaperService及其內部類Engine：壁紙在WallpaperService這個服務中運行，當需要實作自己的壁紙時，繼承和實作這個類，是首先需要做的，Engine是WallpaperService中的一個內部類，實作了壁紙服務視窗的創建以及Surface的維護，同時Engine內部類還提供了onVisibilityChanged()，onCommand()等回呼方法，用于可見狀態變化和用戶觸摸事件等，Engine類因此也是壁紙實作的核心類，實作和重寫其介面在開發中也相當重要，
WallpaperManagerService和WallpaperManager：WallpaperManagerService用于管理壁紙的運行與切換，并通過WallpaperManager對外界提供操作壁紙的介面，
WindowMangerService：該類用于計算壁紙視窗的Z序，可見性以及為壁紙視窗應用影片，

壁紙服務的兩種啟動場景

非首次重啟壁紙服務啟動流程

SystemService行程啟動時，會啟動各種系統服務，在該類的startOtherServices(）方法中會首先拉起
WallpaperManagerService，通過該類，WallpaperService后面才得以啟動，

            if (context.getResources().getBoolean(R.bool.config_enableWallpaperService)) {
                t.traceBegin("StartWallpaperManagerService");
                mSystemServiceManager.startService(WALLPAPER_SERVICE_CLASS);
                t.traceEnd();
            } else {
                Slog.i(TAG, "Wallpaper service disabled by config");
            }

WallpaperManagerService啟動之后systemReady()方法中會通過loadSettingsLocked()方法加載用戶設定過的壁紙資訊，然后監聽用戶切換用戶switchUser()，切換用戶時，switchWallpaper()會呼叫bindWallpaperComponentLocked()方法拉起對應的壁紙服務，

手動切換時壁紙服務的啟動流程

手動切換壁紙服務時需要通過WallpaperManager.getIWallpaperManager().setWallpaperComponent()方法完成，我們在這個介面中傳入壁紙服務對應的ComponentName，getIWallpaperManager回傳的是WallpaperManagerService的Bp(binder proxy binder代理)端，在WallpaperManagerService端，我們可以查看到setWallpaperComponent的具體實作，

private void setWallpaperComponent(ComponentName name, int userId) {
        ...
        /* 首先呼叫該方法的時候回去校驗權限，該權限定義在frameworks/base/core/res/AndroidManifest.xml，
            <permission android:name="android.permission.SET_WALLPAPER_COMPONENT"
        android:protectionLevel="signature|privileged" />
        查看protectionLevel，只有是特權應用或者系統簽名的應用才能獲取到這個系統權限，所以普通的應用是沒有辦法進行壁紙設定的
        */
        checkPermission(android.Manifest.permission.SET_WALLPAPER_COMPONENT);

        int which = FLAG_SYSTEM;
        boolean shouldNotifyColors = false;
        WallpaperData wallpaper;

        synchronized (mLock) {
            Slog.v(TAG, "setWallpaperComponent name=" + name);
            /*
              此處會先通過當前的用戶ID獲取到與該用戶相關的壁紙資訊，WallpaperManagerService支持多用戶機制，用戶的資訊在mWallpaperMap中存盤，每一個用戶對應一個WallpaperData，WallpaperData存盤壁紙相關資訊
			*/
            wallpaper = mWallpaperMap.get(userId);
            if (wallpaper == null) {
                throw new IllegalStateException("Wallpaper not yet initialized for user " + userId);
            }
      		 ...
      		    // 在這里真正會去拉起對應的WallPaperService
                if (bindWallpaperComponentLocked(name, false, true, wallpaper, null)) {
              ...
    }

setWallpaperComponent最終也是通過bindWallpaperComponentLocked拉起壁紙服務

壁紙服務啟動程序

1.校驗是否是壁紙服務

bindWallpaperComponentLocked()方法將會啟動該ComponentName所指定的WallpaperService，在啟動的時候首先會進行校驗，以確定待拉起的服務是一個壁紙服務，

    private boolean bindWallpaperComponentLocked(ComponentName componentName, boolean force,
            boolean fromUser, WallpaperData wallpaper, IRemoteCallback reply) {
      	...
            int serviceUserId = wallpaper.userId;
            ServiceInfo si = mIPackageManager.getServiceInfo(componentName,
                    PackageManager.GET_META_DATA | PackageManager.GET_PERMISSIONS, serviceUserId);
            if (si == null) {
                // The wallpaper component we're trying to use doesn't exist
                Slog.w(TAG, "Attempted wallpaper " + componentName + " is unavailable");
                return false;
            }
            /*
            第一個校驗：  
			啟動的時候首先會校驗這個壁紙服務是否宣告權限為BIND_WALLPAPER權限，
              該權限的定義同樣也在fwk/base/core/res/manifest.xml
                  <permission android:name="android.permission.BIND_WALLPAPER"
        android:protectionLevel="signature|privileged" />
			  該權限也是系統級別的，防止三方應用切換壁紙，
			*/
            if (!android.Manifest.permission.BIND_WALLPAPER.equals(si.permission)) {
                String msg = "Selected service does not have "
                        + android.Manifest.permission.BIND_WALLPAPER
                        + ": " + componentName;
                if (fromUser) {
                    throw new SecurityException(msg);
                }
                Slog.w(TAG, msg);
                return false;
            }

            WallpaperInfo wi = null;

            Intent intent = new Intent(WallpaperService.SERVICE_INTERFACE);
            if (componentName != null && !componentName.equals(mImageWallpaper)) {
                // Make sure the selected service is actually a wallpaper service.
                			/*
			   第二個校驗：
			   這個檢查來校驗服務是否宣告了android.service.wallpaper.WallpaperService這個action，如果這個服務沒有宣告這個action的話那么，ris中就不會含有這個component資訊，
			*/
                List<ResolveInfo> ris =
                        mIPackageManager.queryIntentServices(intent,
                                intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                                PackageManager.GET_META_DATA, serviceUserId).getList();
                for (int i=0; i<ris.size(); i++) {
                    ServiceInfo rsi = ris.get(i).serviceInfo;
                    if (rsi.name.equals(si.name) &&
                            rsi.packageName.equals(si.packageName)) {
                        try {
                        /*
                          第三個檢查：
                          獲取名為android.service.wallpaper中的meta-data資訊，該meta-data資訊中提供了縮略圖，開發者，簡單的描述等，會將這些資訊轉換成WallpaperInfo
                        */
                            wi = new WallpaperInfo(mContext, ris.get(i));
                        } catch (XmlPullParserException e) {
                            if (fromUser) {
                                throw new IllegalArgumentException(e);
                            }
                            Slog.w(TAG, e);
                            return false;
                        } catch (IOException e) {
                            if (fromUser) {
                                throw new IllegalArgumentException(e);
                            }
                            Slog.w(TAG, e);
                            return false;
                        }
                        break;
                    }
                }
                if (wi == null) {
                    String msg = "Selected service is not a wallpaper: "
                            + componentName;
                    if (fromUser) {
                        throw new SecurityException(msg);
                    }
                    Slog.w(TAG, msg);
                    return false;
                }
            }

			// 當壁紙服務支持在ambient模式下進行繪制的時候，需要檢查是否有AMBIENT_WALLPAPER權限，
            if (wi != null && wi.supportsAmbientMode()) {
                final int hasPrivilege = mIPackageManager.checkPermission(
                        android.Manifest.permission.AMBIENT_WALLPAPER, wi.getPackageName(),
                        serviceUserId);
                if (hasPrivilege != PackageManager.PERMISSION_GRANTED) {
                    String msg = "Selected service does not have "
                            + android.Manifest.permission.AMBIENT_WALLPAPER
                            + ": " + componentName;
                    if (fromUser) {
                        throw new SecurityException(msg);
                    }
                    Slog.w(TAG, msg);
                    return false;
                }
            }
            // 檢驗完畢，這里才會開始bind 壁紙服務，如果校驗失敗的話，會回傳false
			...
    }

上面的校驗可以看出一共校驗了三個條件：

啟動的時候首先會校驗這個壁紙服務是否宣告權限為BIND_WALLPAPER權限，該權限的定義在fwk/base/core/res/manifest.xml
< permission android:name=“android.permission.BIND_WALLPAPER”
android:protectionLevel=“signature|privileged” />
該權限也是系統級別的，防止三方應用切換壁紙，
這個檢查來校驗服務是否宣告了android.service.wallpaper.WallpaperService這個action，如果這個服務沒有宣告這個action的話那么，ris中就不會含有這個component資訊，
獲取名為android.service.wallpaper中的meta-data資訊，該meta-data資訊中提供了縮略圖，開發者，簡單的描述等，會將這些資訊轉換成WallpaperInfo，

2.系結壁紙服務

壁紙服務的校驗滿足后，開始啟動和系結目標服務：

    private boolean bindWallpaperComponentLocked(ComponentName componentName, boolean force,
            boolean fromUser, WallpaperData wallpaper, IRemoteCallback reply) {
	// 校驗服務是否符合要求結束后，開始著手啟動服務
	...
	//1. 創建一個WallpaperConnection，該物件可以監聽和WallpaperService之間的連接狀態，同時歸物件繼承了IWallpaperConnection.Stub，這樣該物件有擁有了跨行程通信的能力，當服務系結成功后，onServiceConnected()方法呼叫中，WallpaperConnection實力會被發送到WallpaperService,該實體可以用于WallpaperService想WallpaperManagerService進行通信的橋梁，
	intent.setComponent(componentName);
    intent.putExtra(Intent.EXTRA_CLIENT_LABEL,
                    com.android.internal.R.string.wallpaper_binding_label);
    ...
    /* 2. 這里啟動指定的壁紙服務，服務啟動后，壁紙還沒有辦法進行顯示，還需要WallpaperConnection.onServiceConnected中進行相應的處理*/
    if (!mContext.bindServiceAsUser(intent, newConn,Context.BIND_AUTO_CREATE | Context.BIND_SHOWING_UI| Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE | 
    Context.BIND_INCLUDE_CAPABILITIES,new UserHandle(serviceUserId))) {
}

	/*3. 新的壁紙服務啟動之后，就開始銷毀舊服務*/
	if (wallpaper.userId == mCurrentUserId && mLastWallpaper != null && !wallpaper.equals(mFallbackWallpaper)) {
         detachWallpaperLocked(mLastWallpaper);
    }
    
    /* 4.將新的壁紙服務資訊進行保存*/
	wallpaper.wallpaperComponent = componentName;
    wallpaper.connection = newConn;
    ...

bindWallpaperComponentLocked函式在拉起壁紙服務的時候主要做了下面幾件事情：

創建了WallpaperConnection物件，由于實作了ServiceConnection介面，所以WallpaperConnection可以用來監聽和壁紙服務的連接狀態，另外由于繼承了IWallpoaperConnection.Stub介面，所以WallpaperConnection具有了跨行程通信的能力，
啟動壁紙服務：這里僅僅是拉起服務，和拉起普通服務的方式基本一致，拉起方式上則使用了bindServiceAsUser，查看官方注解，該介面增加了校驗該用戶是否能拉起該服務，其余的行為和bindService相同，
保存當前WallpaperConnection實體，ConponentName，到WallpaperData中

bindWallpaperComponentLocked()函式將壁紙服務拉了起來，但是僅僅將壁紙服務拉起來是沒有辦法顯示影像的，因為啟動的服務并沒有視窗令牌，這樣就沒辦法添加視窗，剩下的這部分顯示的作業在WallpaperConnection的onServiceConnected()方法中進行，在該回呼中同樣也能拿到壁紙服務端服務端提供的Binder物件，
WallpaperService在被bind的時候回傳了一個IWallpaperServiceWrapper物件，從代碼中可以看到，該物件中保存了WallpaperService實體，看了代碼后再去理解這個物件的命名（包裝WallpaperService），果然名副其實，

  class IWallpaperServiceWrapper extends IWallpaperService.Stub {
        private final WallpaperService mTarget;
        private IWallpaperEngineWrapper mEngineWrapper;

        public IWallpaperServiceWrapper(WallpaperService context) {
            mTarget = context;
        }
        
        @Override
        public void attach(IWallpaperConnection conn, IBinder windowToken,
        int windowType, boolean isPreview, int reqWidth, int reqHeight, Rect padding,int displayId) {
		...
		}

        @Override
        public void detach() {
        ...
        }
    }

該介面中一共有兩個介面，attach和detach，attach介面在創建的時候可以將相關資訊傳遞到壁紙服務中，對應的，detach介面在服務銷毀的時候呼叫，

3.引擎的創建和初始化

引擎的創建準備作業開始于onServiceConnected()回呼處，該回呼會傳遞壁紙服務需要的視窗令牌和ServiceConnection物件等，
WallpaperManagerService.java

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            synchronized (mLock) {
                if (mWallpaper.connection == this) {
                    mService = IWallpaperService.Stub.asInterface(service);
                    attachServiceLocked(this, mWallpaper);
                    // XXX should probably do saveSettingsLocked() later
                    // when we have an engine, but I'm not sure about
                    // locking there and anyway we always need to be able to
                    // recover if there is something wrong.
                    if (!mWallpaper.equals(mFallbackWallpaper)) {
                    	// 保存當前的壁紙資訊到檔案系統中，這樣重啟的時候就可以加載之前用戶設定過的壁紙
                        saveSettingsLocked(mWallpaper.userId);
                    }
                    FgThread.getHandler().removeCallbacks(mResetRunnable);
                    mContext.getMainThreadHandler().removeCallbacks(mTryToRebindRunnable);
                }
            }
        }

onServiceConnected()函式中，首先將回傳的binder物件進行了保存，然后在attachServiceLocked()方法中會呼叫connectLocked()方法，connectLocked()介面中呼叫了attach方法傳遞了壁紙服務所需要的資訊，

            void connectLocked(WallpaperConnection connection, WallpaperData wallpaper) {
                ...
                mWindowManagerInternal.addWindowToken(mToken, TYPE_WALLPAPER, mDisplayId);
                final DisplayData wpdData = getDisplayDataOrCreate(mDisplayId);
                try {
                    connection.mService.attach(connection, mToken, TYPE_WALLPAPER, false,
                            wpdData.mWidth, wpdData.mHeight,
                            wpdData.mPadding, mDisplayId);
                }
                ...
            }

attach介面回傳了許多資訊，其中

connection為WallpaperConnection的實體，WallpaperConnection之所以具有跨行程通信的能力是因為繼承了IWallpaperConnection.Stub類，該Stub物件中比較重要的一個介面就是attachEngine()，因為Engine實作才是動態壁紙的核心，WallpaperService會將創建好的Engine參考通過attachEngine()回傳給WallpaperManagerService進行管理，
mToken是向WMS注冊過的視窗令牌，只有擁有了這個令牌，WallpaperService才有權添加壁紙視窗，

傳遞了WallpaperService需要的資訊之后，WallPaperService開始進行引擎的創建，查看WallpaperService中attach()方法的實作，

    class IWallpaperServiceWrapper extends IWallpaperService.Stub {
        ...
        @Override
        public void attach(IWallpaperConnection conn, IBinder windowToken,
                int windowType, boolean isPreview, int reqWidth, int reqHeight, Rect padding,
                int displayId) {
            mEngineWrapper = new IWallpaperEngineWrapper(mTarget, conn, windowToken,
                    windowType, isPreview, reqWidth, reqHeight, padding, displayId);
        }
        ...
     }

attach方法創建了一個IWallpaperEngineWrapper，顧名思義，該物件有壁紙服務創建的引擎的參考，在創建IWallpaperEngineWrapper物件的時候，會發送DO_ATTACH訊息，該訊息用于壁紙服務引擎的創建，

IWallpaperEngineWrapper.java
        IWallpaperEngineWrapper(WallpaperService context,
                IWallpaperConnection conn, IBinder windowToken,
                int windowType, boolean isPreview, int reqWidth, int reqHeight, Rect padding,
                int displayId) {
            mCaller = new HandlerCaller(context, context.getMainLooper(), this, true);
        	...
            Message msg = mCaller.obtainMessage(DO_ATTACH);
            mCaller.sendMessage(msg);
        }
...
		@Override
        public void executeMessage(Message message) {
            switch (message.what) {
                case DO_ATTACH: {
                    try {
                    // 將IWallpaperEngineWapper物件傳遞給WallpaperConnection進行保存，通過這個參考，WallpaperManagerService也可以通過它與engine進行通信
                        mConnection.attachEngine(this, mDisplayId);
                    } catch (RemoteException e) {
                        Log.w(TAG, "Wallpaper host disappeared", e);
                        return;
                    }
                    // 創建一個引擎，該方法為抽象方法，需要子類根據自身實作具體的引擎
                    Engine engine = onCreateEngine();
                    mEngine = engine;
                    mActiveEngines.add(engine);
					// 該方法中會完成視窗的創建，surface創建等作業，
                    engine.attach(this);
                    return;
                }

由于mConnection.attachEngine()方法將IWallpaperEngineWrapper傳遞給了WallpaperManagerService，因此WallpaperManagerService可以轉發相關的請求和設定到Engine物件中，實作WallpaperManagerService到壁紙的通信，
onCreateEngine方法執行后，引擎創建完成，之后通過engine.attach()方法進行引擎相關的初始化：

        void attach(IWallpaperEngineWrapper wrapper) {
            ...
            mIWallpaperEngine = wrapper;
            mCaller = wrapper.mCaller;
            mConnection = wrapper.mConnection;
            mWindowToken = wrapper.mWindowToken;
            mSurfaceHolder.setSizeFromLayout();
            mInitializing = true;

			// 這個session用于和WMS進行通信
            mSession = WindowManagerGlobal.getWindowSession();

			// mWindow是一個IWindow物件，用于接收從WMS發送過來的訊息
            mWindow.setSession(mSession);

            mLayout.packageName = getPackageName();
            mIWallpaperEngine.mDisplayManager.registerDisplayListener(mDisplayListener,
                    mCaller.getHandler());
            mDisplay = mIWallpaperEngine.mDisplay;
            mDisplayContext = createDisplayContext(mDisplay);
            mDisplayState = mDisplay.getState();

            if (DEBUG) Log.v(TAG, "onCreate(): " + this);
            // 子類可以重寫該介面，在該介面中可以修改mSurfaceHolder相關的屬性，這個時候
            // 視窗尚未創建，設定的相關屬性將在updateSurface中創建視窗時使用
            onCreate(mSurfaceHolder);

            mInitializing = false;

            mReportedVisible = false;
			
			// updateSurface會進行視窗以及Surface的創建，
            updateSurface(false, false, false);
        }

attach方法執行的完成，標志著壁紙啟動的完成，之后可以呼叫壁紙的surface顯示影像，

壁紙服務的啟動流程總結

壁紙服務的啟動相比于普通服務的啟動較為復雜，接下來用下面的示意圖對整體的流程進行梳理：
在這里插入圖片描述
壁紙服務在啟動的時候，大體可以分為兩個階段，首先就要是拉起對應的服務，拉起服務后然后將WindowToken等引數傳遞給引擎進行視窗的創建，surface的創建，在WallpaperManagerService和WallpaperService互動的程序中，主要有下面三個跨行程通信的Binder物件：

WallpaperConnection：實作在WallpaperManagerService中，并通過IWallpaperService.attach回呼傳遞給了IWallpaperEngineWrapper，通過WallpaperConnection.attachEngine()方法，WallpaperService將IWallpaperEngineWrapper回傳給了WallpaperManagerService，實作了雙向的通信，
IWallpaperService：實作在WallpaperService中，該物件提供了attach方法，用于從WallpaperManagerService獲取引擎創建時需要的WindowToken等資訊，
IWallpaperEngineWrapper：實作在壁紙服務行程中，同時參考交給了WallpaperManagerService，該物件封裝了Engine類，WallpaperManagerService對引擎相關的控制需要通過該物件提供的介面實作，

自己最近因為需要定位一個開機壁紙服務啟動慢的問題，所以熟悉了下壁紙服務的啟動程序，在此記錄啟動流程，定位該問題梳理從bind到onServiceConnected和引擎相關初始化，對比每一個階段的時間，最終確定問題的原因，
參考：《深入理解Android卷3》第八章：深入理解android壁紙服務

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/252155.html

標籤：其他

上一篇：autojs腳本代碼大全(實戰演練1)

下一篇：Android 在百度地圖上顯示自己的實時位置