文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

详解Android壁纸服务的启动过程

2024-04-02 19:55

关注

壁纸基础

android中的壁纸分为动态壁纸和静态壁纸两种,两种类型的壁纸都以Service的类型运行在系统后台。

壁纸实现时涉及的几个主要的类:

壁纸服务的两种启动场景

非首次重启壁纸服务启动流程

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) {
        ...
        
        checkPermission(android.Manifest.permission.SET_WALLPAPER_COMPONENT);

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

        synchronized (mLock) {
            Slog.v(TAG, "setWallpaperComponent name=" + name);
            
            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;
            }
            
            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.
                			
                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 {
                        
                            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
			...
    }

上面的校验可以看出一共校验了三个条件:

  1. 启动的时候首先会校验这个壁纸服务是否声明权限为BIND_WALLPAPER权限, 该权限的定义在fwk/base/core/res/manifest.xml中,< permission android:name=“android.permission.BIND_WALLPAPER”
    android:protectionLevel=“signature|privileged” />
    该权限也是系统级别的,防止三方应用切换壁纸。
  2. 这个检查来校验服务是否声明了android.service.wallpaper.WallpaperService这个action。如果这个服务没有声明这个action的话那么,ris中就不会含有这个component信息。
  3. 获取名为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);
    ...
    
    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))) {
}

	
	if (wallpaper.userId == mCurrentUserId && mLastWallpaper != null && !wallpaper.equals(mFallbackWallpaper)) {
         detachWallpaperLocked(mLastWallpaper);
    }
    
    
	wallpaper.wallpaperComponent = componentName;
    wallpaper.connection = newConn;
    ...

bindWallpaperComponentLocked函数在拉起壁纸服务的时候主要做了下面几件事情:

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接口回传了许多信息,其中

传递了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对象:

自己最近因为需要定位一个开机壁纸服务启动慢的问题,所以熟悉了下壁纸服务的启动过程,在此记录启动流程。定位该问题梳理从bind到onServiceConnected和引擎相关初始化,对比每一个阶段的时间,最终确定问题的原因。
参考:

到此这篇关于详解Android壁纸服务的启动过程的文章就介绍到这了,更多相关Android壁纸内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-移动开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