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 #include "platform/common/rs_log.h"
20
21 namespace OHOS {
22 namespace Rosen {
23 std::once_flag RSTransactionProxy::flag_;
24 RSTransactionProxy* RSTransactionProxy::instance_ = nullptr;
25
GetInstance()26 RSTransactionProxy* RSTransactionProxy::GetInstance()
27 {
28 std::call_once(flag_, &RSTransactionProxy::Init);
29 return instance_;
30 }
31
RSTransactionProxy()32 RSTransactionProxy::RSTransactionProxy()
33 {
34 }
35
~RSTransactionProxy()36 RSTransactionProxy::~RSTransactionProxy()
37 {
38 }
39
Init()40 void RSTransactionProxy::Init()
41 {
42 instance_ = new RSTransactionProxy();
43 ::atexit(&RSTransactionProxy::Destroy);
44 }
45
Destroy()46 void RSTransactionProxy::Destroy()
47 {
48 instance_ = nullptr;
49 }
50
SetRenderThreadClient(std::unique_ptr<RSIRenderClient> & renderThreadClient)51 void RSTransactionProxy::SetRenderThreadClient(std::unique_ptr<RSIRenderClient>& renderThreadClient)
52 {
53 if (renderThreadClient != nullptr) {
54 renderThreadClient_ = std::move(renderThreadClient);
55 }
56 }
57
SetRenderServiceClient(const std::shared_ptr<RSIRenderClient> & renderServiceClient)58 void RSTransactionProxy::SetRenderServiceClient(const std::shared_ptr<RSIRenderClient>& renderServiceClient)
59 {
60 if (renderServiceClient != nullptr) {
61 renderServiceClient_ = renderServiceClient;
62 }
63 }
64
AddCommand(std::unique_ptr<RSCommand> & command,bool isRenderServiceCommand,FollowType followType,NodeId nodeId)65 void RSTransactionProxy::AddCommand(std::unique_ptr<RSCommand>& command, bool isRenderServiceCommand,
66 FollowType followType, NodeId nodeId)
67 {
68 if ((renderServiceClient_ == nullptr && renderThreadClient_ == nullptr) || command == nullptr) {
69 RS_LOGE("RSTransactionProxy::add command fail, (renderServiceClient_ and renderThreadClient_ is nullptr)"
70 " or command is nullptr");
71 return;
72 }
73
74 std::unique_lock<std::mutex> cmdLock(mutex_);
75
76 RS_LOGI_IF(DEBUG_NODE,
77 "RSTransactionProxy::add command nodeId:%{public}" PRIu64 " isRenderServiceCommand:%{public}d"
78 " followType:%{public}hu", nodeId, isRenderServiceCommand, followType);
79 if (renderServiceClient_ != nullptr && (isRenderServiceCommand || renderThreadClient_ == nullptr)) {
80 AddRemoteCommand(command, nodeId, followType);
81 return;
82 }
83
84 if (!isRenderServiceCommand) {
85 AddCommonCommand(command);
86 return;
87 }
88 ROSEN_LOGE("RSTransactionProxy::AddCommand failed, isRenderServiceCommand:%{public}d %{public}s",
89 isRenderServiceCommand, command->PrintType().c_str());
90 }
91
AddCommandFromRT(std::unique_ptr<RSCommand> & command,NodeId nodeId,FollowType followType)92 void RSTransactionProxy::AddCommandFromRT(std::unique_ptr<RSCommand>& command, NodeId nodeId, FollowType followType)
93 {
94 if (renderServiceClient_ == nullptr || command == nullptr) {
95 return;
96 }
97
98 {
99 std::unique_lock<std::mutex> cmdLock(mutexForRT_);
100 implicitTransactionDataFromRT_->AddCommand(command, nodeId, followType);
101 }
102 }
103
ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask> & task,bool isRenderServiceTask)104 void RSTransactionProxy::ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask>& task, bool isRenderServiceTask)
105 {
106 if (!task) {
107 ROSEN_LOGE("RSTransactionProxy::ExecuteSynchronousTask failed, the task is not exist.");
108 return;
109 }
110
111 if (renderServiceClient_ && isRenderServiceTask) {
112 renderServiceClient_->ExecuteSynchronousTask(task);
113 return;
114 }
115
116 if (renderThreadClient_ && (!isRenderServiceTask)) {
117 renderThreadClient_->ExecuteSynchronousTask(task);
118 return;
119 }
120
121 ROSEN_LOGE("RSTransactionProxy::ExecuteSynchronousTask failed, isRenderServiceTask is %{public}d.",
122 isRenderServiceTask);
123 }
124
FlushImplicitTransaction(uint64_t timestamp,const std::string & abilityName)125 void RSTransactionProxy::FlushImplicitTransaction(uint64_t timestamp, const std::string& abilityName)
126 {
127 std::unique_lock<std::mutex> cmdLock(mutex_);
128 if (!implicitRemoteTransactionDataStack_.empty() && needSync_) {
129 RS_LOGE_LIMIT(__func__, __line__, "FlushImplicitTransaction failed, DataStack not empty");
130 return;
131 }
132 timestamp_ = std::max(timestamp, timestamp_);
133 if (renderThreadClient_ != nullptr && !implicitCommonTransactionData_->IsEmpty()) {
134 implicitCommonTransactionData_->timestamp_ = timestamp_;
135 implicitCommonTransactionData_->abilityName_ = abilityName;
136 renderThreadClient_->CommitTransaction(implicitCommonTransactionData_);
137 implicitCommonTransactionData_ = std::make_unique<RSTransactionData>();
138 } else {
139 if (flushEmptyCallback_) {
140 flushEmptyCallback_(timestamp_);
141 }
142 }
143
144 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionData_->IsEmpty()) {
145 implicitRemoteTransactionData_->timestamp_ = timestamp_;
146 renderServiceClient_->CommitTransaction(implicitRemoteTransactionData_);
147 transactionDataIndex_ = implicitRemoteTransactionData_->GetIndex();
148 implicitRemoteTransactionData_ = std::make_unique<RSTransactionData>();
149 } else {
150 RS_LOGE_LIMIT(__func__, __line__, "FlushImplicitTransaction return, [renderServiceClient_:%{public}d,]" \
151 " transactionData empty:%{public}d",
152 renderServiceClient_ != nullptr, implicitRemoteTransactionData_->IsEmpty());
153 }
154 }
155
GetTransactionDataIndex() const156 uint32_t RSTransactionProxy::GetTransactionDataIndex() const
157 {
158 return transactionDataIndex_;
159 }
160
IsEmpty() const161 bool RSTransactionProxy::IsEmpty() const
162 {
163 bool isEmpty = true;
164 std::unique_lock<std::mutex> cmdLock(mutex_);
165 if (implicitCommonTransactionData_) {
166 isEmpty &= implicitCommonTransactionData_->IsEmpty();
167 }
168 if (implicitRemoteTransactionData_) {
169 isEmpty &= implicitRemoteTransactionData_->IsEmpty();
170 }
171 isEmpty &= implicitCommonTransactionDataStack_.empty();
172 isEmpty &= implicitRemoteTransactionDataStack_.empty();
173 return isEmpty;
174 }
175
FlushImplicitTransactionFromRT(uint64_t timestamp)176 void RSTransactionProxy::FlushImplicitTransactionFromRT(uint64_t timestamp)
177 {
178 std::unique_lock<std::mutex> cmdLock(mutexForRT_);
179 if (renderServiceClient_ != nullptr && !implicitTransactionDataFromRT_->IsEmpty()) {
180 implicitTransactionDataFromRT_->timestamp_ = timestamp;
181 renderServiceClient_->CommitTransaction(implicitTransactionDataFromRT_);
182 implicitTransactionDataFromRT_ = std::make_unique<RSTransactionData>();
183 }
184 }
185
StartSyncTransaction()186 void RSTransactionProxy::StartSyncTransaction()
187 {
188 needSync_ = true;
189 }
190
CloseSyncTransaction()191 void RSTransactionProxy::CloseSyncTransaction()
192 {
193 needSync_ = false;
194 }
195
Begin()196 void RSTransactionProxy::Begin()
197 {
198 std::unique_lock<std::mutex> cmdLock(mutex_);
199 implicitCommonTransactionDataStack_.emplace(std::make_unique<RSTransactionData>());
200 implicitRemoteTransactionDataStack_.emplace(std::make_unique<RSTransactionData>());
201 if (needSync_) {
202 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
203 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
204 }
205 }
206
Commit(uint64_t timestamp)207 void RSTransactionProxy::Commit(uint64_t timestamp)
208 {
209 std::unique_lock<std::mutex> cmdLock(mutex_);
210 if (!implicitCommonTransactionDataStack_.empty()) {
211 implicitCommonTransactionDataStack_.pop();
212 }
213
214 if (!implicitRemoteTransactionDataStack_.empty()) {
215 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionDataStack_.top()->IsEmpty()) {
216 implicitRemoteTransactionDataStack_.top()->timestamp_ = timestamp;
217 renderServiceClient_->CommitTransaction(implicitRemoteTransactionDataStack_.top());
218 }
219 implicitRemoteTransactionDataStack_.pop();
220 }
221 }
222
CommitSyncTransaction(uint64_t timestamp,const std::string & abilityName)223 void RSTransactionProxy::CommitSyncTransaction(uint64_t timestamp, const std::string& abilityName)
224 {
225 std::unique_lock<std::mutex> cmdLock(mutex_);
226 timestamp_ = std::max(timestamp, timestamp_);
227 if (!implicitCommonTransactionDataStack_.empty()) {
228 if (renderThreadClient_ != nullptr && (!implicitCommonTransactionDataStack_.top()->IsEmpty() ||
229 implicitCommonTransactionDataStack_.top()->IsNeedSync())) {
230 implicitCommonTransactionDataStack_.top()->timestamp_ = timestamp;
231 implicitCommonTransactionDataStack_.top()->abilityName_ = abilityName;
232 implicitCommonTransactionDataStack_.top()->SetSyncId(syncId_);
233 renderThreadClient_->CommitTransaction(implicitCommonTransactionDataStack_.top());
234 }
235 implicitCommonTransactionDataStack_.pop();
236 }
237
238 if (!implicitRemoteTransactionDataStack_.empty()) {
239 if (renderServiceClient_ != nullptr && (!implicitRemoteTransactionDataStack_.top()->IsEmpty() ||
240 implicitRemoteTransactionDataStack_.top()->IsNeedSync())) {
241 implicitRemoteTransactionDataStack_.top()->timestamp_ = timestamp;
242 implicitRemoteTransactionDataStack_.top()->SetSyncId(syncId_);
243 renderServiceClient_->CommitTransaction(implicitRemoteTransactionDataStack_.top());
244 }
245 implicitRemoteTransactionDataStack_.pop();
246 }
247 }
248
MarkTransactionNeedSync()249 void RSTransactionProxy::MarkTransactionNeedSync()
250 {
251 std::unique_lock<std::mutex> cmdLock(mutex_);
252 if (!implicitCommonTransactionDataStack_.empty()) {
253 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
254 }
255
256 if (!implicitRemoteTransactionDataStack_.empty()) {
257 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
258 }
259 }
260
MarkTransactionNeedCloseSync(const int32_t transactionCount)261 void RSTransactionProxy::MarkTransactionNeedCloseSync(const int32_t transactionCount)
262 {
263 std::unique_lock<std::mutex> cmdLock(mutex_);
264 if (!implicitCommonTransactionDataStack_.empty()) {
265 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
266 implicitCommonTransactionDataStack_.top()->MarkNeedCloseSync();
267 implicitCommonTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
268 }
269
270 if (!implicitRemoteTransactionDataStack_.empty()) {
271 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
272 implicitRemoteTransactionDataStack_.top()->MarkNeedCloseSync();
273 implicitRemoteTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
274 }
275 }
276
SetSyncTransactionNum(const int32_t transactionCount)277 void RSTransactionProxy::SetSyncTransactionNum(const int32_t transactionCount)
278 {
279 std::unique_lock<std::mutex> cmdLock(mutex_);
280 if (!implicitCommonTransactionDataStack_.empty()) {
281 implicitCommonTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
282 }
283
284 if (!implicitRemoteTransactionDataStack_.empty()) {
285 implicitRemoteTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
286 }
287 }
288
SetParentPid(const int32_t parentPid)289 void RSTransactionProxy::SetParentPid(const int32_t parentPid)
290 {
291 std::unique_lock<std::mutex> cmdLock(mutex_);
292 if (!implicitCommonTransactionDataStack_.empty()) {
293 implicitCommonTransactionDataStack_.top()->SetParentPid(parentPid);
294 }
295
296 if (!implicitRemoteTransactionDataStack_.empty()) {
297 implicitRemoteTransactionDataStack_.top()->SetParentPid(parentPid);
298 }
299 }
300
AddCommonCommand(std::unique_ptr<RSCommand> & command)301 void RSTransactionProxy::AddCommonCommand(std::unique_ptr<RSCommand> &command)
302 {
303 if (!implicitCommonTransactionDataStack_.empty()) {
304 implicitCommonTransactionDataStack_.top()->AddCommand(command, 0, FollowType::NONE);
305 return;
306 }
307 implicitCommonTransactionData_->AddCommand(command, 0, FollowType::NONE);
308 }
309
AddRemoteCommand(std::unique_ptr<RSCommand> & command,NodeId nodeId,FollowType followType)310 void RSTransactionProxy::AddRemoteCommand(std::unique_ptr<RSCommand>& command, NodeId nodeId, FollowType followType)
311 {
312 if (!implicitRemoteTransactionDataStack_.empty()) {
313 implicitRemoteTransactionDataStack_.top()->AddCommand(command, nodeId, followType);
314 return;
315 }
316 implicitRemoteTransactionData_->AddCommand(command, nodeId, followType);
317 }
318
319 } // namespace Rosen
320 } // namespace OHOS
321