1 /*
2 * Copyright (C) 2009 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 #pragma once
18
19 #include <cstdint>
20 #include <future>
21 #include <type_traits>
22 #include <utility>
23
24 #include <android-base/thread_annotations.h>
25 #include <android/gui/IDisplayEventConnection.h>
26 #include <private/gui/BitTube.h>
27 #include <utils/Looper.h>
28 #include <utils/StrongPointer.h>
29 #include <utils/Timers.h>
30
31 #include <scheduler/Time.h>
32 #include <scheduler/VsyncId.h>
33
34 #include "EventThread.h"
35 #include "TracedOrdinal.h"
36 #include "VSyncDispatch.h"
37
38 namespace android {
39
40 struct ICompositor;
41
42 template <typename F>
43 class Task : public MessageHandler {
44 template <typename G>
45 friend auto makeTask(G&&);
46
47 template <typename... Args>
48 friend sp<Task<F>> sp<Task<F>>::make(Args&&... args);
49
Task(F && f)50 explicit Task(F&& f) : mTask(std::move(f)) {}
51
handleMessage(const Message &)52 void handleMessage(const Message&) override { mTask(); }
53
54 using T = std::invoke_result_t<F>;
55 std::packaged_task<T()> mTask;
56 };
57
58 template <typename F>
makeTask(F && f)59 inline auto makeTask(F&& f) {
60 sp<Task<F>> task = sp<Task<F>>::make(std::forward<F>(f));
61 return std::make_pair(task, task->mTask.get_future());
62 }
63
64 class MessageQueue {
65 public:
66 virtual ~MessageQueue() = default;
67
68 virtual void initVsync(std::shared_ptr<scheduler::VSyncDispatch>, frametimeline::TokenManager&,
69 std::chrono::nanoseconds workDuration) = 0;
70 virtual void destroyVsync() = 0;
71 virtual void setDuration(std::chrono::nanoseconds workDuration) = 0;
72 virtual void waitMessage() = 0;
73 virtual void postMessage(sp<MessageHandler>&&) = 0;
74 virtual void postMessageDelayed(sp<MessageHandler>&&, nsecs_t uptimeDelay) = 0;
75 virtual void scheduleConfigure() = 0;
76 virtual void scheduleFrame() = 0;
77
78 using Clock = std::chrono::steady_clock;
79 virtual std::optional<Clock::time_point> getScheduledFrameTime() const = 0;
80 };
81
82 namespace impl {
83
84 class MessageQueue : public android::MessageQueue {
85 protected:
86 class Handler : public MessageHandler {
87 MessageQueue& mQueue;
88 std::atomic_bool mFramePending = false;
89
90 std::atomic<VsyncId> mVsyncId;
91 std::atomic<TimePoint> mExpectedVsyncTime;
92
93 public:
Handler(MessageQueue & queue)94 explicit Handler(MessageQueue& queue) : mQueue(queue) {}
95 void handleMessage(const Message& message) override;
96
97 bool isFramePending() const;
98
99 virtual void dispatchFrame(VsyncId, TimePoint expectedVsyncTime);
100 };
101
102 friend class Handler;
103
104 // For tests.
105 MessageQueue(ICompositor&, sp<Handler>);
106
107 void vsyncCallback(nsecs_t vsyncTime, nsecs_t targetWakeupTime, nsecs_t readyTime);
108
109 void onNewVsyncSchedule(std::shared_ptr<scheduler::VSyncDispatch>) EXCLUDES(mVsync.mutex);
110
111 private:
112 virtual void onFrameSignal(ICompositor&, VsyncId, TimePoint expectedVsyncTime) = 0;
113
114 ICompositor& mCompositor;
115 const sp<Looper> mLooper;
116 const sp<Handler> mHandler;
117
118 struct Vsync {
119 frametimeline::TokenManager* tokenManager = nullptr;
120
121 mutable std::mutex mutex;
122 std::unique_ptr<scheduler::VSyncCallbackRegistration> registration GUARDED_BY(mutex);
123 TracedOrdinal<std::chrono::nanoseconds> workDuration
124 GUARDED_BY(mutex) = {"VsyncWorkDuration-sf", std::chrono::nanoseconds(0)};
125 TimePoint lastCallbackTime GUARDED_BY(mutex);
126 std::optional<nsecs_t> scheduledFrameTime GUARDED_BY(mutex);
127 TracedOrdinal<int> value = {"VSYNC-sf", 0};
128 };
129
130 Vsync mVsync;
131
132 // Returns the old registration so it can be destructed outside the lock to
133 // avoid deadlock.
134 std::unique_ptr<scheduler::VSyncCallbackRegistration> onNewVsyncScheduleLocked(
135 std::shared_ptr<scheduler::VSyncDispatch>) REQUIRES(mVsync.mutex);
136
137 public:
138 explicit MessageQueue(ICompositor&);
139
140 void initVsync(std::shared_ptr<scheduler::VSyncDispatch>, frametimeline::TokenManager&,
141 std::chrono::nanoseconds workDuration) override;
142 void destroyVsync() override;
143 void setDuration(std::chrono::nanoseconds workDuration) override;
144
145 void waitMessage() override;
146 void postMessage(sp<MessageHandler>&&) override;
147 void postMessageDelayed(sp<MessageHandler>&&, nsecs_t uptimeDelay) override;
148
149 void scheduleConfigure() override;
150 void scheduleFrame() override;
151
152 std::optional<Clock::time_point> getScheduledFrameTime() const override;
153 };
154
155 } // namespace impl
156 } // namespace android
157