Screenshot_20170818.png

2.7 AttachInfo构造过程

        AttachInfo(IWindowSession session, IWindow window, Display display,
            ViewRootImpl viewRootImpl, Handler handler, Callbacks effectPlayer) {
        mSession = session;//IWindowSession代理对象，用于与WMS通信 
        mWindow = window;//W对象  
        mWindowToken = window.asBinder();//W本地Binder对象 
        mDisplay = display;
        mViewRootImpl = viewRootImpl;//ViewRootImpl实例  
        mHandler = handler;//ViewRootHandler对象  
        mRootCallbacks = effectPlayer;
    }

2.8 创建Choreographer对象

[->Choreographer.java]

        // Thread local storage for the choreographer.
    private static final ThreadLocal<Choreographer> sThreadInstance =
            new ThreadLocal<Choreographer>() {
        @Override
        protected Choreographer initialValue() {
            Looper looper = Looper.myLooper();
            if (looper == null) {
                throw new IllegalStateException("The current thread must have a looper!");
            }
            return new Choreographer(looper);
        }
    };
    public static Choreographer getInstance() {
        return sThreadInstance.get();
    }
    

为调用线程创建一个Choreographer实例，调用线程必须具备消息循环功能，因为ViewRootImpl对象的构造是在应用程序进程的UI主线程中执行的，因此创建的Choreographer对象将使用UI线程消息队列。
[->Choreographer.java]

    private Choreographer(Looper looper) {
    mLooper = looper;
    //创建消息处理Handler
    mHandler = new FrameHandler(looper);
    //如果系统使用了Vsync机制，则注册一个FrameDisplayEventReceiver接收器 
    mDisplayEventReceiver = USE_VSYNC ? new FrameDisplayEventReceiver(looper) : null;
    mLastFrameTimeNanos = Long.MIN_VALUE;
    //屏幕刷新周期
    mFrameIntervalNanos = (long)(1000000000 / getRefreshRate());
    //创建回调数组  
    mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];
    //初始化数组
    for (int i = 0; i <= CALLBACK_LAST; i++) {
        mCallbackQueues[i] = new CallbackQueue();
    }
}

FrameDisplayEventReceiver详细过程以后再Android 7.1.2(Android N) Choreographer机制实现过程分析。

2.9 视图View添加过程

窗口管理器WindowManagerImpl为当前添加的窗口创建好各种对象后，调用ViewRootImpl的setView函数向WMS服务添加一个窗口对象。
[->ViewRootImpl.java]

    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
        if (mView == null) {
            ////将DecorView保存到ViewRootImpl的成员变量mView中
            mView = view;

            ......

            mSoftInputMode = attrs.softInputMode;
            mWindowAttributesChanged = true;
            mWindowAttributesChangesFlag = WindowManager.LayoutParams.EVERYTHING_CHANGED;
            //同时将DecorView保存到mAttachInfo中  
            mAttachInfo.mRootView = view;
            mAttachInfo.mScalingRequired = mTranslator != null;
            mAttachInfo.mApplicationScale =
                    mTranslator == null ? 1.0f : mTranslator.applicationScale;
            if (panelParentView != null) {
                mAttachInfo.mPanelParentWindowToken
                        = panelParentView.getApplicationWindowToken();
            }
            mAdded = true;
            int res; /* = WindowManagerImpl.ADD_OKAY; */

            //1）在添加窗口前进行UI布局  
            requestLayout();
            if ((mWindowAttributes.inputFeatures
                    & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
                mInputChannel = new InputChannel();
            }
            mForceDecorViewVisibility = (mWindowAttributes.privateFlags
                    & PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY) != 0;
            try {
                mOrigWindowType = mWindowAttributes.type;
                mAttachInfo.mRecomputeGlobalAttributes = true;
                collectViewAttributes();
                 //2)将窗口添加到WMS服务中，mWindow为W本地Binder对象，通过Binder传输到WMS服务端后，变为IWindow代理对象  
                res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                        getHostVisibility(), mDisplay.getDisplayId(),
                        mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                        mAttachInfo.mOutsets, mInputChannel);
            } ......
            //3)建立窗口消息通道  
            if (mInputChannel != null) {
                if (mInputQueueCallback != null) {
                    mInputQueue = new InputQueue();
                    mInputQueueCallback.onInputQueueCreated(mInputQueue);
                }
                mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                        Looper.myLooper());
            }

            ......
        }
    }
}

通过前面的分析可以知道，用户自定义的UI作为一个子View被添加到DecorView中，然后将顶级视图DecorView添加到应用程序进程的窗口管理器中，窗口管理器首先为当前添加的View创建一个ViewRootImpl对象、一个布局参数对象ViewGroup.LayoutParams，然后将这三个对象分别保存到当前应用程序进程的窗口管理器WindowManagerImpl中，最后通过ViewRootImpl对象将当前视图对象注册到WMS服务中。

ViewRootImpl的setView函数向WMS服务添加一个窗口对象过程：

(1) requestLayout()在应用程序进程中进行窗口UI布局；

(2) WindowSession.addToDisplay()向WMS服务注册一个窗口对象；

(3) 注册应用程序进程端的消息接收通道；

(1) requestLayout()在应用程序进程中进行窗口UI布局；

2.10 窗口UI布局过程

