- 应用启动时对
DisplayEventReceiver的创建 - App向
SurfaceFlinger注册回调接口 - VSync信号到
SurfaceFlinger的传递 SurfaceFlinger分发事件到应用- Java层界面重绘
- Native层
Canvas提交绘制请求 - 应用
swapBuffer()交换窗口至SurfaceFlinger SurfaceFlinger合成窗口- 渲染引擎合成到
Composer
应用启动时对DisplayEventReceiver的创建
应用启动时通过ActivityThread.H接收Framewroks的消息, 其handleMessage()中:
// frameworks/base/core/java/android/app/ActivityThread.java
public final class ActivityThread extends ClientTransactionHandler
implements ActivityThreadInternal {
final H mH = new H();
... ...
class H extends Handler {
public static final int BIND_APPLICATION = 110;
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
... ...
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
... ...
break;
mTransactionExecutor的类型是TransactionExecutor, 因此:
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public class TransactionExecutor {
... ...
public void execute(ClientTransaction transaction) {
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
... ...
executeLifecycleState(transaction);
mPendingActions.clear();
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}
... ...
private void executeLifecycleState(ClientTransaction transaction) {
... ...
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
生命周期对象lifecycleItem的类型是ActivityTransactionItem, 因此:
// frameworks/base/core/java/android/app/servertransaction/ActivityTransactionItem.java
public abstract class ActivityTransactionItem extends ClientTransactionItem {
@Override
public final void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
final ActivityClientRecord r = getActivityClientRecord(client, token);
execute(client, r, pendingActions);
}
而此处的ActivityTransactionItem其实有子类的实现ResumeActivityItem, 因此:
// frameworks/base/core/java/android/app/servertransaction/ResumeActivityItem.java
public class ResumeActivityItem extends ActivityLifecycleItem {
... ...
@Override
public void execute(ClientTransactionHandler client, ActivityClientRecord r,
PendingTransactionActions pendingActions) {
client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
"RESUME_ACTIVITY");
}
此处的client类型为ClientTransactionHandler, 其实现又是上文的ActivityThread:
// frameworks/base/core/java/android/app/ActivityThread.java
@Override
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
boolean isForward, String reason) {
if (r.window == null && !a.mFinished && willBeVisible) {
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
wm.addView(decor, l);
... ...
wm的类型是WindowManagerImpl, decor的类型是DecorView, 因此:
// frameworks/base/core/java/android/view/WindowManagerImpl.java
public final class WindowManagerImpl implements WindowManager {
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyTokens(params);
mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
mContext.getUserId());
}
mGlobal的类型是WindowManagerGlobal, 是单例的, 因此:
// frameworks/base/core/java/android/view/WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow, int userId) {
... ...
synchronized (mLock) {
... ...
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
try {
root.setView(view, wparams, panelParentView, userId);
}
... ...
可以看出ViewRootImpl被创建, DecoView通过ViewRootImpl.setView()方法设置给ViewRootImpl, 对于ViewRootImpl, 其构造方法:
// frameworks/base/core/java/android/view/ViewRootImpl.java
public ViewRootImpl(Context context, Display display) {
this(context, display, WindowManagerGlobal.getWindowSession(),
false /* useSfChoreographer */);
}
... ...
public ViewRootImpl(@UiContext Context context, Display display, IWindowSession session,
boolean useSfChoreographer) {
... ...
mChoreographer = useSfChoreographer
? Choreographer.getSfInstance() : Choreographer.getInstance();
ViewRootImpl在初始化mChoreographer成员时, 第一次调用Choreographer.getSfInstance()对Choreographer类进行例化:
// frameworks/base/core/java/android/view/Choreographer.java
public static Choreographer getInstance() {
return sThreadInstance.get();
}
sThreadInstance的类型是ThreadLocal<Choreographer>其实现:
// libcore/ojluni/src/main/java/java/lang/ThreadLocal.java
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
显然ThreadLocal.getMap(t)返回空, 因为还没有Choreographer, 因此调用了setInitialValue()进而调用回Choreographer中的:
// frameworks/base/core/java/android/view/Choreographer.java
private static final ThreadLocal<Choreographer> sThreadInstance =
new ThreadLocal<Choreographer>() {
@Override
protected Choreographer initialValue() {
Looper looper = Looper.myLooper();
... ...
Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
... ...
return choreographer;
}
};
private Choreographer(Looper looper, int vsyncSource) {
mLooper = looper;
mHandler = new FrameHandler(looper);
mDisplayEventReceiver = USE_VSYNC
? new FrameDisplayEventReceiver(looper, vsyncSource)
: null;
... ...
}
... ...
private final class FrameDisplayEventReceiver extends DisplayEventReceiver
implements Runnable {
private boolean mHavePendingVsync;
private long mTimestampNanos;
private int mFrame;
private VsyncEventData mLastVsyncEventData = new VsyncEventData();
public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {
super(looper, vsyncSource, 0);
}
此刻Choreographer类开始构造, 初始化成员mDisplayEventReceiver, 其类型FrameDisplayEventReceiver, 构造FrameDisplayEventReceiver时构造其父类:
// frameworks/base/core/java/android/view/DisplayEventReceiver.java
private static native long nativeInit(WeakReference<DisplayEventReceiver> receiver,
MessageQueue messageQueue, int vsyncSource, int eventRegistration);
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()是Native方法, 其代码:
// frameworks/base/core/jni/android_view_DisplayEventReceiver.cpp
static const JNINativeMethod gMethods[] = {
/* name, signature, funcPtr */
{ "nativeInit",
"(Ljava/lang/ref/WeakReference;Landroid/os/MessageQueue;II)J",
(void*)nativeInit },
... ...
};
static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, jobject messageQueueObj,
jint vsyncSource, jint eventRegistration) {
sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
... ...
sp<NativeDisplayEventReceiver> receiver =
new NativeDisplayEventReceiver(env, receiverWeak, messageQueue, vsyncSource,
eventRegistration);
status_t status = receiver->initialize();
... ...
return reinterpret_cast<jlong>(receiver.get());
}
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的构造, 二来是NativeDisplayEventReceiver父类的DisplayEventDispatcher::initialize().
App向SurfaceFlinger注册回调接口
上文构造NativeDisplayEventReceiver的同时构造了DisplayEventDispatcher:
// frameworks/native/libs/gui/DisplayEventReceiver.cpp
DisplayEventReceiver::DisplayEventReceiver(
ISurfaceComposer::VsyncSource vsyncSource,
ISurfaceComposer::EventRegistrationFlags eventRegistration) {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
if (sf != nullptr) {
mEventConnection = sf->createDisplayEventConnection(vsyncSource, eventRegistration);
if (mEventConnection != nullptr) {
mDataChannel = std::make_unique<gui::BitTube>();
mEventConnection->stealReceiveChannel(mDataChannel.get());
}
}
}
通过Binder调用到SurfaceFlinger::createDisplayEventConnection():
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
ISurfaceComposer::VsyncSource vsyncSource,
ISurfaceComposer::EventRegistrationFlags eventRegistration) {
... ...
return mScheduler->createDisplayEventConnection(handle, eventRegistration);
}
显然mScheduler是Scheduler, 进一步调用``
// frameworks/native/services/surfaceflinger/Scheduler/Scheduler.cpp
sp<IDisplayEventConnection> Scheduler::createDisplayEventConnection(
ConnectionHandle handle, ISurfaceComposer::EventRegistrationFlags eventRegistration) {
... ...
return createConnectionInternal(mConnections[handle].thread.get(), eventRegistration);
}
sp<EventThreadConnection> Scheduler::createConnectionInternal(
EventThread* eventThread, ISurfaceComposer::EventRegistrationFlags eventRegistration) {
return eventThread->createEventConnection([&] { resync(); }, eventRegistration);
}
显然, 继续调用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);
}
SurfaceFlinger创建EventThreadConnection并作为IDisplayEventConnection返回给应用, 然后回到函数DisplayEventReceiver::DisplayEventReceiver():
// frameworks/native/libs/gui/DisplayEventReceiver.cpp
DisplayEventReceiver::DisplayEventReceiver(
ISurfaceComposer::VsyncSource vsyncSource,
ISurfaceComposer::EventRegistrationFlags eventRegistration) {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
if (sf != nullptr) {
mEventConnection = sf->createDisplayEventConnection(vsyncSource, eventRegistration);
if (mEventConnection != nullptr) {
mDataChannel = std::make_unique<gui::BitTube>();
mEventConnection->stealReceiveChannel(mDataChannel.get());
}
}
}
应用拿到IDisplayEventConnection并再次通过Binder调用到SurfaceFlinger中的EventThreadConnection::stealReceiveChannel():
// frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
status_t EventThreadConnection::stealReceiveChannel(gui::BitTube* outChannel) {
outChannel->setReceiveFd(mChannel.moveReceiveFd());
outChannel->setSendFd(base::unique_fd(dup(mChannel.getSendFd())));
return NO_ERROR;
}
至此, 应用和SurfaceFlinger之间已经通过BitTube建立了连接, 也就是说后续SurfaceFlinger有事件, 应用都会通过DisplayEventReceiver来进行接收. 但是此时应用的BitTube中的mFD还未被应用监听, 回到上文的DisplayEventDispatcher::initialize()方法:
// frameworks/native/libs/gui/DisplayEventDispatcher.cpp
status_t DisplayEventDispatcher::initialize() {
status_t result = mReceiver.initCheck();
... ...
if (mLooper != nullptr) {
int rc = mLooper->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT, this, NULL);
... ...
自此应用都会通过DisplayEventReceiver对DisplayEventReceiver::Event时间进行接收.
VSync信号到SurfaceFlinger的传递
ComposerCallbackBridge由SurfaceFlinger创建并持有, 该类继承IComposerCallback接口, 先看一下该类的注册:
// frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp
void HWComposer::setCallback(HWC2::ComposerCallback* callback) {
... ...
mComposer->registerCallback(
sp<ComposerCallbackBridge>::make(callback, mComposer->isVsyncPeriodSwitchSupported()));
}
mComposer的实现是Composer,所以:
// frameworks/native/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
void Composer::registerCallback(const sp<IComposerCallback>& callback)
{
android::hardware::setMinSchedulerPolicy(callback, SCHED_FIFO, 2);
auto ret = [&]() {
if (mClient_2_4) {
return mClient_2_4->registerCallback_2_4(callback);
}
return mClient->registerCallback(callback);
}();
... ...
}
那最后就是IComposerClient::registerCallback_2_4()了. 所以Composer负责通过IComposerCallback接口调用ComposerCallbackBridge通知SurfaceFlinger由VSYNC事件. 对应的ComposerCallbackBridge::onVsync()被调用:
// frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp
Return<void> onVsync_2_4(hal::HWDisplayId display, int64_t timestamp,
hal::VsyncPeriodNanos vsyncPeriodNanos) override {
if (mVsyncSwitchingSupported) {
mCallback->onComposerHalVsync(display, timestamp, vsyncPeriodNanos);
} else {
ALOGW("Unexpected onVsync_2_4 callback on composer <= 2.3, ignoring.");
}
return Void();
}
这里的mCallback类型为HW2::ComposerCallback, 实际上是SurfaceFlinger, 因为SurfaceFlinger的定义:
// frameworks/native/services/surfaceflinger/SurfaceFlinger.h
class SurfaceFlinger : public BnSurfaceComposer,
public PriorityDumper,
private IBinder::DeathRecipient,
private HWC2::ComposerCallback,
private ISchedulerCallback {
public:
...
所以调用到SurfaceFlinger::onComposerHalVsync():
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::onComposerHalVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp,
std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
... ...
mScheduler->addResyncSample(timestamp, vsyncPeriod, &periodFlushed);
if (periodFlushed) {
modulateVsync(&VsyncModulator::onRefreshRateChangeCompleted);
}
}
mScheduler的类型是Scheduler, 所以调用Scheduler::addResyncSample():
// frameworks/native/services/surfaceflinger/Scheduler/Scheduler.cpp
void Scheduler::addResyncSample(nsecs_t timestamp, std::optional<nsecs_t> hwcVsyncPeriod,
bool* periodFlushed) {
bool needsHwVsync = false;
*periodFlushed = false;
{ // Scope for the lock
std::lock_guard<std::mutex> lock(mHWVsyncLock);
if (mPrimaryHWVsyncEnabled) {
needsHwVsync = mVsyncSchedule.controller->addHwVsyncTimestamp(timestamp, hwcVsyncPeriod,
periodFlushed);
}
}
... ...
}
Scheduer会通过TimerKeeper进一步调用到VSyncDispatch::timerCallback(), VSyncDispatch的实现是VSyncDispatchTimerQueue, 因此最终调用到VSyncDispatchTimerQueue::timerCallback():
// frameworks/native/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp
void VSyncDispatchTimerQueue::timerCallback() {
... ...
for (auto const& invocation : invocations) {
invocation.callback->callback(invocation.vsyncTimestamp, invocation.wakeupTimestamp,
invocation.deadlineTimestamp);
}
}
invocation.callback其实还是从mCallbacks中统计过来的, mCallbacks的类型是CallbackRepeater, 因此调用到CallbackRepeater::callback:
// frameworks/native/services/surfaceflinger/Scheduler/DispSyncSource.cpp
void callback(nsecs_t vsyncTime, nsecs_t wakeupTime, nsecs_t readyTime) {
... ...
mCallback(vsyncTime, wakeupTime, readyTime);
... ..
}
mCallback为创建DispSyncSource时通过std::bind()设置的std::function, 其绑定的方法为DispSyncSource::onVsyncCallback():
// frameworks/native/services/surfaceflinger/Scheduler/DispSyncSource.cpp
void DispSyncSource::onVsyncCallback(nsecs_t vsyncTime, nsecs_t targetWakeupTime,
nsecs_t readyTime) {
... ...
if (callback != nullptr) {
callback->onVSyncEvent(targetWakeupTime, vsyncTime, readyTime);
}
}
callback就是mCallback类型为VSyncSource::Callback, 其实现是EventThread, 因此回调到EventThread::onVsyncEvent():
// frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
mCondition.notify_all();
}
void EventThread::onVSyncEvent(nsecs_t timestamp, nsecs_t expectedVSyncTimestamp,
nsecs_t deadlineTimestamp) {
... ...
mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,
expectedVSyncTimestamp, deadlineTimestamp, vsyncId));
mCondition.notify_all();
}
mPendingEvents记录了通过makeVSync生成的Event事件, 该事件在通过std::condition_variable通知到EventThread::threadMain():
// frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
void EventThread::threadMain(std::unique_lock<std::mutex>& lock) {
... ...
... ...
if (!consumers.empty()) {
dispatchEvent(*event, consumers);
consumers.clear();
}
... ...
... ...
}
void EventThread::dispatchEvent(const DisplayEventReceiver::Event& event,
const DisplayEventConsumers& consumers) {
for (const auto& consumer : consumers) {
... ...
switch (consumer->postEvent(copy)) {
... ...
}
}
}
consumers实际上是从mDisplayEventConnections成员中统计的事件接收方, 调用到EventThreadConnection::postEvent():
// frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
status_t EventThreadConnection::postEvent(const DisplayEventReceiver::Event& event) {
... ...
auto size = DisplayEventReceiver::sendEvents(&mChannel, &event, 1);
return toStatus(size);
}
// frameworks/native/libs/gui/DisplayEventReceiver.cpp
ssize_t DisplayEventReceiver::sendEvents(gui::BitTube* dataChannel,
Event const* events, size_t count)
{
return gui::BitTube::sendObjects(dataChannel, events, count);
}
上文我们说过, 应用会通过BitTube接受来自SurfaceFlinger的通知, 揪下来再看应用一侧的处理.
SurfaceFlinger分发事件到应用
应用对事件的监听是从Looper开始的:
// /system/core/libutils/Looper.cpp
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
int result = 0;
for (;;) {
... ...
result = pollInner(timeoutMillis);
}
}
int Looper::pollInner(int timeoutMillis) {
... ...
// Invoke all response callbacks.
for (size_t i = 0; i < mResponses.size(); i++) {
Response& response = mResponses.editItemAt(i);
if (response.request.ident == POLL_CALLBACK) {
int fd = response.request.fd;
... ...
int callbackResult = response.request.callback->handleEvent(fd, events, data);
... ...
}
... ...
}
... ...
}
此处的callback是DisplayEventDispatcher, 所以此时调用的是DisplayEventDispatcher::handleEvent():
// frameworks/native/libs/gui/DisplayEventDispatcher.cpp
int DisplayEventDispatcher::handleEvent(int, int events, void*) {
if (processPendingEvents(&vsyncTimestamp, &vsyncDisplayId, &vsyncCount, &vsyncEventData)) {
... ...
dispatchVsync(vsyncTimestamp, vsyncDisplayId, vsyncCount, vsyncEventData);
}
return 1; // keep the callback
}
此时DisplayEventDispatcher其实是NativeDisplayEventReceiver的子类, 因此直接看NativeDisplayEventReceiver:
// frameworks/base/core/jni/android_view_DisplayEventReceiver.cpp
void NativeDisplayEventReceiver::dispatchVsync(nsecs_t timestamp, PhysicalDisplayId displayId,
uint32_t count, VsyncEventData vsyncEventData) {
JNIEnv* env = AndroidRuntime::getJNIEnv();
ScopedLocalRef<jobject> receiverObj(env, jniGetReferent(env, mReceiverWeakGlobal));
if (receiverObj.get()) {
ALOGV("receiver %p ~ Invoking vsync handler.", this);
env->CallVoidMethod(receiverObj.get(), gDisplayEventReceiverClassInfo.dispatchVsync,
timestamp, displayId.value, count, vsyncEventData.id,
vsyncEventData.deadlineTimestamp, vsyncEventData.frameInterval);
ALOGV("receiver %p ~ Returned from vsync handler.", this);
}
mMessageQueue->raiseAndClearException(env, "dispatchVsync");
}
CallVoidMethod()通过JNI调用的是DisplayEventReceiver.dispatchVsync():
// frameworks/base/core/java/android/view/DisplayEventReceiver.java
// Called from native code.
@SuppressWarnings("unused")
private void dispatchVsync(long timestampNanos, long physicalDisplayId, int frame,
long frameTimelineVsyncId, long frameDeadline, long frameInterval) {
onVsync(timestampNanos, physicalDisplayId, frame,
new VsyncEventData(frameTimelineVsyncId, frameDeadline, frameInterval));
}
此时的DisplayEventReceiver其实是FrameDisplayEventReceiver, 所以调用的其实是FrameDisplayEventReceiver.onVsync():
// frameworks/base/core/java/android/view/Choreographer.java
private final class FrameDisplayEventReceiver extends DisplayEventReceiver implements Runnable {
@Override
public void onVsync(long timestampNanos, long physicalDisplayId, int frame,
VsyncEventData vsyncEventData) {
try {
... ...
Message msg = Message.obtain(mHandler, this);
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
... ...
... ...
此处的mHandler类型是FrameHandler, 特别的Message的what未设置, 其值为MSG_DO_FRAME, 这是需要特别注意的, 因此其FrameHandler.handleMessage()会被调用:
// frameworks/base/core/java/android/view/Choreographer.java
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;
// 此场景下该位置的消息类型不是 MSG_DO_SCHEDULE_VSYNC
case MSG_DO_SCHEDULE_VSYNC:
... ...
... ...
}
}
}
void doFrame(long frameTimeNanos, int frame,
DisplayEventReceiver.VsyncEventData vsyncEventData) {
try {
synchronized (mLock) {
... ...
doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos, frameIntervalNanos);
... ...
}
... ...
}
... ...
}
void doCallbacks(int callbackType, long frameTimeNanos, long frameIntervalNanos) {
CallbackRecord callbacks;
synchronized (mLock) {
callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
now / TimeUtils.NANOS_PER_MS);
... ...
}
try {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
for (CallbackRecord c = callbacks; c != null; c = c.next) {
... ...
c.run(frameTimeNanos);
}
} ... ...
}
Java层界面重绘
上文mCallbackQueues中存储的是应用中所有等待更新的层的回调, 类型是TraversalRunnable, 该类是在ViewRootImpl.scheduleTraversals()时通过Choreographer.postCallback()注册过来的, 其实现是:
// frameworks/base/core/java/android/view/ViewRootImpl.java
public final class ViewRootImpl implements ViewParent,
View.AttachInfo.Callbacks, ThreadedRenderer.DrawCallbacks,
AttachedSurfaceControl {
... ...
final class TraversalRunnable implements Runnable {
@Override
public void run() {
doTraversal();
}
}
final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
void doTraversal() {
if (mTraversalScheduled) {
... ...
performTraversals();
... ...
}
}
private void performTraversals() {
... ...
if (!cancelDraw) {
... ...
performDraw();
}
... ...
}
private void performDraw() {
... ...
try {
boolean canUseAsync = draw(fullRedrawNeeded);
... ...
}
... ...
}
private boolean draw(boolean fullRedrawNeeded) {
Surface surface = mSurface;
if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty || mNextDrawUseBlastSync) {
if (isHardwareEnabled()) {
mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
}
... ...
}
... ...
}
... ...
}
mAttachInfo.mThreadRender的类型显然是ThreadedRenderer, 此时应用开始渲染界面.
DecorView重绘
// frameworks/base/core/java/android/view/ThreadedRenderer.java
public final class ThreadedRenderer extends HardwareRenderer {
void draw(View view, AttachInfo attachInfo, DrawCallbacks callbacks) {
attachInfo.mViewRootImpl.mViewFrameInfo.markDrawStart();
updateRootDisplayList(view, callbacks)
... ...
int syncResult = syncAndDrawFrame(frameInfo);
... ...
}
ThreadedRenderer.updateRootDisplayList()
对于updateRootDisplayList()方法:
// frameworks/base/core/java/android/view/ThreadedRenderer.java
private void updateRootDisplayList(View view, DrawCallbacks callbacks) {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Record View#draw()");
updateViewTreeDisplayList(view);
... ...
}
private void updateViewTreeDisplayList(View view) {
view.mPrivateFlags |= View.PFLAG_DRAWN;
view.mRecreateDisplayList = (view.mPrivateFlags & View.PFLAG_INVALIDATED)
== View.PFLAG_INVALIDATED;
view.mPrivateFlags &= ~View.PFLAG_INVALIDATED;
view.updateDisplayListIfDirty();
view.mRecreateDisplayList = false;
}
对于view, 在窗口中, 其实现是:DecorView, 但此处调用的还是View.updateDisplayListIfDirty:
// frameworks/base/core/java/android/view/View.java
public RenderNode updateDisplayListIfDirty() {
final RenderNode renderNode = mRenderNode;
... ...
if ((mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == 0
|| !renderNode.hasDisplayList()
|| (mRecreateDisplayList)) {
... ...
try {
if (layerType == LAYER_TYPE_SOFTWARE) {
... ...
} else {
... ...
if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
... ...
} else {
draw(canvas);
}
}
}
此时调用父类的方法, 即DecorView.draw():
// frameworks/base/core/java/com/android/internal/policy/DecorView.java
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
if (mMenuBackground != null) {
mMenuBackground.draw(canvas);
}
}
又调回父类的View.draw()方法, 对DecorView进行绘制:
// frameworks/base/core/java/android/view/View.java
@CallSuper
public void draw(Canvas canvas) {
... ...
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
... ...
DecorView子对象重绘
可以看到绘制DecorView时, 会绘制其子控, 这里先说下继承关系:View -> ViewGroup -> FrameLayout -> DecorView, 那么此处调用的其实是ViewGroup.dispatchDraw()
``件:
// frameworks/base/core/java/android/view/ViewGroup.java
@Override
protected void dispatchDraw(Canvas canvas) {
final int childrenCount = mChildrenCount;
final View[] children = mChildren;
int flags = mGroupFlags;
... ...
for (int i = 0; i < childrenCount; i++) {
... ...
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
while (transientIndex >= 0) {
... ...
if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
transientChild.getAnimation() != null) {
more |= drawChild(canvas, transientChild, drawingTime);
}
... ...
}
if (preorderedList != null) preorderedList.clear();
// Draw any disappearing views that have animations
if (mDisappearingChildren != null) {
... ...
for (int i = disappearingCount; i >= 0; i--) {
final View child = disappearingChildren.get(i);
more |= drawChild(canvas, child, drawingTime);
}
}
... ...
}
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
return child.draw(canvas, this, drawingTime);
}
此处ViewGroup.drawChild()将调用第一个子View的: View.draw() -> View.drawBackground()方法绘制背景:
// frameworks/base/core/java/android/view/View.java
@CallSuper
public void draw(Canvas canvas) {
final int privateFlags = mPrivateFlags;
mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
int saveCount;
drawBackground(canvas);
... ...
}
@UnsupportedAppUsage
private void drawBackground(Canvas canvas) {
... ...
if (canvas.isHardwareAccelerated() && mAttachInfo != null
&& mAttachInfo.mThreadedRenderer != null) {
mBackgroundRenderNode = getDrawableRenderNode(background, mBackgroundRenderNode);
... ...
}
... ...
}
注意, 这里View.draw()中的drawBackground()方法, 应用是不能自己调用的, 继续查看getDrawableRenderNode()方法:
// frameworks/base/core/java/android/view/View.java
private RenderNode getDrawableRenderNode(Drawable drawable, RenderNode renderNode) {
... ...
try {
drawable.draw(canvas);
} finally {
renderNode.endRecording();
}
... ...
}
ColorDrawable重绘子View背景
此时renderNode的类型为:ColorDrawable, 因此调用ColorDrawable.draw():
// frameworks/base/graphics/java/android/graphics/drawable/ColorDrawable.java
@Override
public void draw(Canvas canvas) {
final ColorFilter colorFilter = mPaint.getColorFilter();
if ((mColorState.mUseColor >>> 24) != 0 || colorFilter != null
|| mBlendModeColorFilter != null) {
if (colorFilter == null) {
mPaint.setColorFilter(mBlendModeColorFilter);
}
mPaint.setColor(mColorState.mUseColor);
canvas.drawRect(getBounds(), mPaint);
// Restore original color filter.
mPaint.setColorFilter(colorFilter);
}
}
此时的canvas为类型Canvas因此查看Canvas.drawRect()的实现:
// frameworks/base/graphics/java/android/graphics/Canvas.java
public class Canvas extends BaseCanvas {
... ...
public void drawRect(float left, float top, float right, float bottom, @NonNull Paint paint) {
super.drawRect(left, top, right, bottom, paint);
}
到父类:
// frameworks/base/graphics/java/android/graphics/BaseCanvas.java
public abstract class BaseCanvas {
... ...
public void drawRect(float left, float top, float right, float bottom, @NonNull Paint paint) {
throwIfHasHwBitmapInSwMode(paint);
nDrawRect(mNativeCanvasWrapper, left, top, right, bottom, paint.getNativeInstance());
}
Native层Canvas提交绘制请求
nDrawRect在Native层的实现 是CanvasJNI::drawRect:
// frameworks/base/libs/hwui/jni/android_graphics_Canvas.cpp
static void drawRect(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
jfloat right, jfloat bottom, jlong paintHandle) {
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
get_canvas(canvasHandle)->drawRect(left, top, right, bottom, *paint);
}
get_canvas()返回的其实是SkiaCanvas类型, 因此继续调用SkiaCanvas::drawRect():
// frameworks/base/libs/hwui/SkiaCanvas.cpp
void SkiaCanvas::drawRect(float left, float top, float right, float bottom, const Paint& paint) {
if (CC_UNLIKELY(paint.nothingToDraw())) return;
applyLooper(&paint, [&](const SkPaint& p) {
mCanvas->drawRect({left, top, right, bottom}, p);
});
}
// frameworks/base/libs/hwui/SkiaCanvas.h
template <typename Proc>
void applyLooper(const Paint* paint, Proc proc, void (*preFilter)(SkPaint&) = nullptr) {
... ...
this->onFilterPaint(skp);
if (looper) {
... ...
} else {
proc(skp);
}
}
直接调用mCanvas->drawRect(), 注意, 此处虽然mCanvas的类型是SkCanvas, 但其还有子类RecordingCanvas因此此处调用的是RecordingCanvas::drawRect():
// frameworks/base/libs/hwui/RecordingCanvas.cpp
void RecordingCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
fDL->drawRect(rect, paint);
}
fDL的类型是DisplayListData, 因此此处调用:DisplayListData::drawRect():
// frameworks/base/libs/hwui/RecordingCanvas.cpp
void DisplayListData::drawRect(const SkRect& rect, const SkPaint& paint) {
this->push<DrawRect>(0, rect, paint);
}
template <typename T, typename... Args>
void* DisplayListData::push(size_t pod, Args&&... args) {
size_t skip = SkAlignPtr(sizeof(T) + pod);
SkASSERT(skip < (1 << 24));
if (fUsed + skip > fReserved) {
static_assert(SkIsPow2(SKLITEDL_PAGE), "This math needs updating for non-pow2.");
// Next greater multiple of SKLITEDL_PAGE.
fReserved = (fUsed + skip + SKLITEDL_PAGE) & ~(SKLITEDL_PAGE - 1);
fBytes.realloc(fReserved);
LOG_ALWAYS_FATAL_IF(fBytes.get() == nullptr, "realloc(%zd) failed", fReserved);
}
SkASSERT(fUsed + skip <= fReserved);
auto op = (T*)(fBytes.get() + fUsed);
fUsed += skip;
new (op) T{std::forward<Args>(args)...};
op->type = (uint32_t)T::kType;
op->skip = skip;
return op + 1;
}
此处的this->push<DrawRect>()直接插入了一条回调到fBytes中, 这些记录将在DisplayListData::map()执行时被调用.
Java层ThreadedRenderer.syncAndDrawFrame()执行绘制操作
继续调用基类HardwareRenderer的syncAndDrawFrame方法:
// frameworks/base/graphics/java/android/graphics/HardwareRenderer.java
public class HardwareRenderer {
@SyncAndDrawResult
public int syncAndDrawFrame(@NonNull FrameInfo frameInfo) {
return nSyncAndDrawFrame(mNativeProxy, frameInfo.frameInfo, frameInfo.frameInfo.length);
}
... ...
}
nSyncAndDrawFrame()是个native方法:
// frameworks/base/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
static int android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
jlong proxyPtr, jlongArray frameInfo, jint frameInfoSize) {
... ...
RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
env->GetLongArrayRegion(frameInfo, 0, frameInfoSize, proxy->frameInfo());
return proxy->syncAndDrawFrame();
}
// frameworks/base/libs/hwui/renderthread/RenderProxy.cpp
int RenderProxy::syncAndDrawFrame() {
return mDrawFrameTask.drawFrame();
}
// frameworks/base/libs/hwui/renderthread/DrawFrameTask.cpp
int DrawFrameTask::drawFrame() {
... ...
postAndWait();
return mSyncResult;
}
void DrawFrameTask::postAndWait() {
AutoMutex _lock(mLock);
mRenderThread->queue().post([this]() { run(); });
mSignal.wait(mLock);
}
DrawFrameTask::postAndWait()负责提交绘图请求, 并触发RenderThread执行渲染, 因此DrawFrameTask::run()会调度到:
// frameworks/base/libs/hwui/renderthread/DrawFrameTask.cpp
void DrawFrameTask::run() {
... ...
if (CC_LIKELY(canDrawThisFrame)) {
dequeueBufferDuration = context->draw();
}
... ...
}
context的类型是CanvasContext, 因此调用CanvasContext::draw():
// frameworks/base/libs/hwui/renderthread/CanvasContext.cpp
nsecs_t CanvasContext::draw() {
... ...
Frame frame = mRenderPipeline->getFrame();
SkRect windowDirty = computeDirtyRect(frame, &dirty);
bool drew = mRenderPipeline->draw(frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue,
mContentDrawBounds, mOpaque, mLightInfo, mRenderNodes,
&(profiler()));
... ...
bool didSwap =
mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo, &requireSwap);
... ...
}
mRenderPipeline的类型是SkiaOpenGLPipeline, 注意它的基类是SkiaPipeline, 先看SkiaOpenGLPipeline::draw();
在SkiaOpenGLPipeline::draw()时:
// frameworks/base/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
bool opaque, const LightInfo& lightInfo,
const std::vector<sp<RenderNode>>& renderNodes,
FrameInfoVisualizer* profiler) {
... ...
renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, contentDrawBounds, surface,
SkMatrix::I());
... ...
{
ATRACE_NAME("flush commands");
surface->flushAndSubmit();
}
... ...
}
Native层Skia对SkiaPipeline::renderFrame()对界面执行渲染
在SkiaPipeline::renderFrame()中:
这里的renderFrame(), 其属于父类, 因此::
// frameworks/base/libs/hwui/pipeline/skia/SkiaPipeline.cpp
void SkiaPipeline::renderFrame(const LayerUpdateQueue& layers, const SkRect& clip,
const std::vector<sp<RenderNode>>& nodes, bool opaque,
const Rect& contentDrawBounds, sk_sp<SkSurface> surface,
const SkMatrix& preTransform) {
... ...
renderFrameImpl(clip, nodes, opaque, contentDrawBounds, canvas, preTransform);
void SkiaPipeline::renderFrameImpl(const SkRect& clip,
const std::vector<sp<RenderNode>>& nodes, bool opaque,
const Rect& contentDrawBounds, SkCanvas* canvas,
const SkMatrix& preTransform) {
... ...
if (1 == nodes.size()) {
if (!nodes[0]->nothingToDraw()) {
RenderNodeDrawable root(nodes[0].get(), canvas);
root.draw(canvas);
}
} else if (0 == nodes.size()) {
// nothing to draw
} else {
... ...
RenderNodeDrawable contentNode(nodes[1].get(), canvas);
if (!backdrop.isEmpty()) {
... ...
contentNode.draw(canvas);
} else {
SkAutoCanvasRestore acr(canvas, true);
contentNode.draw(canvas);
}
... ...
这里分两种情况, 就是nodes.size()为1或者为其它(0不做任何操作), 我们先关注contentNode.draw(canvas), 其中 contentNode是RenderNodeDrawable, 其draw()方法是父类的, 调用是会调回RenderNodeDrawable::onDraw():
// frameworks/base/libs/hwui/pipeline/skia/RenderNodeDrawable.cpp
void RenderNodeDrawable::onDraw(SkCanvas* canvas) {
... ...
if ((!mInReorderingSection) || MathUtils::isZero(mRenderNode->properties().getZ())) {
this->forceDraw(canvas);
}
}
void RenderNodeDrawable::forceDraw(SkCanvas* canvas) const {
RenderNode* renderNode = mRenderNode.get();
... ...
if (!properties.getProjectBackwards()) {
drawContent(canvas);
... ...
void RenderNodeDrawable::drawContent(SkCanvas* canvas) const {
RenderNode* renderNode = mRenderNode.get();
... ...
if (!quickRejected) {
SkiaDisplayList* displayList = renderNode->getDisplayList().asSkiaDl();
const LayerProperties& layerProperties = properties.layerProperties();
// composing a hardware layer
if (renderNode->getLayerSurface() && mComposeLayer) {
...
} else {
if (alphaMultiplier < 1.0f) {
// Non-layer draw for a view with getHasOverlappingRendering=false, will apply
// the alpha to the paint of each nested draw.
AlphaFilterCanvas alphaCanvas(canvas, alphaMultiplier);
displayList->draw(&alphaCanvas);
} else {
displayList->draw(canvas);
}
}
}
关注displayList->draw(canvas)的调用, 对应的是SkiaDisplayList::draw():
// frameworks/base/libs/hwui/pipeline/skia/SkiaDisplayList.h
class SkiaDisplayList {
public:
void draw(SkCanvas* canvas) { mDisplayList.draw(canvas); }
mDisplayList的类型为DisplayListData, 因此调用DisplayListData::draw():
// frameworks/base/libs/hwui/RecordingCanvas.cpp
void DisplayListData::draw(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, false);
this->map(draw_fns, canvas, canvas->getTotalMatrix());
}
template <typename Fn, typename... Args>
inline void DisplayListData::map(const Fn fns[], Args... args) const {
auto end = fBytes.get() + fUsed;
for (const uint8_t* ptr = fBytes.get(); ptr < end;) {
auto op = (const Op*)ptr;
auto type = op->type;
auto skip = op->skip;
if (auto fn = fns[type]) { // We replace no-op functions with nullptrs
fn(op, args...); // to avoid the overhead of a pointless call.
}
ptr += skip;
}
}
查看draw_fns的定义:
// All ops implement draw().
#define X(T) \
[](const void* op, SkCanvas* c, const SkMatrix& original) { \
((const T*)op)->draw(c, original); \
},
static const draw_fn draw_fns[] = {
#include "DisplayListOps.in"
};
#undef X
而在DisplayListOps.in中:
X(Flush)
X(Save)
X(Restore)
X(SaveLayer)
X(SaveBehind)
X(Concat)
X(SetMatrix)
X(Scale)
X(Translate)
X(ClipPath)
X(ClipRect)
X(ClipRRect)
X(ClipRegion)
X(DrawPaint)
X(DrawBehind)
X(DrawPath)
X(DrawRect)
X(DrawRegion)
X(DrawOval)
X(DrawArc)
X(DrawRRect)
X(DrawDRRect)
X(DrawAnnotation)
X(DrawDrawable)
X(DrawPicture)
X(DrawImage)
X(DrawImageRect)
X(DrawImageLattice)
X(DrawTextBlob)
X(DrawPatch)
X(DrawPoints)
X(DrawVertices)
X(DrawAtlas)
X(DrawShadowRec)
X(DrawVectorDrawable)
X(DrawRippleDrawable)
X(DrawWebView)
回顾上文的DisplayListData::drawRect():
// frameworks/base/libs/hwui/RecordingCanvas.cpp
void DisplayListData::drawRect(const SkRect& rect, const SkPaint& paint) {
this->push(0, rect, paint);
}
可以看到, 这里采用的是X(DrawRect), 因此, 调用的方法为:DrawRect::draw():
// frameworks/base/libs/hwui/RecordingCanvas.cpp
struct DrawRect final : Op {
... ...
void draw(SkCanvas* c, const SkMatrix&) const { c->drawRect(rect, paint); }
};
调用到上文的SkCanvas::drawRect():
// external/skia/src/core/SkCanvas.cpp
void SkCanvas::drawRect(const SkRect& r, const SkPaint& paint) {
TRACE_EVENT0("skia", TRACE_FUNC);
// To avoid redundant logic in our culling code and various backends, we always sort rects
// before passing them along.
this->onDrawRect(r.makeSorted(), paint);
}
void SkCanvas::onDrawRect(const SkRect& r, const SkPaint& paint) {
... ...
this->topDevice()->drawRect(r, layer.paint());
}
this->topDevice()得到的是SkGpuDevice, 因此此时调用的是SkGpuDevice::drawRect():
// external/skia/src/gpu/SkGpuDevice.cpp
void SkGpuDevice::drawRect(const SkRect& rect, const SkPaint& paint) {
... ...
fSurfaceDrawContext->drawRect(this->clip(), std::move(grPaint),
fSurfaceDrawContext->chooseAA(paint), this->localToDevice(), rect,
&style);
}
fSurfaceDrawContext的类型是GrSurfaceDrawContext, 故GrSurfaceDrawContext::drawRect()
void GrSurfaceDrawContext::drawRect(const GrClip* clip,
GrPaint&& paint,
GrAA aa,
const SkMatrix& viewMatrix,
const SkRect& rect,
const GrStyle* style) {
... ...
const SkStrokeRec& stroke = style->strokeRec();
if (stroke.getStyle() == SkStrokeRec::kFill_Style) {
... ...
} else if ((stroke.getStyle() == SkStrokeRec::kStroke_Style ||
stroke.getStyle() == SkStrokeRec::kHairline_Style) &&
(rect.width() && rect.height())) {
... ...
GrOp::Owner op = GrStrokeRectOp::Make(
fContext, std::move(paint), aaType, viewMatrix, rect, stroke);
if (op) {
this->addDrawOp(clip, std::move(op));
return;
}
}
... ...
}
void GrSurfaceDrawContext::addDrawOp(const GrClip* clip,
GrOp::Owner op,
const std::function<WillAddOpFn>& willAddFn) {
... ...
auto opsTask = this->getOpsTask();
opsTask->addDrawOp(this->drawingManager(), std::move(op), fixedFunctionFlags, analysis,
std::move(appliedClip), dstProxyView,
GrTextureResolveManager(this->drawingManager()), *this->caps());
}
this->getOpsTask()得到的就是GrOpsTask, 因此:
// external/skia/src/gpu/GrOpsTask.cpp
void GrOpsTask::addDrawOp(GrDrawingManager* drawingMgr, GrOp::Owner op,
GrDrawOp::FixedFunctionFlags fixedFunctionFlags,
const GrProcessorSet::Analysis& processorAnalysis, GrAppliedClip&& clip,
const DstProxyView& dstProxyView,
GrTextureResolveManager textureResolveManager, const GrCaps& caps) {
... ...
this->recordOp(std::move(op), processorAnalysis, clip.doesClip() ? &clip : nullptr,
&dstProxyView, caps);
}
void GrOpsTask::recordOp(
GrOp::Owner op, GrProcessorSet::Analysis processorAnalysis, GrAppliedClip* clip,
const DstProxyView* dstProxyView, const GrCaps& caps) {
... ...
fOpChains.emplace_back(std::move(op), processorAnalysis, clip, dstProxyView);
}
fOpChains记录了所有应该绘制的操作, 这些操作会在GrOpsTask::execute()时执行, 相应的操作流程将在本文后续内容介绍.
SkSurface::flushAndSubmit()提交绘制请求
在函数末尾的surface->flushAndSubmit():
surface的类型时SkSurface, 故此处调用SkSurface::flushAndSubmit():
// external/skia/src/image/SkSurface.cpp
void SkSurface::flushAndSubmit(bool syncCpu) {
this->flush(BackendSurfaceAccess::kNoAccess, GrFlushInfo());
}
GrSemaphoresSubmitted SkSurface::flush(BackendSurfaceAccess access, const GrFlushInfo& flushInfo) {
return asSB(this)->onFlush(access, flushInfo, nullptr);
}
其实此处SkSurface由SkSurface_Gpu继承, 因此调用SkSurface_Gpu::onDraw():
// external/skqp/src/image/SkSurface_Gpu.cpp
GrSemaphoresSubmitted SkSurface_Gpu::onFlush(BackendSurfaceAccess access, const GrFlushInfo& info,
const GrBackendSurfaceMutableState* newState) {
auto dContext = fDevice->recordingContext()->asDirectContext();
... ...
GrSurfaceDrawContext* sdc = fDevice->surfaceDrawContext();
return dContext->priv().flushSurface(sdc->asSurfaceProxy(), access, info, newState);
}
dContext的类型时GrDirectContext, dContext->priv()返回的是GrDirectContextPriv, 因此:
// external/skia/src/gpu/GrDirectContextPriv.h
class GrDirectContextPriv {
GrSemaphoresSubmitted flushSurface(
GrSurfaceProxy* proxy,
SkSurface::BackendSurfaceAccess access = SkSurface::BackendSurfaceAccess::kNoAccess,
const GrFlushInfo& info = {},
const GrBackendSurfaceMutableState* newState = nullptr) {
size_t size = proxy ? 1 : 0;
return this->flushSurfaces({&proxy, size}, access, info, newState);
}
实现在:
// external/skia/src/gpu/GrDirectContextPriv.cpp
GrSemaphoresSubmitted GrDirectContextPriv::flushSurfaces(
SkSpan<GrSurfaceProxy*> proxies,
SkSurface::BackendSurfaceAccess access,
const GrFlushInfo& info,
const GrBackendSurfaceMutableState* newState) {
... ...
return fContext->drawingManager()->flushSurfaces(proxies, access, info, newState);
}
fContext->drawingManager()返回GrDrawingManager, 所以调用:
// external/skia/src/gpu/GrDrawingManager.cpp
GrSemaphoresSubmitted GrDrawingManager::flushSurfaces(
SkSpan<GrSurfaceProxy*> proxies,
SkSurface::BackendSurfaceAccess access,
const GrFlushInfo& info,
const GrBackendSurfaceMutableState* newState) {
... ...
bool didFlush = this->flush(proxies, access, info, newState);
... ...
}
bool GrDrawingManager::flush(
SkSpan<GrSurfaceProxy*> proxies,
SkSurface::BackendSurfaceAccess access,
const GrFlushInfo& info,
const GrBackendSurfaceMutableState* newState) {
... ...
bool flushed = !resourceAllocator.failedInstantiation() &&
this->executeRenderTasks(&flushState);
this->removeRenderTasks();
... ...
}
bool GrDrawingManager::executeRenderTasks(GrOpFlushState* flushState) {
// Execute the normal op lists.
for (const auto& renderTask : fDAG) {
... ...
if (renderTask->execute(flushState)) {
anyRenderTasksExecuted = true;
}
if (++numRenderTasksExecuted >= kMaxRenderTasksBeforeFlush) {
flushState->gpu()->submitToGpu(false);
numRenderTasksExecuted = 0;
}
}
renderTask的类型是GrRenderTask, 其实现是GrOpsTask, 因此:
// external/skia/src/gpu/GrRenderTask.h
class GrRenderTask : public SkRefCnt {
public:
bool execute(GrOpFlushState* flushState) { return this->onExecute(flushState); }
// external/skia/src/gpu/GrOpsTask.cpp
bool GrOpsTask::onExecute(GrOpFlushState* flushState) {
... ...
// Draw all the generated geometry.
for (const auto& chain : fOpChains) {
if (!chain.shouldExecute()) {
continue;
}
GrOpFlushState::OpArgs opArgs(chain.head(),
dstView,
fUsesMSAASurface,
chain.appliedClip(),
chain.dstProxyView(),
fRenderPassXferBarriers,
fColorLoadOp);
flushState->setOpArgs(&opArgs);
chain.head()->execute(flushState, chain.bounds());
flushState->setOpArgs(nullptr);
}
此处开始依次执行每个OpChain::head()的execute()方法. 本文中此处的GrOp为GrStrokeRectOp::Make()所创建的NonAAStrokeRectOp, 其继承关系:GrOp -> GrDrawOp -> GrMeshDrawOp -> NonAAStrokeRectOp, 那么此时:
// external/skia/src/gpu/ops/GrOp.h
class GrOp : private SkNoncopyable {
public:
... ...
/** Issues the op's commands to GrGpu. */
void execute(GrOpFlushState* state, const SkRect& chainBounds) {
TRACE_EVENT0("skia.gpu", name());
this->onExecute(state, chainBounds);
}
// external/skia/src/gpu/ops/GrStrokeRectOp.cpp
class NonAAStrokeRectOp final : public GrMeshDrawOp {
... ...
void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
... ...
flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds);
flushState->bindTextures(fProgramInfo->geomProc(), nullptr, fProgramInfo->pipeline());
flushState->drawMesh(*fMesh);
}
显然这时调用了GrOpFlushState的各种方法完成绘图.
应用swapBuffer()交换窗口至SurfaceFlinger
在SkiaOpenGLPipeline::draw()完成工作后, CanvasContext::draw()将调用SkiaOpenGLPipeline::swapBuffers(), 查看其实现:
// frameworks/base/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
bool SkiaOpenGLPipeline::swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
FrameInfo* currentFrameInfo, bool* requireSwap) {
... ...
if (*requireSwap && (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty)))) {
return false;
}
... ...
}
mEglManager的类型是EglManager, 故:
// frameworks/base/libs/hwui/renderthread/EglManager.cpp
bool EglManager::swapBuffers(const Frame& frame, const SkRect& screenDirty) {
... ...
eglSwapBuffersWithDamageKHR(mEglDisplay, frame.mSurface, rects, screenDirty.isEmpty() ? 0 : 1);
... ...
}
eglSwapBuffersWithDamageKHR()属于libEGL.so, 没有源码, 该方法执行完成后, libEGL.so将回调ANativeWindow::queueBuffer进一步回调到Surface::hook_queueBuffer(), 代码:
// frameworks/native/libs/gui/Surface.cpp
int Surface::hook_queueBuffer(ANativeWindow* window,
ANativeWindowBuffer* buffer, int fenceFd) {
Surface* c = getSelf(window);
{
std::shared_lock<std::shared_mutex> lock(c->mInterceptorMutex);
if (c->mQueueInterceptor != nullptr) {
auto interceptor = c->mQueueInterceptor;
auto data = c->mQueueInterceptorData;
return interceptor(window, Surface::queueBufferInternal, data, buffer, fenceFd);
}
}
return c->queueBuffer(buffer, fenceFd);
}
int Surface::queueBufferInternal(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) {
Surface* c = getSelf(window);
return c->queueBuffer(buffer, fenceFd);
}
int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
... ...
status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output);
... ...
}
Android S以后BufferQueue改到应用侧, 因此此处mGraphicBufferProducer为本地得BufferQueueProducer, 而不再通过Binder传递GraphicBuffer到SurfaceFlinger, 因此:
// frameworks/native/libs/gui/BufferQueueProducer.cpp
status_t BufferQueueProducer::queueBuffer(int slot,
const QueueBufferInput &input, QueueBufferOutput *output) {
... ...
{ // scope for the lock
... ...
if (frameAvailableListener != nullptr) {
frameAvailableListener->onFrameAvailable(item);
} else if (frameReplacedListener != nullptr) {
frameReplacedListener->onFrameReplaced(item);
}
此处得frameAvailableListener是BLASTBufferQueue, 因此BLASTBufferQueue::onFrameAvailable()被调用:
// frameworks/native/libs/gui/BLASTBufferQueue.cpp
return item.mCrop;
}
void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) {
... ...
processNextBufferLocked(nextTransactionSet /* useNextTransaction */);
}
void BLASTBufferQueue::processNextBufferLocked(bool useNextTransaction) {
... ...
SurfaceComposerClient::Transaction* t = &localTransaction;
... ...
if (applyTransaction) {
t->setApplyToken(mApplyToken).apply();
}
显然调用到SurfaceComposerClient::Transaction::apply():
// frameworks/native/libs/gui/SurfaceComposerClient.cpp
status_t SurfaceComposerClient::Transaction::apply(bool synchronous) {
... ...
sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags, applyToken,
mInputWindowCommands, mDesiredPresentTime, mIsAutoTimestamp,
{} /*uncacheBuffer - only set in doUncacheBufferTransaction*/,
hasListenerCallbacks, listenerCallbacks, mId);
... ...
}
此时通过Binder, SurfaceFlinger::setTransactionState()被调用:
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::setTransactionState(
const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
... ...
queueTransaction(state);
... ...
void SurfaceFlinger::queueTransaction(TransactionState& state) {
... ...
setTransactionFlags(eTransactionFlushNeeded, schedule, state.applyToken);
}
uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
return setTransactionFlags(flags, TransactionSchedule::Late);
}
uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags, TransactionSchedule schedule,
const sp<IBinder>& token) {
... ...
if ((old & flags) == 0) signalTransaction();
return old;
}
void SurfaceFlinger::signalTransaction() {
mScheduler->resetIdleTimer();
mPowerAdvisor.notifyDisplayUpdateImminent();
mEventQueue->invalidate();
}
此处比较关键的操作是:mEventQueue->invalidate(), 对应MessageQueue::invalidate():
// frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp
mLooper->sendMessage(handler, Message());
}
void MessageQueue::invalidate() {
... ...
mVsync.expectedWakeupTime =
mVsync.registration->schedule({.workDuration = mVsync.workDuration.get().count(),
.readyDuration = 0,
.earliestVsync = mVsync.lastCallbackTime.count()});
}
尤其注意此处的mVsync.registration->schedule(), 该方法调度了一个VSyncCallbackRegistration在Scheduler, 而此处的VSyncCallbackRegistration在如下位置被注册:
// frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp
void MessageQueue::initVsync(scheduler::VSyncDispatch& dispatch,
frametimeline::TokenManager& tokenManager,
std::chrono::nanoseconds workDuration) {
setDuration(workDuration);
mVsync.tokenManager = &tokenManager;
mVsync.registration = std::make_unique<
scheduler::VSyncCallbackRegistration>(dispatch,
std::bind(&MessageQueue::vsyncCallback, this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3),
"sf");
}
回到VSyncDispatchTimerQueue::timerCallback()方法中, 其通过invocation.callback->callback()通知App完成绘制时, 也继续调用了MessageQueue::vsyncCallback()方法, 因此:
// frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp
void MessageQueue::vsyncCallback(nsecs_t vsyncTime, nsecs_t targetWakeupTime, nsecs_t readyTime) {
... ...
mHandler->dispatchInvalidate(mVsync.tokenManager->generateTokenForPredictions(
{targetWakeupTime, readyTime, vsyncTime}),
... ...
}
void MessageQueue::Handler::dispatchInvalidate(int64_t vsyncId, nsecs_t expectedVSyncTimestamp) {
if ((mEventMask.fetch_or(eventMaskInvalidate) & eventMaskInvalidate) == 0) {
... ....
mQueue.mLooper->sendMessage(this, Message(MessageQueue::INVALIDATE));
}
}
这里的MessageQueue::INVALIDATE消息会被MessageQueue::Handler::handleMessage响应, 因此:
void MessageQueue::Handler::handleMessage(const Message& message) {
switch (message.what) {
case INVALIDATE:
mEventMask.fetch_and(~eventMaskInvalidate);
mQueue.mFlinger->onMessageReceived(message.what, mVsyncId, mExpectedVSyncTime);
break;
case REFRESH:
... ...
break;
}
}
SurfaceFlinger合成窗口
显然SurfaceFlinger::onMessageReceived()被调用:
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::onMessageReceived(int32_t what, int64_t vsyncId, nsecs_t expectedVSyncTime) {
switch (what) {
case MessageQueue::INVALIDATE: {
onMessageInvalidate(vsyncId, expectedVSyncTime);
break;
}
... ...
}
}
void SurfaceFlinger::onMessageInvalidate(int64_t vsyncId, nsecs_t expectedVSyncTime) {
... ...
mCompositionEngine->present(refreshArgs);
... ...
SurfaceFlinger调用了CompositionEngine::present()对App发送过来的Layer进行合成:
// frameworks/native/services/surfaceflinger/CompositionEngine/src/CompositionEngine.cpp
void CompositionEngine::present(CompositionRefreshArgs& args) {
preComposition(args);
{
... ...
LayerFESet latchedLayers;
for (const auto& output : args.outputs) {
output->prepare(args, latchedLayers);
}
}
updateLayerStateFromFE(args);
for (const auto& output : args.outputs) {
output->present(args);
}
}
显然有:
void Output::present(const compositionengine::CompositionRefreshArgs& refreshArgs) {
ATRACE_CALL();
ALOGV(__FUNCTION__);
updateColorProfile(refreshArgs);
updateCompositionState(refreshArgs);
planComposition();
writeCompositionState(refreshArgs);
setColorTransform(refreshArgs);
beginFrame();
prepareFrame();
devOptRepaintFlash(refreshArgs);
finishFrame(refreshArgs);
postFramebuffer();
renderCachedSets(refreshArgs);
}
在Output::finishFrame()时有:
void Output::finishFrame(const compositionengine::CompositionRefreshArgs& refreshArgs) {
... ...
// swap buffers (presentation)
mRenderSurface->queueBuffer(std::move(*optReadyFence));
}
渲染引擎合成到Composer
mRenderSurface->queueBuffer()完成将合成的屏幕内容送显.
在Output::postFramebuffer()时有:
void Output::postFramebuffer() {
... ...
mRenderSurface->flip();
auto frame = presentAndGetFrameFences();
... ...
}
compositionengine::Output::FrameFences Output::presentAndGetFrameFences() {
compositionengine::Output::FrameFences result;
if (getState().usesClientComposition) {
result.clientTargetAcquireFence = mRenderSurface->getClientTargetAcquireFence();
}
return result;
}
mRenderSurface->flip()完成交换动作, presentAndGetFrameFences()用于等待mRenderSurface释放交换回来的无用缓冲区.
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
