1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "drag_vsync_station.h"
17
18 #include <cstdint>
19
20 #include "concurrent_task_client.h"
21 #include "devicestatus_common.h"
22 #include "devicestatus_define.h"
23 #include "include/util.h"
24 #include "qos.h"
25 #include "transaction/rs_interfaces.h"
26 #undef LOG_TAG
27 #define LOG_TAG "DragVSyncStation"
28
29 namespace OHOS {
30 namespace Msdp {
31 namespace DeviceStatus {
32 namespace {
33 const std::string THREAD_NAME { "os_dargRenderRunner" };
34 constexpr int32_t INVALID_VALUE { -1 };
35 }
36
RequestFrame(int32_t frameType,std::shared_ptr<DragFrameCallback> callback)37 int32_t DragVSyncStation::RequestFrame(int32_t frameType, std::shared_ptr<DragFrameCallback> callback)
38 {
39 CHKPR(callback, RET_ERR);
40 if (frameType < TYPE_FLUSH_DRAG_POSITION || frameType >= REQUEST_TYPE_MAX) {
41 FI_HILOGE("Frame callback type is invalid, type:%{public}d", frameType);
42 return RET_ERR;
43 }
44 std::lock_guard<std::mutex> lock(mtx_);
45 int32_t ret = Init();
46 if (ret != RET_OK) {
47 FI_HILOGE("Init receiver failed");
48 return RET_ERR;
49 }
50 ret = receiver_->RequestNextVSync(frameCallback_);
51 if (ret != RET_OK) {
52 FI_HILOGE("Request next vSync failed");
53 return RET_ERR;
54 }
55 vSyncCallbacks_.emplace(frameType, callback);
56 return RET_OK;
57 }
58
StopVSyncRequest()59 void DragVSyncStation::StopVSyncRequest()
60 {
61 FI_HILOGI("StopVSyncRequest in");
62 std::lock_guard<std::mutex> lock(mtx_);
63 vSyncCallbacks_.erase(vSyncCallbacks_.begin(), vSyncCallbacks_.end());
64 if (handler_ != nullptr) {
65 handler_->RemoveAllEvents();
66 handler_->RemoveAllFileDescriptorListeners();
67 handler_ = nullptr;
68 }
69 receiver_ = nullptr;
70 vSyncPeriod_ = 0;
71 if (mmiHandleTid_ > 0) {
72 OHOS::QOS::ResetQosForOtherThread(mmiHandleTid_);
73 mmiHandleTid_ = INVALID_VALUE;
74 }
75 }
76
GetVSyncPeriod()77 uint64_t DragVSyncStation::GetVSyncPeriod()
78 {
79 std::lock_guard<std::mutex> lock(mtx_);
80 if (vSyncPeriod_ != 0) {
81 return vSyncPeriod_;
82 }
83 int64_t period = 0;
84 if (receiver_ != nullptr) {
85 int32_t ret = receiver_->GetVSyncPeriod(period);
86 if (ret != RET_OK) {
87 FI_HILOGE("GetVSyncPeriod failed");
88 }
89 }
90 vSyncPeriod_ = (period <= 0 ? 0 : static_cast<uint64_t>(period));
91 return vSyncPeriod_;
92 }
93
Init()94 int32_t DragVSyncStation::Init()
95 {
96 FI_HILOGD("Init receiver in");
97 if (receiver_ != nullptr) {
98 return RET_OK;
99 }
100 if (handler_ == nullptr) {
101 auto runner = AppExecFwk::EventRunner::Create(THREAD_NAME);
102 CHKPR(runner, RET_ERR);
103 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner));
104 SetThreadQosLevel(handler_);
105 }
106 mmiHandleTid_ = gettid();
107 SetQosForOtherThread(mmiHandleTid_);
108 CHKPR(handler_, RET_ERR);
109 receiver_ = Rosen::RSInterfaces::GetInstance().CreateVSyncReceiver("DragVSyncStation", handler_);
110 CHKPR(receiver_, RET_ERR);
111 int32_t ret = receiver_->Init();
112 if (ret != RET_OK) {
113 FI_HILOGE("Init receiver, %{public}d", ret);
114 return RET_ERR;
115 }
116 frameCallback_ = {
117 .userData_ = this,
118 .callback_ = OnVSync,
119 };
120 FI_HILOGI("Init receiver success");
121 return RET_OK;
122 }
123
SetThreadQosLevel(std::shared_ptr<AppExecFwk::EventHandler> handler)124 void DragVSyncStation::SetThreadQosLevel(std::shared_ptr<AppExecFwk::EventHandler> handler)
125 {
126 if (handler != nullptr) {
127 handler->PostTask([]() {
128 std::unordered_map<std::string, std::string> payload;
129 payload["pid"] = std::to_string(getpid());
130 OHOS::ConcurrentTask::ConcurrentTaskClient::GetInstance().RequestAuth(payload);
131 auto ret = OHOS::QOS::SetThreadQos(OHOS::QOS::QosLevel::QOS_USER_INTERACTIVE);
132 if (ret != 0) {
133 FI_HILOGE("SetThreadQos failed, ret:%{public}d", ret);
134 } else {
135 FI_HILOGE("SetThreadQos success");
136 }
137 });
138 }
139 }
140
SetQosForOtherThread(int32_t tid)141 void DragVSyncStation::SetQosForOtherThread(int32_t tid)
142 {
143 std::unordered_map<std::string, std::string> payload;
144 payload["pid"] = std::to_string(getpid());
145 OHOS::ConcurrentTask::ConcurrentTaskClient::GetInstance().RequestAuth(payload);
146 auto ret = OHOS::QOS::SetQosForOtherThread(OHOS::QOS::QosLevel::QOS_USER_INTERACTIVE, tid);
147 if (ret != 0) {
148 FI_HILOGE("Set mmi thread qos failed, ret:%{public}d", ret);
149 } else {
150 FI_HILOGE("Set mmi thread qos success");
151 }
152 }
153
OnVSyncInner(uint64_t nanoTimestamp)154 void DragVSyncStation::OnVSyncInner(uint64_t nanoTimestamp)
155 {
156 std::map<int32_t, std::shared_ptr<DragFrameCallback>> vSyncCallbacks;
157 {
158 std::lock_guard<std::mutex> lock(mtx_);
159 vSyncCallbacks.swap(vSyncCallbacks_);
160 }
161 for (auto const &callback : vSyncCallbacks) {
162 if (callback.second != nullptr) {
163 (*callback.second)(nanoTimestamp);
164 }
165 }
166 }
167
OnVSync(uint64_t nanoTimestamp,void * client)168 void DragVSyncStation::OnVSync(uint64_t nanoTimestamp, void *client)
169 {
170 auto vSyncClient = static_cast<DragVSyncStation *>(client);
171 if (vSyncClient != nullptr) {
172 vSyncClient->OnVSyncInner(nanoTimestamp);
173 } else {
174 FI_HILOGE("VSync client is null");
175 }
176 }
177 } // namespace DeviceStatus
178 } // namespace Msdp
179 } // namespace OHOS