requestLayout函数调用里面使用了Hanlder的一个小手段，那就是利用postSyncBarrier添加了一个Barrier（挡板），这个挡板的作用是阻塞普通的同步消息的执行，在挡板被撤销之前，只会执行异步消息，而requestLayout先添加了一个挡板Barrier，之后自己插入了一个异步任务mTraversalRunnable，其主要作用就是保证mTraversalRunnable在所有同步Message之前被执行，保证View绘制的最高优先级。具体实现如下：

    @Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}
    void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        if (!mUnbufferedInputDispatch) {
            scheduleConsumeBatchedInput();
        }
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

2.10.1 添加回调过程

[->Choreographer.java]

    public void postCallback(int callbackType, Runnable action, Object token) {
    postCallbackDelayed(callbackType, action, token, 0);
}

public void postCallbackDelayed(int callbackType,
        Runnable action, Object token, long delayMillis) {
    ......
    postCallbackDelayedInternal(callbackType, action, token, delayMillis);
}

private void postCallbackDelayedInternal(int callbackType,
        Object action, Object token, long delayMillis) {
    ......

    synchronized (mLock) {
        final long now = SystemClock.uptimeMillis();
        final long dueTime = now + delayMillis;
        //将要执行的回调封装成CallbackRecord对象，保存到mCallbackQueues数组中
        mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
        
        if (dueTime <= now) {
            scheduleFrameLocked(now);
        } else {
            Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
            msg.arg1 = callbackType;
            msg.setAsynchronous(true);
            mHandler.sendMessageAtTime(msg, dueTime);
        }
    }
}
        private void scheduleFrameLocked(long now) {
    if (!mFrameScheduled) {
        mFrameScheduled = true;
        if (USE_VSYNC) {
            if (isRunningOnLooperThreadLocked()) {
                scheduleVsyncLocked();
            } else {
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtFrontOfQueue(msg);
            }
        } else {
            final long nextFrameTime = Math.max(
                    mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
            Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
            msg.setAsynchronous(true);
            mHandler.sendMessageAtTime(msg, nextFrameTime);
        }
    }
}

消息处理：

    private final class FrameHandler extends Handler {
    public FrameHandler(Looper looper) {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_DO_SCHEDULE_VSYNC:
                doScheduleVsync();
                break;
        }
    }
}
        void doScheduleVsync() {
    synchronized (mLock) {
        if (mFrameScheduled) {
            scheduleVsyncLocked();
        }
    }
}
private void scheduleVsyncLocked() {  
//申请Vsync信号  
mDisplayEventReceiver.scheduleVsync();  
}  

在该函数中考虑了两种情况，一种是系统没有使用Vsync机制，在这种情况下，首先根据屏幕刷新频率计算下一次刷新时间，通过异步消息方式延时执行doFrame()函数实现屏幕刷新。如果系统使用了Vsync机制，并且当前线程具备消息循环，则直接请求Vsync信号，否则就通过主线程来请求Vsync信号。

2.10.2 Vsync请求过程

我们知道在Choreographer构造函数中，构造了一个FrameDisplayEventReceiver对象，用于请求并接收Vsync信号，Vsync信号请求过程如下：

private void scheduleVsyncLocked() {  
//申请Vsync信号  
mDisplayEventReceiver.scheduleVsync();  
}  

[->DisplayEventReceiver.java]

        public void scheduleVsync() {
    if (mReceiverPtr == 0) {
        Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "
                + "receiver has already been disposed.");
    } else {
        nativeScheduleVsync(mReceiverPtr);
    }
}

[->android_view_DisplayEventReceiver.cpp ]

static void nativeScheduleVsync(JNIEnv* env, jclass clazz, jlong receiverPtr) {
sp<NativeDisplayEventReceiver> receiver =
        reinterpret_cast<NativeDisplayEventReceiver*>(receiverPtr);
status_t status = receiver->scheduleVsync();
if (status) {
    String8 message;
    message.appendFormat("Failed to schedule next vertical sync pulse.  status=%d", status);
    jniThrowRuntimeException(env, message.string());
}
}

VSync请求过程又转交给了DisplayEventReceiver：
[->DisplayEventReceiver.cpp]

status_t DisplayEventReceiver::requestNextVsync() {
if (mEventConnection != NULL) {
    mEventConnection->requestNextVsync();
    return NO_ERROR;
}
return NO_INIT;
}

这里又通过IDisplayEventConnection接口来请求Vsync信号，IDisplayEventConnection实现了Binder通信框架，可以跨进程调用，因为Vsync信号请求进程和Vsync产生进程有可能不在同一个进程空间，因此这里就借助IDisplayEventConnection接口来实现。下面通过图来梳理Vsync请求的调用流程：

20140630193116703.png

需要说明的是/Vsync/之间的代码此时其实还未执行，call requestNextVsync()来告诉系统我要在下一个VSYNC需要被trigger.

继续ViewRootImpl的setView函数中的WindowSession.addToDisplay()。

(2) mWindowSession.addToDisplay()向WMS服务注册一个窗口对象；

[Session.java]

    @Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
        Rect outOutsets, InputChannel outInputChannel) {
    return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
            outContentInsets, outStableInsets, outOutsets, outInputChannel);
}

