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