详解Android Surface系统

  1. public void scheduleTraversals() {

  2. if (!mTraversalScheduled) {

  3. mTraversalScheduled = true;

  4. sendEmptyMessage(DO_TRAVERSAL);

  5. }

  6. }

我们看看跨进程的那个调用。sWindowSession.add。它的最终实现在WindowManagerService中。

[—>WindowSession::add()]

  1. public int add(IWindow window, WindowManager.LayoutParams attrs,

  2. int viewVisibility, Rect outContentInsets) {

  3. return addWindow(this, window, attrs, viewVisibility, outContentInsets);

  4. }

WindowSession是个内部类,会调用外部类的addWindow。

这个函数巨复杂无比,但是我们的核心目标是找到创建显示相关的部分。所以,最后精简的话就简单了。

[—>WindowManagerService:: addWindow]

  1. public int addWindow(Session session, IWindow client,

  2. WindowManager.LayoutParams attrs, int viewVisibility,

  3. Rect outContentInsets) {

  4. //创建一个WindowState,这个又是什么玩意儿呢?

  5. win = new WindowState(session, client, token,

  6. attachedWindow, attrs, viewVisibility);

  7. win.attach();

  8. return res;

  9. }

WindowState类中有一个和Surface相关的成员变量,叫SurfaceSession。它会在attach函数中被创建。SurfaceSession嘛,就和SurfaceFlinger有关系了。我们待会看。

好,我们知道ViewRoot创建及调用add后,我们客户端的View系统就和WindowManagerService建立了牢不可破的关系。