[WindowManagerService.java]

    public int addWindow(Session session, IWindow client, int seq,
        WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
        Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
        InputChannel outInputChannel) {
    ......
    boolean reportNewConfig = false;
    WindowState attachedWindow = null;
    long origId;
    final int callingUid = Binder.getCallingUid();
    final int type = attrs.type;
    synchronized(mWindowMap) {
        ......
        final DisplayContent displayContent = getDisplayContentLocked(displayId);
        ......
        boolean addToken = false;
        WindowToken token = mTokenMap.get(attrs.token);
        AppWindowToken atoken = null;
        boolean addToastWindowRequiresToken = false;
        ......
        WindowState win = new WindowState(this, session, client, token,
                attachedWindow, appOp[0], seq, attrs, viewVisibility, displayContent);

            return WindowManagerGlobal.ADD_APP_EXITING;
        }
        ......
        mPolicy.adjustWindowParamsLw(win.mAttrs);
        win.setShowToOwnerOnlyLocked(mPolicy.checkShowToOwnerOnly(attrs));
        res = mPolicy.prepareAddWindowLw(win, attrs);
        ......
        final boolean openInputChannels = (outInputChannel != null
                && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
        if  (openInputChannels) {
            win.openInputChannel(outInputChannel);
        }
        ......
        if (addToken) {
            mTokenMap.put(attrs.token, token);
        }
        win.attach();
        mWindowMap.put(client.asBinder(), win);
        ......
        }
        boolean imMayMove = true;
        if (type == TYPE_INPUT_METHOD) {
            win.mGivenInsetsPending = true;
            mInputMethodWindow = win;
            addInputMethodWindowToListLocked(win);
            imMayMove = false;
        } else if (type == TYPE_INPUT_METHOD_DIALOG) {
            mInputMethodDialogs.add(win);
            addWindowToListInOrderLocked(win, true);
            moveInputMethodDialogsLocked(findDesiredInputMethodWindowIndexLocked(true));
            imMayMove = false;
        } else {
            addWindowToListInOrderLocked(win, true);
            if (type == TYPE_WALLPAPER) {
                mWallpaperControllerLocked.clearLastWallpaperTimeoutTime();
                displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
            } else if ((attrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
                displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
            } else if (mWallpaperControllerLocked.isBelowWallpaperTarget(win)) {
                displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
            }
        }
        ......
        mInputMonitor.setUpdateInputWindowsNeededLw();

        boolean focusChanged = false;
        if (win.canReceiveKeys()) {
            focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
                    false /*updateInputWindows*/);
            if (focusChanged) {
                imMayMove = false;
            }
        }
        ......
        mLayersController.assignLayersLocked(displayContent.getWindowList());
        // Don't do layout here, the window must call
        // relayout to be displayed, so we'll do it there.
        if (focusChanged) {
            mInputMonitor.setInputFocusLw(mCurrentFocus, false /*updateInputWindows*/);
        }
        mInputMonitor.updateInputWindowsLw(false /*force*/);
        ......
    }
    if (reportNewConfig) {
        sendNewConfiguration();
    }
    return res;
}

我们知道当应用程序进程添加一个DecorView到窗口管理器时，会为当前添加的窗口创建ViewRootImpl对象，同时构造了一个W本地Binder对象，无论是窗口视图对象DecorView还是ViewRootImpl对象，都只是存在于应用程序进程中，在添加窗口过程中仅仅将该窗口的W对象传递给WMS服务，经过Binder传输后，到达WMS服务端进程后变为IWindow.Proxy代理对象，因此该函数的参数client的类型为IWindow.Proxy。参数attrs的类型为WindowManager.LayoutParams，在应用程序进程启动Activity时，handleResumeActivity()函数通过WindowManager.LayoutParams l = r.window.getAttributes();来得到应用程序窗口布局参数，由于WindowManager.LayoutParams实现了Parcelable接口，因此WindowManager.LayoutParams对象可以跨进程传输，WMS服务的addWindow函数中的attrs参数就是应用程序进程发送过来的窗口布局参数。在WindowManagerImpl的addView函数中为窗口布局参数设置了相应的token，如果是应用程序窗口，则布局参数的token设为W本地Binder对象。如果不是应用程序窗口，同时当前窗口没有父窗口，则设置token为当前窗口的IApplicationToken.Proxy代理对象，否则设置为父窗口的IApplicationToken.Proxy代理对象，由于应用程序和WMS分属于两个不同的进程空间，因此经过Binder传输后，布局参数的令牌attrs.token就转变为IWindow.Proxy或者Token。以上函数首先根据布局参数的token等信息构造一个WindowToken对象，然后在构造一个WindowState对象，并将添加的窗口信息记录到mTokenMap和mWindowMap哈希表中。

在WMS服务端创建了所需对象后，接着调用了WindowState的attach()来进一步完成窗口添加。
[WindowState.java]

    void attach() {
    if (WindowManagerService.localLOGV) Slog.v(
        TAG, "Attaching " + this + " token=" + mToken
        + ", list=" + mToken.windows);
    mSession.windowAddedLocked();
}

[Session.java]

    void windowAddedLocked() {
    if (mSurfaceSession == null) {
        if (WindowManagerService.localLOGV) Slog.v(
            TAG_WM, "First window added to " + this + ", creating SurfaceSession");
        mSurfaceSession = new SurfaceSession();
        if (SHOW_TRANSACTIONS) Slog.i(
                TAG_WM, "  NEW SURFACE SESSION " + mSurfaceSession);
        mService.mSessions.add(this);
        if (mLastReportedAnimatorScale != mService.getCurrentAnimatorScale()) {
            mService.dispatchNewAnimatorScaleLocked(this);
        }
    }
    mNumWindow++;
}

SurfaceSession建立过程

