1 /*
2 * Copyright (c) 2021-2023 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 "transaction/rs_transaction_proxy.h"
17 #include <stdlib.h>
18
19 #ifdef ROSEN_OHOS
20 #include "mem_mgr_client.h"
21 #endif
22 #include "platform/common/rs_log.h"
23 #include "platform/common/rs_system_properties.h"
24 #include "rs_trace.h"
25
26 namespace OHOS {
27 namespace Rosen {
28 std::once_flag RSTransactionProxy::flag_;
29 RSTransactionProxy* RSTransactionProxy::instance_ = nullptr;
30
GetInstance()31 RSTransactionProxy* RSTransactionProxy::GetInstance()
32 {
33 std::call_once(flag_, &RSTransactionProxy::Init);
34 return instance_;
35 }
36
RSTransactionProxy()37 RSTransactionProxy::RSTransactionProxy()
38 {
39 }
40
~RSTransactionProxy()41 RSTransactionProxy::~RSTransactionProxy()
42 {
43 }
44
Init()45 void RSTransactionProxy::Init()
46 {
47 instance_ = new RSTransactionProxy();
48 ::atexit(&RSTransactionProxy::Destroy);
49 }
50
Destroy()51 void RSTransactionProxy::Destroy()
52 {
53 instance_ = nullptr;
54 }
55
SetRenderThreadClient(std::unique_ptr<RSIRenderClient> & renderThreadClient)56 void RSTransactionProxy::SetRenderThreadClient(std::unique_ptr<RSIRenderClient>& renderThreadClient)
57 {
58 if (renderThreadClient != nullptr) {
59 renderThreadClient_ = std::move(renderThreadClient);
60 }
61 }
62
SetRenderServiceClient(const std::shared_ptr<RSIRenderClient> & renderServiceClient)63 void RSTransactionProxy::SetRenderServiceClient(const std::shared_ptr<RSIRenderClient>& renderServiceClient)
64 {
65 if (renderServiceClient != nullptr) {
66 renderServiceClient_ = renderServiceClient;
67 }
68 }
69
AddCommand(std::unique_ptr<RSCommand> & command,bool isRenderServiceCommand,FollowType followType,NodeId nodeId)70 void RSTransactionProxy::AddCommand(std::unique_ptr<RSCommand>& command, bool isRenderServiceCommand,
71 FollowType followType, NodeId nodeId)
72 {
73 if ((renderServiceClient_ == nullptr && renderThreadClient_ == nullptr) || command == nullptr) {
74 RS_LOGE("RSTransactionProxy::add command fail, (renderServiceClient_ and renderThreadClient_ is nullptr)"
75 " or command is nullptr");
76 return;
77 }
78
79 std::unique_lock<std::mutex> cmdLock(mutex_);
80
81 RS_LOGI_IF(DEBUG_NODE,
82 "RSTransactionProxy::add command nodeId:%{public}" PRIu64 " isRenderServiceCommand:%{public}d"
83 " followType:%{public}hu", nodeId, isRenderServiceCommand, followType);
84 if (renderServiceClient_ != nullptr && (isRenderServiceCommand || renderThreadClient_ == nullptr)) {
85 #ifdef ROSEN_OHOS
86 int appPid = ExtractPid(nodeId);
87 if (isRenderServiceCommand && command->GetSubType() == RSCommandType::ANIMATION &&
88 RSSystemProperties::GetDmaReclaimParam()) {
89 RS_TRACE_NAME_FMT("MemoryStatusChanged from proxy pid[%d]", appPid);
90 Memory::MemMgrClient::GetInstance().MemoryStatusChanged(appPid,
91 static_cast<int32_t>(Memory::MemoryTypeCode::DMABUF),
92 static_cast<int32_t>(Memory::MemoryStatusCode::USED));
93 }
94 #endif
95 AddRemoteCommand(command, nodeId, followType);
96 return;
97 }
98
99 if (!isRenderServiceCommand) {
100 AddCommonCommand(command);
101 return;
102 }
103 ROSEN_LOGE("RSTransactionProxy::AddCommand failed, isRenderServiceCommand:%{public}d %{public}s",
104 isRenderServiceCommand, command->PrintType().c_str());
105 }
106
AddCommandFromRT(std::unique_ptr<RSCommand> & command,NodeId nodeId,FollowType followType)107 void RSTransactionProxy::AddCommandFromRT(std::unique_ptr<RSCommand>& command, NodeId nodeId, FollowType followType)
108 {
109 if (renderServiceClient_ == nullptr || command == nullptr) {
110 return;
111 }
112
113 {
114 std::unique_lock<std::mutex> cmdLock(mutexForRT_);
115 implicitTransactionDataFromRT_->AddCommand(command, nodeId, followType);
116 }
117 }
118
ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask> & task,bool isRenderServiceTask)119 void RSTransactionProxy::ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask>& task, bool isRenderServiceTask)
120 {
121 if (!task) {
122 ROSEN_LOGE("RSTransactionProxy::ExecuteSynchronousTask failed, the task is not exist.");
123 return;
124 }
125
126 if (renderServiceClient_ && isRenderServiceTask) {
127 renderServiceClient_->ExecuteSynchronousTask(task);
128 return;
129 }
130
131 if (renderThreadClient_ && (!isRenderServiceTask)) {
132 renderThreadClient_->ExecuteSynchronousTask(task);
133 return;
134 }
135
136 ROSEN_LOGE("RSTransactionProxy::ExecuteSynchronousTask failed, isRenderServiceTask is %{public}d.",
137 isRenderServiceTask);
138 }
139
FlushImplicitTransaction(uint64_t timestamp,const std::string & abilityName)140 void RSTransactionProxy::FlushImplicitTransaction(uint64_t timestamp, const std::string& abilityName)
141 {
142 std::unique_lock<std::mutex> cmdLock(mutex_);
143 if (!implicitRemoteTransactionDataStack_.empty() && needSync_) {
144 RS_LOGE_LIMIT(__func__, __line__, "FlushImplicitTransaction failed, DataStack not empty");
145 return;
146 }
147 timestamp_ = std::max(timestamp, timestamp_);
148 if (renderThreadClient_ != nullptr && !implicitCommonTransactionData_->IsEmpty()) {
149 implicitCommonTransactionData_->timestamp_ = timestamp_;
150 implicitCommonTransactionData_->abilityName_ = abilityName;
151 renderThreadClient_->CommitTransaction(implicitCommonTransactionData_);
152 implicitCommonTransactionData_ = std::make_unique<RSTransactionData>();
153 } else {
154 if (flushEmptyCallback_) {
155 flushEmptyCallback_(timestamp_);
156 }
157 }
158
159 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionData_->IsEmpty()) {
160 implicitRemoteTransactionData_->timestamp_ = timestamp_;
161 renderServiceClient_->CommitTransaction(implicitRemoteTransactionData_);
162 transactionDataIndex_ = implicitRemoteTransactionData_->GetIndex();
163 implicitRemoteTransactionData_ = std::make_unique<RSTransactionData>();
164 } else {
165 RS_LOGE_LIMIT(__func__, __line__, "FlushImplicitTransaction return, [renderServiceClient_:%{public}d," \
166 " transactionData empty:%{public}d]",
167 renderServiceClient_ != nullptr, implicitRemoteTransactionData_->IsEmpty());
168 }
169 }
170
GetTransactionDataIndex() const171 uint32_t RSTransactionProxy::GetTransactionDataIndex() const
172 {
173 return transactionDataIndex_;
174 }
175
IsEmpty() const176 bool RSTransactionProxy::IsEmpty() const
177 {
178 bool isEmpty = true;
179 std::unique_lock<std::mutex> cmdLock(mutex_);
180 if (implicitCommonTransactionData_) {
181 isEmpty &= implicitCommonTransactionData_->IsEmpty();
182 }
183 if (implicitRemoteTransactionData_) {
184 isEmpty &= implicitRemoteTransactionData_->IsEmpty();
185 }
186 isEmpty &= implicitCommonTransactionDataStack_.empty();
187 isEmpty &= implicitRemoteTransactionDataStack_.empty();
188 return isEmpty;
189 }
190
FlushImplicitTransactionFromRT(uint64_t timestamp)191 void RSTransactionProxy::FlushImplicitTransactionFromRT(uint64_t timestamp)
192 {
193 std::unique_lock<std::mutex> cmdLock(mutexForRT_);
194 if (renderServiceClient_ != nullptr && !implicitTransactionDataFromRT_->IsEmpty()) {
195 implicitTransactionDataFromRT_->timestamp_ = timestamp;
196 renderServiceClient_->CommitTransaction(implicitTransactionDataFromRT_);
197 implicitTransactionDataFromRT_ = std::make_unique<RSTransactionData>();
198 }
199 }
200
StartSyncTransaction()201 void RSTransactionProxy::StartSyncTransaction()
202 {
203 needSync_ = true;
204 }
205
CloseSyncTransaction()206 void RSTransactionProxy::CloseSyncTransaction()
207 {
208 needSync_ = false;
209 }
210
StartCloseSyncTransactionFallbackTask(std::shared_ptr<AppExecFwk::EventHandler> handler,bool isOpen)211 void RSTransactionProxy::StartCloseSyncTransactionFallbackTask(
212 std::shared_ptr<AppExecFwk::EventHandler> handler, bool isOpen)
213 {
214 std::unique_lock<std::mutex> cmdLock(mutex_);
215 static uint32_t num = 0;
216 const std::string name = "CloseSyncTransactionFallbackTask";
217 const int timeOutDelay = 5000;
218 if (!handler) {
219 ROSEN_LOGD("StartCloseSyncTransactionFallbackTask handler is null");
220 return;
221 }
222 if (isOpen) {
223 num++;
224 auto taskName = name + std::to_string(num);
225 taskNames_.push(taskName);
226 auto task = [this]() {
227 RS_TRACE_NAME("CloseSyncTransaction timeout");
228 ROSEN_LOGE("CloseSyncTransaction timeout");
229 auto transactionProxy = RSTransactionProxy::GetInstance();
230 if (transactionProxy != nullptr) {
231 transactionProxy->CommitSyncTransaction();
232 transactionProxy->CloseSyncTransaction();
233 }
234 if (!taskNames_.empty()) {
235 taskNames_.pop();
236 }
237 };
238 handler->PostTask(task, taskName, timeOutDelay);
239 } else {
240 if (!taskNames_.empty()) {
241 handler->RemoveTask(taskNames_.front());
242 taskNames_.pop();
243 }
244 }
245 }
246
Begin()247 void RSTransactionProxy::Begin()
248 {
249 std::unique_lock<std::mutex> cmdLock(mutex_);
250 implicitCommonTransactionDataStack_.emplace(std::make_unique<RSTransactionData>());
251 implicitRemoteTransactionDataStack_.emplace(std::make_unique<RSTransactionData>());
252 if (needSync_) {
253 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
254 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
255 }
256 }
257
Commit(uint64_t timestamp)258 void RSTransactionProxy::Commit(uint64_t timestamp)
259 {
260 std::unique_lock<std::mutex> cmdLock(mutex_);
261 if (!implicitCommonTransactionDataStack_.empty()) {
262 implicitCommonTransactionDataStack_.pop();
263 }
264
265 if (!implicitRemoteTransactionDataStack_.empty()) {
266 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionDataStack_.top()->IsEmpty()) {
267 implicitRemoteTransactionDataStack_.top()->timestamp_ = timestamp;
268 renderServiceClient_->CommitTransaction(implicitRemoteTransactionDataStack_.top());
269 }
270 implicitRemoteTransactionDataStack_.pop();
271 }
272 }
273
CommitSyncTransaction(uint64_t timestamp,const std::string & abilityName)274 void RSTransactionProxy::CommitSyncTransaction(uint64_t timestamp, const std::string& abilityName)
275 {
276 std::unique_lock<std::mutex> cmdLock(mutex_);
277 timestamp_ = std::max(timestamp, timestamp_);
278 if (!implicitCommonTransactionDataStack_.empty()) {
279 if (renderThreadClient_ != nullptr && (!implicitCommonTransactionDataStack_.top()->IsEmpty() ||
280 implicitCommonTransactionDataStack_.top()->IsNeedSync())) {
281 implicitCommonTransactionDataStack_.top()->timestamp_ = timestamp;
282 implicitCommonTransactionDataStack_.top()->abilityName_ = abilityName;
283 implicitCommonTransactionDataStack_.top()->SetSyncId(syncId_);
284 renderThreadClient_->CommitTransaction(implicitCommonTransactionDataStack_.top());
285 }
286 implicitCommonTransactionDataStack_.pop();
287 }
288
289 if (!implicitRemoteTransactionDataStack_.empty()) {
290 if (renderServiceClient_ != nullptr && (!implicitRemoteTransactionDataStack_.top()->IsEmpty() ||
291 implicitRemoteTransactionDataStack_.top()->IsNeedSync())) {
292 implicitRemoteTransactionDataStack_.top()->timestamp_ = timestamp;
293 implicitRemoteTransactionDataStack_.top()->SetSyncId(syncId_);
294 renderServiceClient_->CommitTransaction(implicitRemoteTransactionDataStack_.top());
295 }
296 implicitRemoteTransactionDataStack_.pop();
297 }
298 }
299
MarkTransactionNeedSync()300 void RSTransactionProxy::MarkTransactionNeedSync()
301 {
302 std::unique_lock<std::mutex> cmdLock(mutex_);
303 if (!implicitCommonTransactionDataStack_.empty()) {
304 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
305 }
306
307 if (!implicitRemoteTransactionDataStack_.empty()) {
308 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
309 }
310 }
311
MarkTransactionNeedCloseSync(const int32_t transactionCount)312 void RSTransactionProxy::MarkTransactionNeedCloseSync(const int32_t transactionCount)
313 {
314 std::unique_lock<std::mutex> cmdLock(mutex_);
315 if (!implicitCommonTransactionDataStack_.empty()) {
316 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
317 implicitCommonTransactionDataStack_.top()->MarkNeedCloseSync();
318 implicitCommonTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
319 }
320
321 if (!implicitRemoteTransactionDataStack_.empty()) {
322 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
323 implicitRemoteTransactionDataStack_.top()->MarkNeedCloseSync();
324 implicitRemoteTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
325 }
326 }
327
SetSyncTransactionNum(const int32_t transactionCount)328 void RSTransactionProxy::SetSyncTransactionNum(const int32_t transactionCount)
329 {
330 std::unique_lock<std::mutex> cmdLock(mutex_);
331 if (!implicitCommonTransactionDataStack_.empty()) {
332 implicitCommonTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
333 }
334
335 if (!implicitRemoteTransactionDataStack_.empty()) {
336 implicitRemoteTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
337 }
338 }
339
SetParentPid(const int32_t parentPid)340 void RSTransactionProxy::SetParentPid(const int32_t parentPid)
341 {
342 std::unique_lock<std::mutex> cmdLock(mutex_);
343 if (!implicitCommonTransactionDataStack_.empty()) {
344 implicitCommonTransactionDataStack_.top()->SetParentPid(parentPid);
345 }
346
347 if (!implicitRemoteTransactionDataStack_.empty()) {
348 implicitRemoteTransactionDataStack_.top()->SetParentPid(parentPid);
349 }
350 }
351
AddCommonCommand(std::unique_ptr<RSCommand> & command)352 void RSTransactionProxy::AddCommonCommand(std::unique_ptr<RSCommand> &command)
353 {
354 if (!implicitCommonTransactionDataStack_.empty()) {
355 implicitCommonTransactionDataStack_.top()->AddCommand(command, 0, FollowType::NONE);
356 return;
357 }
358 implicitCommonTransactionData_->AddCommand(command, 0, FollowType::NONE);
359 }
360
AddRemoteCommand(std::unique_ptr<RSCommand> & command,NodeId nodeId,FollowType followType)361 void RSTransactionProxy::AddRemoteCommand(std::unique_ptr<RSCommand>& command, NodeId nodeId, FollowType followType)
362 {
363 if (!implicitRemoteTransactionDataStack_.empty()) {
364 implicitRemoteTransactionDataStack_.top()->AddCommand(command, nodeId, followType);
365 return;
366 }
367 implicitRemoteTransactionData_->AddCommand(command, nodeId, followType);
368 }
369
370 } // namespace Rosen
371 } // namespace OHOS
372