另外,我们知道ViewRoot是一个handler,而且刚才我们调用了requestLayout,所以接下来消息循环下一个将调用的就是ViewRoot的handleMessage。

  1. public void handleMessage(Message msg) {

  2. switch (msg.what) {

  3. case DO_TRAVERSAL:

  4. performTraversals();

performTraversals更加复杂无比,经过我仔细挑选,目标锁定为下面几个函数。当然,后面我们还会回到performTraversals,不过我们现在更感兴趣的是Surface是如何创建的。

  1. private void performTraversals() {

  2. // cache mView since it is used so much below…

  3. final View host = mView;

  4. boolean initialized = false;

  5. boolean contentInsetsChanged = false;

  6. boolean visibleInsetsChanged;

  7. try {

  8. //ViewRoot也有一个Surface成员变量,叫mSurface,这个就是代表SurfaceFlinger的客户端

  9. //ViewRoot在这个Surface上作画,最后将由SurfaceFlinger来合成显示。刚才说了mSurface还没有什么内容。

  10. relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);

[---->ViewRoot:: relayoutWindow()]

  1. private int relayoutWindow(WindowManager.LayoutParams params, int viewVisibility,

  2. boolean insetsPending) throws RemoteException {

  3. //relayOut是跨进程调用,mSurface做为参数传进去了,看来离真相越来越近了呀!

  4. int relayoutResult = sWindowSession.relayout(

  5. mWindow, params,

  6. (int) (mView.mMeasuredWidth * appScale + 0.5f),

  7. (int) (mView.mMeasuredHeight * appScale + 0.5f),

  8. viewVisibility, insetsPending, mWinFrame,

  9. mPendingContentInsets, mPendingVisibleInsets,

  10. mPendingConfiguration, mSurface); mSurface做为参数传进去了。

  11. }

我们赶紧转到WindowManagerService去看看吧。

  1. public int relayoutWindow(Session session, IWindow client,

  2. WindowManager.LayoutParams attrs, int requestedWidth,

  3. int requestedHeight, int viewVisibility, boolean insetsPending,

  4. Rect outFrame, Rect outContentInsets, Rect outVisibleInsets,

  5. Configuration outConfig, Surface outSurface){

  6. try {

  7. //看到这里,我内心一阵狂喜,有戏,太有戏了!

  8. //其中win是我们最初创建的WindowState!

  9. Surface surface = win.createSurfaceLocked();

  10. if (surface != null) {

  11. //先创建一个本地surface,然后把传入的参数outSurface copyFrom一下

  12. outSurface.copyFrom(surface);

  13. win.mReportDestroySurface = false;

  14. win.mSurfacePendingDestroy = false;

  15. } else {

  16. outSurface.release();

  17. }

  18. }

  19. }

[—>WindowState::createSurfaceLocked]

  1. Surface createSurfaceLocked() {

  2. try {

  3. mSurface = new Surface(

  4. mSession.mSurfaceSession, mSession.mPid,

  5. mAttrs.getTitle().toString(),

  6. 0, w, h, mAttrs.format, flags);

  7. }

  8. Surface.openTransaction();

这里使用了Surface的另外一个构造函数。

  1. public Surface(SurfaceSession s,

  2. int pid, String name, int display, int w, int h, int format, int flags)

  3. throws OutOfResourcesException {

  4. mCanvas = new CompatibleCanvas();

  5. init(s,pid,name,display,w,h,format,flags); ---->调用了native的init函数。

  6. mName = name;

  7. }

到这里,不进入JNI是不可能说清楚了。不过我们要先回顾下之前的关键步骤。

◆ add中,new了一个SurfaceSession

◆创建new了一个Surface

◆调用copyFrom,把本地Surface信息传到outSurface中

JNI层

上面两个类的JNI实现都在framework/base/core/jni/android_view_Surface.cpp中。

[---->SurfaceSession:: SurfaceSession()]

  1. public class SurfaceSession {

  2. /** Create a new connection with the surface flinger. */

  3. public SurfaceSession() {

  4. init();

  5. }

它的init函数对应为:

[—>SurfaceSession_init]

  1. static void SurfaceSession_init(JNIEnv* env, jobject clazz)

  2. {

  3. //SurfaceSession对应为SurfaceComposerClient

  4. sp client = new SurfaceComposerClient;

  5. client->incStrong(clazz);

  6. //Google常用做法,在JAVA对象中保存C++对象的指针。

  7. env->SetIntField(clazz, sso.client, (int)client.get());

  8. }

Surface的init对应为:

[—>Surface_init]

  1. static void Surface_init(

  2. JNIEnv* env, jobject clazz,

  3. jobject session,

  4. jint pid, jstring jname, jint dpy, jint w, jint h, jint format, jint flags)

  5. {

  6. SurfaceComposerClient* client =

  7. (SurfaceComposerClient*)env->GetIntField(session, sso.client);

  8. sp surface;

  9. if (jname == NULL) {

  10. //client是SurfaceComposerClient,返回的surface是一个SurfaceControl

  11. //真得很复杂!

  12. surface = client->createSurface(pid, dpy, w, h, format, flags);

  13. } else {

  14. const jchar* str = env->GetStringCritical(jname, 0);

  15. const String8 name(str, env->GetStringLength(jname));

  16. env->ReleaseStringCritical(jname, str);

  17. surface = client->createSurface(pid, name, dpy, w, h, format, flags);

  18. }

  19. //把surfaceControl信息设置到Surface对象中

  20. setSurfaceControl(env, clazz, surface);

  21. }

  22. static void setSurfaceControl(JNIEnv* env, jobject clazz,

  23. const sp& surface)

  24. {

  25. SurfaceControl* const p =

  26. (SurfaceControl*)env->GetIntField(clazz, so.surfaceControl);

  27. if (surface.get()) {

  28. surface->incStrong(clazz);

  29. }

  30. if § {

  31. p->decStrong(clazz);

  32. }

  33. env->SetIntField(clazz, so.surfaceControl, (int)surface.get());

  34. }

[—>Surface_copyFrom]

  1. static void Surface_copyFrom(

  2. JNIEnv* env, jobject clazz, jobject other)

  3. {

  4. const sp& surface = getSurfaceControl(env, clazz);

  5. const sp& rhs = getSurfaceControl(env, other);

  6. if (!SurfaceControl::isSameSurface(surface, rhs)) {

  7. setSurfaceControl(env, clazz, rhs);

  8. //把本地那个surface的surfaceControl对象转移到outSurface上

  9. }

  10. }

这里仅仅是surfaceControl的转移,但是并没有看到Surface相关的信息。

那么Surface在哪里创建的呢?为了解释这个问题,我使用了终极武器,aidl。

1 终极武器AIDL

aidl可以把XXX.aidl文件转换成对应的java文件。我们刚才调用的是WindowSession的

relayOut函数。如下:

  1. sWindowSession.relayout(

  2. mWindow, params,

  3. (int) (mView.mMeasuredWidth * appScale + 0.5f),

  4. (int) (mView.mMeasuredHeight * appScale + 0.5f),

  5. viewVisibility, insetsPending, mWinFrame,

  6. mPendingContentInsets, mPendingVisibleInsets,

  7. mPendingConfiguration, mSurface);

它的aidl文件在framework/base/core/java/android/view/IWindowSession.aidl中

  1. interface IWindowSession {

  2. int add(IWindow window, in WindowManager.LayoutParams attrs,

  3. in int viewVisibility, out Rect outContentInsets);

  4. void remove(IWindow window);

  5. //注意喔,这个outSurface前面的是out,表示输出参数,这个类似于C++的引用。

  6. int relayout(IWindow window, in WindowManager.LayoutParams attrs,

  7. int requestedWidth, int requestedHeight, int viewVisibility,

  8. boolean insetsPending, out Rect outFrame, out Rect outContentInsets,

  9. out Rect outVisibleInsets, out Configuration outConfig,

  10. out Surface outSurface);

刚才说了,JNI及其JAVA调用只是copyFrom了SurfaceControl对象到outSurface中,但是没看到哪里创建Surface。这其中的奥秘就在aidl文件编译后生成的java文件中。

你在命令行下可以输入:

aidl -Id:\android-2.2-froyo-20100625-source\source\frameworks\base\core\java\ -Id:\android-2.2-froyo-20100625-source\source\frameworks\base\Graphics\java d:\android-2.2-froyo-20100625-source\source\frameworks\base\core\java\android\view\IWindowSession.aidl test.java

以生成test.java文件。-I参数指定include目录,例如aidl有些参数是在别的java文件中指定的,那么这个-I就需要把这些目录包含进来。

先看看ViewRoot这个客户端生成的代码是什么。

  1. public int relayout(

  2. android.view.IWindow window,

  3. android.view.WindowManager.LayoutParams attrs,

  4. int requestedWidth, int requestedHeight,

  5. int viewVisibility, boolean insetsPending,

  6. android.graphics.Rect outFrame,

  7. android.graphics.Rect outContentInsets,

  8. android.graphics.Rect outVisibleInsets,

  9. android.content.res.Configuration outConfig,

  10. android.view.Surface outSurface) ---->outSurface是第11个参数

  11. throws android.os.RemoteException

  12. {

  13. android.os.Parcel _data = android.os.Parcel.obtain();

  14. android.os.Parcel _reply = android.os.Parcel.obtain();

  15. int _result;

  16. try {

  17. _data.writeInterfaceToken(DESCRIPTOR);

  18. _data.writeStrongBinder((((window!=null))?(window.asBinder()):(null)));

  19. if ((attrs!=null)) {

  20. _data.writeInt(1);

  21. attrs.writeToParcel(_data, 0);

  22. }

  23. else {

  24. _data.writeInt(0);

  25. }

  26. _data.writeInt(requestedWidth);

  27. _data.writeInt(requestedHeight);

  28. _data.writeInt(viewVisibility);

  29. _data.writeInt(((insetsPending)?(1):(0)));

  30. //奇怪,outSurface的信息没有写到_data中。那…

  31. mRemote.transact(Stub.TRANSACTION_relayout, _data, _reply, 0);

  32. _reply.readException();

  33. _result = _reply.readInt();

  34. if ((0!=_reply.readInt())) {

  35. outFrame.readFromParcel(_reply);

  36. }

  37. if ((0!=_reply.readInt())) {

  38. outSurface.readFromParcel(_reply); //从Parcel中读取信息来填充outSurface

  39. }

  40. }

  41. finally {

  42. _reply.recycle();

  43. _data.recycle();

  44. }

  45. return _result;

  46. }

真奇怪啊,Binder客户端这头竟然没有把outSurface的信息发过去。我们赶紧看看服务端。

服务端这边处理是在onTranscat函数中。

  1. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException

  2. {

  3. switch (code)

  4. {

  5. case TRANSACTION_relayout:

  6. {

  7. data.enforceInterface(DESCRIPTOR);

  8. android.view.IWindow _arg0;

  9. android.view.Surface _arg10;

  10. //刚才说了,Surface信息并没有传过来,那么我们在relayOut中看到的outSurface是怎么

  11. //出来的呢?看下面这句,原来在服务端这边竟然new了一个新的Surface!!!

  12. _arg10 = new android.view.Surface();

  13. int _result = this.relayout(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10);

  14. reply.writeNoException();

  15. reply.writeInt(_result);

  16. //_arg10是copyFrom了,那怎么传到客户端呢?

  17. if ((_arg10!=null)) {

  18. reply.writeInt(1);//调用Surface的writeToParcel,把信息加入reply

  19. _arg10.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);

  20. }

  21. return true;

  22. }

太诡异了!竟然有这么多花花肠子。我相信如果没有aidl的帮助,我无论如何也不会知道这其中的奥妙。

那好,我们的流程明白了。

◆客户端虽然传了一个surface,但其实没传递给服务端

◆服务端调用writeToParcel,把信息写到Parcel中,然后数据传回客户端

◆客户端调用Surface的readFromParcel,获得surface信息。

那就去看看writeToParcel吧。

[---->Surface_writeToParcel]

  1. static void Surface_writeToParcel(

  2. JNIEnv* env, jobject clazz, jobject argParcel, jint flags)

  3. {

  4. Parcel* parcel = (Parcel*)env->GetIntField(

  5. argParcel, no.native_parcel);

  6. const sp& control(getSurfaceControl(env, clazz));

  7. //还好,只是把数据序列化到Parcel中

  8. SurfaceControl::writeSurfaceToParcel(control, parcel);

  9. if (flags & PARCELABLE_WRITE_RETURN_VALUE) {

  10. setSurfaceControl(env, clazz, 0);

  11. }

  12. }

那看看客户端的Surface_readFromParcel吧。

[----->Surface_readFromParcel]

  1. static void Surface_readFromParcel(

  2. JNIEnv* env, jobject clazz, jobject argParcel)

  3. {

  4. Parcel* parcel = (Parcel*)env->GetIntField( argParcel, no.native_parcel);

  5. //客户端这边还没有surface呢

  6. const sp& control(getSurface(env, clazz));

  7. //不过我们看到希望了,根据服务端那边Parcel信息来构造一个新的surface

  8. sp rhs = new Surface(*parcel);

  9. if (!Surface::isSameSurface(control, rhs)) {

  10. setSurface(env, clazz, rhs); //把这个新surface赋给客户端。终于我们有了surface!

  11. }

  12. }

到此,我们终于七拐八绕的得到了surface,这其中经历太多曲折了。下一节,我们将精简这其中复杂的操作,统一归到Native层,以这样为切入点来了解Surface的工作流程和原理。

好,反正你知道ViewRoot调用了relayout后,Surface就真正从WindowManagerService那得到了。继续回到ViewRoot,其中还有一个重要地方是我们知道却不了解的。

  1. private void performTraversals() {

  2. // cache mView since it is used so much below…

  3. final View host = mView;

  4. boolean initialized = false;

  5. boolean contentInsetsChanged = false;

  6. boolean visibleInsetsChanged;

  7. try {

  8. relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);

  9. // relayoutWindow完后,我们得到了一个无比宝贵的Surface

  10. //那我们画界面的地方在哪里?就在这个函数中,离relayoutWindow不远处。

  11. boolean cancelDraw = attachInfo.mTreeObserver.dispatchOnPreDraw();

  12. if (!cancelDraw && !newSurface) {

  13. mFullRedrawNeeded = false;

  14. draw(fullRedrawNeeded); //draw?draw什么呀?

  15. }

[—>ViewRoot::draw()]

  1. private void draw(boolean fullRedrawNeeded) {

  2. Surface surface = mSurface; //嘿嘿,不担心了,surface资源都齐全了

  3. if (surface == null || !surface.isValid()) {

  4. return;

  5. }

  6. if (mAttachInfo.mViewScrollChanged) {

  7. mAttachInfo.mViewScrollChanged = false;

  8. mAttachInfo.mTreeObserver.dispatchOnScrollChanged();

  9. }

  10. int yoff;

  11. final boolean scrolling = mScroller != null && mScroller.computeScrollOffset();

  12. if (scrolling) {

  13. yoff = mScroller.getCurrY();

  14. } else {

  15. yoff = mScrollY;

  16. }

  17. if (mCurScrollY != yoff) {

  18. mCurScrollY = yoff;

  19. fullRedrawNeeded = true;

  20. }

  21. float appScale = mAttachInfo.mApplicationScale;

  22. boolean scalingRequired = mAttachInfo.mScalingRequired;

  23. Rect dirty = mDirty;

  24. if (mUseGL) { //我们不用OPENGL

  25. }

  26. Canvas canvas;

  27. try {

  28. int left = dirty.left;

  29. int top = dirty.top;

  30. int right = dirty.right;

  31. int bottom = dirty.bottom;

  32. //从Surface中锁定一块区域,这块区域是我们认为的需要重绘的区域

  33. canvas = surface.lockCanvas(dirty);

  34. // TODO: Do this in native

  35. canvas.setDensity(mDensity);

  36. }

  37. try {

  38. if (!dirty.isEmpty() || mIsAnimating) {

  39. long startTime = 0L;

  40. try {

  41. canvas.translate(0, -yoff);

  42. if (mTranslator != null) {

  43. mTranslator.translateCanvas(canvas);

  44. }

  45. canvas.setScreenDensity(scalingRequired

  46. ? DisplayMetrics.DENSITY_DEVICE : 0);

  47. //mView就是之前的decoreView,

  48. mView.draw(canvas);

  49. }

  50. } finally {

  51. //我们的图画完了,告诉surface释放这块区域

  52. surface.unlockCanvasAndPost(canvas);

  53. }

  54. if (scrolling) {

  55. mFullRedrawNeeded = true;

  56. scheduleTraversals();

  57. }

自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。

深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!

因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。

img

img

img

img

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!

由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!

如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)

学习分享

①「Android面试真题解析大全」PDF完整高清版+②「Android面试知识体系」学习思维导图压缩包

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门即可获取!

{

  1. if (!dirty.isEmpty() || mIsAnimating) {

  2. long startTime = 0L;

  3. try {

  4. canvas.translate(0, -yoff);

  5. if (mTranslator != null) {

  6. mTranslator.translateCanvas(canvas);

  7. }

  8. canvas.setScreenDensity(scalingRequired

  9. ? DisplayMetrics.DENSITY_DEVICE : 0);

  10. //mView就是之前的decoreView,

  11. mView.draw(canvas);

  12. }

  13. } finally {

  14. //我们的图画完了,告诉surface释放这块区域

  15. surface.unlockCanvasAndPost(canvas);

  16. }

  17. if (scrolling) {

  18. mFullRedrawNeeded = true;

  19. scheduleTraversals();

  20. }

自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。

深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!

因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。

[外链图片转存中…(img-CoRNz83M-1712052917106)]

[外链图片转存中…(img-zbESHM3R-1712052917106)]

[外链图片转存中…(img-OSKP9NzX-1712052917107)]

[外链图片转存中…(img-MTO9XOtX-1712052917107)]

[外链图片转存中…(img-72yHLZCi-1712052917107)]

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!

由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!

如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)

学习分享

①「Android面试真题解析大全」PDF完整高清版+②「Android面试知识体系」学习思维导图压缩包

[外链图片转存中…(img-os6P7RUN-1712052917108)]

[外链图片转存中…(img-vWjpVS1W-1712052917108)]

[外链图片转存中…(img-qvOMfIs5-1712052917108)]

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门即可获取!
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值