Android13 Choreographer 创建流程

一个学渣的自我救赎

已于 2024-05-16 08:29:04 修改

阅读量828

点赞数 18

于 2024-05-05 17:07:18 首次发布

本文链接：https://blog.csdn.net/liuning1985622/article/details/138469521

版权

Android Framework 同时被 2 个专栏收录

372 篇文章 40 订阅

订阅专栏

Android Graphics

23 篇文章 2 订阅

订阅专栏

Choreographer实例在ViewRootImpl构造器中被赋值给mChoreographer变量，代码如下：

//frameworks/base/core/java/android/view/ViewRootImpl.java
public final class ViewRootImpl implements ViewParent,
        View.AttachInfo.Callbacks, ThreadedRenderer.DrawCallbacks,
        AttachedSurfaceControl {
    public ViewRootImpl(@UiContext Context context, Display display, IWindowSession session,
            boolean useSfChoreographer) {
        mChoreographer = useSfChoreographer
                ? Choreographer.getSfInstance() : Choreographer.getInstance();
    }
}

根据是否使用SfChoreographer来决定调用Choreographer.getSfInstance()或Choreographer.getInstance()：

调用Choreographer的getSfInstance方法：

//frameworks/base/core/java/android/view/Choreographer.java
public final class Choreographer {
    public static Choreographer getSfInstance() {
        return sSfThreadInstance.get();
    }
}

sSfThreadInstance的赋值如下：

//frameworks/base/core/java/android/view/Choreographer.java
public final class Choreographer {
    private static final ThreadLocal<Choreographer> sSfThreadInstance =
            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, VSYNC_SOURCE_SURFACE_FLINGER);
                }
            };
}

调用Choreographer的getInstance方法：

//frameworks/base/core/java/android/view/Choreographer.java
public final class Choreographer {
    public static Choreographer getInstance() {
        return sThreadInstance.get();
    }
}

sThreadInstance的赋值如下：

//frameworks/base/core/java/android/view/Choreographer.java
public final class 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!");
            }
            Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
            if (looper == Looper.getMainLooper()) {
                mMainInstance = choreographer;
            }
            return choreographer;
        }
    };
}

都是通过new的方式创建Choreographer对象，只是参数不同，Choreographer构造方法如下：

//frameworks/base/core/java/android/view/Choreographer.java
public final class Choreographer {
    private Choreographer(Looper looper, int vsyncSource) {
        mLooper = looper;
        // 1.创建处理 frame 事件相关的handler。
        mHandler = new FrameHandler(looper);
 // 2.创建mDisplayEventReceiver，VSYNC信号接收器。
        mDisplayEventReceiver = USE_VSYNC
                ? new FrameDisplayEventReceiver(looper, vsyncSource)
                : null;
 // 3.记录最后绘制的时间
        mLastFrameTimeNanos = Long.MIN_VALUE;
        // 4.记录每帧间隔: 1s / 屏幕刷新率
        mFrameIntervalNanos = (long)(1000000000 / getRefreshRate());


 // 5.初始化CallbackQueue，数组大小为 5。
        mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];
        for (int i = 0; i <= CALLBACK_LAST; i++) {
            mCallbackQueues[i] = new CallbackQueue();
        }
        // b/68769804: For low FPS experiments.
        setFPSDivisor(SystemProperties.getInt(ThreadedRenderer.DEBUG_FPS_DIVISOR, 1));
    }
}

上述方法主要处理如下：

1、通过new的方式创建FrameHandler对象。

2、通过new的方式创建FrameDisplayEventReceiver对象。

下面分别进行分析：

new FrameHandler

通过new的方式创建FrameHandler对象，Choreographer 的所有任务最终都会发送到该 Looper 所在的线程进行处理。

//frameworks/base/core/java/android/view/Choreographer.java
public final class Choreographer {
    private final class FrameHandler extends Handler {
        public FrameHandler(Looper looper) {
            super(looper);
        }


        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_DO_FRAME:
                    doFrame(System.nanoTime(), 0, new DisplayEventReceiver.VsyncEventData());
                    break;
                case MSG_DO_SCHEDULE_VSYNC:
                    doScheduleVsync();
                    break;
                case MSG_DO_SCHEDULE_CALLBACK:
                    doScheduleCallback(msg.arg1);
                    break;
            }
        }
    }
}

