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