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