1 /*
2 * Copyright (c) 2025 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 "rs_adapter.h"
17
18 #include <parameters.h>
19
20 #include "window_manager_hilog.h"
21
22 #define RETURN_IF_PARAM_IS_NULL(param, ...) \
23 do { \
24 if (!param) { \
25 TLOGE(WmsLogTag::WMS_SCB, "The %{public}s is null", #param); \
26 return __VA_ARGS__; \
27 } \
28 } while (false) \
29
30 namespace OHOS {
31 namespace Rosen {
32
33 InvokerType RSTransactionAdapter::invokerType_ = InvokerType::NONE;
34
35 // LCOV_EXCL_START
RSTransactionAdapter(const std::shared_ptr<RSUIContext> & rsUIContext)36 RSTransactionAdapter::RSTransactionAdapter(const std::shared_ptr<RSUIContext>& rsUIContext)
37 {
38 rsUIContext_ = rsUIContext;
39 if (RSAdapterUtil::IsClientMultiInstanceEnabled()) {
40 rsTransHandler_ = rsUIContext_ ? rsUIContext_->GetRSTransaction() : nullptr;
41 rsTransProxy_ = nullptr;
42 TLOGD(WmsLogTag::WMS_SCB, "Use RSTransactionHandler: %{public}s",
43 RSAdapterUtil::RSUIContextToStr(rsUIContext_).c_str());
44 } else {
45 rsTransHandler_ = nullptr;
46 rsTransProxy_ = RSTransactionProxy::GetInstance();
47 TLOGD(WmsLogTag::WMS_SCB, "Fallback to RSTransactionProxy");
48 }
49 }
50
RSTransactionAdapter(const std::shared_ptr<RSNode> & rsNode)51 RSTransactionAdapter::RSTransactionAdapter(const std::shared_ptr<RSNode>& rsNode) :
52 RSTransactionAdapter(rsNode ? rsNode->GetRSUIContext() : nullptr) {}
53
RSTransactionAdapter(const std::shared_ptr<RSUIDirector> & rsUIDirector)54 RSTransactionAdapter::RSTransactionAdapter(const std::shared_ptr<RSUIDirector>& rsUIDirector) :
55 RSTransactionAdapter(rsUIDirector ? rsUIDirector->GetRSUIContext() : nullptr) {}
56
GetRSUIContext() const57 std::shared_ptr<RSUIContext> RSTransactionAdapter::GetRSUIContext() const
58 {
59 RETURN_IF_RS_CLIENT_MULTI_INSTANCE_DISABLED(nullptr);
60 return rsUIContext_;
61 }
62
63 template<typename Func>
InvokeTransaction(Func && func,const char * caller)64 void RSTransactionAdapter::InvokeTransaction(Func&& func, const char* caller)
65 {
66 invokerType_ = InvokerType::NONE;
67 if (RSAdapterUtil::IsClientMultiInstanceEnabled()) {
68 RETURN_IF_PARAM_IS_NULL(rsTransHandler_);
69 invokerType_ = InvokerType::RS_TRANSACTION_HANDLER;
70 TLOGND(WmsLogTag::WMS_SCB, "%{public}s: Use RSTransactionHandler: %{public}s",
71 caller, RSAdapterUtil::RSUIContextToStr(rsUIContext_).c_str());
72 func(rsTransHandler_);
73 } else {
74 RETURN_IF_PARAM_IS_NULL(rsTransProxy_);
75 invokerType_ = InvokerType::RS_TRANSACTION_PROXY;
76 TLOGND(WmsLogTag::WMS_SCB, "%{public}s: Fallback to RSTransactionProxy", caller);
77 func(rsTransProxy_);
78 }
79 }
80
Begin()81 void RSTransactionAdapter::Begin()
82 {
83 InvokeTransaction(
84 [](auto& invoker) {
85 RETURN_IF_PARAM_IS_NULL(invoker);
86 invoker->Begin();
87 }, __func__);
88 }
89
Commit(uint64_t timestamp)90 void RSTransactionAdapter::Commit(uint64_t timestamp)
91 {
92 InvokeTransaction(
93 [timestamp](auto& invoker) {
94 RETURN_IF_PARAM_IS_NULL(invoker);
95 invoker->Commit(timestamp);
96 }, __func__);
97 }
98
FlushImplicitTransaction(uint64_t timestamp,const std::string & abilityName)99 void RSTransactionAdapter::FlushImplicitTransaction(uint64_t timestamp, const std::string& abilityName)
100 {
101 InvokeTransaction(
102 [timestamp, &abilityName](auto& invoker) {
103 RETURN_IF_PARAM_IS_NULL(invoker);
104 invoker->FlushImplicitTransaction(timestamp, abilityName);
105 }, __func__);
106 }
107 // LCOV_EXCL_STOP
108
FlushImplicitTransaction(const std::shared_ptr<RSUIContext> & rsUIContext,uint64_t timestamp,const std::string & abilityName)109 void RSTransactionAdapter::FlushImplicitTransaction(
110 const std::shared_ptr<RSUIContext>& rsUIContext, uint64_t timestamp, const std::string& abilityName)
111 {
112 invokerType_ = InvokerType::NONE;
113 if (RSAdapterUtil::IsClientMultiInstanceEnabled()) {
114 auto rsTransHandler = rsUIContext ? rsUIContext->GetRSTransaction() : nullptr;
115 RETURN_IF_PARAM_IS_NULL(rsTransHandler);
116 invokerType_ = InvokerType::RS_TRANSACTION_HANDLER;
117 TLOGD(WmsLogTag::WMS_SCB, "Use RSTransactionHandler: %{public}s",
118 RSAdapterUtil::RSUIContextToStr(rsUIContext).c_str());
119 rsTransHandler->FlushImplicitTransaction(timestamp, abilityName);
120 } else {
121 auto rsTransProxy = RSTransactionProxy::GetInstance();
122 RETURN_IF_PARAM_IS_NULL(rsTransProxy);
123 invokerType_ = InvokerType::RS_TRANSACTION_PROXY;
124 TLOGD(WmsLogTag::WMS_SCB, "Fallback to RSTransactionProxy");
125 rsTransProxy->FlushImplicitTransaction(timestamp, abilityName);
126 }
127 }
128
129 // LCOV_EXCL_START
FlushImplicitTransaction(const std::unordered_set<std::shared_ptr<RSUIContext>> & rsUIContexts,uint64_t timestamp,const std::string & abilityName)130 void RSTransactionAdapter::FlushImplicitTransaction(
131 const std::unordered_set<std::shared_ptr<RSUIContext>>& rsUIContexts,
132 uint64_t timestamp, const std::string& abilityName)
133 {
134 if (!RSAdapterUtil::IsClientMultiInstanceEnabled()) {
135 FlushImplicitTransaction(std::shared_ptr<RSUIContext>(nullptr), timestamp, abilityName);
136 return;
137 }
138 for (const auto& rsUIContext : rsUIContexts) {
139 FlushImplicitTransaction(rsUIContext, timestamp, abilityName);
140 }
141 }
142
FlushImplicitTransaction(std::initializer_list<std::shared_ptr<RSUIContext>> rsUIContexts,uint64_t timestamp,const std::string & abilityName)143 void RSTransactionAdapter::FlushImplicitTransaction(
144 std::initializer_list<std::shared_ptr<RSUIContext>> rsUIContexts,
145 uint64_t timestamp, const std::string& abilityName)
146 {
147 if (!RSAdapterUtil::IsClientMultiInstanceEnabled()) {
148 FlushImplicitTransaction(std::shared_ptr<RSUIContext>(nullptr), timestamp, abilityName);
149 return;
150 }
151 std::unordered_set<std::shared_ptr<RSUIContext>> rsUIContextSet;
152 for (const auto& rsUIContext : rsUIContexts) {
153 rsUIContextSet.insert(rsUIContext);
154 }
155 FlushImplicitTransaction(rsUIContextSet, timestamp, abilityName);
156 }
157
FlushImplicitTransaction(const std::shared_ptr<RSUIDirector> & rsUIDirector,uint64_t timestamp,const std::string & abilityName)158 void RSTransactionAdapter::FlushImplicitTransaction(
159 const std::shared_ptr<RSUIDirector>& rsUIDirector, uint64_t timestamp, const std::string& abilityName)
160 {
161 FlushImplicitTransaction(rsUIDirector ? rsUIDirector->GetRSUIContext() : nullptr, timestamp, abilityName);
162 }
163
FlushImplicitTransaction(std::initializer_list<std::shared_ptr<RSUIDirector>> rsUIDirectors,uint64_t timestamp,const std::string & abilityName)164 void RSTransactionAdapter::FlushImplicitTransaction(
165 std::initializer_list<std::shared_ptr<RSUIDirector>> rsUIDirectors,
166 uint64_t timestamp, const std::string& abilityName)
167 {
168 if (!RSAdapterUtil::IsClientMultiInstanceEnabled()) {
169 FlushImplicitTransaction(std::shared_ptr<RSUIContext>(nullptr), timestamp, abilityName);
170 return;
171 }
172 std::unordered_set<std::shared_ptr<RSUIContext>> rsUIContexts;
173 for (const auto& rsUIDirector : rsUIDirectors) {
174 rsUIContexts.insert(rsUIDirector ? rsUIDirector->GetRSUIContext() : nullptr);
175 }
176 FlushImplicitTransaction(rsUIContexts, timestamp, abilityName);
177 }
178 // LCOV_EXCL_STOP
179
FlushImplicitTransaction(const std::shared_ptr<RSNode> & rsNode,uint64_t timestamp,const std::string & abilityName)180 void RSTransactionAdapter::FlushImplicitTransaction(
181 const std::shared_ptr<RSNode>& rsNode, uint64_t timestamp, const std::string& abilityName)
182 {
183 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
184 FlushImplicitTransaction(rsNode ? rsNode->GetRSUIContext() : nullptr, timestamp, abilityName);
185 }
186
187 // LCOV_EXCL_START
FlushImplicitTransaction(std::initializer_list<std::shared_ptr<RSNode>> rsNodes,uint64_t timestamp,const std::string & abilityName)188 void RSTransactionAdapter::FlushImplicitTransaction(
189 std::initializer_list<std::shared_ptr<RSNode>> rsNodes,
190 uint64_t timestamp, const std::string& abilityName)
191 {
192 if (!RSAdapterUtil::IsClientMultiInstanceEnabled()) {
193 FlushImplicitTransaction(std::shared_ptr<RSUIContext>(nullptr), timestamp, abilityName);
194 return;
195 }
196 std::unordered_set<std::shared_ptr<RSUIContext>> rsUIContexts;
197 for (const auto& rsNode : rsNodes) {
198 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
199 rsUIContexts.insert(rsNode ? rsNode->GetRSUIContext() : nullptr);
200 }
201 FlushImplicitTransaction(rsUIContexts, timestamp, abilityName);
202 }
203
AutoRSTransaction(const std::shared_ptr<RSUIContext> & rsUIContext,bool enable)204 AutoRSTransaction::AutoRSTransaction(const std::shared_ptr<RSUIContext>& rsUIContext, bool enable)
205 {
206 if (enable) {
207 rsTransAdapter_ = std::make_shared<RSTransactionAdapter>(rsUIContext);
208 rsTransAdapter_->Begin();
209 } else {
210 rsTransAdapter_ = nullptr;
211 }
212 }
213
AutoRSTransaction(const std::shared_ptr<RSNode> & rsNode,bool enable)214 AutoRSTransaction::AutoRSTransaction(const std::shared_ptr<RSNode>& rsNode, bool enable) :
215 AutoRSTransaction(rsNode ? rsNode->GetRSUIContext() : nullptr, enable)
216 {
217 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
218 }
219
AutoRSTransaction(const std::shared_ptr<RSTransactionAdapter> & rsTransAdapter,bool enable)220 AutoRSTransaction::AutoRSTransaction(const std::shared_ptr<RSTransactionAdapter>& rsTransAdapter, bool enable)
221 {
222 if (rsTransAdapter != nullptr && enable) {
223 rsTransAdapter_ = rsTransAdapter;
224 rsTransAdapter_->Begin();
225 } else {
226 rsTransAdapter_ = nullptr;
227 }
228 }
229
~AutoRSTransaction()230 AutoRSTransaction::~AutoRSTransaction()
231 {
232 if (rsTransAdapter_) {
233 rsTransAdapter_->Commit();
234 }
235 }
236
237 InvokerType RSSyncTransactionAdapter::invokerType_ = InvokerType::NONE;
238
RSSyncTransactionAdapter(const std::shared_ptr<RSUIContext> & rsUIContext)239 RSSyncTransactionAdapter::RSSyncTransactionAdapter(const std::shared_ptr<RSUIContext>& rsUIContext)
240 {
241 rsUIContext_ = rsUIContext;
242 if (RSAdapterUtil::IsClientMultiInstanceEnabled()) {
243 rsSyncTransHandler_ = rsUIContext_ ? rsUIContext_->GetSyncTransactionHandler() : nullptr;
244 rsSyncTransController_ = nullptr;
245 TLOGD(WmsLogTag::WMS_SCB, "Use RSSyncTransactionHandler: %{public}s",
246 RSAdapterUtil::RSUIContextToStr(rsUIContext_).c_str());
247 } else {
248 rsSyncTransHandler_ = nullptr;
249 rsSyncTransController_ = RSSyncTransactionController::GetInstance();
250 TLOGD(WmsLogTag::WMS_SCB, "Fallback to RSSyncTransactionController");
251 }
252 }
253
RSSyncTransactionAdapter(const std::shared_ptr<RSNode> & rsNode)254 RSSyncTransactionAdapter::RSSyncTransactionAdapter(const std::shared_ptr<RSNode>& rsNode) :
255 RSSyncTransactionAdapter(rsNode ? rsNode->GetRSUIContext() : nullptr) {}
256
257 template<typename ReturnType, typename Func>
InvokeSyncTransaction(Func && func,const char * caller)258 ReturnType RSSyncTransactionAdapter::InvokeSyncTransaction(Func&& func, const char* caller)
259 {
260 invokerType_ = InvokerType::NONE;
261 if (RSAdapterUtil::IsClientMultiInstanceEnabled()) {
262 if (rsSyncTransHandler_) {
263 invokerType_ = InvokerType::RS_SYNC_TRANSACTION_HANDLER;
264 TLOGND(WmsLogTag::WMS_SCB, "%{public}s: Use RSSyncTransactionHandler: %{public}s",
265 caller, RSAdapterUtil::RSUIContextToStr(rsUIContext_).c_str());
266 return func(rsSyncTransHandler_);
267 }
268 } else {
269 if (rsSyncTransController_) {
270 invokerType_ = InvokerType::RS_SYNC_TRANSACTION_CONTROLLER;
271 TLOGND(WmsLogTag::WMS_SCB, "%{public}s: Fallback to RSSyncTransactionController", caller);
272 return func(rsSyncTransController_);
273 }
274 }
275 TLOGNE(WmsLogTag::WMS_SCB,
276 "%{public}s: Failed to invoke RSSyncTransaction", caller);
277 if constexpr (!std::is_void_v<ReturnType>) {
278 return nullptr;
279 }
280 }
281
GetRSUIContext() const282 std::shared_ptr<RSUIContext> RSSyncTransactionAdapter::GetRSUIContext() const
283 {
284 RETURN_IF_RS_CLIENT_MULTI_INSTANCE_DISABLED(nullptr);
285 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSUIContextToStr(rsUIContext_).c_str());
286 return rsUIContext_;
287 }
288
GetRSTransaction()289 std::shared_ptr<RSTransaction> RSSyncTransactionAdapter::GetRSTransaction()
290 {
291 return InvokeSyncTransaction<std::shared_ptr<RSTransaction>>(
292 [](auto& invoker) {
293 RETURN_IF_PARAM_IS_NULL(invoker, std::shared_ptr<RSTransaction>(nullptr));
294 return invoker->GetRSTransaction();
295 },
296 __func__);
297 }
298
OpenSyncTransaction(const std::shared_ptr<AppExecFwk::EventHandler> & handler)299 void RSSyncTransactionAdapter::OpenSyncTransaction(const std::shared_ptr<AppExecFwk::EventHandler>& handler)
300 {
301 InvokeSyncTransaction<void>(
302 [handler](auto& invoker) {
303 RETURN_IF_PARAM_IS_NULL(invoker);
304 invoker->OpenSyncTransaction(handler);
305 },
306 __func__);
307 }
308
CloseSyncTransaction(const std::shared_ptr<AppExecFwk::EventHandler> & handler)309 void RSSyncTransactionAdapter::CloseSyncTransaction(const std::shared_ptr<AppExecFwk::EventHandler>& handler)
310 {
311 InvokeSyncTransaction<void>(
312 [handler](auto& invoker) {
313 RETURN_IF_PARAM_IS_NULL(invoker);
314 invoker->CloseSyncTransaction(handler);
315 },
316 __func__);
317 }
318
319 template<typename ReturnType, typename Func>
InvokeSyncTransaction(const std::shared_ptr<RSUIContext> & rsUIContext,Func && func,const char * caller)320 ReturnType RSSyncTransactionAdapter::InvokeSyncTransaction(
321 const std::shared_ptr<RSUIContext>& rsUIContext, Func&& func, const char* caller)
322 {
323 invokerType_ = InvokerType::NONE;
324 if (RSAdapterUtil::IsClientMultiInstanceEnabled()) {
325 auto rsSyncTransHandler = rsUIContext ? rsUIContext->GetSyncTransactionHandler() : nullptr;
326 if (rsSyncTransHandler) {
327 invokerType_ = InvokerType::RS_SYNC_TRANSACTION_HANDLER;
328 TLOGND(WmsLogTag::WMS_SCB, "%{public}s: Use RSSyncTransactionHandler: %{public}s",
329 caller, RSAdapterUtil::RSUIContextToStr(rsUIContext).c_str());
330 return func(rsSyncTransHandler);
331 }
332 } else {
333 auto rsSyncTransController = RSSyncTransactionController::GetInstance();
334 if (rsSyncTransController) {
335 invokerType_ = InvokerType::RS_SYNC_TRANSACTION_CONTROLLER;
336 TLOGND(WmsLogTag::WMS_SCB, "%{public}s: Fallback to RSSyncTransactionController", caller);
337 return func(rsSyncTransController);
338 }
339 }
340 TLOGNE(WmsLogTag::WMS_SCB,
341 "%{public}s: Failed to invoke RSSyncTransaction", caller);
342 if constexpr (!std::is_void_v<ReturnType>) {
343 return nullptr;
344 }
345 }
346
GetRSTransaction(const std::shared_ptr<RSUIContext> & rsUIContext)347 std::shared_ptr<RSTransaction> RSSyncTransactionAdapter::GetRSTransaction(
348 const std::shared_ptr<RSUIContext>& rsUIContext)
349 {
350 return InvokeSyncTransaction<std::shared_ptr<RSTransaction>>(
351 rsUIContext,
352 [](auto& invoker) {
353 RETURN_IF_PARAM_IS_NULL(invoker, std::shared_ptr<RSTransaction>(nullptr));
354 return invoker->GetRSTransaction();
355 },
356 __func__);
357 }
358
GetRSTransaction(const std::shared_ptr<RSNode> & rsNode)359 std::shared_ptr<RSTransaction> RSSyncTransactionAdapter::GetRSTransaction(const std::shared_ptr<RSNode>& rsNode)
360 {
361 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
362 return GetRSTransaction(rsNode ? rsNode->GetRSUIContext() : nullptr);
363 }
364
OpenSyncTransaction(const std::shared_ptr<RSUIContext> & rsUIContext,const std::shared_ptr<AppExecFwk::EventHandler> & handler)365 void RSSyncTransactionAdapter::OpenSyncTransaction(
366 const std::shared_ptr<RSUIContext>& rsUIContext, const std::shared_ptr<AppExecFwk::EventHandler>& handler)
367 {
368 InvokeSyncTransaction<void>(
369 rsUIContext,
370 [handler](auto& invoker) {
371 RETURN_IF_PARAM_IS_NULL(invoker);
372 invoker->OpenSyncTransaction(handler);
373 },
374 __func__);
375 }
376
OpenSyncTransaction(const std::shared_ptr<RSNode> & rsNode,const std::shared_ptr<AppExecFwk::EventHandler> & handler)377 void RSSyncTransactionAdapter::OpenSyncTransaction(
378 const std::shared_ptr<RSNode>& rsNode, const std::shared_ptr<AppExecFwk::EventHandler>& handler)
379 {
380 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
381 OpenSyncTransaction(rsNode ? rsNode->GetRSUIContext() : nullptr, handler);
382 }
383
CloseSyncTransaction(const std::shared_ptr<RSUIContext> & rsUIContext,const std::shared_ptr<AppExecFwk::EventHandler> & handler)384 void RSSyncTransactionAdapter::CloseSyncTransaction(
385 const std::shared_ptr<RSUIContext>& rsUIContext, const std::shared_ptr<AppExecFwk::EventHandler>& handler)
386 {
387 InvokeSyncTransaction<void>(
388 rsUIContext,
389 [handler](auto& invoker) {
390 RETURN_IF_PARAM_IS_NULL(invoker);
391 invoker->CloseSyncTransaction(handler);
392 },
393 __func__);
394 }
395
CloseSyncTransaction(const std::shared_ptr<RSNode> & rsNode,const std::shared_ptr<AppExecFwk::EventHandler> & handler)396 void RSSyncTransactionAdapter::CloseSyncTransaction(
397 const std::shared_ptr<RSNode>& rsNode, const std::shared_ptr<AppExecFwk::EventHandler>& handler)
398 {
399 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
400 CloseSyncTransaction(rsNode ? rsNode->GetRSUIContext() : nullptr, handler);
401 }
402
AutoRSSyncTransaction(const std::shared_ptr<RSUIContext> & rsUIContext,bool needFlushImplicitTransaction,const std::shared_ptr<AppExecFwk::EventHandler> & handler)403 AutoRSSyncTransaction::AutoRSSyncTransaction(
404 const std::shared_ptr<RSUIContext>& rsUIContext,
405 bool needFlushImplicitTransaction,
406 const std::shared_ptr<AppExecFwk::EventHandler>& handler) : handler_(handler)
407 {
408 if (needFlushImplicitTransaction) {
409 RSTransactionAdapter::FlushImplicitTransaction(rsUIContext);
410 }
411 rsSyncTransAdapter_ = std::make_shared<RSSyncTransactionAdapter>(rsUIContext);
412 rsSyncTransAdapter_->OpenSyncTransaction(handler_);
413 }
414
AutoRSSyncTransaction(const std::shared_ptr<RSNode> & rsNode,bool needFlushImplicitTransaction,const std::shared_ptr<AppExecFwk::EventHandler> & handler)415 AutoRSSyncTransaction::AutoRSSyncTransaction(
416 const std::shared_ptr<RSNode>& rsNode,
417 bool needFlushImplicitTransaction,
418 const std::shared_ptr<AppExecFwk::EventHandler>& handler) :
419 AutoRSSyncTransaction(rsNode ? rsNode->GetRSUIContext() : nullptr, needFlushImplicitTransaction, handler)
420 {
421 TLOGD(WmsLogTag::WMS_SCB, "%{public}s", RSAdapterUtil::RSNodeToStr(rsNode).c_str());
422 }
423
AutoRSSyncTransaction(const std::shared_ptr<RSSyncTransactionAdapter> & rsSyncTransAdapter,bool needFlushImplicitTransaction,const std::shared_ptr<AppExecFwk::EventHandler> & handler)424 AutoRSSyncTransaction::AutoRSSyncTransaction(
425 const std::shared_ptr<RSSyncTransactionAdapter>& rsSyncTransAdapter,
426 bool needFlushImplicitTransaction,
427 const std::shared_ptr<AppExecFwk::EventHandler>& handler) :
428 rsSyncTransAdapter_(rsSyncTransAdapter), handler_(handler)
429 {
430 if (rsSyncTransAdapter_) {
431 if (needFlushImplicitTransaction) {
432 RSTransactionAdapter::FlushImplicitTransaction(rsSyncTransAdapter_->GetRSUIContext());
433 }
434 rsSyncTransAdapter_->OpenSyncTransaction(handler);
435 }
436 }
437
~AutoRSSyncTransaction()438 AutoRSSyncTransaction::~AutoRSSyncTransaction()
439 {
440 if (rsSyncTransAdapter_) {
441 rsSyncTransAdapter_->CloseSyncTransaction(handler_);
442 }
443 }
444
AllowInMultiThreadGuard(const std::shared_ptr<RSNode> & rsNode)445 AllowInMultiThreadGuard::AllowInMultiThreadGuard(const std::shared_ptr<RSNode>& rsNode) : rsNode_(rsNode)
446 {
447 if (rsNode_) {
448 TLOGD(WmsLogTag::WMS_SCB,
449 "Skip check in RS multi-instance: %{public}s", RSAdapterUtil::RSNodeToStr(rsNode_).c_str());
450 rsNode_->SetSkipCheckInMultiInstance(true);
451 }
452 }
453
~AllowInMultiThreadGuard()454 AllowInMultiThreadGuard::~AllowInMultiThreadGuard()
455 {
456 if (rsNode_) {
457 TLOGD(WmsLogTag::WMS_SCB,
458 "Reopen check in RS multi-instance: %{public}s", RSAdapterUtil::RSNodeToStr(rsNode_).c_str());
459 rsNode_->SetSkipCheckInMultiInstance(false);
460 }
461 }
462 // LCOV_EXCL_STOP
463
IsClientMultiInstanceEnabled()464 bool RSAdapterUtil::IsClientMultiInstanceEnabled()
465 {
466 static bool enabled = [] {
467 bool value = system::GetParameter("persist.rosen.rsclientmultiinstance.enabled", "0") != "0";
468 TLOGNI(WmsLogTag::WMS_SCB, "RS multi-instance enabled: %{public}d", value);
469 return value;
470 }();
471 return enabled;
472 }
473
InitRSUIDirector(std::shared_ptr<RSUIDirector> & rsUIDirector,bool shouldCreateRenderThread,bool isMultiInstance)474 void RSAdapterUtil::InitRSUIDirector(std::shared_ptr<RSUIDirector>& rsUIDirector,
475 bool shouldCreateRenderThread, bool isMultiInstance)
476 {
477 RETURN_IF_RS_CLIENT_MULTI_INSTANCE_DISABLED();
478 if (rsUIDirector) {
479 TLOGW(WmsLogTag::WMS_SCB,
480 "RSUIDirector already exists: %{public}s", RSAdapterUtil::RSUIDirectorToStr(rsUIDirector).c_str());
481 return;
482 }
483 rsUIDirector = RSUIDirector::Create();
484 if (rsUIDirector) {
485 rsUIDirector->Init(shouldCreateRenderThread, isMultiInstance);
486 TLOGI(WmsLogTag::WMS_SCB,
487 "Create RSUIDirector: %{public}s", RSAdapterUtil::RSUIDirectorToStr(rsUIDirector).c_str());
488 } else {
489 TLOGE(WmsLogTag::WMS_SCB, "Failed to create RSUIDirector");
490 }
491 }
492
493 // LCOV_EXCL_START
SetRSUIContext(const std::shared_ptr<RSNode> & rsNode,const std::shared_ptr<RSUIContext> & rsUIContext,bool skipCheckInMultiInstance)494 void RSAdapterUtil::SetRSUIContext(const std::shared_ptr<RSNode>& rsNode,
495 const std::shared_ptr<RSUIContext>& rsUIContext,
496 bool skipCheckInMultiInstance)
497 {
498 RETURN_IF_RS_CLIENT_MULTI_INSTANCE_DISABLED();
499 if (!rsNode) {
500 TLOGE(WmsLogTag::WMS_SCB, "RSNode is null");
501 return;
502 }
503 // The creation of RSUIContext and the use of RSNode may occur in different
504 // threads, so skip checks can be set.
505 rsNode->SetSkipCheckInMultiInstance(skipCheckInMultiInstance);
506 if (!rsUIContext) {
507 TLOGE(WmsLogTag::WMS_SCB, "RSUIContext is null, %{public}s",
508 RSAdapterUtil::RSNodeToStr(rsNode).c_str());
509 return;
510 }
511 auto originalRSUIContext = rsNode->GetRSUIContext();
512 if (rsUIContext == originalRSUIContext) {
513 TLOGD(WmsLogTag::WMS_SCB, "RSNode already has the same RSUIContext, %{public}s",
514 RSAdapterUtil::RSNodeToStr(rsNode).c_str());
515 return;
516 }
517 rsNode->SetRSUIContext(rsUIContext);
518 TLOGD(WmsLogTag::WMS_SCB,
519 "%{public}s, skipCheckInMultiInstance = %{public}d, original %{public}s",
520 RSAdapterUtil::RSNodeToStr(rsNode).c_str(), skipCheckInMultiInstance,
521 RSAdapterUtil::RSUIContextToStr(originalRSUIContext).c_str());
522 }
523 // LCOV_EXCL_STOP
524
SetRSTransactionHandler(const std::shared_ptr<RSTransaction> & rsTransaction,const std::shared_ptr<RSUIContext> & rsUIContext)525 void RSAdapterUtil::SetRSTransactionHandler(const std::shared_ptr<RSTransaction>& rsTransaction,
526 const std::shared_ptr<RSUIContext>& rsUIContext)
527 {
528 RETURN_IF_RS_CLIENT_MULTI_INSTANCE_DISABLED();
529 RETURN_IF_PARAM_IS_NULL(rsTransaction);
530 RETURN_IF_PARAM_IS_NULL(rsUIContext);
531 auto rsTransHandler = rsUIContext->GetRSTransaction();
532 RETURN_IF_PARAM_IS_NULL(rsTransHandler);
533 rsTransaction->SetTransactionHandler(rsTransHandler);
534 TLOGD(WmsLogTag::WMS_SCB, "syncId: %{public}" PRIu64 ", %{public}s",
535 rsTransaction->GetSyncId(), RSAdapterUtil::RSUIContextToStr(rsUIContext).c_str());
536 }
537
SetSkipCheckInMultiInstance(const std::shared_ptr<RSNode> & rsNode,bool skipCheckInMultiInstance)538 void RSAdapterUtil::SetSkipCheckInMultiInstance(const std::shared_ptr<RSNode>& rsNode,
539 bool skipCheckInMultiInstance)
540 {
541 RETURN_IF_RS_CLIENT_MULTI_INSTANCE_DISABLED();
542 RETURN_IF_PARAM_IS_NULL(rsNode);
543 rsNode->SetSkipCheckInMultiInstance(skipCheckInMultiInstance);
544 TLOGD(WmsLogTag::WMS_SCB, "%{public}s, skipCheckInMultiInstance = %{public}d",
545 RSAdapterUtil::RSNodeToStr(rsNode).c_str(), skipCheckInMultiInstance);
546 }
547
548 // LCOV_EXCL_START
GetRSNode(const std::shared_ptr<RSUIContext> & rsUIContext,NodeId id)549 const std::shared_ptr<RSBaseNode> RSAdapterUtil::GetRSNode(
550 const std::shared_ptr<RSUIContext>& rsUIContext, NodeId id)
551 {
552 if (!RSAdapterUtil::IsClientMultiInstanceEnabled()) {
553 return RSNodeMap::Instance().GetNode(id);
554 }
555 RETURN_IF_PARAM_IS_NULL(rsUIContext, nullptr);
556 return rsUIContext->GetNodeMap().GetNode(id);
557 }
558 // LCOV_EXCL_STOP
559
RSUIContextToStr(const std::shared_ptr<RSUIContext> & rsUIContext)560 std::string RSAdapterUtil::RSUIContextToStr(const std::shared_ptr<RSUIContext>& rsUIContext)
561 {
562 if (!rsUIContext) {
563 return "RSUIContext is null";
564 }
565 std::ostringstream oss;
566 oss << "RSUIContext [token: " << rsUIContext->GetToken()
567 << ", tid: "
568 << static_cast<int32_t>(rsUIContext->GetToken() >> 32) // 32: tid's offset position in the token
569 << "]";
570 return oss.str();
571 }
572
RSNodeToStr(const std::shared_ptr<RSNode> & rsNode)573 std::string RSAdapterUtil::RSNodeToStr(const std::shared_ptr<RSNode>& rsNode)
574 {
575 if (!rsNode) {
576 return "RSNode is null";
577 }
578 std::ostringstream oss;
579 oss << "RSNode [id: " << rsNode->GetId() << "], "
580 << RSUIContextToStr(rsNode->GetRSUIContext());
581 return oss.str();
582 }
583
RSUIDirectorToStr(const std::shared_ptr<RSUIDirector> & rsUIDirector)584 std::string RSAdapterUtil::RSUIDirectorToStr(const std::shared_ptr<RSUIDirector>& rsUIDirector)
585 {
586 if (!rsUIDirector) {
587 return "RSUIDirector is null";
588 }
589 std::ostringstream oss;
590 oss << "RSUIDirector's " << RSUIContextToStr(rsUIDirector->GetRSUIContext());
591 return oss.str();
592 }
593 } // namespace Rosen
594 } // namespace OHOS
595