new FrameDisplayEventReceiver

通过new的方式创建FrameDisplayEventReceiver对象：

//frameworks/base/core/java/android/view/Choreographer.java
public final class Choreographer {
    private final class FrameDisplayEventReceiver extends DisplayEventReceiver
            implements Runnable {
        public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {
            super(looper, vsyncSource, 0);
        }
    }
}

调用父类DisplayEventReceiver的构造方法：

//frameworks/base/core/java/android/view/DisplayEventReceiver.java
public abstract class DisplayEventReceiver {
    public DisplayEventReceiver(Looper looper, int vsyncSource, int eventRegistration) {
        if (looper == null) {
            throw new IllegalArgumentException("looper must not be null");
        }


        mMessageQueue = looper.getQueue();
        mReceiverPtr = nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue,
                vsyncSource, eventRegistration);
    }
}

调用nativeInit方法，nativeInit是一个Native方法，在中android_view_DisplayEventReceiver.cpp实现：

//frameworks/base/core/jni/android_view_DisplayEventReceiver.cpp
static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, jobject messageQueueObj,
                        jint vsyncSource, jint eventRegistration) {
    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
    if (messageQueue == NULL) {
        jniThrowRuntimeException(env, "MessageQueue is not initialized.");
        return 0;
    }
    // 1.实例化NativeDisplayEventReceiver
    sp<NativeDisplayEventReceiver> receiver =
            new NativeDisplayEventReceiver(env, receiverWeak, messageQueue, vsyncSource,
                                           eventRegistration);
     // 2.initialize
    status_t status = receiver->initialize();
    if (status) {
        String8 message;
        message.appendFormat("Failed to initialize display event receiver.  status=%d", status);
        jniThrowRuntimeException(env, message.string());
        return 0;
    }


    receiver->incStrong(gDisplayEventReceiverClassInfo.clazz); // retain a reference for the object
    return reinterpret_cast<jlong>(receiver.get());
}

上面方法主要处理如下：

1、调用NativeDisplayEventReceiver方法，实例化NativeDisplayEventReceiver。

2、调用receiver(NativeDisplayEventReceiver)的initialize方法，进行初期化。

下面分别进行分析：

new NativeDisplayEventReceiver

通过new的方式创建NativeDisplayEventReceiver对象，NativeDisplayEventReceiver的构造方法如下：

//frameworks/base/core/jni/android_view_DisplayEventReceiver.cpp
NativeDisplayEventReceiver::NativeDisplayEventReceiver(JNIEnv* env, jobject receiverWeak,
                                                       const sp<MessageQueue>& messageQueue,
                                                       jint vsyncSource, jint eventRegistration)
      : DisplayEventDispatcher(messageQueue->getLooper(),
                               static_cast<ISurfaceComposer::VsyncSource>(vsyncSource),
                               static_cast<ISurfaceComposer::EventRegistration>(eventRegistration)),
        mReceiverWeakGlobal(env->NewGlobalRef(receiverWeak)),
        mMessageQueue(messageQueue) {
    ALOGV("receiver %p ~ Initializing display event receiver.", this);
}

NativeDisplayEventReceiver继承自父类DisplayEventDispatcher，DisplayEventDispatcher的构造方法如下：

//frameworks/native/libs/gui/DisplayEventDispatcher.cpp
class DisplayEventDispatcher : public LooperCallback {
DisplayEventDispatcher::DisplayEventDispatcher(
        const sp<Looper>& looper, ISurfaceComposer::VsyncSource vsyncSource,
        ISurfaceComposer::EventRegistrationFlags eventRegistration)
      : mLooper(looper), mReceiver(vsyncSource, eventRegistration), mWaitingForVsync(false),
        mLastVsyncCount(0), mLastScheduleVsyncTime(0) {
    ALOGV("dispatcher %p ~ Initializing display event dispatcher.", this);
}
}

DisplayEventDispatcher通过传递过来的参数实例化DisplayEventReceiver对象mReceiver，查看DisplayEventReceiver定义：

