1 /*
2 * Copyright (c) 2024 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 "asset_callback_manager.h"
17
18 #include "network/softbus/softbus_handler_asset.h"
19 #include "utils_log.h"
20
21 namespace OHOS {
22 namespace Storage {
23 namespace DistributedFile {
GetInstance()24 AssetCallbackManager &AssetCallbackManager::GetInstance()
25 {
26 static AssetCallbackManager instance;
27 return instance;
28 }
29
AddRecvCallback(const sptr<IAssetRecvCallback> & recvCallback)30 void AssetCallbackManager::AddRecvCallback(const sptr<IAssetRecvCallback> &recvCallback)
31 {
32 if (recvCallback == nullptr) {
33 LOGE("recvCallback is nullptr");
34 return;
35 }
36 std::lock_guard<std::mutex> lock(recvCallbackListMutex_);
37 for (auto callback : recvCallbackList_) {
38 if (recvCallback->AsObject() == callback->AsObject()) {
39 LOGI("recvCallback registered!");
40 return;
41 }
42 }
43 recvCallbackList_.emplace_back(recvCallback);
44 }
45
RemoveRecvCallback(const sptr<IAssetRecvCallback> & recvCallback)46 void AssetCallbackManager::RemoveRecvCallback(const sptr<IAssetRecvCallback> &recvCallback)
47 {
48 if (recvCallback == nullptr) {
49 LOGE("recvCallback is nullptr");
50 return;
51 }
52 std::lock_guard<std::mutex> lock(recvCallbackListMutex_);
53 for (auto iter = recvCallbackList_.begin(); iter != recvCallbackList_.end();) {
54 if ((*iter)->AsObject() == recvCallback->AsObject()) {
55 iter = recvCallbackList_.erase(iter);
56 } else {
57 iter++;
58 }
59 }
60 }
61
AddSendCallback(const std::string & taskId,const sptr<IAssetSendCallback> & sendCallback)62 void AssetCallbackManager::AddSendCallback(const std::string &taskId, const sptr<IAssetSendCallback> &sendCallback)
63 {
64 if (taskId.empty()) {
65 LOGI("taskId is empty");
66 return;
67 }
68 std::lock_guard<std::mutex> lock(sendCallbackMapMutex_);
69 auto iter = sendCallbackMap_.find(taskId);
70 if (iter != sendCallbackMap_.end()) {
71 LOGI("taskId exist, taskId %{public}s", taskId.c_str());
72 return;
73 }
74 sendCallbackMap_.insert(std::pair<std::string, sptr<IAssetSendCallback>>(taskId, sendCallback));
75 }
76
RemoveSendCallback(const std::string & taskId)77 void AssetCallbackManager::RemoveSendCallback(const std::string &taskId)
78 {
79 std::lock_guard<std::mutex> lock(sendCallbackMapMutex_);
80 auto iter = sendCallbackMap_.find(taskId);
81 if (iter == sendCallbackMap_.end()) {
82 LOGE("taskId not exist, taskId %{public}s", taskId.c_str());
83 return;
84 }
85 sendCallbackMap_.erase(iter);
86 }
87
NotifyAssetRecvStart(const std::string & srcNetworkId,const std::string & dstNetworkId,const std::string & sessionId,const std::string & dstBundleName)88 void AssetCallbackManager::NotifyAssetRecvStart(const std::string &srcNetworkId,
89 const std::string &dstNetworkId,
90 const std::string &sessionId,
91 const std::string &dstBundleName)
92 {
93 LOGI("NotifyAssetRecvStart.");
94 std::lock_guard<std::mutex> lock(recvCallbackListMutex_);
95 for (auto callback : recvCallbackList_) {
96 if (callback != nullptr) {
97 callback->OnStart(srcNetworkId, dstNetworkId, sessionId, dstBundleName);
98 } else {
99 LOGE("IAssetRecvCallback is empty, sessionId is %{public}s, dstBundleName is %{public}s",
100 sessionId.c_str(), dstBundleName.c_str());
101 }
102 }
103 }
104
NotifyAssetRecvFinished(const std::string & srcNetworkId,const sptr<AssetObj> & assetObj,int32_t result)105 void AssetCallbackManager::NotifyAssetRecvFinished(const std::string &srcNetworkId,
106 const sptr<AssetObj> &assetObj,
107 int32_t result)
108 {
109 LOGI("NotifyAssetRecvFinished.");
110 std::lock_guard<std::mutex> lock(recvCallbackListMutex_);
111 for (auto callback : recvCallbackList_) {
112 if (callback == nullptr) {
113 LOGE("IAssetRecvCallback is empty, sessionId is %{public}s, dstBundleName is %{public}s",
114 assetObj->sessionId_.c_str(), assetObj->dstBundleName_.c_str());
115 } else {
116 callback->OnFinished(srcNetworkId, assetObj, result);
117 }
118 }
119 }
120
NotifyAssetSendResult(const std::string & taskId,const sptr<AssetObj> & assetObj,int32_t result)121 void AssetCallbackManager::NotifyAssetSendResult(const std::string &taskId,
122 const sptr<AssetObj> &assetObj,
123 int32_t result)
124 {
125 LOGI("NotifyAssetSendResult.");
126 std::lock_guard<std::mutex> lock(sendCallbackMapMutex_);
127 auto iter = sendCallbackMap_.find(taskId);
128 if (iter == sendCallbackMap_.end()) {
129 LOGE("taskId not exist, taskId %{public}s", taskId.c_str());
130 return;
131 }
132 if (iter->second == nullptr) {
133 LOGE("IAssetSendCallback is empty!");
134 return;
135 }
136 iter->second->OnSendResult(assetObj, result);
137 }
138 } // namespace DistributedFile
139 } // namespace Storage
140 } // namespace OHOS