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_device.h"
17 
18 #include "anonymous_string.h"
19 #include "constants.h"
20 #include "dcamera.h"
21 #include "dcamera_host.h"
22 #include "dcamera_provider.h"
23 #include "distributed_hardware_log.h"
24 #include "metadata_utils.h"
25 
26 namespace OHOS {
27 namespace DistributedHardware {
28 using ErrorCallback = std::function<void (ErrorType, int32_t)>;
29 using ResultCallback = std::function<void (uint64_t, std::shared_ptr<OHOS::Camera::CameraMetadata>)>;
DCameraDevice(const DHBase & dhBase,const std::string & sinkAbilityInfo,const std::string & sourceCodecInfo)30 DCameraDevice::DCameraDevice(const DHBase &dhBase, const std::string &sinkAbilityInfo,
31     const std::string &sourceCodecInfo)
32     : isOpened_(false),
33       dCameraId_(GenerateCameraId(dhBase)),
34       dhBase_(dhBase),
35       dCameraAbilityInfo_(sinkAbilityInfo),
36       sourceCodecInfo_(sourceCodecInfo),
37       dCameraDeviceCallback_(nullptr),
38       dCameraStreamOperator_(nullptr),
39       dMetadataProcessor_(nullptr)
40 {
41     DHLOGI("DCameraDevice construct");
42     Init(sinkAbilityInfo);
43 }
44 
Init(const std::string & sinkAbilityInfo)45 void DCameraDevice::Init(const std::string &sinkAbilityInfo)
46 {
47     if (dMetadataProcessor_ == nullptr) {
48         dMetadataProcessor_ = std::make_shared<DMetadataProcessor>();
49     }
50     dMetadataProcessor_->InitDCameraAbility(sinkAbilityInfo);
51 }
52 
CreateDStreamOperator()53 DCamRetCode DCameraDevice::CreateDStreamOperator()
54 {
55     if (dCameraStreamOperator_ == nullptr) {
56         dCameraStreamOperator_ = sptr<DStreamOperator>(new (std::nothrow) DStreamOperator(dMetadataProcessor_));
57         if (dCameraStreamOperator_ == nullptr) {
58             DHLOGE("Create distributed camera stream operator failed.");
59             return DEVICE_NOT_INIT;
60         }
61     }
62 
63     DCamRetCode ret = dCameraStreamOperator_->SetOutputVal(dhBase_, dCameraAbilityInfo_,
64         sourceCodecInfo_);
65     if (ret != SUCCESS) {
66         DHLOGE("set output value failed, ret=%{public}d.", ret);
67         return ret;
68     }
69 
70     ErrorCallback onErrorCallback =
71         [this](ErrorType type, int32_t errorMsg) -> void {
72             if (dCameraDeviceCallback_) {
73                 DHLOGI("DCameraDevice onErrorCallback type: %{public}u, errorMsg: %{public}d", type, errorMsg);
74                 dCameraDeviceCallback_->OnError(type, errorMsg);
75             }
76         };
77     ResultCallback onResultCallback =
78         [this](uint64_t timestamp, const std::shared_ptr<OHOS::Camera::CameraMetadata> &result) -> void {
79             if (dCameraDeviceCallback_) {
80                 DHLOGI("DCameraDevice onResultCallback timestamp: %{public}" PRIu64, timestamp);
81                 std::vector<uint8_t> metadata;
82                 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(result, metadata);
83                 dCameraDeviceCallback_->OnResult(timestamp, metadata);
84             }
85         };
86     dCameraStreamOperator_->SetDeviceCallback(onErrorCallback, onResultCallback);
87 
88     return ret;
89 }
90 
GetStreamOperator(const sptr<HDI::Camera::V1_0::IStreamOperatorCallback> & callbackObj,sptr<HDI::Camera::V1_0::IStreamOperator> & streamOperator)91 int32_t DCameraDevice::GetStreamOperator(const sptr<HDI::Camera::V1_0::IStreamOperatorCallback> &callbackObj,
92     sptr<HDI::Camera::V1_0::IStreamOperator> &streamOperator)
93 {
94     if (callbackObj == nullptr) {
95         DHLOGE("DCameraDevice::GetStreamOperator, input stream operator callback is null.");
96         return CamRetCode::INVALID_ARGUMENT;
97     }
98 
99     if (dCameraStreamOperator_ == nullptr) {
100         DHLOGE("DCameraDevice::GetStreamOperator, input distributed camera stream operator is null.");
101         return CamRetCode::DEVICE_ERROR;
102     }
103 
104     DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callbackObj);
105     if (ret != SUCCESS) {
106         DHLOGE("Set stream operator callbackObj failed, ret=%{public}d.", ret);
107         return MapToExternalRetCode(ret);
108     }
109 
110     streamOperator = dCameraStreamOperator_;
111     return CamRetCode::NO_ERROR;
112 }
113 
GetStreamOperator_V1_1(const sptr<HDI::Camera::V1_0::IStreamOperatorCallback> & callbackObj,sptr<HDI::Camera::V1_1::IStreamOperator> & streamOperator)114 int32_t DCameraDevice::GetStreamOperator_V1_1(const sptr<HDI::Camera::V1_0::IStreamOperatorCallback> &callbackObj,
115     sptr<HDI::Camera::V1_1::IStreamOperator> &streamOperator)
116 {
117     if (callbackObj == nullptr) {
118         DHLOGE("DCameraDevice::GetStreamOperator_V1_1, input stream operator callback is null.");
119         return CamRetCode::INVALID_ARGUMENT;
120     }
121 
122     if (dCameraStreamOperator_ == nullptr) {
123         DHLOGE("DCameraDevice::GetStreamOperator_V1_1, input distributed camera stream operator is null.");
124         return CamRetCode::DEVICE_ERROR;
125     }
126 
127     DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callbackObj);
128     if (ret != SUCCESS) {
129         DHLOGE("Set stream operator callbackObj failed, ret=%{public}d.", ret);
130         return MapToExternalRetCode(ret);
131     }
132 
133     streamOperator = dCameraStreamOperator_;
134     return CamRetCode::NO_ERROR;
135 }
136 
GetStreamOperator_V1_2(const sptr<HDI::Camera::V1_2::IStreamOperatorCallback> & callbackObj,sptr<HDI::Camera::V1_2::IStreamOperator> & streamOperator)137 int32_t DCameraDevice::GetStreamOperator_V1_2(const sptr<HDI::Camera::V1_2::IStreamOperatorCallback> &callbackObj,
138     sptr<HDI::Camera::V1_2::IStreamOperator> &streamOperator)
139 {
140     if (callbackObj == nullptr) {
141         DHLOGE("DCameraDevice::GetStreamOperator_V1_2, input stream operator callback is null.");
142         return CamRetCode::INVALID_ARGUMENT;
143     }
144 
145     if (dCameraStreamOperator_ == nullptr) {
146         DHLOGE("DCameraDevice::GetStreamOperator_V1_2, input distributed camera stream operator is null.");
147         return CamRetCode::DEVICE_ERROR;
148     }
149 
150     DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callbackObj);
151     if (ret != SUCCESS) {
152         DHLOGE("Set stream operator callbackObj failed, ret=%{public}d.", ret);
153         return MapToExternalRetCode(ret);
154     }
155 
156     streamOperator = dCameraStreamOperator_;
157     return CamRetCode::NO_ERROR;
158 }
159 
GetStreamOperator_V1_3(const sptr<HDI::Camera::V1_3::IStreamOperatorCallback> & callbackObj,sptr<HDI::Camera::V1_3::IStreamOperator> & streamOperator)160 int32_t DCameraDevice::GetStreamOperator_V1_3(const sptr<HDI::Camera::V1_3::IStreamOperatorCallback> &callbackObj,
161     sptr<HDI::Camera::V1_3::IStreamOperator> &streamOperator)
162 {
163     if (callbackObj == nullptr) {
164         DHLOGE("DCameraDevice::GetStreamOperator_V1_3, input stream operator callback is null.");
165         return CamRetCode::INVALID_ARGUMENT;
166     }
167 
168     if (dCameraStreamOperator_ == nullptr) {
169         DHLOGE("DCameraDevice::GetStreamOperator_V1_3, input distributed camera stream operator is null.");
170         return CamRetCode::DEVICE_ERROR;
171     }
172 
173     DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callbackObj);
174     if (ret != SUCCESS) {
175         DHLOGE("Set stream operator callbackObj failed, ret=%{public}d.", ret);
176         return MapToExternalRetCode(ret);
177     }
178 
179     streamOperator = dCameraStreamOperator_;
180     return CamRetCode::NO_ERROR;
181 }
182 
GetSecureCameraSeq(uint64_t & seqId)183 int32_t DCameraDevice::GetSecureCameraSeq(uint64_t &seqId)
184 {
185     (void)seqId;
186     return CamRetCode::NO_ERROR;
187 }
188 
GetStatus(const std::vector<uint8_t> & metaIn,std::vector<uint8_t> & metaOut)189 int32_t DCameraDevice::GetStatus(const std::vector<uint8_t> &metaIn, std::vector<uint8_t> &metaOut)
190 {
191     (void)metaIn;
192     (void)metaOut;
193     return CamRetCode::NO_ERROR;
194 }
195 
Reset()196 int32_t DCameraDevice::Reset()
197 {
198     return CamRetCode::NO_ERROR;
199 }
200 
GetDefaultSettings(std::vector<uint8_t> & settings)201 int32_t DCameraDevice::GetDefaultSettings(std::vector<uint8_t> &settings)
202 {
203     (void)settings;
204     return CamRetCode::NO_ERROR;
205 }
206 
UpdateSettings(const std::vector<uint8_t> & settings)207 int32_t DCameraDevice::UpdateSettings(const std::vector<uint8_t>& settings)
208 {
209     if (settings.empty() || settings.size() > METADATA_CAPACITY_MAX_SIZE) {
210         DHLOGE("DCameraDevice::UpdateSettings, input settings is invalid.");
211         return CamRetCode::INVALID_ARGUMENT;
212     }
213 
214     if (!IsOpened()) {
215         DHLOGE("DCameraDevice::UpdateSettings, dcamera device %{public}s already closed.",
216             GetAnonyString(dCameraId_).c_str());
217         return CamRetCode::CAMERA_CLOSED;
218     }
219 
220     std::shared_ptr<OHOS::Camera::CameraMetadata> updateSettings = nullptr;
221     OHOS::Camera::MetadataUtils::ConvertVecToMetadata(settings, updateSettings);
222     std::string abilityString = OHOS::Camera::MetadataUtils::EncodeToString(updateSettings);
223     std::string encodeString = Base64Encode(reinterpret_cast<const unsigned char *>(abilityString.c_str()),
224         abilityString.length());
225 
226     DCameraSettings dcSetting;
227     dcSetting.type_ = DCSettingsType::UPDATE_METADATA;
228     dcSetting.value_ = encodeString;
229 
230     std::vector<DCameraSettings> dcSettings;
231     dcSettings.push_back(dcSetting);
232 
233     OHOS::sptr<DCameraProvider> provider = DCameraProvider::GetInstance();
234     if (provider == nullptr) {
235         DHLOGE("Distributed camera provider instance is null.");
236         return CamRetCode::DEVICE_ERROR;
237     }
238     int32_t ret = provider->UpdateSettings(dhBase_, dcSettings);
239 
240     return MapToExternalRetCode(static_cast<DCamRetCode>(ret));
241 }
242 
GetSettings(std::vector<uint8_t> & settings)243 int32_t DCameraDevice::GetSettings(std::vector<uint8_t> &settings)
244 {
245     if (settings.empty()) {
246         DHLOGE("Get settings failed.");
247         return CamRetCode::DEVICE_ERROR;
248     }
249     return CamRetCode::NO_ERROR;
250 }
251 
SetResultMode(ResultCallbackMode mode)252 int32_t DCameraDevice::SetResultMode(ResultCallbackMode mode)
253 {
254     if (dMetadataProcessor_ == nullptr) {
255         DHLOGE("Metadata processor not init.");
256         return CamRetCode::DEVICE_ERROR;
257     }
258 
259     DCamRetCode ret = dMetadataProcessor_->SetMetadataResultMode(mode);
260     if (ret != SUCCESS) {
261         DHLOGE("Set metadata result mode failed, ret=%{public}d.", ret);
262     }
263     return MapToExternalRetCode(ret);
264 }
265 
GetEnabledResults(std::vector<int32_t> & results)266 int32_t DCameraDevice::GetEnabledResults(std::vector<int32_t> &results)
267 {
268     if (dMetadataProcessor_ == nullptr) {
269         DHLOGE("Metadata processor not init.");
270         return CamRetCode::DEVICE_ERROR;
271     }
272 
273     DCamRetCode ret = dMetadataProcessor_->GetEnabledMetadataResults(results);
274     if (ret != SUCCESS) {
275         DHLOGE("Get enabled metadata results failed, ret=%{public}d.", ret);
276     }
277     return MapToExternalRetCode(ret);
278 }
279 
EnableResult(const std::vector<int32_t> & results)280 int32_t DCameraDevice::EnableResult(const std::vector<int32_t> &results)
281 {
282     if (results.empty() || results.size() > METADATA_CAPACITY_MAX_SIZE) {
283         DHLOGE("DCameraDevice::EnableResult, input results is invalid.");
284         return CamRetCode::DEVICE_ERROR;
285     }
286 
287     if (dMetadataProcessor_ == nullptr) {
288         DHLOGE("Metadata processor not init.");
289         return CamRetCode::DEVICE_ERROR;
290     }
291 
292     DCamRetCode ret = dMetadataProcessor_->EnableMetadataResult(results);
293     if (ret != SUCCESS) {
294         DHLOGE("Enable metadata result failed, ret=%{public}d.", ret);
295         return MapToExternalRetCode(ret);
296     }
297 
298     stringstream sstream;
299     std::reverse_copy(results.begin(), results.end(), ostream_iterator<int32_t>(sstream, ""));
300     DCameraSettings dcSetting;
301     dcSetting.type_ = DCSettingsType::ENABLE_METADATA;
302     dcSetting.value_ = sstream.str();
303 
304     OHOS::sptr<DCameraProvider> provider = DCameraProvider::GetInstance();
305     if (provider == nullptr) {
306         DHLOGE("Enable metadata failed, provider is nullptr.");
307         return CamRetCode::DEVICE_ERROR;
308     }
309     std::vector<DCameraSettings> dcSettings;
310     dcSettings.push_back(dcSetting);
311     int32_t retProv = provider->UpdateSettings(dhBase_, dcSettings);
312     return MapToExternalRetCode(static_cast<DCamRetCode>(retProv));
313 }
314 
DisableResult(const std::vector<int32_t> & results)315 int32_t DCameraDevice::DisableResult(const std::vector<int32_t> &results)
316 {
317     if (results.empty() || results.size() > METADATA_CAPACITY_MAX_SIZE) {
318         DHLOGE("DCameraDevice::DisableResult, input results is invalid.");
319         return CamRetCode::DEVICE_ERROR;
320     }
321 
322     if (dMetadataProcessor_ == nullptr) {
323         DHLOGE("Metadata processor not init.");
324         return CamRetCode::DEVICE_ERROR;
325     }
326 
327     DCamRetCode ret = dMetadataProcessor_->DisableMetadataResult(results);
328     if (ret != SUCCESS) {
329         DHLOGE("Disable metadata result failed, ret=%{public}d.", ret);
330         return MapToExternalRetCode(ret);
331     }
332 
333     stringstream sstream;
334     std::reverse_copy(results.begin(), results.end(), ostream_iterator<int32_t>(sstream, ""));
335     DCameraSettings dcSetting;
336     dcSetting.type_ = DCSettingsType::DISABLE_METADATA;
337     dcSetting.value_ = sstream.str();
338 
339     OHOS::sptr<DCameraProvider> provider = DCameraProvider::GetInstance();
340     if (provider == nullptr) {
341         DHLOGE("Metadata processor provider is nullptr.");
342         return CamRetCode::DEVICE_ERROR;
343     }
344     std::vector<DCameraSettings> dcSettings;
345     dcSettings.push_back(dcSetting);
346     int32_t retProv = provider->UpdateSettings(dhBase_, dcSettings);
347     return MapToExternalRetCode(static_cast<DCamRetCode>(retProv));
348 }
349 
Close()350 int32_t DCameraDevice::Close()
351 {
352     DHLOGI("DCameraDevice::Close distributed camera: %{public}s", GetAnonyString(dCameraId_).c_str());
353 
354     OHOS::sptr<DCameraProvider> provider = DCameraProvider::GetInstance();
355     if ((provider != nullptr) && (dCameraStreamOperator_ != nullptr)) {
356         std::vector<int> streamIds = dCameraStreamOperator_->GetStreamIds();
357         provider->StopCapture(dhBase_, streamIds);
358     }
359     if (dCameraStreamOperator_ != nullptr) {
360         dCameraStreamOperator_->Release();
361         dCameraStreamOperator_ = nullptr;
362     }
363     if (provider != nullptr) {
364         provider->CloseSession(dhBase_);
365     }
366     if (dMetadataProcessor_ != nullptr) {
367         dMetadataProcessor_->ResetEnableResults();
368     }
369     dCameraDeviceCallback_ = nullptr;
370     isOpenSessFailed_ = false;
371     isOpened_ = false;
372     return CamRetCode::NO_ERROR;
373 }
374 
OpenDCamera(const OHOS::sptr<ICameraDeviceCallback> & callback)375 CamRetCode DCameraDevice::OpenDCamera(const OHOS::sptr<ICameraDeviceCallback> &callback)
376 {
377     if (callback == nullptr) {
378         DHLOGE("Input callback is null.");
379         return CamRetCode::INVALID_ARGUMENT;
380     }
381     dCameraDeviceCallback_ = callback;
382 
383     OHOS::sptr<DCameraProvider> provider = DCameraProvider::GetInstance();
384     if (provider == nullptr) {
385         DHLOGE("Get distributed camera provider instance is null.");
386         return CamRetCode::DEVICE_ERROR;
387     }
388     int32_t ret = provider->OpenSession(dhBase_);
389     if (ret != DCamRetCode::SUCCESS) {
390         DHLOGE("Open distributed camera control session failed, ret = %{public}d.", ret);
391         return MapToExternalRetCode(static_cast<DCamRetCode>(ret));
392     }
393 
394     unique_lock<mutex> lock(openSesslock_);
395     auto st = openSessCV_.wait_for(lock, chrono::seconds(WAIT_OPEN_TIMEOUT_SEC));
396     if (st == cv_status::timeout) {
397         DHLOGE("Wait for distributed camera session open timeout.");
398         return CamRetCode::DEVICE_ERROR;
399     }
400     {
401         unique_lock<mutex> openStateLock(isOpenSessFailedlock_);
402         if (isOpenSessFailed_) {
403             DHLOGE("Open distributed camera session failed.");
404             return CamRetCode::DEVICE_ERROR;
405         }
406     }
407 
408     DCamRetCode retDCode = CreateDStreamOperator();
409     if (ret != SUCCESS) {
410         DHLOGE("Create distributed camera stream operator failed.");
411         return MapToExternalRetCode(retDCode);
412     }
413     isOpened_ = true;
414 
415     return MapToExternalRetCode(retDCode);
416 }
417 
TriggerGetFullCaps()418 CamRetCode DCameraDevice::TriggerGetFullCaps()
419 {
420     DHLOGI("DCameraDevice TriggerGetFullCaps enter.");
421     DCameraHDFEvent dCameraEvent;
422     dCameraEvent.type_ = DCameraEventType::DCAMERE_GETFULLCAP;
423     if (dCameraProviderCallback_ == nullptr) {
424         DHLOGE("The dCameraProviderCallback_ is null.");
425         return CamRetCode::INVALID_ARGUMENT;
426     }
427     dCameraProviderCallback_->NotifyEvent(dhBase_, dCameraEvent);
428     {
429         std::unique_lock<std::mutex> lck(getFullLock_);
430         DHLOGI("Wait get full caps");
431         auto status = getFullWaitCond_.wait_for(lck, std::chrono::seconds(GET_FULL_WAIT_SECONDS));
432         if (status == std::cv_status::timeout) {
433             DHLOGE("Wait get full caps timeout(%{public}ds).", GET_FULL_WAIT_SECONDS);
434             return CamRetCode::INVALID_ARGUMENT;
435         }
436         if (!GetRefreshFlag()) {
437             DHLOGI("It is not refreshed.");
438             return CamRetCode::INVALID_ARGUMENT;
439         }
440     }
441     DHLOGI("DCameraDevice TriggerGetFullCaps wait end.");
442     return CamRetCode::NO_ERROR;
443 }
444 
GetDCameraAbility(std::shared_ptr<CameraAbility> & ability)445 CamRetCode DCameraDevice::GetDCameraAbility(std::shared_ptr<CameraAbility> &ability)
446 {
447     DHLOGI("DCameraDevice GetDCameraAbility enter.");
448     if (dCameraAbilityInfo_.find(FULL_DATA_KEY) == dCameraAbilityInfo_.npos) {
449         auto res = TriggerGetFullCaps();
450         if (res != CamRetCode::NO_ERROR) {
451             DHLOGE("TriggerGetFullCaps failed");
452             return res;
453         }
454     } else {
455         DHLOGI("DCameraDevice has full ability, no need to GetDCameraAbility.");
456     }
457     if (dMetadataProcessor_ == nullptr) {
458         DHLOGE("Metadata processor not init.");
459         return CamRetCode::DEVICE_ERROR;
460     }
461     DCamRetCode ret = dMetadataProcessor_->GetDCameraAbility(ability);
462     if (ret != SUCCESS) {
463         DHLOGE("Get distributed camera ability failed, ret=%{public}d.", ret);
464     }
465     return MapToExternalRetCode(ret);
466 }
467 
AcquireBuffer(int streamId,DCameraBuffer & buffer)468 DCamRetCode DCameraDevice::AcquireBuffer(int streamId, DCameraBuffer &buffer)
469 {
470     if (dCameraStreamOperator_ == nullptr) {
471         DHLOGE("Stream operator not init.");
472         return DEVICE_NOT_INIT;
473     }
474 
475     DCamRetCode ret = dCameraStreamOperator_->AcquireBuffer(streamId, buffer);
476     if (ret != SUCCESS) {
477         DHLOGE("Acquire buffer failed, ret=%{public}d.", ret);
478     }
479     return ret;
480 }
481 
ShutterBuffer(int streamId,const DCameraBuffer & buffer)482 DCamRetCode DCameraDevice::ShutterBuffer(int streamId, const DCameraBuffer &buffer)
483 {
484     if (dCameraStreamOperator_ == nullptr) {
485         DHLOGE("Stream operator not init.");
486         return DEVICE_NOT_INIT;
487     }
488 
489     DCamRetCode ret = dCameraStreamOperator_->ShutterBuffer(streamId, buffer);
490     if (ret != SUCCESS) {
491         DHLOGE("Shutter buffer failed, ret=%{public}d.", ret);
492     }
493     return ret;
494 }
495 
OnSettingsResult(const std::shared_ptr<DCameraSettings> & result)496 DCamRetCode DCameraDevice::OnSettingsResult(const std::shared_ptr<DCameraSettings> &result)
497 {
498     if (result == nullptr) {
499         DHLOGE("Input camera settings is null.");
500         return DCamRetCode::INVALID_ARGUMENT;
501     }
502 
503     if (dMetadataProcessor_ == nullptr) {
504         DHLOGE("Metadata processor not init.");
505         return DCamRetCode::DEVICE_NOT_INIT;
506     }
507 
508     if (result->type_ != DCSettingsType::METADATA_RESULT) {
509         DHLOGE("Invalid camera setting type = %{public}d.", result->type_);
510         return DCamRetCode::INVALID_ARGUMENT;
511     }
512     if ((result->value_).empty()) {
513         DHLOGE("Camera settings result is empty.");
514         return DCamRetCode::INVALID_ARGUMENT;
515     }
516 
517     DCamRetCode ret = dMetadataProcessor_->SaveResultMetadata(result->value_);
518     if (ret != DCamRetCode::SUCCESS) {
519         DHLOGE("Save result metadata failed, ret = %{public}d", ret);
520     }
521     return ret;
522 }
523 
Notify(const std::shared_ptr<DCameraHDFEvent> & event)524 DCamRetCode DCameraDevice::Notify(const std::shared_ptr<DCameraHDFEvent> &event)
525 {
526     CHECK_AND_RETURN_RET_LOG(event == nullptr, DCamRetCode::INVALID_ARGUMENT, "event is nullptr");
527     DHLOGI("DCameraDevice::Notify for event type = %{public}d, result = %{public}d, content = %{public}s.",
528         event->type_, event->result_, event->content_.c_str());
529     if ((event->type_ != DCameraEventType::DCAMERA_MESSAGE) && (event->type_ != DCameraEventType::DCAMERA_OPERATION)) {
530         DHLOGE("Invalid distributed camera event type = %{public}d.", event->type_);
531         return DCamRetCode::INVALID_ARGUMENT;
532     }
533     switch (event->result_) {
534         case DCameraEventResult::DCAMERA_EVENT_CHANNEL_CONNECTED: {
535             IsOpenSessFailedState(false);
536             break;
537         }
538         case DCameraEventResult::DCAMERA_EVENT_OPEN_CHANNEL_ERROR: {
539             IsOpenSessFailedState(true);
540             break;
541         }
542         case DCameraEventResult::DCAMERA_EVENT_CHANNEL_DISCONNECTED: {
543             NotifyCameraError(ErrorType::DEVICE_DISCONNECT);
544             break;
545         }
546         case DCameraEventResult::DCAMERA_EVENT_CONFIG_STREAMS_ERROR:
547         case DCameraEventResult::DCAMERA_EVENT_START_CAPTURE_ERROR: {
548             NotifyStartCaptureError();
549             break;
550         }
551         case DCameraEventResult::DCAMERA_EVENT_DEVICE_ERROR: {
552             NotifyCameraError(ErrorType::DRIVER_ERROR);
553             break;
554         }
555         case DCameraEventResult::DCAMERA_EVENT_DEVICE_PREEMPT: {
556             NotifyCameraError(ErrorType::DEVICE_PREEMPT);
557             break;
558         }
559         case DCameraEventResult::DCAMERA_EVENT_DEVICE_IN_USE: {
560             NotifyCameraError(ErrorType::DCAMERA_ERROR_DEVICE_IN_USE);
561             break;
562         }
563         case DCameraEventResult::DCAMERA_EVENT_NO_PERMISSION: {
564             NotifyCameraError(ErrorType::DCAMERA_ERROR_NO_PERMISSION);
565             break;
566         }
567         default:
568             break;
569     }
570     return SUCCESS;
571 }
572 
IsOpenSessFailedState(bool state)573 void DCameraDevice::IsOpenSessFailedState(bool state)
574 {
575     {
576         unique_lock<mutex> lock(isOpenSessFailedlock_);
577         isOpenSessFailed_ = state;
578     }
579     openSessCV_.notify_one();
580 }
581 
NotifyStartCaptureError()582 void DCameraDevice::NotifyStartCaptureError()
583 {
584     if (dCameraDeviceCallback_ != nullptr) {
585         dCameraDeviceCallback_->OnError(ErrorType::REQUEST_TIMEOUT, 0);
586     }
587     OHOS::sptr<DCameraProvider> provider = DCameraProvider::GetInstance();
588     if ((provider != nullptr) && (dCameraStreamOperator_ != nullptr)) {
589         std::vector<int> streamIds = dCameraStreamOperator_->GetStreamIds();
590         provider->StopCapture(dhBase_, streamIds);
591     }
592     if (dCameraStreamOperator_ != nullptr) {
593         dCameraStreamOperator_->Release();
594     }
595 }
596 
NotifyCameraError(const ErrorType type)597 void DCameraDevice::NotifyCameraError(const ErrorType type)
598 {
599     if (dCameraDeviceCallback_ != nullptr) {
600         dCameraDeviceCallback_->OnError(type, 0);
601         Close();
602     }
603 }
604 
SetProviderCallback(const OHOS::sptr<IDCameraProviderCallback> & callback)605 void DCameraDevice::SetProviderCallback(const OHOS::sptr<IDCameraProviderCallback> &callback)
606 {
607     dCameraProviderCallback_ = callback;
608 }
609 
GetProviderCallback()610 OHOS::sptr<IDCameraProviderCallback> DCameraDevice::GetProviderCallback()
611 {
612     return dCameraProviderCallback_;
613 }
614 
GenerateCameraId(const DHBase & dhBase)615 std::string DCameraDevice::GenerateCameraId(const DHBase &dhBase)
616 {
617     return dhBase.deviceId_ + "__" + dhBase.dhId_;
618 }
619 
GetDCameraId()620 std::string DCameraDevice::GetDCameraId()
621 {
622     return dCameraId_;
623 }
624 
IsOpened()625 bool DCameraDevice::IsOpened()
626 {
627     return isOpened_;
628 }
629 
SetDcameraAbility(const std::string & sinkAbilityInfo)630 void DCameraDevice::SetDcameraAbility(const std::string& sinkAbilityInfo)
631 {
632     DHLOGI("DCameraDevice SetDcameraAbility enter.");
633     if (dCameraAbilityInfo_.find(FULL_DATA_KEY) != sinkAbilityInfo.npos &&
634         sinkAbilityInfo.find(META_DATA_KEY) != sinkAbilityInfo.npos) {
635         SetRefreshFlag(false);
636         DHLOGE("The sinkAbilityInfo is meta data, it is not allowed to refresh full data.");
637     } else {
638         SetRefreshFlag(true);
639         dCameraAbilityInfo_ = sinkAbilityInfo;
640         CHECK_AND_RETURN_LOG(dMetadataProcessor_ == nullptr, "dMetadataProcessor_ is nullptr");
641         DCamRetCode ret = dMetadataProcessor_->InitDCameraAbility(sinkAbilityInfo);
642         if (ret != SUCCESS) {
643             DHLOGE("The dMetadataProcessor_ InitDCameraAbility failed, check.");
644             SetRefreshFlag(false);
645         }
646     }
647     std::lock_guard<std::mutex> dataLock(getFullLock_);
648     getFullWaitCond_.notify_all();
649     DHLOGI("DCameraDevice SetDcameraAbility end.");
650 }
651 
SetRefreshFlag(bool flag)652 void DCameraDevice::SetRefreshFlag(bool flag)
653 {
654     refreshFlag_.store(flag);
655 }
656 
GetRefreshFlag()657 bool DCameraDevice::GetRefreshFlag()
658 {
659     return refreshFlag_.load();
660 }
661 } // namespace DistributedHardware
662 } // namespace OHOS
663