//frameworks/native/libs/gui/DisplayEventReceiver.cpp
sp<IDisplayEventConnection> mEventConnection;
class DisplayEventReceiver {
DisplayEventReceiver::DisplayEventReceiver(
        ISurfaceComposer::VsyncSource vsyncSource,
        ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    // 1.获取SurfaceFlinger对象
    sp<ISurfaceComposer> sf(ComposerService::getComposerService());
    if (sf != nullptr) {
        // 2.surfaceflinger创建新的连接
        mEventConnection = sf->createDisplayEventConnection(vsyncSource, eventRegistration);
        if (mEventConnection != nullptr) {
     // 3.实例化BitTube对象，BitTube实例使用socket本地通信
            mDataChannel = std::make_unique<gui::BitTube>();
     // 4.BitTube实例关联IDisplayEventConnection
            const auto status = mEventConnection->stealReceiveChannel(mDataChannel.get());
            if (!status.isOk()) {
                ALOGE("stealReceiveChannel failed: %s", status.toString8().c_str());
                mInitError = std::make_optional<status_t>(status.transactionError());
                mDataChannel.reset();
                mEventConnection.clear();
            }
        }
    }
}
}

DisplayEventReceiver构造方法中主要做了4件事：

1、通过ComposerService::getComposerService()获取SurfaceFlinger对象，getComposerService()方法在SurfaceComposerClient.cpp文件中实现，返回的对象是SurfaceFlinger。

2、sf->createDisplayEventConnection创建新的连接，通过EventThread实例化新的EventThreadConnection对象，EventThread负责发送VSYNC信号给DisplayEventReceiver，EventThreadConnection持有变量gui::BitTube mChannel作为发送信号通道。

3、实例化BitTube对象，BitTube类表示DisplayEventReceiver和SurfaceFlinger具体通信通道的实现，内部使用socket本地通信实现，socketpair()创建两个互相连接本地通信（AF_UNIX）的socket，分别赋值给发送端BitTube.mSendFd，接收端BitTube.mReceiveFd

4、mEventConnection->stealReceiveChannel将刚创建好的BitTube对象传递给EventThreadConnection，至此VSYNC信号接收通道就创建好了。

下面分别进行分析：

ComposerService getComposerService

调用ComposerService的getComposerService方法，返回ISurfaceComposer，ISurfaceComposer一个接口，它是SurfaceFlinger服务的客户端与服务器端通信的主要接口。

//frameworks/native/libs/gui/SurfaceComposerClient.cpp
sp<ISurfaceComposer> ComposerService::getComposerService() {
    ComposerService& instance = ComposerService::getInstance();
    Mutex::Autolock _l(instance.mLock);
    if (instance.mComposerService == nullptr) {
        if (ComposerService::getInstance().connectLocked()) {
            ALOGD("ComposerService reconnected");
            WindowInfosListenerReporter::getInstance()->reconnect(instance.mComposerService);
        }
    }
    return instance.mComposerService;
}

BpSurfaceComposer createDisplayEventConnection

调用sf(ISurfaceComposer)的createDisplayEventConnection创建新的连接：

//frameworks/native/libs/gui/ISurfaceComposer.cpp
class BpSurfaceComposer : public BpInterface<ISurfaceComposer>
    sp<IDisplayEventConnection> createDisplayEventConnection(
            VsyncSource vsyncSource, EventRegistrationFlags eventRegistration) override {
        Parcel data, reply;
        sp<IDisplayEventConnection> result;
        int err = data.writeInterfaceToken(
                ISurfaceComposer::getInterfaceDescriptor());
        if (err != NO_ERROR) {
            return result;
        }
        data.writeInt32(static_cast<int32_t>(vsyncSource));
        data.writeUint32(eventRegistration.get());
        err = remote()->transact(
                BnSurfaceComposer::CREATE_DISPLAY_EVENT_CONNECTION,
                data, &reply);
        if (err != NO_ERROR) {
            ALOGE("ISurfaceComposer::createDisplayEventConnection: error performing "
                    "transaction: %s (%d)", strerror(-err), -err);
            return result;
        }
        result = interface_cast<IDisplayEventConnection>(reply.readStrongBinder());
        return result;
    }
}

