VSyncDispatchTimerQueue::registerCallback 调用流程分析
调用链路总览
registerCallback 调用链 (从上到下):
1. VSyncCallbackRegistration 构造函数
↓
2. VSyncDispatchTimerQueue::registerCallback()
核心调用点: VSyncCallbackRegistration 的构造函数中直接调用 mDispatch->registerCallback()
完整调用流程图
┌─────────────────────────────────────────────────────────────────────────────┐
│ 调用方 1: EventThread 构造函数 │
│ │
│ EventThread::EventThread(...) │
│ ↓ │
│ 初始化列表：mVsyncRegistration(...) │
│ ↓ │
│ VSyncCallbackRegistration::VSyncCallbackRegistration(dispatch, callback) │
│ ↓ (构造函数体内) │
│ mDispatch->registerCallback(callback, callbackName) ← 调用点 │
│ ↓ │
│ VSyncDispatchTimerQueue::registerCallback() │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ 调用方 2: VsyncSchedule::PredictedVsyncTracer 构造函数 │
│ │
│ VsyncSchedule::VsyncSchedule(...) │
│ ↓ │
│ 初始化列表：mTracer(...) │
│ ↓ │
│ PredictedVsyncTracer::PredictedVsyncTracer(dispatch) │
│ ↓ │
│ 初始化列表：mRegistration(dispatch, makeVsyncCallback(), __func__) │
│ ↓ (构造函数体内) │
│ mDispatch->registerCallback(callback, callbackName) ← 调用点 │
│ ↓ │
│ VSyncDispatchTimerQueue::registerCallback() │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ 调用方 3: EventThread::onNewVsyncScheduleInternal() │
│ │
│ EventThread::onNewVsyncScheduleInternal(schedule) │
│ ↓ │
│ std::exchange(mVsyncRegistration, │
│ VSyncCallbackRegistration(mVsyncSchedule->getDispatch(), │
│ createDispatchCallback(), │
│ mThreadName)) │
│ ↓ (VSyncCallbackRegistration 构造函数) │
│ mDispatch->registerCallback(callback, callbackName) ← 调用点 │
│ ↓ │
│ VSyncDispatchTimerQueue::registerCallback() │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ 调用方 4: MessageQueue::onNewVsyncScheduleLocked() │
│ │
│ MessageQueue::onNewVsyncScheduleLocked(dispatch) │
│ ↓ │
│ mVsync.registration = std::make_unique<VSyncCallbackRegistration>( │
│ dispatch, createCallback(), "MessageQueue") │
│ ↓ (VSyncCallbackRegistration 构造函数) │
│ mDispatch->registerCallback(callback, callbackName) ← 调用点 │
│ ↓ │
│ VSyncDispatchTimerQueue::registerCallback() │
└─────────────────────────────────────────────────────────────────────────────┘
详细调用分析
调用点 1：EventThread 构造函数
文件: frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp:241-254
EventThread::EventThread(const char* name,
std::shared_ptr<scheduler::VsyncSchedule> vsyncSchedule,
android::frametimeline::TokenManager* tokenManager,
ThrottleVsyncCallback throttleVsyncCallback,
GetVsyncPeriodFunction getVsyncPeriodFunction,
std::chrono::nanoseconds workDuration,
std::chrono::nanoseconds readyDuration)
: mThreadName(name),
mVsyncTracer(base::StringPrintf("VSYNC-%s", name), 0),
mWorkDuration(base::StringPrintf("VsyncWorkDuration-%s", name), workDuration),
mReadyDuration(readyDuration),
mVsyncSchedule(std::move(vsyncSchedule)),
// ← 关键：在初始化列表中创建 VSyncCallbackRegistration
mVsyncRegistration(mVsyncSchedule->getDispatch(), createDispatchCallback(), name),
mTokenManager(tokenManager),
mThrottleVsyncCallback(std::move(throttleVsyncCallback)),
mGetVsyncPeriodFunction(std::move(getVsyncPeriodFunction)) {
// ...
}
调用链:
EventThread::EventThread()
→ mVsyncRegistration 初始化 (VSyncCallbackRegistration 类型)
→ VSyncCallbackRegistration::VSyncCallbackRegistration(dispatch, callback, name)
→ mDispatch->registerCallback(std::move(callback), std::move(callbackName))
→ VSyncDispatchTimerQueue::registerCallback()
调用点 2：VsyncSchedule::PredictedVsyncTracer 构造函数
文件: frameworks/native/services/surfaceflinger/Scheduler/VsyncSchedule.cpp:35-53
class VsyncSchedule::PredictedVsyncTracer {
// Invoked from the thread of the VsyncDispatch owned by this VsyncSchedule.
constexpr auto makeVsyncCallback() {
return [this](nsecs_t, nsecs_t, nsecs_t) {
mParity = !mParity;
schedule();
};
}
public:
// ← 关键：在初始化列表中创建 VSyncCallbackRegistration
explicit PredictedVsyncTracer(std::shared_ptr<VsyncDispatch> dispatch)
: mRegistration(std::move(dispatch), makeVsyncCallback(), __func__) {
schedule();
}
private:
void schedule() { mRegistration.schedule({0, 0, 0}); }
TracedOrdinal<bool> mParity = {"VSYNC-predicted", 0};
VSyncCallbackRegistration mRegistration; // ← 成员变量
};
调用链:
VsyncSchedule::VsyncSchedule()
→ mTracer 初始化 (PredictedVsyncTracer 类型，仅当 kTracePredictedVsync 启用)
→ PredictedVsyncTracer::PredictedVsyncTracer(dispatch)
→ mRegistration 初始化 (VSyncCallbackRegistration 类型)
→ VSyncCallbackRegistration::VSyncCallbackRegistration(dispatch, callback, __func__)
→ mDispatch->registerCallback(std::move(callback), std::move(callbackName))
→ VSyncDispatchTimerQueue::registerCallback()
调用点 3：EventThread::onNewVsyncScheduleInternal
文件: frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp:728-748
scheduler::VSyncCallbackRegistration EventThread::onNewVsyncScheduleInternal(
std::shared_ptr<scheduler::VsyncSchedule> schedule) {
std::lock_guard<std::mutex> lock(mMutex);
// 取消旧的注册
const bool reschedule = mVsyncRegistration.cancel() == scheduler::CancelResult::Cancelled;
// 更新 VsyncSchedule
mVsyncSchedule = std::move(schedule);
// ← 关键：创建新的 VSyncCallbackRegistration 替换旧的
auto oldRegistration =
std::exchange(mVsyncRegistration,
scheduler::VSyncCallbackRegistration(
mVsyncSchedule->getDispatch(), // ← 新的 dispatch
createDispatchCallback(), // ← 新的 callback
mThreadName)); // ← callback 名称
// 如果需要，重新调度
if (reschedule) {
mVsyncRegistration.schedule({.workDuration = mWorkDuration.get().count(),
.readyDuration = mReadyDuration.count(),
.earliestVsync = mLastVsyncCallbackTime.ns()});
}
return oldRegistration;
}
调用链:
EventThread::onNewVsyncScheduleInternal(schedule)
→ std::exchange(mVsyncRegistration, VSyncCallbackRegistration(...))
→ VSyncCallbackRegistration::VSyncCallbackRegistration(dispatch, callback, name)
→ mDispatch->registerCallback(std::move(callback), std::move(callbackName))
→ VSyncDispatchTimerQueue::registerCallback()
触发时机:
- 当 Scheduler 切换 VSYNC 配置时调用
- 例如：刷新率切换、显示模式变化
调用栈:
Scheduler::applyNewVsyncSchedule(vsyncSchedule)
→ Scheduler::onNewVsyncSchedule(vsyncSchedule->getDispatch())
→ MessageQueue::onNewVsyncSchedule(dispatch)
同时遍历所有 EventThread:
→ EventThread::onNewVsyncSchedule(vsyncSchedule)
→ EventThread::onNewVsyncScheduleInternal(schedule)
→ VSyncCallbackRegistration 构造函数
→ registerCallback()
调用点 4：MessageQueue::onNewVsyncScheduleLocked
文件: frameworks/native/services/surfaceflinger/Scheduler/MessageQueue.cpp:111-130
std::unique_ptr<scheduler::VSyncCallbackRegistration>
MessageQueue::onNewVsyncScheduleLocked(std::shared_ptr<scheduler::VSyncDispatch> dispatch) {
const bool reschedule = mVsync.registration &&
mVsync.registration->cancel() == scheduler::CancelResult::Cancelled;
// ← 关键：创建新的 VSyncCallbackRegistration
mVsync.registration = std::make_unique<scheduler::VSyncCallbackRegistration>(
dispatch, createCallback(), "MessageQueue");
if (reschedule) {
mVsync.registration->schedule({.workDuration = mVsync.workDuration,
.readyDuration = mVsync.readyDuration,
.earliestVsync = mVsync.earliestVsync});
}
return reschedule ? std::make_unique<scheduler::VSyncCallbackRegistration>() : nullptr;
}
调用链:
MessageQueue::onNewVsyncScheduleLocked(dispatch)
→ std::make_unique<VSyncCallbackRegistration>(dispatch, callback, "MessageQueue")
→ VSyncCallbackRegistration::VSyncCallbackRegistration(dispatch, callback, name)
→ mDispatch->registerCallback(std::move(callback), std::move(callbackName))
→ VSyncDispatchTimerQueue::registerCallback()
触发时机:
- Scheduler 初始化时
- VSYNC 配置更新时
调用栈:
Scheduler::initVsync()
→ MessageQueue::initVsync()
→ MessageQueue::onNewVsyncSchedule(dispatch)
→ MessageQueue::onNewVsyncScheduleLocked(dispatch)
→ VSyncCallbackRegistration 构造函数
→ registerCallback()
VSyncCallbackRegistration 类实现
文件: frameworks/native/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp:445-488
// 构造函数 - 这里调用 registerCallback
VSyncCallbackRegistration::VSyncCallbackRegistration(
std::shared_ptr<VSyncDispatch> dispatch,
VSyncDispatch::Callback callback,
std::string callbackName)
: mDispatch(std::move(dispatch)),
mToken(mDispatch->registerCallback(std::move(callback), // ← 调用点
std::move(callbackName))) {}
// 移动构造函数
VSyncCallbackRegistration::VSyncCallbackRegistration(
VSyncCallbackRegistration&& other)
: mDispatch(std::move(other.mDispatch)),
mToken(std::exchange(other.mToken, std::nullopt)) {}
// 移动赋值运算符
VSyncCallbackRegistration& VSyncCallbackRegistration::operator=(
VSyncCallbackRegistration&& other) {
if (this == &other) return *this;
if (mToken) {
mDispatch->unregisterCallback(*mToken); // ← 注销旧回调
}
mDispatch = std::move(other.mDispatch);
mToken = std::exchange(other.mToken, std::nullopt);
return *this;
}
// 析构函数 - 自动注销回调
VSyncCallbackRegistration::~VSyncCallbackRegistration() {
if (mToken) mDispatch->unregisterCallback(*mToken); // ← 注销回调
}
// 调度回调
ScheduleResult VSyncCallbackRegistration::schedule(
VSyncDispatch::ScheduleTiming scheduleTiming) {
if (!mToken) {
return std::nullopt;
}
return mDispatch->schedule(*mToken, scheduleTiming);
}
registerCallback 实现
文件: frameworks/native/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp:328-337
VSyncDispatchTimerQueue::CallbackToken VSyncDispatchTimerQueue::registerCallback(
Callback callback, std::string callbackName) {
std::lock_guard lock(mMutex);
// ← 将回调包装成 VSyncDispatchTimerQueueEntry 并存储到 mCallbacks map
return CallbackToken{
mCallbacks
.emplace(++mCallbackToken,
std::make_shared<VSyncDispatchTimerQueueEntry>(
std::move(callbackName),
std::move(callback), // ← 保存 callback
mMinVsyncDistance))
.first->first};
}
关键点:
- 每次调用
registerCallback都会生成一个新的CallbackToken(自增 ID) - Callback 被包装成
VSyncDispatchTimerQueueEntry对象 - 存储在
mCallbacksunordered_map 中 - 返回
CallbackToken用于后续的 schedule/update/cancel 操作
完整调用栈示例
场景 1：EventThread 初始化
#0 VSyncDispatchTimerQueue::registerCallback()
#1 VSyncCallbackRegistration::VSyncCallbackRegistration()
#2 EventThread::EventThread() [初始化列表]
#3 std::make_unique<EventThread>(...)
#4 Scheduler::Scheduler()
#5 SurfaceFlinger::SurfaceFlinger()
场景 2：刷新率切换
#0 VSyncDispatchTimerQueue::registerCallback()
#1 VSyncCallbackRegistration::VSyncCallbackRegistration()
#2 EventThread::onNewVsyncScheduleInternal()
#3 EventThread::onNewVsyncSchedule()
#4 Scheduler::applyNewVsyncSchedule()
#5 Scheduler::setPacesetterDisplay() 或 Scheduler::updatePolicy()
场景 3：Scheduler 初始化
#0 VSyncDispatchTimerQueue::registerCallback()
#1 VSyncCallbackRegistration::VSyncCallbackRegistration()
#2 MessageQueue::onNewVsyncScheduleLocked()
#3 MessageQueue::onNewVsyncSchedule()
#4 MessageQueue::initVsync()
#5 Scheduler::Scheduler()
关键设计模式
1. RAII 管理回调生命周期
class VSyncCallbackRegistration {
std::shared_ptr<VSyncDispatch> mDispatch;
std::optional<CallbackToken> mToken;
// 构造函数自动注册
VSyncCallbackRegistration(dispatch, callback, name)
: mDispatch(dispatch), mToken(dispatch->registerCallback(callback, name)) {}
// 析构函数自动注销
~VSyncCallbackRegistration() {
if (mToken) mDispatch->unregisterCallback(*mToken);
}
};
优点:
- 无需手动管理回调注销
- 避免回调泄漏
- 异常安全
2. Token 模式
using CallbackToken = StrongTyping<size_t, class CallbackTokenTag, Compare, Hash>;
// 注册时返回 Token
CallbackToken token = mDispatch->registerCallback(callback, name);
// 使用 Token 进行后续操作
mDispatch->schedule(token, timing);
mDispatch->cancel(token);
mDispatch->unregisterCallback(token);
优点:
- 类型安全的回调标识
- 支持多个回调并存
- 可单独管理每个回调
3. std::function 回调
using Callback = std::function<void(nsecs_t, nsecs_t, nsecs_t)>;
// 支持 lambda、函数指针、bind 等
registerCallback([this](nsecs_t a, nsecs_t b, nsecs_t c) {
onVsync(a, b, c);
}, "EventThread");
优点:
- 灵活的回调定义
- 支持捕获上下文
- 类型擦除，接口简洁
总结
registerCallback 调用方汇总
| 调用方 | 位置 | 触发时机 |
|---|---|---|
EventThread 构造函数 | EventThread.cpp:253 | EventThread 创建时 |
PredictedVsyncTracer 构造函数 | VsyncSchedule.cpp:46 | VsyncSchedule 创建且启用 tracing 时 |
EventThread::onNewVsyncScheduleInternal() | EventThread.cpp:740 | VSYNC 配置更新时 |
MessageQueue::onNewVsyncScheduleLocked() | MessageQueue.cpp:114 | MessageQueue 初始化/VSYNC 更新时 |
调用链核心
VSyncCallbackRegistration 构造函数
↓
mDispatch->registerCallback(callback, name)
↓ (mDispatch 实际类型是 VSyncDispatchTimerQueue)
VSyncDispatchTimerQueue::registerCallback()
↓
mCallbacks.emplace(token, VSyncDispatchTimerQueueEntry(callback, ...))
生命周期管理
创建 → VSyncCallbackRegistration 构造函数 → registerCallback()
使用 → schedule()/update()/cancel()
销毁 → ~VSyncCallbackRegistration() → unregisterCallback()
