// frameworks/native/services/surfaceflinger/Scheduler/VsyncConfiguration.cpp
struct VsyncConfiguration {
    // 应用 Vsync 相对于硬件 Vsync 的偏移
    nsecs_t appOffset;
    // SurfaceFlinger Vsync 相对于硬件 Vsync 的偏移  
    nsecs_t sfOffset;
    // 早期应用 Vsync 偏移（用于特殊情况）
    nsecs_t appOffsetEarly;
    // 早期 SurfaceFlinger Vsync 偏移
    nsecs_t sfOffsetEarly;
};

// hardware/interfaces/graphics/composer/2.1/utils/hwc2on1adapter/HWC2On1Adapter.cpp
// 注意：这是 HWC 1.x 到 2.x 的兼容性适配器，现代设备通常使用原生 HWC 2.x+
// 基于 Android 16 AOSP 最新代码
void HWC2On1Adapter::vsyncThread() {
    while (!mVsyncEnded) {
        if (mVsyncEnabled) {
            const auto now = std::chrono::steady_clock::now();
            const auto vsyncPeriod = std::chrono::nanoseconds(mVsyncPeriod);
            const auto nextVsync = mLastVsync + vsyncPeriod;
            
            if (now >= nextVsync) {
                // 产生硬件 Vsync 时间戳
                auto timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(
                    nextVsync.time_since_epoch()).count();
                
                // 回调到 SurfaceFlinger
                if (mVsyncCallback) {
                    mVsyncCallback->onVsync(timestamp, mDisplayId);
                }
                mLastVsync = nextVsync;
            }
        }
        std::this_thread::sleep_for(std::chrono::microseconds(100));
    }
}

// frameworks/native/services/surfaceflinger/Scheduler/VsyncController.h
// 实际实现通常在 VSyncReactor.cpp 中
// 基于 Android 16 AOSP 最新代码
void VsyncController::onVsync(nsecs_t timestamp, int32_t hwcDisplayId) {
    std::lock_guard<std::mutex> lock(mMutex);
    
    // 记录硬件 Vsync 时间戳到追踪器
    mVsyncTracker->addVsyncTimestamp(timestamp);
    
    // 检查是否需要更多硬件 Vsync 样本来校准预测模型
    if (mVsyncTracker->needsMoreSamples()) {
        // 模型还需要更多样本，继续启用硬件 Vsync
        ALOGV("VsyncController: Need more samples, keeping HW Vsync enabled");
    } else {
        // 模型已经稳定，可以关闭硬件 Vsync 节省电量
        ALOGV("VsyncController: Model stable, disabling HW Vsync");
        enableHardwareVsync(false);
    }
    
    // 通知所有等待的客户端
    for (auto& callback : mCallbacks) {
        callback->onVsync(timestamp);
    }
}

void VsyncController::enableHardwareVsync(bool enable) {
    if (mHwVsyncEnabled != enable) {
        mHwVsyncEnabled = enable;
        // 通过 HWC 接口控制硬件 Vsync
        mHwc.setVsyncEnabled(mDisplayId, enable);
        
        // 在 Perfetto trace 中可以看到这个状态变化
        ATRACE_INT("HW_VSYNC", enable ? 1 : 0);
    }
}

// frameworks/native/services/surfaceflinger/Scheduler/VSyncDispatch.h
// 实际实现在 VSyncDispatchTimerQueue.cpp 中
// 基于 Android 16 AOSP 最新代码
VsyncDispatch::CallbackToken VsyncDispatch::registerCallback(
        Callback callback, std::string callbackName) {
    std::lock_guard<decltype(mMutex)> lock(mMutex);
    
    // 为每个回调生成唯一的 token
    auto token = CallbackToken(mCallbackMap.size());
    mCallbackMap[token] = std::make_unique<CallbackEntry>(
        std::move(callback), std::move(callbackName));
    
    return token;
}

