public void setWallpaperComponent(ComponentNamename) {

    // 设置动态壁纸需要调用者拥有一个签名级的系统权限

    checkPermission(android.Manifest.permission.SET_WALLPAPER_COMPONENT);

   synchronized (mLock) {

        /* ① 首先从mWallpaperMap中获取壁纸的运行信息WallpaperData。

         WallpaperManagerService支持多用户机制，因此设备上的每一个用户可以设置自己

          的壁纸。mWallpaperMap中为每一个用户保存了一个WallpaperData实例，这个实例

          中保存了和壁纸运行状态相关的信息。例如WallpaperService的ComponentName，

          到WallpaperService的ServiceConnection等。于是当发生用户切换时，

          WallpaperManagerService可以从mWallpaperMap中获取新用户的WallpaperData，

          并通过保存在其中的ComponentName重新启动该用户所设置的壁纸。因此，

          当通过setWallpaperComponent()设置新壁纸时，需要获取当前用户的WallpaperData，

          并在随后更新其内容使之保存新壁纸的信息 */

        intuserId = UserHandle.getCallingUserId();

       WallpaperData wallpaper = mWallpaperMap.get(userId);

       ......

       final long ident = Binder.clearCallingIdentity();

           ......

           // ② 启动新壁纸的WallpaperService

           bindWallpaperComponentLocked(name, false, true, wallpaper, null);

        }finally {

           Binder.restoreCallingIdentity(ident);

注意 WallpaperManager.getIWallpaperManager()并没有作为SDK的一部分提供给开发者。因此第三方应用程序是无法进行动态壁纸的设置的。

boolean bindWallpaperComponentLocked(ComponentNamecomponentName, boolean force,

       boolean fromUser, WallpaperData wallpaper, IRemoteCallback reply) {

    ......

        /* 当componentName为null时表示使用默认壁纸。

          这里会将componentName参数改为默认壁纸的componentName */

        if(componentName == null) {

           /* 首先会尝试从com.android.internal.R.string.default_wallpaper_component

              中获取默认壁纸的componentName。这个值的设置位于res/values/config.xml中，

              开发者可以通过修改这个值设置默认壁纸*/

           String defaultComponent = mContext.getString(

                         com.android.internal.R.string.default_wallpaper_component);

           if (defaultComponent != null) {

               componentName = ComponentName.unflattenFromString(defaultComponent);

           /* 倘若在上述的资源文件中没有指定一个默认壁纸，即default_wallpaper_component的

              值被设置为@null)，则使用ImageWallpaper代替默认壁纸。ImageWallpaper就是前文

              所述的静态壁纸 */

           if (componentName == null) {

               componentName = IMAGE_WALLPAPER;

        /* 接下来WallpaperMangerService会尝试从PackageManager中尝试获取ComponentName所

          指定的Service的描述信息,获取此信息的目的在于确认该Service是一个符合要求的壁纸服务 */

        intserviceUserId = wallpaper.userId;

       ServiceInfo si = mIPackageManager.getServiceInfo(componentName,

                             PackageManager.GET_META_DATA |

                              PackageManager.GET_PERMISSIONS,serviceUserId);

        /* ① 第一个检查，要求这个Service必须声明其访问权限为BIND_WALLPAPER。这个签名级的系

          统权限这是为了防止壁纸服务被第三方应用程序启动而产生混乱 */

        if(!android.Manifest.permission.BIND_WALLPAPER.equals(si.permission)) {

           if (fromUser) {

               throw new SecurityException(msg);

           return false;

       WallpaperInfo wi = null;

        /* ② 第二个检查，要求这个Service必须可以用来处理

           android.service.wallpaper.WallpaperService这个Action。

           其检查方式是从PackageManager中查询所有可以处理

           android.service.wallpaper.WallpaperService的服务，然后检查即将启动的服务

           是否在PackageManager的查询结果之中 */

       Intent intent = new Intent(WallpaperService.SERVICE_INTERFACE);

        if(componentName != null && !componentName.equals(IMAGE_WALLPAPER)) {

           // 获取所有可以处理android.service.wallpaper.WallpaperService的服务信息

           List<ResolveInfo> ris =

                   mIPackageManager.queryIntentServices(intent,

                           intent.resolveTypeIfNeeded(mContext.getContentResolver()),

                           PackageManager.GET_META_DATA, serviceUserId);

            /* ③ 第三个检查，要求这个Service必须在其meta-data中提供关于壁纸的描述信息。如果

             即将启动的服务位于查询结果之中，便可以确定这是一个壁纸服务。此时会创建一

             个WallpaperInfo的实例以解析并存储此壁纸服务的描述信息。壁纸服务的描述信息包含

             了壁纸的开发者、缩略图、简单的描述文字以及用于对此壁纸进行参数设置的Activity的

             名字等。壁纸开发者可以在AndroidManifest.xml中将一个包含了上述信息的xml文件设

             置在名为android.service.wallpaper的meta-data中以提供这些信息 */

           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)){

                        wi = newWallpaperInfo(mContext, ris.get(i));

                   } catch (XmlPullParserException e) {......}

                   break;

            if (wi == null) {

               /* wi为null表示即将启动的服务没有位于查询结果之中，或者没有提供必须的meta-data。

                 此时返回false表示绑定失败 */

               return false;

       ......

    ......

boolean bindWallpaperComponentLocked(ComponentNamecomponentName, boolean force,

       boolean fromUser, WallpaperData wallpaper, IRemoteCallback reply) {

       ...... // 检查服务是否符合要求的代码

        /* ① 创建一个WallpaperConnection。它不仅实现了ServiceConnection接口用于监

          听和WallpaperService之间的连接状态，同时还实现了IWallpaperConnection.Stub，

          也就是说它支持跨进程通信。

          在服务绑定成功后的WallpaperConnection.onServiceConnected()方法调用中，

          WallpaperConnection的实例会被发送给WallpaperService，使其作为WallpaperService

          向WallpaperManagerService进行通信的桥梁 */

       WallpaperConnection newConn = new WallpaperConnection(wi, wallpaper);

        // 为启动壁纸服务准备Intent

       intent.setComponent(componentName);

       intent.putExtra(Intent.EXTRA_CLIENT_LABEL,

               com.android.internal.R.string.wallpaper_binding_label);

       intent.putExtra(Intent.EXTRA_CLIENT_INTENT,PendingIntent.getActivityAsUser(

               mContext, 0,

               Intent.createChooser(new Intent(Intent.ACTION_SET_WALLPAPER),

                 mContext.getText(com.android.internal.R.string.chooser_wallpaper)),

               0, null, new UserHandle(serviceUserId)));

        /* ② 启动制定的壁纸服务。当服务启动完成后，剩下的启动流程会在

          WallpaperConnection.onServiceConnected()中继续 */

        if(!mContext.bindService(intent,

                              newConn,Context.BIND_AUTO_CREATE, serviceUserId)) {

        // ③ 新的的壁纸服务启动成功后，便通过detachWallpaperLocked()销毁旧有的壁纸服务

        if(wallpaper.userId == mCurrentUserId && mLastWallpaper != null) {

           detachWallpaperLocked(mLastWallpaper);

        // ④ 将新的壁纸服务的运行信息保存到WallpaperData中

       wallpaper.wallpaperComponent = componentName;

       wallpaper.connection = newConn;

        /* 设置wallpaper.lastDiedTime。这个成员变量与其说描述壁纸的死亡时间戳，不如说是

          描述其启动的时间戳。它用来在壁纸服务意外断开时(即壁纸服务非正常停止）检查此壁纸服务

          的存活时间。当存活时间小于一个特定的时长时将会认为这个壁纸的软件质量不可靠

          从而选择使用默认壁纸，而不是重启这个壁纸服务 */

       wallpaper.lastDiedTime = SystemClock.uptimeMillis();

       newConn.mReply = reply;

        /* ④ 最后向WMS申请注册一个WALLPAPER类型的窗口令牌。这个令牌会在onServiceConnected()

          之后被传递给WallpaperService用于作为后者添加窗口的通行证 */

           if (wallpaper.userId == mCurrentUserId) {

                mIWindowManager.addWindowToken(newConn.mToken,

                       WindowManager.LayoutParams.TYPE_WALLPAPER);

               mLastWallpaper = wallpaper;

        } catch (RemoteException e) {}

    } catch(RemoteException e) {}

    returntrue;

public final IBinder onBind(Intent intent) {

    /*onBind()新建了一个IWallpaperServiceWrapper实例，并将

      其返回给WallpaperManagerService */

    returnnew IWallpaperServiceWrapper(this);

public void onServiceConnected(ComponentName name,IBinder service) {

   synchronized (mLock) {

        if (mWallpaper.connection == this) {

           // 更新壁纸的启动时间戳

           mWallpaper.lastDiedTime = SystemClock.uptimeMillis();

           // ① 将WallpaperService传回的IWallpaperService接口保存为mService

           mService = IWallpaperService.Stub.asInterface(service);

           /* ② 绑定壁纸服务。attachServiceLocked()会调用IWallpaperService.attach()

             方法以将壁纸服务创建窗口所需的信息传递过去 */

           attachServiceLocked(this, mWallpaper);

           // ③ 保存当前壁纸的运行状态到文件系统中，以便在系统重启或发生用户切换时可以恢复

           saveSettingsLocked(mWallpaper);

void attachServiceLocked(WallpaperConnection conn,WallpaperData wallpaper) {

        /* 调用IWallpaperService的唯一接口attach()，将创建壁纸窗口所需要的参数传递

          给WallpaperService */

       conn.mService.attach(conn, conn.mToken,

               WindowManager.LayoutParams.TYPE_WALLPAPER, false,

               wallpaper.width, wallpaper.height);

    } catch(RemoteException e) {......}

public void attach(IWallpaperConnection conn,IBinder windowToken,

        intwindowType, boolean isPreview, int reqWidth, int reqHeight) {

    // 使用WallpaperManagerService提供的参数构造一个IWallpaperEngineWarapper实例

    newIWallpaperEngineWrapper(mTarget, conn, windowToken,

           windowType, isPreview, reqWidth, reqHeight);

IWallpaperEngineWrapper(WallpaperService context,

       IWallpaperConnection conn, IBinder windowToken,

        intwindowType, boolean isPreview, int reqWidth, int reqHeight) {

    /* 创建一个HandlerCaller。

      HandlerCaller是Handler的一个封装，而它与Handler的区别是额外提供了

      一个executeOrSendMessage()方法。当开发者在HandlerCaller所在的线程

      执行此方法时会使得消息的处理函数立刻得到执行，在其他线程中执行此方法的效果

      则与Handler.sendMessage()别无二致。除非阅读代码时遇到这个方法，读者

      只需要将其理解为Handler即可。

      注意意通过其构造函数的参数可知HandlerCaller保存了IWallpaperEngineWrapper的实例 */

    mCaller= new HandlerCaller(context,

           mCallbackLooper != null

                   ? mCallbackLooper : context.getMainLooper(),

           this);

    // 将WallpaperManagerService所提供的参数保存下来

   mConnection = conn; // conn即是WallpaperManagerService中的WallpaperConnection

   mWindowToken = windowToken;

   mWindowType = windowType;

   mIsPreview = isPreview;

   mReqWidth = reqWidth;

   mReqHeight = reqHeight;

    // 发送DO_ATTACH消息。后续的流程转到DO_ATTACH消息的处理中进行

    Messagemsg = mCaller.obtainMessage(DO_ATTACH);

   mCaller.sendMessage(msg);

注意 在这里貌似并没有保存新建的IWallpaperEngineWrapper实例，它岂不是有可能在DO_ATTACH消息执行前就被Java的垃圾回收机制回收了？其实不是这样。HandlerCaller的构造函数以及最后的sendMessage()操作使得这个IWallpaperEngineWrapper的实例得以坚持到DO_ATTACH消息可以得到处理的时刻。sendMessage()方法的调用使得Message被目标线程的MessageQueue引用，并且对应的Handler的被Message引用，而这个Handler是HandlerCaller的内部类，因此在Handler中有一个隐式的指向HandlerCaller的引用，最后在HandlerCaller中又存在着IWallpaperEngineWrapper的引用。因此IWallpaperEngineWrapper间接地被HandlerCaller所在线程的MessageQueue所引用着，因此在完成DO_ATTACH消息的处理之前，IWallpaperEngineWrapper并不会被回收。虽然这是建立在对Java引用以及Handler工作原理的深刻理解之上所完成的精妙实现，但是它确实已经接近危险的边缘了。

public void executeMessage(Message message) {

    switch(message.what) {

        caseDO_ATTACH: {

               /* ① 把IWallpaperEngineWrapper实例传递给WallpaperConnection进行保存。

                至此这个实例便名花有主，再也不用担心被回收了，而且WallpaperManagerService

                还可以通过它与实际的Engine进行通信 */

               mConnection.attachEngine(this);

           } catch (RemoteException e) {}

           /* ② 通过onCreateEngine()方法创建一个Engine。

             onCreateEngine()是定义在WallpaperService中的一个抽象方法。

             WallpaperService的实现者需要根据自己的需要返回一个自定义的Engine的子类 */

           Engine engine = onCreateEngine();

           mEngine = engine;

           /* ③ 将新建的Engine添加到WallpaperService.mActiveEngines列表中。

             读者可能会比较奇怪，为什么是列表？难道一个Wallpaper可能会有多个Engine么？

            这个奇怪之处还是壁纸预览所引入的。当壁纸A已经被设置为当前壁纸之时，系统中会存

            在一个它所对应的WallpaperService,以及在其内部会存在一个Engine。

            此时当LivePicker或其他壁纸管理工具预览壁纸A时，它所对应的WallpaperService

            仍然只有一个，但是在其内部会变成两个Engine。

            这一现象更能说明，WallpaperService仅仅是提供壁纸运行的场所，而Engine才是真正

            的壁纸的实现 */

           mActiveEngines.add(engine);

           // ④ 最后engine.attach()将会完成窗口的创建、第一帧的绘制等工作

            engine.attach(this);

           return;

说明 按照常规的思想来推断，WallpaperManagerService与WallpaperService之间应该仅仅需要IWallpaperService提供接口对壁纸进行操作与设置。为什么要增加一个IWallpaperEngineWrapper呢？这得从WallpaperService与Engine之间的关系说起。IWallpaperService在WallpaperManagerService看来表示的是WallpaperService，而IWallpaperEngineWrapper则表示的是Engine。WallpaperService是Engine运行的容器，因此它所提供的唯一的方法attach()用来在WallpaperService中创建新的Engine实例（由创建一个IWallpaperEngineWrapper实例来完成）。Engine则是壁纸的具体实现，因此IWallpaperEngineWrapper所提供的方法用来对壁纸进行操作与设置。从这个意义上来讲IWallpaperService与IWallpaperEngineWrapper的同时存在是合理的。另外，将IWallpaperService与IWallpaperEngineWrapper分开还有着简化实现的意义。从DO_ATTACH消息的处理过程可知，WallpaperService中可以同时运行多个Engine实例。而WallpaperManagerService或LivePicker所关心的只是某一个Engine，而不是WallpaperService中的所有Engine，因此相对于使用IWallpaperService的接口时必须在参数中指明所需要操作的Engine，直接操作IWallpaperEngineWrapper更加简洁直接。

void attach(IWallpaperEngineWrapper wrapper) {

    ......

    // 保存必要的信息

   mIWallpaperEngine = wrapper;

    mCaller= wrapper.mCaller;

   mConnection = wrapper.mConnection;

   mWindowToken = wrapper.mWindowToken;

    /* ① mSurfaceHolder是一个BaseSurfaceHolder类型的内部类的实例。

      Engine对其进行了简单的定制。开发者可以通过mSurfaceHolder定制所需要的Surface类型 */

   mSurfaceHolder.setSizeFromLayout();

   mInitializing = true;

    // 获取WindowSession,用于与WMS进行通信

    mSession= WindowManagerGlobal.getWindowSession(getMainLooper());

    //mWindow是IWindow的实现，窗口创建之后它将用于接收来自WMS的回调

   mWindow.setSession(mSession);

    //Engine需要监听屏幕状态。这是为了保证在屏幕关闭之后，动态壁纸可以停止动画的渲染以节省电量

   mScreenOn =

           ((PowerManager)getSystemService(Context.POWER_SERVICE)).isScreenOn();

   IntentFilter filter = new IntentFilter();

    filter.addAction(Intent.ACTION_SCREEN_ON);

   filter.addAction(Intent.ACTION_SCREEN_OFF);

   registerReceiver(mReceiver, filter);

    /* ② 调用Engine.onCreate()。

      Engine的子类往往需要重写此方法以修改mSurfaceHolder的属性，如像素格式，尺寸等。

      注意此时尚未创建窗口，在这里所设置的SurfaceHolder的属性将会在创建窗口时生效 */

   onCreate(mSurfaceHolder);

   mInitializing = false;

   mReportedVisible = false;

    /* ③ 最后updateSurface将会根据SurfaceHolder的属性创建窗口以及Surface，并进行

      壁纸的第一次绘制 */

   updateSurface(false, false, false);