1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "Choreographer"
18//#define LOG_NDEBUG 0
19
20#include <cinttypes>
21#include <queue>
22#include <thread>
23
24#include <android/choreographer.h>
25#include <androidfw/DisplayEventDispatcher.h>
26#include <gui/ISurfaceComposer.h>
27#include <utils/Looper.h>
28#include <utils/Mutex.h>
29#include <utils/Timers.h>
30
31namespace android {
32
33static inline const char* toString(bool value) {
34    return value ? "true" : "false";
35}
36
37struct FrameCallback {
38    AChoreographer_frameCallback callback;
39    void* data;
40    nsecs_t dueTime;
41
42    inline bool operator<(const FrameCallback& rhs) const {
43        // Note that this is intentionally flipped because we want callbacks due sooner to be at
44        // the head of the queue
45        return dueTime > rhs.dueTime;
46    }
47};
48
49
50class Choreographer : public DisplayEventDispatcher, public MessageHandler {
51public:
52    void postFrameCallback(AChoreographer_frameCallback cb, void* data);
53    void postFrameCallbackDelayed(AChoreographer_frameCallback cb, void* data, nsecs_t delay);
54
55    enum {
56        MSG_SCHEDULE_CALLBACKS = 0,
57        MSG_SCHEDULE_VSYNC = 1
58    };
59    virtual void handleMessage(const Message& message) override;
60
61    static Choreographer* getForThread();
62
63protected:
64    virtual ~Choreographer() = default;
65
66private:
67    explicit Choreographer(const sp<Looper>& looper);
68    Choreographer(const Choreographer&) = delete;
69
70    virtual void dispatchVsync(nsecs_t timestamp, int32_t id, uint32_t count);
71    virtual void dispatchHotplug(nsecs_t timestamp, int32_t id, bool connected);
72
73    void scheduleCallbacks();
74
75    // Protected by mLock
76    std::priority_queue<FrameCallback> mCallbacks;
77
78    mutable Mutex mLock;
79
80    const sp<Looper> mLooper;
81    const std::thread::id mThreadId;
82};
83
84
85static thread_local Choreographer* gChoreographer;
86Choreographer* Choreographer::getForThread() {
87    if (gChoreographer == nullptr) {
88        sp<Looper> looper = Looper::getForThread();
89        if (!looper.get()) {
90            ALOGW("No looper prepared for thread");
91            return nullptr;
92        }
93        gChoreographer = new Choreographer(looper);
94        status_t result = gChoreographer->initialize();
95        if (result != OK) {
96            ALOGW("Failed to initialize");
97            return nullptr;
98        }
99    }
100    return gChoreographer;
101}
102
103Choreographer::Choreographer(const sp<Looper>& looper) :
104    DisplayEventDispatcher(looper), mLooper(looper), mThreadId(std::this_thread::get_id()) {
105}
106
107void Choreographer::postFrameCallback(AChoreographer_frameCallback cb, void* data) {
108    postFrameCallbackDelayed(cb, data, 0);
109}
110
111void Choreographer::postFrameCallbackDelayed(
112        AChoreographer_frameCallback cb, void* data, nsecs_t delay) {
113    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
114    FrameCallback callback{cb, data, now + delay};
115    {
116        AutoMutex _l{mLock};
117        mCallbacks.push(callback);
118    }
119    if (callback.dueTime <= now) {
120        if (std::this_thread::get_id() != mThreadId) {
121            Message m{MSG_SCHEDULE_VSYNC};
122            mLooper->sendMessage(this, m);
123        } else {
124            scheduleVsync();
125        }
126    } else {
127        Message m{MSG_SCHEDULE_CALLBACKS};
128        mLooper->sendMessageDelayed(delay, this, m);
129    }
130}
131
132void Choreographer::scheduleCallbacks() {
133    AutoMutex _{mLock};
134    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
135    if (mCallbacks.top().dueTime <= now) {
136        ALOGV("choreographer %p ~ scheduling vsync", this);
137        scheduleVsync();
138        return;
139    }
140}
141
142
143void Choreographer::dispatchVsync(nsecs_t timestamp, int32_t id, uint32_t) {
144    if (id != ISurfaceComposer::eDisplayIdMain) {
145        ALOGV("choreographer %p ~ ignoring vsync signal for non-main display (id=%d)", this, id);
146        scheduleVsync();
147        return;
148    }
149    std::vector<FrameCallback> callbacks{};
150    {
151        AutoMutex _l{mLock};
152        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
153        while (!mCallbacks.empty() && mCallbacks.top().dueTime < now) {
154            callbacks.push_back(mCallbacks.top());
155            mCallbacks.pop();
156        }
157    }
158    for (const auto& cb : callbacks) {
159        cb.callback(timestamp, cb.data);
160    }
161}
162
163void Choreographer::dispatchHotplug(nsecs_t, int32_t id, bool connected) {
164    ALOGV("choreographer %p ~ received hotplug event (id=%" PRId32 ", connected=%s), ignoring.",
165            this, id, toString(connected));
166}
167
168void Choreographer::handleMessage(const Message& message) {
169    switch (message.what) {
170    case MSG_SCHEDULE_CALLBACKS:
171        scheduleCallbacks();
172        break;
173    case MSG_SCHEDULE_VSYNC:
174        scheduleVsync();
175        break;
176    }
177}
178
179}
180
181/* Glue for the NDK interface */
182
183using android::Choreographer;
184
185static inline Choreographer* AChoreographer_to_Choreographer(AChoreographer* choreographer) {
186    return reinterpret_cast<Choreographer*>(choreographer);
187}
188
189static inline AChoreographer* Choreographer_to_AChoreographer(Choreographer* choreographer) {
190    return reinterpret_cast<AChoreographer*>(choreographer);
191}
192
193AChoreographer* AChoreographer_getInstance() {
194    return Choreographer_to_AChoreographer(Choreographer::getForThread());
195}
196
197void AChoreographer_postFrameCallback(AChoreographer* choreographer,
198        AChoreographer_frameCallback callback, void* data) {
199    AChoreographer_to_Choreographer(choreographer)->postFrameCallback(callback, data);
200}
201void AChoreographer_postFrameCallbackDelayed(AChoreographer* choreographer,
202        AChoreographer_frameCallback callback, void* data, long delayMillis) {
203    AChoreographer_to_Choreographer(choreographer)->postFrameCallbackDelayed(
204            callback, data, ms2ns(delayMillis));
205}
206