nsecs_t VsyncDispatch::schedule(CallbackToken token, 
                               nsecs_t workDuration, 
                               nsecs_t earliestVsync) {
    std::lock_guard<decltype(mMutex)> lock(mMutex);
    
    auto it = mCallbackMap.find(token);
    if (it == mCallbackMap.end()) {
        return kInvalidTime;
    }
    
    // 计算目标 Vsync 时间
    auto targetVsync = mVsyncTracker->nextVsyncTime(earliestVsync);
    
    // 计算唤醒时间 = 目标 Vsync - 工作时长
    auto wakeupTime = targetVsync - workDuration;
    
    // 如果唤醒时间已经过了，推到下一个 Vsync
    auto now = systemTime(SYSTEM_TIME_MONOTONIC);
    if (wakeupTime < now) {
        targetVsync = mVsyncTracker->nextVsyncTime(targetVsync + 1);
        wakeupTime = targetVsync - workDuration;
    }
    
    // 设置回调的触发时间
    it->second->wakeupTime = wakeupTime;
    it->second->targetVsync = targetVsync;
    it->second->workDuration = workDuration;
    
    // 重新调度定时器
    reschedule();
    
    return targetVsync;
}

void VsyncDispatch::reschedule() {
    // 找到最早需要触发的回调
    nsecs_t nextWakeup = std::numeric_limits<nsecs_t>::max();
    for (const auto& [token, entry] : mCallbackMap) {
        if (entry->wakeupTime > 0 && entry->wakeupTime < nextWakeup) {
            nextWakeup = entry->wakeupTime;
        }
    }
    
    if (nextWakeup != std::numeric_limits<nsecs_t>::max()) {
        // 设置定时器在 nextWakeup 时间触发
        mTimeKeeper->alarmAt(std::bind(&VsyncDispatch::timerCallback, this), nextWakeup);
    }
}

void VsyncDispatch::timerCallback() {
    std::vector<std::pair<CallbackToken, CallbackEntry*>> firedCallbacks;
    
    {
        std::lock_guard<decltype(mMutex)> lock(mMutex);
        auto now = systemTime(SYSTEM_TIME_MONOTONIC);
        
        // 找到所有应该触发的回调
        for (auto& [token, entry] : mCallbackMap) {
            if (entry->wakeupTime > 0 && now >= entry->wakeupTime) {
                firedCallbacks.push_back({token, entry.get()});
                entry->wakeupTime = 0; // 重置
            }
        }
    }
    
    // 在锁外执行回调，避免死锁
    for (auto& [token, entry] : firedCallbacks) {
        entry->callback(entry->targetVsync, entry->wakeupTime);
    }
}

// frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
EventThread::EventThread(std::unique_ptr<VSyncSource> vsyncSource,
                        std::unique_ptr<InterceptVSyncCallback> interceptVSyncCallback,
                        const char* threadName)
    : mVSyncSource(std::move(vsyncSource))
    , mInterceptVSyncCallback(std::move(interceptVSyncCallback))
    , mThreadName(threadName) {
    
    // 向 VsyncDispatch 注册回调
    mVSyncSource->setCallback(this);
    
    // 启动 EventThread 线程
    mThread = std::thread([this] { threadMain(); });
}

void EventThread::threadMain() {
    std::unique_lock<std::mutex> lock(mMutex);
    
    while (mKeepRunning) {
        // 等待 Vsync 事件或连接变化
        mCondition.wait(lock, [this] {
            return !mPendingEvents.empty() || !mKeepRunning;
        });
        
        // 处理所有待处理的事件
        auto pendingEvents = std::move(mPendingEvents);
        lock.unlock();
        
        for (const auto& event : pendingEvents) {
            // 分发给所有连接的客户端
            for (const auto& connection : mConnections) {
                if (connection->vsyncRequest != VSyncRequest::None) {
                    connection->postEvent(event);
                }
            }
        }
        
        lock.lock();
    }
}

void EventThread::onVSyncEvent(nsecs_t timestamp, int32_t displayId) {
    std::lock_guard<std::mutex> lock(mMutex);
    
    // 创建 Vsync 事件
    DisplayEventReceiver::Event event;
    event.header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
    event.header.id = displayId;
    event.header.timestamp = timestamp;
    event.vsync.count = ++mVSyncCount;
    
    // 添加到待处理事件队列
    mPendingEvents.push_back(event);
    mCondition.notify_all();
}

// frameworks/base/core/jni/android_view_DisplayEventReceiver.cpp
static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak,
        jobject messageQueueObj, jint vsyncSource, jint configChanged) {
    
    // 获取 Java 层的 MessageQueue
    sp<MessageQueue&