SurfaceSession对象承担了应用程序与SurfaceFlinger之间的通信过程，每一个需要与SurfaceFlinger进程交互的应用程序端都需要创建一个SurfaceSession对象。

客户端请求
[SurfaceSession.java]

    public SurfaceSession() {
    mNativeClient = nativeCreate();
}

Java层的SurfaceSession对象构造过程会通过JNI在native层创建一个SurfaceComposerClient对象。

[android_view_SurfaceSession.cpp]

static jlong nativeCreate(JNIEnv* env, jclass clazz) {
SurfaceComposerClient* client = new SurfaceComposerClient();
client->incStrong((void*)nativeCreate);
return reinterpret_cast<jlong>(client);
}

Java层的SurfaceSession对象与C++层的SurfaceComposerClient对象之间是一对一关系。
[SurfaceComposerClient.cpp]

SurfaceComposerClient::SurfaceComposerClient()
: mStatus(NO_INIT), mComposer(Composer::getInstance()){}
void SurfaceComposerClient::onFirstRef() {
//得到SurfaceFlinger的代理对象BpSurfaceComposer  
sp<ISurfaceComposer> sm(ComposerService::getComposerService());
if (sm != 0) {
    sp<ISurfaceComposerClient> conn = sm->createConnection();
    if (conn != 0) {
        mClient = conn;
        mStatus = NO_ERROR;
    }
}
}

SurfaceComposerClient继承于RefBase类，当第一次被强引用时，onFirstRef函数被回调，在该函数中SurfaceComposerClient会请求SurfaceFlinger为当前应用程序创建一个Client对象，专门接收该应用程序的请求，在SurfaceFlinger端创建好Client本地Binder对象后，将该Binder代理对象返回给应用程序端，并保存在SurfaceComposerClient的成员变量mClient中。

服务端处理
在SurfaceFlinger服务端为应用程序创建交互的Client对象
[SurfaceFlinger.cpp]

sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
{
sp<ISurfaceComposerClient> bclient;
sp<Client> client(new Client(this));
status_t err = client->initCheck();
if (err == NO_ERROR) {
    bclient = client;
}
return bclient;
}

20140331134703796.png

/****************************************************Vsync****************************************************/

Vsync信号处理

以上是请求过程，FrameDisplayEventReceiver对象用于请求并接收Vsync信号，当Vsync信号到来时，系统会自动调用其onVsync()函数，后面会回调到FrameDisplayEventReceiver.run方法（Why “同步分割栏”？再分析），再回调函数中执行doFrame()实现屏幕刷新。
当VSYNC信号到达时，Choreographer doFrame()函数被调用
[->Choreographer.java]

    void doFrame(long frameTimeNanos, int frame) {
    final long startNanos;
    ......
    
        long intendedFrameTimeNanos = frameTimeNanos;
        //保存起始时间 
        startNanos = System.nanoTime();
        //由于Vsync事件处理采用的是异步方式，因此这里计算消息发送与函数调用开始之间所花费的时间 
        final long jitterNanos = startNanos - frameTimeNanos;
        //计算函数调用期间所错过的帧数  
        if (jitterNanos >= mFrameIntervalNanos) {
            final long skippedFrames = jitterNanos / mFrameIntervalNanos;
            if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {
                Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                        + "The application may be doing too much work on its main thread.");
            }
            final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;
            frameTimeNanos = startNanos - lastFrameOffset;
        }
        //如果frameTimeNanos小于一个屏幕刷新周期，则重新请求VSync信号 
        if (frameTimeNanos < mLastFrameTimeNanos) {
            scheduleVsyncLocked();
            return;
        }

        mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
        mFrameScheduled = false;
        mLastFrameTimeNanos = frameTimeNanos;
    }

    try {
       //分别回调CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL、CALLBACK_COMMIT事件  
        doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);
        doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);
        doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);
        doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
    }
}

20140630192141906.png

Choreographer类中分别定义了CallbackRecord、CallbackQueue内部类，CallbackQueue是一个按时间先后顺序保存CallbackRecord的单向循环链表。

20140630192252750.png

在Choreographer中定义了三个CallbackQueue队列，用数组mCallbackQueues表示，用于分别保存CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL这三种类型的Callback，当调用Choreographer类的postCallback()函数时，就是往指定类型的CallbackQueue队列中通过addCallbackLocked()函数添加一个CallbackRecord项：首先构造一个CallbackRecord对象，然后按时间先后顺序插入到CallbackQueue链表中。从代码注释中，我们可以知道CALLBACK_INPUT是指输入回调，该回调优先级最高，首先得到执行，而CALLBACK_TRAVERSAL是指处理布局和绘图的回调，只有在所有异步消息都执行完后才得到执行，CALLBACK_ANIMATION是指动画回调，比CALLBACK_TRAVERSAL优先执行，从doFrame()函数中的doCallbacks调用就能印证这点。
当Vsync事件到来时，顺序执行CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL 和CALLBACK_COMMIT 对应CallbackQueue队列中注册的回调。
[->Choreographer.java]

    void doCallbacks(int callbackType, long frameTimeNanos) {
    CallbackRecord callbacks;
    synchronized (mLock) {
        final long now = System.nanoTime();
        //从指定类型的CallbackQueue队列中查找执行时间到的CallbackRecord 
        callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
                now / TimeUtils.NANOS_PER_MS);
        ......

        if (callbackType == Choreographer.CALLBACK_COMMIT) {
            final long jitterNanos = now - frameTimeNanos;
            if (jitterNanos >= 2 * mFrameIntervalNanos) {
                final long lastFrameOffset = jitterNanos % mFrameIntervalNanos
                        + mFrameIntervalNanos;
                    mDebugPrintNextFrameTimeDelta = true;
                }
                frameTimeNanos = now - lastFrameOffset;
                mLastFrameTimeNanos = frameTimeNanos;
            }
        }
    }
    try {
        for (CallbackRecord c = callbacks; c != null; c = c.next) {
          //由于CallbackQueues是按时间先后顺序排序的，因此遍历执行所有时间到的CallbackRecord  
            c.run(frameTimeNanos);
        }
    } finally {
        synchronized (mLock) {
            mCallbacksRunning = false;
            do {
                final CallbackRecord next = callbacks.next;
                recycleCallbackLocked(callbacks);
                callbacks = next;
            } while (callbacks != null);
        }
    }
}

