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 #include "rs_transaction.h" 16 17 #include "ipc_callbacks/rs_sync_transaction_controller_proxy.h" 18 #include "platform/common/rs_log.h" 19 #include "rs_process_transaction_controller.h" 20 #include "sandbox_utils.h" 21 #include "transaction/rs_transaction_proxy.h" 22 23 namespace OHOS { 24 namespace Rosen { 25 FlushImplicitTransaction()26void RSTransaction::FlushImplicitTransaction() 27 { 28 auto transactionProxy = RSTransactionProxy::GetInstance(); 29 if (transactionProxy != nullptr) { 30 transactionProxy->FlushImplicitTransaction(); 31 } 32 } 33 OpenSyncTransaction()34void RSTransaction::OpenSyncTransaction() 35 { 36 syncId_ = GenerateSyncId(); 37 auto transactionProxy = RSTransactionProxy::GetInstance(); 38 if (transactionProxy != nullptr) { 39 transactionProxy->StartSyncTransaction(); 40 transactionProxy->Begin(); 41 } 42 } 43 CloseSyncTransaction(const uint64_t transactionCount)44void RSTransaction::CloseSyncTransaction(const uint64_t transactionCount) 45 { 46 auto transactionProxy = RSTransactionProxy::GetInstance(); 47 if (transactionProxy != nullptr) { 48 transactionProxy->MarkTransactionNeedCloseSync(transactionCount); 49 transactionProxy->SetSyncId(syncId_); 50 transactionProxy->CommitSyncTransaction(); 51 transactionProxy->CloseSyncTransaction(); 52 } 53 ResetSyncTransactionInfo(); 54 } 55 Begin()56void RSTransaction::Begin() 57 { 58 auto transactionProxy = RSTransactionProxy::GetInstance(); 59 if (transactionProxy != nullptr) { 60 transactionProxy->StartSyncTransaction(); 61 transactionProxy->Begin(); 62 } 63 } 64 Commit()65void RSTransaction::Commit() 66 { 67 CreateTransactionFinish(); 68 auto transactionProxy = RSTransactionProxy::GetInstance(); 69 if (transactionProxy != nullptr) { 70 transactionProxy->SetSyncId(syncId_); 71 transactionProxy->CommitSyncTransaction(); 72 transactionProxy->CloseSyncTransaction(); 73 } 74 } 75 GenerateSyncId()76uint64_t RSTransaction::GenerateSyncId() 77 { 78 static pid_t pid_ = GetRealPid(); 79 static std::atomic<uint32_t> currentId_ = 0; 80 81 auto currentId = currentId_.fetch_add(1, std::memory_order_relaxed); 82 if (currentId == UINT32_MAX) { 83 // [PLANNING]:process the overflow situations 84 ROSEN_LOGE("Transaction sync Id overflow"); 85 } 86 87 // concat two 32-bit numbers to one 64-bit number 88 return ((uint64_t)pid_ << 32) | currentId; 89 } 90 ResetSyncTransactionInfo()91void RSTransaction::ResetSyncTransactionInfo() 92 { 93 std::unique_lock<std::mutex> lock(mutex_); 94 syncId_ = 0; 95 controllers_.clear(); 96 } 97 Unmarshalling(Parcel & parcel)98RSTransaction* RSTransaction::Unmarshalling(Parcel& parcel) 99 { 100 auto rsTransaction = new RSTransaction(); 101 if (rsTransaction->UnmarshallingParam(parcel)) { 102 return rsTransaction; 103 } 104 ROSEN_LOGE("RSTransactionData Unmarshalling Failed"); 105 delete rsTransaction; 106 return nullptr; 107 } 108 Marshalling(Parcel & parcel) const109bool RSTransaction::Marshalling(Parcel& parcel) const 110 { 111 if (!parcel.WriteUint64(syncId_)) { 112 ROSEN_LOGE("RSTransaction marshalling failed"); 113 return false; 114 } 115 return true; 116 } 117 UnmarshallingParam(Parcel & parcel)118bool RSTransaction::UnmarshallingParam(Parcel& parcel) 119 { 120 if (!parcel.ReadUint64(syncId_)) { 121 ROSEN_LOGE("RSTransaction unmarshallingParam failed"); 122 return false; 123 } 124 return true; 125 } 126 MarshallTransactionSyncController(MessageParcel & parcel)127void RSTransaction::MarshallTransactionSyncController(MessageParcel& parcel) 128 { 129 sptr<RSProcessTransactionController> controller = new RSProcessTransactionController(); 130 if (!parcel.WriteRemoteObject(controller->AsObject())) { 131 ROSEN_LOGE("RSTransaction Marshall transactionSyncController failed"); 132 return; 133 } 134 135 TransactionFinishedCallback callback = [this]() { 136 CallCreateFinishCallback(); 137 }; 138 controller->SetTransactionFinishedCallback(callback); 139 CallCreateStartCallback(); 140 std::unique_lock<std::mutex> lock(mutex_); 141 controllers_.emplace_back(controller); 142 } 143 UnmarshallTransactionSyncController(MessageParcel & parcel)144void RSTransaction::UnmarshallTransactionSyncController(MessageParcel& parcel) 145 { 146 sptr<IRemoteObject> controllerObject = parcel.ReadRemoteObject(); 147 if (controllerObject == nullptr) { 148 ROSEN_LOGE("RSTransaction unmarshalling transactionSyncController failed"); 149 return; 150 } 151 152 sptr<RSISyncTransactionController> controller = iface_cast<RSISyncTransactionController>(controllerObject); 153 std::unique_lock<std::mutex> lock(mutex_); 154 controllers_.emplace_back(controller); 155 } 156 SetCreateStartCallback(const std::function<void ()> & callback)157void RSTransaction::SetCreateStartCallback(const std::function<void()>& callback) 158 { 159 createStartCallback_ = callback; 160 } 161 SetCreateFinishCallback(const std::function<void ()> & callback)162void RSTransaction::SetCreateFinishCallback(const std::function<void()>& callback) 163 { 164 createFinishCallback_ = callback; 165 } 166 CallCreateStartCallback()167void RSTransaction::CallCreateStartCallback() 168 { 169 if (createStartCallback_) { 170 createStartCallback_(); 171 } 172 } 173 CallCreateFinishCallback()174void RSTransaction::CallCreateFinishCallback() 175 { 176 if (createFinishCallback_) { 177 createFinishCallback_(); 178 } 179 } 180 CreateTransactionFinish()181void RSTransaction::CreateTransactionFinish() 182 { 183 std::unique_lock<std::mutex> lock(mutex_); 184 if (!controllers_.empty() && controllers_.back()) { 185 controllers_.back()->CreateTransactionFinished(); 186 } 187 controllers_.clear(); 188 } 189 } // namespace Rosen 190 } // namespace OHOS 191