1 /*
2 * Copyright (c) 2021 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 "communication_adapter/include/sa_async_handler.h"
17
18 #include "communication_adapter/include/future_listener.h"
19 #include "protocol/retcode_inner/aie_retcode_inner.h"
20 #include "server_executor/include/i_async_task_manager.h"
21 #include "utils/aie_guard.h"
22 #include "utils/log/aie_log.h"
23
24 namespace OHOS {
25 namespace AI {
26 std::mutex SaAsyncHandler::mutex_;
27 SaAsyncHandler *SaAsyncHandler::instance_ = nullptr;
28
GetInstance()29 SaAsyncHandler *SaAsyncHandler::GetInstance()
30 {
31 CHK_RET(instance_ != nullptr, instance_);
32
33 std::lock_guard<std::mutex> lock(mutex_);
34 CHK_RET(instance_ != nullptr, instance_);
35
36 AIE_NEW(instance_, SaAsyncHandler);
37 return instance_;
38 }
39
40 SaAsyncHandler::SaAsyncHandler() = default;
41
~SaAsyncHandler()42 SaAsyncHandler::~SaAsyncHandler()
43 {
44 for (auto &iter : clients_) {
45 AIE_DELETE(iter.second);
46 }
47 clients_.clear();
48 }
49
StopClientListenerHandler(int clientId)50 void SaAsyncHandler::StopClientListenerHandler(int clientId)
51 {
52 ReadGuard<RwLock> guard(rwLock_);
53 auto iter = clients_.find(clientId);
54 CHK_RET_NONE(iter == clients_.end());
55
56 iter->second->StopAsyncProcessThread();
57 }
58
RemoveClientListenerHandler(int clientId)59 void SaAsyncHandler::RemoveClientListenerHandler(int clientId)
60 {
61 WriteGuard<RwLock> guard(rwLock_);
62 ClientListenerHandlerMap::iterator iter = clients_.find(clientId);
63 CHK_RET_NONE(iter == clients_.end());
64
65 AIE_DELETE(iter->second);
66 clients_.erase(iter);
67 }
68
FindClientListenerHandler(int clientId)69 ClientListenerHandler *SaAsyncHandler::FindClientListenerHandler(int clientId)
70 {
71 ReadGuard<RwLock> guard(rwLock_);
72 ClientListenerHandlerMap::iterator iter = clients_.find(clientId);
73 CHK_RET(iter == clients_.end(), nullptr);
74
75 return iter->second;
76 }
77
AddClientListenerHandler(int clientId)78 ClientListenerHandler *SaAsyncHandler::AddClientListenerHandler(int clientId)
79 {
80 ClientListenerHandler *handler = nullptr;
81 AIE_NEW(handler, ClientListenerHandler);
82 CHK_RET(handler == nullptr, nullptr);
83
84 WriteGuard<RwLock> guard(rwLock_);
85 clients_[clientId] = handler;
86 return handler;
87 }
88
RemoveTransaction(long long transactionId)89 void SaAsyncHandler::RemoveTransaction(long long transactionId)
90 {
91 WriteGuard<RwLock> guard(rwLock_);
92 transactions_.erase(transactionId);
93 }
94
IsExistTransaction(long long transactionId)95 bool SaAsyncHandler::IsExistTransaction(long long transactionId)
96 {
97 ReadGuard<RwLock> guard(rwLock_);
98 auto iter = transactions_.find(transactionId);
99 return (iter != transactions_.end());
100 }
101
SaveTransaction(long long transactionId)102 void SaAsyncHandler::SaveTransaction(long long transactionId)
103 {
104 WriteGuard<RwLock> guard(rwLock_);
105 transactions_.insert(transactionId);
106 }
107
PushAsyncResponse(int clientId,IResponse * response)108 void SaAsyncHandler::PushAsyncResponse(int clientId, IResponse *response)
109 {
110 ClientListenerHandler *client = FindClientListenerHandler(clientId);
111 CHK_RET_NONE(client == nullptr);
112 client->AddCallbackRecord(response);
113 }
114
RegisterAsyncHandler(int clientId)115 int SaAsyncHandler::RegisterAsyncHandler(int clientId)
116 {
117 if (FindClientListenerHandler(clientId) != nullptr) {
118 HILOGI("[SaAsyncHandler]The client has already add handler, clientId: %d.", clientId);
119 return RETCODE_SUCCESS;
120 }
121
122 AddClientListenerHandler(clientId);
123 return RETCODE_SUCCESS;
124 }
125
StartAsyncProcess(int clientId,SaServerAdapter * adapter)126 int SaAsyncHandler::StartAsyncProcess(int clientId, SaServerAdapter *adapter)
127 {
128 ReadGuard<RwLock> guard(rwLock_);
129 ClientListenerHandlerMap::iterator iter = clients_.find(clientId);
130 if (iter == clients_.end()) {
131 HILOGE("[SaAsyncHandler]The client do not preRegister AsyncHandler, clientId: %d.", clientId);
132 return RETCODE_SA_ASYNC_HANDLER_NOT_FOUND;
133 }
134
135 if (iter->second == nullptr) {
136 HILOGE("[SaAsyncHandler]AsyncHandler is null, clientId: %d.", clientId);
137 return RETCODE_SA_ASYNC_HANDLER_NOT_FOUND;
138 }
139 return iter->second->StartAsyncProcessThread(clientId, adapter);
140 }
141
StopAsyncProcess(int clientId)142 void SaAsyncHandler::StopAsyncProcess(int clientId)
143 {
144 StopClientListenerHandler(clientId);
145 RemoveClientListenerHandler(clientId);
146 }
147
StartAsyncTransaction(long long transactionId,int clientId)148 int SaAsyncHandler::StartAsyncTransaction(long long transactionId, int clientId)
149 {
150 CHK_RET(IsExistTransaction(transactionId), RETCODE_SUCCESS);
151 IFutureListener *listener = nullptr;
152 AIE_NEW(listener, FutureListener(this, clientId));
153 if (listener == nullptr) {
154 HILOGE("[SaAsyncHandler]Allocate future listener failed.");
155 return RETCODE_OUT_OF_MEMORY;
156 }
157 IAsyncTaskManager *taskManager = GetAsyncTaskManager();
158 if (taskManager == nullptr) {
159 HILOGE("[SaAsyncHandler]Failed to get async task manager.");
160 AIE_DELETE(listener);
161 return RETCODE_OUT_OF_MEMORY;
162 }
163 taskManager->RegisterListener(listener, transactionId);
164 SaveTransaction(transactionId);
165 return RETCODE_SUCCESS;
166 }
167
StopAsyncTransaction(long long transactionId)168 void SaAsyncHandler::StopAsyncTransaction(long long transactionId)
169 {
170 CHK_RET_NONE(!IsExistTransaction(transactionId));
171
172 IAsyncTaskManager *taskManager = GetAsyncTaskManager();
173 if (taskManager == nullptr) {
174 HILOGE("[SaAsyncHandler]Failed to get async task manager, transactionId:0x%llx.", transactionId);
175 return;
176 }
177 taskManager->UnRegisterListener(transactionId);
178 RemoveTransaction(transactionId);
179 }
180 } // namespace AI
181 } // namespace OHOS