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 "dcamera_source_callback.h"
17
18 #include "anonymous_string.h"
19 #include "distributed_camera_errno.h"
20 #include "distributed_hardware_log.h"
21
22 namespace OHOS {
23 namespace DistributedHardware {
~DCameraSourceCallback()24 DCameraSourceCallback::~DCameraSourceCallback()
25 {
26 regCallbacks_.clear();
27 unregCallbacks_.clear();
28 }
29
OnNotifyRegResult(const std::string & devId,const std::string & dhId,const std::string & reqId,int32_t status,std::string & data)30 int32_t DCameraSourceCallback::OnNotifyRegResult(const std::string& devId, const std::string& dhId,
31 const std::string& reqId, int32_t status, std::string& data)
32 {
33 DHLOGI("DCameraSourceCallback OnNotifyRegResult devId: %{public}s dhId: %{public}s",
34 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
35 std::lock_guard<std::mutex> lock(mapMutex_);
36 auto iter = regCallbacks_.find(reqId);
37 if (iter == regCallbacks_.end()) {
38 DHLOGE("DCameraSourceCallback OnNotifyRegResult not found devId: %{public}s dhId: %{public}s",
39 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
40 return DCAMERA_NOT_FOUND;
41 }
42
43 if (iter->second == nullptr) {
44 DHLOGE("DCameraSourceCallback OnNotifyRegResult callback is null");
45 regCallbacks_.erase(iter);
46 return DCAMERA_BAD_VALUE;
47 }
48
49 int32_t ret = iter->second->OnRegisterResult(devId, dhId, status, data);
50 if (ret != DCAMERA_OK) {
51 DHLOGE("DCameraSourceCallback OnNotifyRegResult failed, devId: %{public}s dhId: %{public}s ret: %{public}d",
52 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), ret);
53 }
54 regCallbacks_.erase(iter);
55 return ret;
56 }
57
OnNotifyUnregResult(const std::string & devId,const std::string & dhId,const std::string & reqId,int32_t status,std::string & data)58 int32_t DCameraSourceCallback::OnNotifyUnregResult(const std::string& devId, const std::string& dhId,
59 const std::string& reqId, int32_t status, std::string& data)
60 {
61 DHLOGI("DCameraSourceCallback OnNotifyUnregResult devId: %{public}s dhId: %{public}s",
62 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
63 std::lock_guard<std::mutex> lock(mapMutex_);
64 auto iter = unregCallbacks_.find(reqId);
65 if (iter == unregCallbacks_.end()) {
66 DHLOGE("DCameraSourceCallback OnNotifyUnregResult not found devId: %{public}s dhId: %{public}s",
67 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
68 return DCAMERA_NOT_FOUND;
69 }
70 if (iter->second == nullptr) {
71 DHLOGE("DCameraSourceCallback OnNotifyUnregResult callback is null");
72 unregCallbacks_.erase(iter);
73 return DCAMERA_BAD_VALUE;
74 }
75 int32_t ret = iter->second->OnUnregisterResult(devId, dhId, status, data);
76 if (ret != DCAMERA_OK) {
77 DHLOGE("DCameraSourceCallback OnNotifyUnregResult failed, devId: %{public}s dhId: %{public}s ret: %{public}d",
78 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), ret);
79 }
80 unregCallbacks_.erase(iter);
81 return ret;
82 }
83
OnHardwareStateChanged(const std::string & devId,const std::string & dhId,int32_t status)84 int32_t DCameraSourceCallback::OnHardwareStateChanged(const std::string &devId, const std::string &dhId,
85 int32_t status)
86 {
87 DHLOGI("On hardware state changed, devId: %{public}s, dhId: %{public}s, status: %{public}d",
88 GetAnonyString(devId).c_str(), dhId.c_str(), status);
89 std::lock_guard<std::mutex> stateLck(stateListenerMtx_);
90 if (stateListener_ == nullptr) {
91 DHLOGE("State listener is null.");
92 return DCAMERA_BAD_VALUE;
93 }
94 if (devId.empty() || devId.size() > DID_MAX_SIZE || dhId.empty() || dhId.size() > DID_MAX_SIZE) {
95 DHLOGE("devId or dhId is invalid");
96 return DCAMERA_BAD_VALUE;
97 }
98 if (status < 0) {
99 DHLOGE("status in invalid.");
100 return DCAMERA_BAD_VALUE;
101 }
102 BusinessState currentState = static_cast<BusinessState>(status);
103 stateListener_->OnStateChanged(devId, dhId, currentState);
104 return DCAMERA_OK;
105 }
106
OnDataSyncTrigger(const std::string & devId)107 int32_t DCameraSourceCallback::OnDataSyncTrigger(const std::string &devId)
108 {
109 DHLOGI("On data sync trigger, devId: %{public}s", GetAnonyString(devId).c_str());
110 std::lock_guard<std::mutex> triggerLck(triggerListenerMtx_);
111 if (devId.empty() || devId.size() > DID_MAX_SIZE) {
112 DHLOGE("devId is invalid");
113 return DCAMERA_BAD_VALUE;
114 }
115 if (triggerListener_ == nullptr) {
116 DHLOGE("Trigger listener is null.");
117 return DCAMERA_BAD_VALUE;
118 }
119 triggerListener_->OnDataSyncTrigger(devId);
120 return DCAMERA_OK;
121 }
122
PushRegCallback(std::string & reqId,std::shared_ptr<RegisterCallback> & callback)123 void DCameraSourceCallback::PushRegCallback(std::string& reqId, std::shared_ptr<RegisterCallback>& callback)
124 {
125 std::lock_guard<std::mutex> lock(mapMutex_);
126 regCallbacks_.emplace(reqId, callback);
127 }
128
PopRegCallback(std::string & reqId)129 void DCameraSourceCallback::PopRegCallback(std::string& reqId)
130 {
131 std::lock_guard<std::mutex> lock(mapMutex_);
132 regCallbacks_.erase(reqId);
133 }
134
PushUnregCallback(std::string & reqId,std::shared_ptr<UnregisterCallback> & callback)135 void DCameraSourceCallback::PushUnregCallback(std::string& reqId, std::shared_ptr<UnregisterCallback>& callback)
136 {
137 std::lock_guard<std::mutex> lock(mapMutex_);
138 unregCallbacks_.emplace(reqId, callback);
139 }
140
PopUnregCallback(std::string & reqId)141 void DCameraSourceCallback::PopUnregCallback(std::string& reqId)
142 {
143 std::lock_guard<std::mutex> lock(mapMutex_);
144 unregCallbacks_.erase(reqId);
145 }
146
RegisterStateListener(const std::shared_ptr<DistributedHardwareStateListener> listener)147 void DCameraSourceCallback::RegisterStateListener(const std::shared_ptr<DistributedHardwareStateListener> listener)
148 {
149 DHLOGD("Register state listener.");
150 std::lock_guard<std::mutex> stateLck(stateListenerMtx_);
151 stateListener_ = listener;
152 }
153
UnRegisterStateListener()154 void DCameraSourceCallback::UnRegisterStateListener()
155 {
156 DHLOGD("UnRegister state listener.");
157 std::lock_guard<std::mutex> stateLck(stateListenerMtx_);
158 stateListener_ = nullptr;
159 }
160
RegisterTriggerListener(const std::shared_ptr<DataSyncTriggerListener> listener)161 void DCameraSourceCallback::RegisterTriggerListener(const std::shared_ptr<DataSyncTriggerListener> listener)
162 {
163 DHLOGD("Register trigger listener.");
164 std::lock_guard<std::mutex> triggerLck(triggerListenerMtx_);
165 triggerListener_ = listener;
166 }
167
UnRegisterTriggerListener()168 void DCameraSourceCallback::UnRegisterTriggerListener()
169 {
170 DHLOGD("UnRegister trigger listener.");
171 std::lock_guard<std::mutex> triggerLck(triggerListenerMtx_);
172 triggerListener_ = nullptr;
173 }
174 } // namespace DistributedHardware
175 } // namespace OHOS
176