我们知道Choreographer对外提供了两个接口函数用于注册指定的Callback，postCallback()用于注册Runnable对象，而postFrameCallback()函数用于注册FrameCallback对象，无论注册的是Runnable对象还是FrameCallback对象，在CallbackRecord对象中统一装箱为Object类型。在执行其回调函数时，就需要区别这两种对象类型，如果注册的是Runnable对象，则调用其run()函数，如果注册的是FrameCallback对象，则调用它的doFrame()函数。

20140630192623921.png

2.11 视图View添加过程

20140701194427750.png

关于Choreographer的postCallback()用法在前面进行了详细的介绍，当Vsync事件到来时，mTraversalRunnable对象的run()函数将被调用。

mTraversalRunnable对象的类型为TraversalRunnable，该类实现了Runnable接口，在其run()函数中调用了doTraversal()函数来完成窗口布局。
[->ViewRootImpl.java]

    final class TraversalRunnable implements Runnable {
    @Override
    public void run() {
        doTraversal();
    }
}
final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

        if (mProfile) {
            Debug.startMethodTracing("ViewAncestor");
        }

        performTraversals();

        if (mProfile) {
            Debug.stopMethodTracing();
            mProfile = false;
        }
    }
}

performTraversals函数相当复杂，其主要实现以下几个重要步骤：

1.执行窗口测量；

2.执行窗口注册；

3.执行窗口布局；

4.执行窗口绘图；

[->ViewRootImpl.java]

    private void performTraversals() {
    ......
    final View host = mView;
    mIsInTraversal = true;
    mWillDrawSoon = true;
    boolean windowSizeMayChange = false;
    boolean newSurface = false;
    boolean surfaceChanged = false;
    WindowManager.LayoutParams lp = mWindowAttributes;

    int desiredWindowWidth;
    int desiredWindowHeight;

    final int viewVisibility = getHostVisibility();
    final boolean viewVisibilityChanged = !mFirst
            && (mViewVisibility != viewVisibility || mNewSurfaceNeeded);
    final boolean viewUserVisibilityChanged = !mFirst &&
            ((mViewVisibility == View.VISIBLE) != (viewVisibility == View.VISIBLE));

    WindowManager.LayoutParams params = null;
    if (mWindowAttributesChanged) {
        mWindowAttributesChanged = false;
        surfaceChanged = true;
        params = lp;
    }
    ......
    /****************执行窗口测量******************/  
    boolean layoutRequested = mLayoutRequested && (!mStopped || mReportNextDraw);
    if (layoutRequested) {

        windowSizeMayChange |= measureHierarchy(host, lp, res,
                desiredWindowWidth, desiredWindowHeight);
    }
    ......
    /****************向WMS服务添加窗口******************/  
    if (mFirst || windowShouldResize || insetsChanged ||
            viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
        ......
        try {
            ......
            relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
            ......
        } catch (RemoteException e) {
        }
        ......
        if (!mStopped || mReportNextDraw) {
            ......
                 // Ask host how big it wants to be
                performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                ......
            }
        }
    } else {
        ......
    }
    /****************执行窗口布局******************/ 
    final boolean didLayout = layoutRequested && (!mStopped || mReportNextDraw);
    boolean triggerGlobalLayoutListener = didLayout
            || mAttachInfo.mRecomputeGlobalAttributes;
    if (didLayout) {
        performLayout(lp, mWidth, mHeight);
        ......
        }
    /****************查找窗口焦点******************/ 
    if (mFirst) {
    ......
        if (mView != null) {
            if (!mView.hasFocus()) {
                mView.requestFocus(View.FOCUS_FORWARD);
            } else {}
        }
    }

    final boolean changedVisibility = (viewVisibilityChanged || mFirst) && isViewVisible;
    final boolean hasWindowFocus = mAttachInfo.mHasWindowFocus && isViewVisible;
    final boolean regainedFocus = hasWindowFocus && mLostWindowFocus;
    if (regainedFocus) {
        mLostWindowFocus = false;
    } else if (!hasWindowFocus && mHadWindowFocus) {
        mLostWindowFocus = true;
    }

    if (changedVisibility || regainedFocus) {
        // Toasts are presented as notifications - don't present them as windows as well
        boolean isToast = (mWindowAttributes == null) ? false
                : (mWindowAttributes.type == WindowManager.LayoutParams.TYPE_TOAST);
        if (!isToast) {
            host.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
        }
    }

    mFirst = false;
    mWillDrawSoon = false;
    mNewSurfaceNeeded = false;
    mActivityRelaunched = false;
    mViewVisibility = viewVisibility;
    mHadWindowFocus = hasWindowFocus;

    if (hasWindowFocus && !isInLocalFocusMode()) {
        final boolean imTarget = WindowManager.LayoutParams
                .mayUseInputMethod(mWindowAttributes.flags);
        if (imTarget != mLastWasImTarget) {
            mLastWasImTarget = imTarget;
            InputMethodManager imm = InputMethodManager.peekInstance();
            if (imm != null && imTarget) {
                imm.onPreWindowFocus(mView, hasWindowFocus);
                imm.onPostWindowFocus(mView, mView.findFocus(),
                        mWindowAttributes.softInputMode,
                        !mHasHadWindowFocus, mWindowAttributes.flags);
            }
        }
    }

    // Remember if we must report the next draw.
    if ((relayoutResult & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
        mReportNextDraw = true;
    }
    /****************执行窗口绘制******************/  
    boolean cancelDraw = mAttachInfo.mTreeObserver.dispatchOnPreDraw() || !isViewVisible;

    if (!cancelDraw && !newSurface) {
        if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).startChangingAnimations();
            }
            mPendingTransitions.clear();
        }

        performDraw();
    } else {
        if (isViewVisible) {
            // Try again
            scheduleTraversals();
        } else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).endChangingAnimations();
            }
            mPendingTransitions.clear();
        }
    }

    mIsInTraversal = false;
}

