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 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner));
103 SetThreadQosLevel(handler_);
104 }
105 mmiHandleTid_ = gettid();
106 SetQosForOtherThread(mmiHandleTid_);
107 CHKPR(handler_, RET_ERR);
108 receiver_ = Rosen::RSInterfaces::GetInstance().CreateVSyncReceiver("DragVSyncStation", handler_);
109 CHKPR(receiver_, RET_ERR);
110 int32_t ret = receiver_->Init();
111 if (ret != RET_OK) {
112 FI_HILOGE("Init receiver, %{public}d", ret);
113 return RET_ERR;
114 }
115 frameCallback_ = {
116 .userData_ = this,
117 .callback_ = OnVSync,
118 };
119 FI_HILOGI("Init receiver success");
120 return RET_OK;
121 }
122
SetThreadQosLevel(std::shared_ptr<AppExecFwk::EventHandler> handler)123 void DragVSyncStation::SetThreadQosLevel(std::shared_ptr<AppExecFwk::EventHandler> handler)
124 {
125 if (handler != nullptr) {
126 handler->PostTask([]() {
127 std::unordered_map<std::string, std::string> payload;
128 payload["pid"] = std::to_string(getpid());
129 OHOS::ConcurrentTask::ConcurrentTaskClient::GetInstance().RequestAuth(payload);
130 auto ret = OHOS::QOS::SetThreadQos(OHOS::QOS::QosLevel::QOS_USER_INTERACTIVE);
131 if (ret != 0) {
132 FI_HILOGE("SetThreadQos failed, ret:%{public}d", ret);
133 } else {
134 FI_HILOGE("SetThreadQos success");
135 }
136 });
137 }
138 }
139
SetQosForOtherThread(int32_t tid)140 void DragVSyncStation::SetQosForOtherThread(int32_t tid)
141 {
142 std::unordered_map<std::string, std::string> payload;
143 payload["pid"] = std::to_string(getpid());
144 OHOS::ConcurrentTask::ConcurrentTaskClient::GetInstance().RequestAuth(payload);
145 auto ret = OHOS::QOS::SetQosForOtherThread(OHOS::QOS::QosLevel::QOS_USER_INTERACTIVE, tid);
146 if (ret != 0) {
147 FI_HILOGE("Set mmi thread qos failed, ret:%{public}d", ret);
148 } else {
149 FI_HILOGE("Set mmi thread qos success");
150 }
151 }
152
OnVSyncInner(uint64_t nanoTimestamp)153 void DragVSyncStation::OnVSyncInner(uint64_t nanoTimestamp)
154 {
155 std::map<int32_t, std::shared_ptr<DragFrameCallback>> vSyncCallbacks;
156 {
157 std::lock_guard<std::mutex> lock(mtx_);
158 vSyncCallbacks.swap(vSyncCallbacks_);
159 }
160 for (auto const &callback : vSyncCallbacks) {
161 if (callback.second != nullptr) {
162 (*callback.second)(nanoTimestamp);
163 }
164 }
165 }
166
OnVSync(uint64_t nanoTimestamp,void * client)167 void DragVSyncStation::OnVSync(uint64_t nanoTimestamp, void *client)
168 {
169 auto vSyncClient = static_cast<DragVSyncStation *>(client);
170 if (vSyncClient != nullptr) {
171 vSyncClient->OnVSyncInner(nanoTimestamp);
172 } else {
173 FI_HILOGE("VSync client is null");
174 }
175 }
176 } // namespace DeviceStatus
177 } // namespace Msdp
178 } // namespace OHOS