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 return;
70 }
71
72 std::unique_lock<std::mutex> cmdLock(mutex_);
73
74 if (renderServiceClient_ != nullptr && (isRenderServiceCommand || renderThreadClient_ == nullptr)) {
75 AddRemoteCommand(command, nodeId, followType);
76 return;
77 }
78
79 if (!isRenderServiceCommand) {
80 AddCommonCommand(command);
81 return;
82 }
83 ROSEN_LOGE("RSTransactionProxy::AddCommand failed, isRenderServiceCommand:%{public}d %{public}s",
84 isRenderServiceCommand, command->PrintType().c_str());
85 }
86
AddCommandFromRT(std::unique_ptr<RSCommand> & command,NodeId nodeId,FollowType followType)87 void RSTransactionProxy::AddCommandFromRT(std::unique_ptr<RSCommand>& command, NodeId nodeId, FollowType followType)
88 {
89 if (renderServiceClient_ == nullptr || command == nullptr) {
90 return;
91 }
92
93 {
94 std::unique_lock<std::mutex> cmdLock(mutexForRT_);
95 implicitTransactionDataFromRT_->AddCommand(command, nodeId, followType);
96 }
97 }
98
ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask> & task,bool isRenderServiceTask)99 void RSTransactionProxy::ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask>& task, bool isRenderServiceTask)
100 {
101 if (!task) {
102 ROSEN_LOGE("RSTransactionProxy::ExecuteSynchronousTask failed, the task is not exist.");
103 return;
104 }
105
106 if (renderServiceClient_ && isRenderServiceTask) {
107 renderServiceClient_->ExecuteSynchronousTask(task);
108 return;
109 }
110
111 if (renderThreadClient_ && (!isRenderServiceTask)) {
112 renderThreadClient_->ExecuteSynchronousTask(task);
113 return;
114 }
115
116 ROSEN_LOGE("RSTransactionProxy::ExecuteSynchronousTask failed, isRenderServiceTask is %{public}d.",
117 isRenderServiceTask);
118 }
119
FlushImplicitTransaction(uint64_t timestamp,const std::string & abilityName)120 void RSTransactionProxy::FlushImplicitTransaction(uint64_t timestamp, const std::string& abilityName)
121 {
122 std::unique_lock<std::mutex> cmdLock(mutex_);
123 if (!implicitRemoteTransactionDataStack_.empty() && needSync_) {
124 return;
125 }
126
127 timestamp_ = std::max(timestamp, timestamp_);
128 if (renderThreadClient_ != nullptr && !implicitCommonTransactionData_->IsEmpty()) {
129 implicitCommonTransactionData_->timestamp_ = timestamp_;
130 implicitCommonTransactionData_->abilityName_ = abilityName;
131 renderThreadClient_->CommitTransaction(implicitCommonTransactionData_);
132 implicitCommonTransactionData_ = std::make_unique<RSTransactionData>();
133 }
134 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionData_->IsEmpty()) {
135 implicitRemoteTransactionData_->timestamp_ = timestamp_;
136 renderServiceClient_->CommitTransaction(implicitRemoteTransactionData_);
137 implicitRemoteTransactionData_ = std::make_unique<RSTransactionData>();
138 }
139 }
140
FlushImplicitTransactionFromRT(uint64_t timestamp)141 void RSTransactionProxy::FlushImplicitTransactionFromRT(uint64_t timestamp)
142 {
143 std::unique_lock<std::mutex> cmdLock(mutexForRT_);
144 if (renderServiceClient_ != nullptr && !implicitTransactionDataFromRT_->IsEmpty()) {
145 implicitTransactionDataFromRT_->timestamp_ = timestamp;
146 renderServiceClient_->CommitTransaction(implicitTransactionDataFromRT_);
147 implicitTransactionDataFromRT_ = std::make_unique<RSTransactionData>();
148 }
149 }
150
StartSyncTransaction()151 void RSTransactionProxy::StartSyncTransaction()
152 {
153 needSync_ = true;
154 }
155
CloseSyncTransaction()156 void RSTransactionProxy::CloseSyncTransaction()
157 {
158 needSync_ = false;
159 }
160
Begin()161 void RSTransactionProxy::Begin()
162 {
163 std::unique_lock<std::mutex> cmdLock(mutex_);
164 implicitCommonTransactionDataStack_.emplace(std::make_unique<RSTransactionData>());
165 implicitRemoteTransactionDataStack_.emplace(std::make_unique<RSTransactionData>());
166 if (needSync_) {
167 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
168 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
169 }
170 }
171
Commit(uint64_t timestamp)172 void RSTransactionProxy::Commit(uint64_t timestamp)
173 {
174 std::unique_lock<std::mutex> cmdLock(mutex_);
175 if (!implicitCommonTransactionDataStack_.empty()) {
176 implicitCommonTransactionDataStack_.pop();
177 }
178
179 if (!implicitRemoteTransactionDataStack_.empty()) {
180 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionDataStack_.top()->IsEmpty()) {
181 implicitRemoteTransactionDataStack_.top()->timestamp_ = timestamp;
182 renderServiceClient_->CommitTransaction(implicitRemoteTransactionDataStack_.top());
183 }
184 implicitRemoteTransactionDataStack_.pop();
185 }
186 }
187
CommitSyncTransaction(uint64_t timestamp,const std::string & abilityName)188 void RSTransactionProxy::CommitSyncTransaction(uint64_t timestamp, const std::string& abilityName)
189 {
190 std::unique_lock<std::mutex> cmdLock(mutex_);
191 timestamp_ = std::max(timestamp, timestamp_);
192 if (!implicitCommonTransactionDataStack_.empty()) {
193 if (renderThreadClient_ != nullptr && !implicitCommonTransactionDataStack_.top()->IsEmpty()) {
194 implicitCommonTransactionDataStack_.top()->timestamp_ = timestamp;
195 implicitCommonTransactionDataStack_.top()->abilityName_ = abilityName;
196 implicitCommonTransactionDataStack_.top()->SetSyncId(syncId_);
197 renderThreadClient_->CommitTransaction(implicitCommonTransactionDataStack_.top());
198 }
199 implicitCommonTransactionDataStack_.pop();
200 }
201
202 if (!implicitRemoteTransactionDataStack_.empty()) {
203 if (renderServiceClient_ != nullptr && !implicitRemoteTransactionDataStack_.top()->IsEmpty()) {
204 implicitRemoteTransactionDataStack_.top()->timestamp_ = timestamp;
205 implicitRemoteTransactionDataStack_.top()->SetSyncId(syncId_);
206 renderServiceClient_->CommitTransaction(implicitRemoteTransactionDataStack_.top());
207 }
208 implicitRemoteTransactionDataStack_.pop();
209 }
210 }
211
MarkTransactionNeedSync()212 void RSTransactionProxy::MarkTransactionNeedSync()
213 {
214 std::unique_lock<std::mutex> cmdLock(mutex_);
215 if (!implicitCommonTransactionDataStack_.empty()) {
216 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
217 }
218
219 if (!implicitRemoteTransactionDataStack_.empty()) {
220 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
221 }
222 }
223
MarkTransactionNeedCloseSync(const int32_t transactionCount)224 void RSTransactionProxy::MarkTransactionNeedCloseSync(const int32_t transactionCount)
225 {
226 std::unique_lock<std::mutex> cmdLock(mutex_);
227 if (!implicitCommonTransactionDataStack_.empty()) {
228 implicitCommonTransactionDataStack_.top()->MarkNeedSync();
229 implicitCommonTransactionDataStack_.top()->MarkNeedCloseSync();
230 implicitCommonTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
231 }
232
233 if (!implicitRemoteTransactionDataStack_.empty()) {
234 implicitRemoteTransactionDataStack_.top()->MarkNeedSync();
235 implicitRemoteTransactionDataStack_.top()->MarkNeedCloseSync();
236 implicitRemoteTransactionDataStack_.top()->SetSyncTransactionNum(transactionCount);
237 }
238 }
239
AddCommonCommand(std::unique_ptr<RSCommand> & command)240 void RSTransactionProxy::AddCommonCommand(std::unique_ptr<RSCommand> &command)
241 {
242 if (!implicitCommonTransactionDataStack_.empty()) {
243 implicitCommonTransactionDataStack_.top()->AddCommand(command, 0, FollowType::NONE);
244 return;
245 }
246 implicitCommonTransactionData_->AddCommand(command, 0, FollowType::NONE);
247 }
248
AddRemoteCommand(std::unique_ptr<RSCommand> & command,NodeId nodeId,FollowType followType)249 void RSTransactionProxy::AddRemoteCommand(std::unique_ptr<RSCommand>& command, NodeId nodeId, FollowType followType)
250 {
251 if (!implicitRemoteTransactionDataStack_.empty()) {
252 implicitRemoteTransactionDataStack_.top()->AddCommand(command, nodeId, followType);
253 return;
254 }
255 implicitRemoteTransactionData_->AddCommand(command, nodeId, followType);
256 }
257
258 } // namespace Rosen
259 } // namespace OHOS
260