1.执行窗口测量performMeasure()

[->ViewRootImpl.java]

    private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
    try {
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

2.执行窗口注册relayoutWindow；

[->ViewRootImpl.java]

    private int relayoutWindow(WindowManager.LayoutParams params, int viewVisibility,
        boolean insetsPending) throws RemoteException {

    ......
    int relayoutResult = mWindowSession.relayout(
            mWindow, mSeq, params,
            (int) (mView.getMeasuredWidth() * appScale + 0.5f),
            (int) (mView.getMeasuredHeight() * appScale + 0.5f),
            viewVisibility, insetsPending ? WindowManagerGlobal.RELAYOUT_INSETS_PENDING : 0,
            mWinFrame, mPendingOverscanInsets, mPendingContentInsets, mPendingVisibleInsets,
            mPendingStableInsets, mPendingOutsets, mPendingBackDropFrame, mPendingConfiguration,
            mSurface);

    ......
    return relayoutResult;
}

这里通过前面获取的IWindowSession代理对象请求WMS服务执行窗口布局，mSurface是ViewRootImpl的成员变量
[->ViewRootImpl.java]

    final Surface mSurface = new Surface();

[->Surface.java]

/**
 * Create an empty surface, which will later be filled in by readFromParcel().
 * @hide
 */
public Surface() {
}

该Surface构造函数仅仅创建了一个空Surface对象，并没有对该Surface进程native层的初始化，到此我们知道应用程序进程为每个窗口对象都创建了一个Surface对象。并且将该Surface通过跨进程方式传输给WMS服务进程，我们知道，在Android系统中，如果一个对象需要在不同进程间传输，必须实现Parcelable接口，Surface类正好实现了Parcelable接口。ViewRootImpl通过IWindowSession接口请求WMS的完整过程如下：

[->IWindowSession.java$ Proxy]

/*
* This file is auto-generated.  DO NOT MODIFY
*  * Original file: frameworks/base/core/java/android/view/IWindowSession.aidl
*/
@Override
  public int relayout(android.view.IWindow window, int seq, android.view.WindowManager.LayoutParams attrs, int requestedWidth, int requestedHeight, int viewVisibility, int flags, android.graphics.Rect outFrame, android.graphics.Rect outOverscanInsets, android.graphics.Rect outContentInsets, android.graphics.Rect outVisibleInsets, android.graphics.Rect outStableInsets, android.graphics.Rect outOutsets, android.graphics.Rect outBackdropFrame, android.content.res.Configuration outConfig, android.view.Surface outSurface) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
    ......
    mRemote.transact(Stub.TRANSACTION_relayout, _data, _reply, 0);
    ......
    if ((0 != _reply.readInt())) {
        outSurface.readFromParcel(_reply);
    }
} finally {
    ......
}
return _result;
}

从该函数的实现可以看出，应用程序进程中创建的Surface对象并没有传递到WMS服务进程，只是读取WMS服务进程返回来的Surface。那么WMS服务进程是如何响应应用程序进程布局请求的呢？

[->IWindowSession.java$ Stub]

@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case TRANSACTION_relayout:
  {
    ......
    android.view.Surface _arg15;
    _arg15 = new android.view.Surface();
    int _result = this.relayout(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10, _arg11, _arg12, _arg13, _arg14, _arg15);
    reply.writeNoException();
    reply.writeInt(_result);
    ......
    if ((_arg15!=null)) {
    reply.writeInt(1);
    _arg15.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
    }
    return true;
  }
}

该函数可以看出，WMS服务在响应应用程序进程请求添加窗口时，首先在当前进程空间创建一个Surface对象，然后调用Session的relayout()函数进一步完成窗口添加过程，最后将WMS服务中创建的Surface返回给应用程序进程。

20140701140158895.png

到目前为止，在应用程序进程和WMS

版权声明：本文来源简书，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://www.jianshu.com/p/c321faba9f5c
站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。

• 发表于 2020-01-07 21:07:58
• 阅读 ( 1263 )
• 分类：

0 推荐 收藏

你可能感兴趣的文章