调用remote()->transact()发送远程消息CREATE_DISPLAY_EVENT_CONNECTION，消息在BnSurfaceComposer的onTransact方法中处理：

//frameworks/native/libs/gui/ISurfaceComposer.cpp
status_t BnSurfaceComposer::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    switch(code) {
        case CREATE_DISPLAY_EVENT_CONNECTION: {
            CHECK_INTERFACE(ISurfaceComposer, data, reply);
            auto vsyncSource = static_cast<ISurfaceComposer::VsyncSource>(data.readInt32());
            EventRegistrationFlags eventRegistration =
                    static_cast<EventRegistration>(data.readUint32());


            sp<IDisplayEventConnection> connection(
                    createDisplayEventConnection(vsyncSource, eventRegistration));
            reply->writeStrongBinder(IInterface::asBinder(connection));
            return NO_ERROR;
        }
    }
}

通过Binder实现跨进程调用，最终到SurfaceFlinger中：

//frameworks/native/service/surfaceflinger/SurfaeFlinger.cpp
sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
        ISurfaceComposer::VsyncSource vsyncSource,
        ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    const auto& handle =
            vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;


    return mScheduler->createDisplayEventConnection(handle, eventRegistration);
}

Scheduler createDisplayEventConnection

调用mScheduler(Scheduler)的createDisplayEventConnection方法：

//frameworks/native/services/surfaceflinger/Scheduler/Scheduler.cpp
sp<IDisplayEventConnection> Scheduler::createDisplayEventConnection(
        ConnectionHandle handle, ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    std::lock_guard<std::mutex> lock(mConnectionsLock);
    RETURN_IF_INVALID_HANDLE(handle, nullptr);
    return createConnectionInternal(mConnections[handle].thread.get(), eventRegistration);
}

调用createConnectionInternal方法：

//frameworks/native/services/surfaceflinger/Scheduler/Scheduler.cpp
sp<EventThreadConnection> Scheduler::createConnectionInternal(
        EventThread* eventThread, ISurfaceComposer::EventRegistrationFlags eventRegistration) {
    return eventThread->createEventConnection([&] { resync(); }, eventRegistration);
}

调用eventThread(EventThread)的createEventConnection方法：

//frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
sp<EventThreadConnection> EventThread::createEventConnection(
        ResyncCallback resyncCallback,
        ISurfaceComposer::EventRegistrationFlags eventRegistration) const {
    return new EventThreadConnection(const_cast<EventThread*>(this),
                                     IPCThreadState::self()->getCallingUid(),
                                     std::move(resyncCallback), eventRegistration);
}

通过new的方式创建EventThreadConnection对象，EventThreadConnection构造方法如下：

//frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
EventThreadConnection::EventThreadConnection(
        EventThread* eventThread, uid_t callingUid, ResyncCallback resyncCallback,
        ISurfaceComposer::EventRegistrationFlags eventRegistration)
      : resyncCallback(std::move(resyncCallback)),
        mOwnerUid(callingUid),
        mEventRegistration(eventRegistration),
        mEventThread(eventThread),
        mChannel(gui::BitTube::DefaultSize) {}

DisplayEventDispatcher initialize

调用receiver(NativeDisplayEventReceiver)的initialize方法，NativeDisplayEventReceiver的父类是DisplayEventDispatcher，调用DisplayEventDispatcher的initialize：

//frameworks/native/libs/gui/DisplayEventDispatcher.cpp
class DisplayEventDispatcher : public LooperCallback {
status_t DisplayEventDispatcher::initialize() {
    status_t result = mReceiver.initCheck();
    if (result) {
        ALOGW("Failed to initialize display event receiver, status=%d", result);
        return result;
    }


    if (mLooper != nullptr) {
        int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT, this, NULL);
        if (rc < 0) {
            return UNKNOWN_ERROR;
        }
    }


    return OK;
}
}

这个函数就比较简单了，调用Looper的addFd将我们前面得到的mReceiveFd添加到Handler进行监听，当mSendFd写入数据时就能收到消息，并回调DisplayEventDispatcher的handleEvent函数。