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 "dcamera_provider_callback_impl.h"
17
18 #include "dcamera_index.h"
19 #include "dcamera_source_dev.h"
20
21 #include "anonymous_string.h"
22 #include "distributed_camera_errno.h"
23 #include "distributed_hardware_log.h"
24
25 namespace OHOS {
26 namespace DistributedHardware {
DCameraProviderCallbackImpl(std::string devId,std::string dhId,std::shared_ptr<DCameraSourceDev> & sourceDev)27 DCameraProviderCallbackImpl::DCameraProviderCallbackImpl(std::string devId, std::string dhId,
28 std::shared_ptr<DCameraSourceDev>& sourceDev) : devId_(devId), dhId_(dhId), sourceDev_(sourceDev)
29 {
30 DHLOGI("DCameraProviderCallbackImpl create devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
31 GetAnonyString(dhId_).c_str());
32 }
33
~DCameraProviderCallbackImpl()34 DCameraProviderCallbackImpl::~DCameraProviderCallbackImpl()
35 {
36 DHLOGI("DCameraProviderCallbackImpl delete devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
37 GetAnonyString(dhId_).c_str());
38 }
39
OpenSession(const DHBase & dhBase)40 int32_t DCameraProviderCallbackImpl::OpenSession(const DHBase& dhBase)
41 {
42 DHLOGI("DCameraProviderCallbackImpl OpenSession devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
43 GetAnonyString(dhId_).c_str());
44 if (!CheckDHBase(dhBase)) {
45 DHLOGE("DCameraProviderCallbackImpl OpenSession input is invalid");
46 return FAILED;
47 }
48 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
49 if (sourceDev == nullptr) {
50 DHLOGE("DCameraProviderCallbackImpl OpenSession failed, can not get device, devId: %s, dhId: %s",
51 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
52 return FAILED;
53 }
54 DCameraIndex camIndex(devId_, dhId_);
55 int32_t ret = sourceDev->OpenSession(camIndex);
56 if (ret != DCAMERA_OK) {
57 DHLOGE("DCameraProviderCallbackImpl OpenSession failed, ret: %d, devId: %s, dhId: %s", ret,
58 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
59 return FAILED;
60 }
61 return SUCCESS;
62 }
63
CloseSession(const DHBase & dhBase)64 int32_t DCameraProviderCallbackImpl::CloseSession(const DHBase& dhBase)
65 {
66 DHLOGI("DCameraProviderCallbackImpl CloseSession devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
67 GetAnonyString(dhId_).c_str());
68 if (!CheckDHBase(dhBase)) {
69 DHLOGE("DCameraProviderCallbackImpl CloseSession input is invalid");
70 return FAILED;
71 }
72 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
73 if (sourceDev == nullptr) {
74 DHLOGE("DCameraProviderCallbackImpl CloseSession failed, can not get device, devId: %s, dhId: %s",
75 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
76 return FAILED;
77 }
78 DCameraIndex camIndex(devId_, dhId_);
79 int32_t ret = sourceDev->CloseSession(camIndex);
80 if (ret != DCAMERA_OK) {
81 DHLOGE("DCameraProviderCallbackImpl CloseSession failed, ret: %d, devId: %s, dhId: %s", ret,
82 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
83 return FAILED;
84 }
85 return SUCCESS;
86 }
87
CheckDHBase(const DHBase & dhBase)88 bool DCameraProviderCallbackImpl::CheckDHBase(const DHBase& dhBase)
89 {
90 if (dhBase.deviceId_.empty() || dhBase.deviceId_.size() > DID_MAX_SIZE ||
91 dhBase.dhId_.empty() || dhBase.dhId_.size() > DID_MAX_SIZE) {
92 DHLOGE("DCameraProviderCallbackImpl CheckDHBase dhBase is invalid");
93 return false;
94 }
95 return true;
96 }
97
ConfigureStreams(const DHBase & dhBase,const std::vector<DCStreamInfo> & streamInfos)98 int32_t DCameraProviderCallbackImpl::ConfigureStreams(const DHBase& dhBase,
99 const std::vector<DCStreamInfo>& streamInfos)
100 {
101 DHLOGI("DCameraProviderCallbackImpl ConfigStreams devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
102 GetAnonyString(dhId_).c_str());
103 if (!CheckDHBase(dhBase) || streamInfos.empty() || streamInfos.size() > PARAM_MAX_SIZE) {
104 DHLOGE("DCameraProviderCallbackImpl ConfigStreams input is invalid");
105 return FAILED;
106 }
107 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
108 if (sourceDev == nullptr) {
109 DHLOGE("DCameraProviderCallbackImpl ConfigStreams failed, can not get device, devId: %s, dhId: %s",
110 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
111 return FAILED;
112 }
113 std::vector<std::shared_ptr<DCStreamInfo>> streams;
114 for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
115 if (!CheckStreamInfo(*iter)) {
116 DHLOGE("DCameraProviderCallbackImpl ConfigStreams streamInfo is invalid");
117 return FAILED;
118 }
119 std::shared_ptr<DCStreamInfo> stream = std::make_shared<DCStreamInfo>();
120 stream->streamId_ = iter->streamId_;
121 stream->width_ = iter->width_;
122 stream->height_ = iter->height_;
123 stream->stride_ = iter->stride_;
124 stream->format_ = iter->format_;
125 stream->dataspace_ = iter->dataspace_;
126 stream->encodeType_ = iter->encodeType_;
127 stream->type_ = iter->type_;
128 streams.push_back(stream);
129 }
130 int32_t ret = sourceDev->ConfigCameraStreams(streams);
131 if (ret != DCAMERA_OK) {
132 DHLOGE("DCameraProviderCallbackImpl CloseSession failed, ret: %d, devId: %s, dhId: %s", ret,
133 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
134 return FAILED;
135 }
136 return SUCCESS;
137 }
138
CheckStreamInfo(const DCStreamInfo & stream)139 bool DCameraProviderCallbackImpl::CheckStreamInfo(const DCStreamInfo& stream)
140 {
141 if (stream.streamId_ < 0 || stream.width_ < 0 || stream.height_ < 0 ||
142 (stream.width_ * stream.height_ > RESOLUTION_MAX_WIDTH * RESOLUTION_MAX_HEIGHT)) {
143 DHLOGE("DCameraProviderCallbackImpl CheckStreamInfo stream is invalid");
144 return false;
145 }
146
147 if (stream.stride_ < 0 || stream.format_ < 0 || stream.dataspace_ < 0) {
148 DHLOGE("DCameraProviderCallbackImpl CheckStreamInfo stream is invalid");
149 return false;
150 }
151 return true;
152 }
153
ReleaseStreams(const DHBase & dhBase,const std::vector<int> & streamIds)154 int32_t DCameraProviderCallbackImpl::ReleaseStreams(const DHBase& dhBase, const std::vector<int>& streamIds)
155 {
156 DHLOGI("DCameraProviderCallbackImpl ReleaseStreams devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
157 GetAnonyString(dhId_).c_str());
158 if (!CheckDHBase(dhBase) || streamIds.size() > PARAM_MAX_SIZE) {
159 DHLOGE("DCameraProviderCallbackImpl ReleaseStreams input is invalid");
160 return FAILED;
161 }
162 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
163 if (sourceDev == nullptr) {
164 DHLOGE("DCameraProviderCallbackImpl ReleaseStreams failed, can not get device, devId: %s, dhId: %s",
165 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
166 return FAILED;
167 }
168 int32_t ret = sourceDev->ReleaseCameraStreams(streamIds);
169 if (ret != DCAMERA_OK) {
170 DHLOGE("DCameraProviderCallbackImpl ReleaseStreams failed, ret: %d, devId: %s, dhId: %s", ret,
171 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
172 return FAILED;
173 }
174 return SUCCESS;
175 }
176
StartCapture(const DHBase & dhBase,const std::vector<DCCaptureInfo> & captureInfos)177 int32_t DCameraProviderCallbackImpl::StartCapture(const DHBase& dhBase, const std::vector<DCCaptureInfo>& captureInfos)
178 {
179 DHLOGI("DCameraProviderCallbackImpl StartCapture devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
180 GetAnonyString(dhId_).c_str());
181 if (!CheckDHBase(dhBase) || captureInfos.empty() || captureInfos.size() > PARAM_MAX_SIZE) {
182 DHLOGE("DCameraProviderCallbackImpl StartCapture input is invalid");
183 return FAILED;
184 }
185 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
186 if (sourceDev == nullptr) {
187 DHLOGE("DCameraProviderCallbackImpl StartCapture failed, can not get device, devId: %s, dhId: %s",
188 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
189 return FAILED;
190 }
191
192 std::vector<std::shared_ptr<DCCaptureInfo>> captures;
193 for (auto iter = captureInfos.begin(); iter != captureInfos.end(); iter++) {
194 if (!CheckCaptureInfo(*iter)) {
195 DHLOGE("DCameraProviderCallbackImpl StartCapture captureInfo is invalid");
196 return FAILED;
197 }
198 for (auto item : iter->captureSettings_) {
199 if (item.value_.size() > PARAM_MAX_SIZE) {
200 DHLOGE("DCameraProviderCallbackImpl StartCapture captureSettings value is too long");
201 return FAILED;
202 }
203 }
204 std::shared_ptr<DCCaptureInfo> capture = std::make_shared<DCCaptureInfo>();
205 capture->streamIds_.assign(iter->streamIds_.begin(), iter->streamIds_.end());
206 capture->width_ = iter->width_;
207 capture->height_ = iter->height_;
208 capture->stride_ = iter->stride_;
209 capture->format_ = iter->format_;
210 capture->dataspace_ = iter->dataspace_;
211 capture->isCapture_ = iter->isCapture_;
212 capture->encodeType_ = iter->encodeType_;
213 capture->type_ = iter->type_;
214 capture->captureSettings_.assign(iter->captureSettings_.begin(), iter->captureSettings_.end());
215 captures.push_back(capture);
216 }
217 int32_t ret = sourceDev->StartCameraCapture(captures);
218 if (ret != DCAMERA_OK) {
219 DHLOGE("DCameraProviderCallbackImpl StartCapture failed, ret: %d, devId: %s, dhId: %s", ret,
220 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
221 return FAILED;
222 }
223 return SUCCESS;
224 }
225
CheckCaptureInfo(const DCCaptureInfo & captureInfo)226 bool DCameraProviderCallbackImpl::CheckCaptureInfo(const DCCaptureInfo& captureInfo)
227 {
228 if (sizeof(captureInfo.streamIds_) > PARAM_MAX_SIZE || captureInfo.width_ < 0 || captureInfo.height_ < 0 ||
229 (captureInfo.width_ * captureInfo.height_ > RESOLUTION_MAX_WIDTH * RESOLUTION_MAX_HEIGHT)) {
230 DHLOGE("DCameraProviderCallbackImpl CheckCaptureInfo captureInfo is invalid");
231 return false;
232 }
233
234 if (captureInfo.stride_ < 0 || captureInfo.format_ < 0 || captureInfo.dataspace_ < 0 ||
235 sizeof(captureInfo.captureSettings_) > PARAM_MAX_SIZE) {
236 DHLOGE("DCameraProviderCallbackImpl CheckCaptureInfo captureInfo is invalid");
237 return false;
238 }
239 return true;
240 }
241
StopCapture(const DHBase & dhBase,const std::vector<int> & streamIds)242 int32_t DCameraProviderCallbackImpl::StopCapture(const DHBase& dhBase, const std::vector<int>& streamIds)
243 {
244 DHLOGI("DCameraProviderCallbackImpl StopCapture devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
245 GetAnonyString(dhId_).c_str());
246 if (!CheckDHBase(dhBase) || streamIds.size() > PARAM_MAX_SIZE) {
247 DHLOGE("DCameraProviderCallbackImpl StopCapture input is invalid");
248 return FAILED;
249 }
250 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
251 if (sourceDev == nullptr) {
252 DHLOGE("DCameraProviderCallbackImpl StopCapture failed, can not get device, devId: %s, dhId: %s",
253 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
254 return FAILED;
255 }
256 int32_t ret = sourceDev->StopCameraCapture(streamIds);
257 if (ret != DCAMERA_OK) {
258 DHLOGE("DCameraProviderCallbackImpl StopCapture failed, ret: %d, devId: %s, dhId: %s", ret,
259 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
260 return FAILED;
261 }
262 return SUCCESS;
263 }
264
UpdateSettings(const DHBase & dhBase,const std::vector<DCameraSettings> & settings)265 int32_t DCameraProviderCallbackImpl::UpdateSettings(const DHBase& dhBase, const std::vector<DCameraSettings>& settings)
266 {
267 DHLOGI("DCameraProviderCallbackImpl UpdateSettings devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
268 GetAnonyString(dhId_).c_str());
269 if (!CheckDHBase(dhBase) || settings.size() > PARAM_MAX_SIZE) {
270 DHLOGE("DCameraProviderCallbackImpl UpdateSettings input is invalid");
271 return FAILED;
272 }
273 std::shared_ptr<DCameraSourceDev> sourceDev = sourceDev_.lock();
274 if (sourceDev == nullptr) {
275 DHLOGE("DCameraProviderCallbackImpl UpdateSettings failed, can not get device, devId: %s, dhId: %s",
276 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
277 return FAILED;
278 }
279
280 std::vector<std::shared_ptr<DCameraSettings>> settingInfos;
281 for (auto iter = settings.begin(); iter != settings.end(); iter++) {
282 if (iter->value_.size() > PARAM_MAX_SIZE) {
283 DHLOGE("DCameraProviderCallbackImpl UpdateSettings value is too long");
284 return FAILED;
285 }
286 std::shared_ptr<DCameraSettings> settingInfo = std::make_shared<DCameraSettings>();
287 settingInfo->type_ = iter->type_;
288 settingInfo->value_ = iter->value_;
289 settingInfos.push_back(settingInfo);
290 }
291 int32_t ret = sourceDev->UpdateCameraSettings(settingInfos);
292 if (ret != DCAMERA_OK) {
293 DHLOGE("DCameraProviderCallbackImpl UpdateSettings failed, ret: %d, devId: %s, dhId: %s", ret,
294 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
295 return FAILED;
296 }
297 return SUCCESS;
298 }
299 } // namespace DistributedHardware
300 } // namespace OHOS
301