• 【Android】版本更替 2028 浏览
• 【Android】通知准时送达之日历事件 1727 浏览
• android多线程详解之Handler 2013 浏览
• android多线程详解之AsyncTask 1958 浏览
• 第二十期 在Android中修改GPS定位数据的完整方案《手机就是开发板》 1890 浏览
• 第三期 Android Kernel 下载和编译 《手机就是开发板》 1818 浏览
• Android studio关于Cmake的使用（第三章·引用第三方库文件） 1920 浏览
• android-Goggle后端支付验证流程 1892 浏览
• unity-与Android交互(unity、android studio) 2466 浏览

精选的优质文章

• 也许 Go 开发可以更简单！ 10576 浏览
• 如何使用 Golang 日志监控你的应用程序？ 12049 浏览
• 从Go语言实现模板设计模式浅谈Go的抽象能力 14102 浏览
• 阿里云基于 Go 的微服务架构分享 23968 浏览
• java是否会被取代？Go会否给Java带来冲击？ 28490 浏览
• 千万级规模高性能、高并发的网络架构经验分享 30047 浏览
• 阿里部分面试题汇总,对想进阿里的同学非常实用 62342 浏览
• 实用好文：知乎实时数仓架构实践及演进 31364 浏览
• 支撑马蜂窝「双11」营销大战背后的技术架构 228306 浏览
• 想进大厂？50个多线程面试题，你会多少？（一） 23103 浏览

0 条评论

请先 登录 后评论

官方社群

GO教程

  1. Go语言简介  

• 1.1 Go语言简介
• 1.2 Go语言的特性
• 1.3 Go语言为并发而生
• 1.4 哪些项目使用Go语言开发？
• 1.5 哪些大公司正在使用Go语言
• 1.6 Go语言的性能如何？
• 1.7 Go语言标准库强大
• 1.8 Go语言上手简单
• 1.9 Go语言代码风格清晰、简单
• 1.10 Go语言工程结构详述
• 1.11 第一个Go语言程序
• 1.12 Go语言历史版本

  2. Go语言基本语法  

• 2.1 Go语言变量的声明
• 2.2 Go语言变量的初始化
• 2.3 Go语言多个变量同时赋值
• 2.4 Go语言匿名变量
• 2.5 Go语言变量的作用域
• 2.6 Go语言整型（整数类型）
• 2.7 Go语言浮点类型（小数类型）
• 2.8 Go语言复数
• 2.9 Go语言bool类型（布尔类型）
• 2.10 Go语言字符串
• 2.11 Go语言字符类型（byte和rune）
• 2.12 Go语言数据类型转换
• 2.13 Go语言指针
• 2.14 Go语言变量的生命周期
• 2.15 Go语言常量
• 2.16 Go语言类型别名
• 2.17 Go语言关键字与标识符
• 2.18 Go语言运算符的优先级

  3. Go语言数据结构  

• 3.1 Go语言数组
• 3.2 Go语言多维数组
• 3.3 Go语言切片
• 3.4 使用append()为切片添加元素
• 3.5 Go语言切片复制
• 3.6 Go语言从切片中删除元素
• 3.7 Go语言range关键字
• 3.8 Go语言多维切片
• 3.9 Go语言map（映射）
• 3.10 Go语言遍历map
• 3.11 map元素的删除和清空
• 3.12 Go语言sync.Map
• 3.13 Go语言list（列表）
• 3.14 Go语言nil：空值/零值

  4. Go语言流程控制  

• 4.1 Go语言分支结构
• 4.2 Go语言循环结构
• 4.4 Go语言键值循环
• 4.5 Go语言switch语句
• 4.6 Go语言goto语句
• 4.7 Go语言break（跳出循环）
• 4.8 Go语言continue

  5. Go语言函数  

• 5.1 Go语言函数声明
• 5.2 Go语言函数变量
• 5.3 Go语言匿名函数
• 5.4 Go语言函数类型实现接口
• 5.5 Go语言闭包（Closure）
• 5.6 Go语言可变参数
• 5.7 Go语言defer（延迟执行语句）
• 5.8 Go语言递归函数
• 5.9 Go语言处理运行时错误
• 5.10 Go语言宕机（panic）
• 5.11 Go语言宕机恢复（recover）
• 5.12 Go语言计算函数执行时间
• 5.13 Go语言Test功能测试函数

  6. Go语言结构体  

• 6.1 Go语言结构体定义
• 6.2 Go语言实例化结构体
• 6.3 初始化结构体的成员变量
• 6.4 Go语言构造函数
• 6.5 类型内嵌和结构体内嵌
• 6.6 初始化内嵌结构体
• 6.7 内嵌结构体成员名字冲突
• 6.8 Go语言垃圾回收和SetFinalizer
• 6.9 Go语言链表操作
• 6.10 Go语言数据I/O对象及操作

  7. Go语言接口  

• 7.1 Go语言接口声明（定义）
• 7.2 Go语言实现接口的条件
• 7.3 Go语言类型与接口的关系
• 7.4 Go语言类型断言
• 7.5 Go语言排序
• 7.6 Go语言接口的嵌套组合
• 7.9 Go语言接口和类型之间的转换
• 7.10 Go语言空接口类型
• 7.11 Go语言类型分支
• 7.12 Go语言error接口

  8. Go语言包  

• 8.1 包的基本概念
• 8.2 Go语言封装简介及实现细节
• 8.3 Go语言GOPATH
• 8.4 Go语言常用内置包
• 8.5 Go语言自定义包
• 8.6 Go语言package
• 8.7 Go语言导出包中的标识符
• 8.8 Go语言import导入包
• 8.9 Go语言sync包与锁
• 8.10 Go语言big包
• 8.11 Go语言正则表达式：regexp包
• 8.12 Go语言time包：时间和日期
• 8.13 Go语言os包用法简述
• 8.14 Go语言flag包：命令行参数解析
• 8.15 Go语言go mod包依赖管理工具
• 8.16 Go语言runtime包:运行时

  9. Go语言并发  

• 9.1 Go语言并发简述
• 9.2 Go语言轻量级线程
• 9.3 Go语言并发通信
• 9.4 Go语言竞争状态
• 9.5 Go语言调整并发的运行性能
• 9.6 并发和并行的区别
• 9.7 goroutine和coroutine的区别
• 9.8 Go语言通道（chan）
• 9.9 示例：并发打印
• 9.10 Go语言单向通道
• 9.11 Go语言无缓冲的通道
• 9.12 Go语言带缓冲的通道
• 9.13 Go语言channel超时机制
• 9.14 Go语言多核并行化
• 9.15 互斥锁和读写互斥锁
• 9.16 Go语言等待组
• 9.17 死锁、活锁和饥饿概述
• 9.18 Go语言CSP：通信顺序进程简述
• 9.19 示例：聊天服务器

  10. Go语言反射  

• 10.1 Go语言反射（reflection）
• 10.2 Go语言反射规则浅析
• 10.3 通过反射获取类型信息
• 10.4 通过反射获取指针指向的元素类型
• 10.5 通过反射获取结构体的成员类型
• 10.6 Go语言结构体标签
• 10.7 通过反射获取值信息
• 10.8 通过反射访问结构体成员的值
• 10.9 判断反射值的空和有效性
• 10.10 通过反射修改变量的值
• 10.11 通过类型信息创建实例
• 10.12 通过反射调用函数
• 10.13 Go语言inject库：依赖注入

  11. Go语言文件处理  

• 11.1 Go语言自定义数据文件
• 11.2 Go语言JSON文件的读写操作
• 11.3 Go语言XML文件的读写操作
• 11.4 Go语言使用Gob传输数据
• 11.5 Go语言纯文本文件的读写操作
• 11.6 Go语言二进制文件的读写操作
• 11.7 Go语言自定义二进制文件的读写操作
• 11.8 Go语言zip归档文件的读写操作
• 11.9 Go语言tar归档文件的读写操作
• 11.10 Go语言使用buffer读取文件
• 11.11 Go语言文件的写入、追加、读取、复制操作
• 11.12 Go语言文件锁操作

  12. Go语言编译和工具链  

• 12.1 go build命令
• 12.2 go clean命令
• 12.3 go run命令
• 12.4 go fmt命令
• 12.5 go install命令
• 12.6 go get命令
• 12.7 go generate命令
• 12.8 go test命令
• 12.9 go pprof命令

  13. Go语言进阶  

• 13.1 Go语言的深拷贝和浅拷贝
• 13.2 Go语言引用传递和值传递
• 13.3 Go语言的Socket编程

  14. 常见面试题  

• 14.1 Golang Map底层实现
• 14.2 go语言触发异常的场景有哪些
• 14.3 Printf()、Sprintf()、Fprintf()函数的区别用法是什么
• 14.4 详细说说new和make的区别
• 14.5 详细说说切片和数组的区别
• 14.6 Golang的内存模型，为什么小对象多了会造成gc压力
• 14.7 Data Race问题怎么解决？能不能不加锁解决这个问题
• 14.8 在 range 迭代 slice 时，你怎么修改值的
• 14.9 select可以用于什么
• 14.10 go语言编程的好处是什么
• 14.11 你是否主动关闭过http连接，为啥要这样做
• 14.12 recover的执行时机
• 14.13 说出一个避免Goroutine泄露的措施
• 14.14 如何跳出for select 循环
• 14.15 如何初始化带嵌套结构的结构体
• 14.16 Printf()、Sprintf()、Fprintf()函数的区别用法是什么
• 14.17 go语言中的引用类型包含哪些
• 14.18 说说go语言的select机制

推荐文章

• Android中Context的使用总结
• Android 中 Context 的理解及使用
• Android中使用HorizontalScrollView横向滑动布局
• Android RatingBar 修改 颜色 大小 图片
• 第一节，Android Studio UiAutomator搭建及实例
• Android 内存泄露检测神器
• Android Studio更新升级方法
• 引入开源库依赖时，com.android.support版本不同引发冲突的解决办法
• Android如何设置ListView不可点击
• java.lang.InstantiationException: java.lang.Class com.android.tools.ir.runtime.IncrementalChange

猜你喜欢

随便看看

• 开发两年拿下阿里P6的offer,只因靠这位大佬总结的Java面试题总集
• 源码阅读(19)：Java中主要的Map结构——HashMap容器（下1）
• 零基础自学java要多久 学完能找到工作吗
• 10年Java开发经验，给转行Java新人的3点建议！
• 分享最近.Net面试题目
• 2017年前端面试题整理汇总100题
• 木兰编程语言，当事人最新回复来了
• 程序员接私活必备的10款开源前端后台框架
• 如何正确应对面试最后一问：你有什么问题想问我吗？
• 《吊打面试官》系列-Redis双写一致性、并发竞争、线程模型

×

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！

---