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 "ohos_camera_demo_3a.h"
17#include "metadata_utils.h"
18
19namespace OHOS::Camera {
20OhosCameraDemo::OhosCameraDemo() {}
21OhosCameraDemo::~OhosCameraDemo() {}
22
23std::vector<int32_t> results_list_;
24const int32_t FPS_RANGE = 30;
25
26void OhosCameraDemo::SetStreamInfo(StreamInfo& streamInfo,
27    const std::shared_ptr<StreamCustomer> &streamCustomer,
28    const int streamId, const StreamIntent intent)
29{
30    constexpr uint32_t dataspace = 8;
31    constexpr uint32_t tunneledMode = 5;
32    sptr<OHOS::IBufferProducer> producer;
33
34    if (intent == PREVIEW) {
35        constexpr uint32_t width = CAMERA_PREVIEW_WIDTH;
36        constexpr uint32_t height = CAMERA_PREVIEW_HEIGHT;
37        streamInfo.width_ = width;
38        streamInfo.height_ = height;
39    } else if (intent == STILL_CAPTURE) {
40        constexpr uint32_t width = CAMERA_CAPTURE_WIDTH;
41        constexpr uint32_t height = CAMERA_CAPTURE_HEIGHT;
42        streamInfo.width_ = width;
43        streamInfo.height_ = height;
44        streamInfo.encodeType_ = CAMERA_CAPTURE_ENCODE_TYPE;
45    } else {
46        constexpr uint32_t width = CAMERA_VIDEO_WIDTH;
47        constexpr uint32_t height = CAMERA_VIDEO_HEIGHT;
48        streamInfo.width_ = width;
49        streamInfo.height_ = height;
50        streamInfo.encodeType_ = CAMERA_VIDEO_ENCODE_TYPE;
51    }
52
53    streamInfo.streamId_ = streamId;
54    streamInfo.format_ =  CAMERA_FORMAT;
55    streamInfo.dataspace_ = dataspace;
56    streamInfo.intent_ = intent;
57    streamInfo.tunneledMode_ = tunneledMode;
58
59    producer = streamCustomer->CreateProducer();
60    streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
61    CHECK_IF_PTR_NULL_RETURN_VOID(streamInfo.bufferQueue_);
62    streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
63}
64
65void OhosCameraDemo::GetStreamOpt()
66{
67    if (streamOperator_ == nullptr) {
68#ifdef CAMERA_BUILT_ON_OHOS_LITE
69        const std::shared_ptr<IStreamOperatorCallback> streamOperatorCallback =
70            std::make_shared<DemoStreamOperatorCallback>();
71#else
72        const sptr<IStreamOperatorCallback> streamOperatorCallback = new DemoStreamOperatorCallback();
73#endif
74        int rc = demoCameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_);
75        if (rc != HDI::Camera::V1_0::NO_ERROR) {
76            CAMERA_LOGE("demo test: GetStreamOpt GetStreamOperator fail");
77            streamOperator_ = nullptr;
78        }
79    }
80}
81
82RetCode OhosCameraDemo::CaptureON(const int streamId,
83    const int captureId, CaptureMode mode)
84{
85    CAMERA_LOGI("demo test: CaptureON enter streamId == %{public}d and captureId == %{public}d and mode == %{public}d",
86        streamId, captureId, mode);
87    std::lock_guard<std::mutex> l(metaDatalock_);
88    if (mode == CAPTURE_SNAPSHOT) {
89        constexpr double latitude = 27.987500; // dummy data: Qomolangma latitde
90        constexpr double longitude = 86.927500; // dummy data: Qomolangma longituude
91        constexpr double altitude = 8848.86; // dummy data: Qomolangma altitude
92        constexpr size_t entryCapacity = 100;
93        constexpr size_t dataCapacity = 2000;
94        captureSetting_ = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
95        captureQuality_ = OHOS_CAMERA_JPEG_LEVEL_HIGH;
96        captureOrientation_ = OHOS_CAMERA_JPEG_ROTATION_270;
97        mirrorSwitch_ = OHOS_CAMERA_MIRROR_ON;
98        gps_.push_back(latitude);
99        gps_.push_back(longitude);
100        gps_.push_back(altitude);
101        captureSetting_->addEntry(OHOS_JPEG_QUALITY, static_cast<void*>(&captureQuality_),
102            sizeof(captureQuality_));
103        captureSetting_->addEntry(OHOS_JPEG_ORIENTATION, static_cast<void*>(&captureOrientation_),
104            sizeof(captureOrientation_));
105        captureSetting_->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, static_cast<void*>(&mirrorSwitch_),
106            sizeof(mirrorSwitch_));
107        captureSetting_->addEntry(OHOS_JPEG_GPS_COORDINATES, gps_.data(), gps_.size());
108    }
109
110    std::vector<uint8_t> setting;
111    MetadataUtils::ConvertMetadataToVec(captureSetting_, setting);
112    captureInfo_.streamIds_ = {streamId};
113    if (mode == CAPTURE_SNAPSHOT) {
114        captureInfo_.captureSetting_ = setting;
115    } else {
116        captureInfo_.captureSetting_ = cameraAbility_;
117    }
118    captureInfo_.enableShutterCallback_ = false;
119
120    int rc = streamOperator_->Capture(captureId, captureInfo_, true);
121    if (rc != HDI::Camera::V1_0::NO_ERROR) {
122        CAMERA_LOGE("demo test: CaptureStart Capture error");
123        streamOperator_->ReleaseStreams(captureInfo_.streamIds_);
124        return RC_ERROR;
125    }
126
127    if (mode == CAPTURE_PREVIEW) {
128        streamCustomerPreview_->ReceiveFrameOn(nullptr);
129    } else if (mode == CAPTURE_SNAPSHOT) {
130        streamCustomerCapture_->ReceiveFrameOn([this](void* addr, const uint32_t size) {
131            StoreImage(addr, size);
132        });
133    } else if (mode == CAPTURE_VIDEO) {
134        OpenVideoFile();
135
136        streamCustomerVideo_->ReceiveFrameOn([this](void* addr, const uint32_t size) {
137            StoreVideo(addr, size);
138        });
139    }
140    CAMERA_LOGD("demo test: CaptureON exit");
141
142    return RC_OK;
143}
144
145RetCode OhosCameraDemo::CaptureOff(const int captureId, const CaptureMode mode)
146{
147    int rc = 0;
148    CAMERA_LOGD("demo test: CaptureOff enter mode == %{public}d", mode);
149
150    if (streamOperator_ == nullptr) {
151        CAMERA_LOGE("demo test: CaptureOff streamOperator_ is nullptr");
152        return RC_ERROR;
153    }
154
155    if (mode == CAPTURE_PREVIEW) {
156        streamCustomerPreview_->ReceiveFrameOff();
157        rc = streamOperator_->CancelCapture(captureId);
158    } else if (mode == CAPTURE_SNAPSHOT) {
159        streamCustomerCapture_->ReceiveFrameOff();
160        rc = streamOperator_->CancelCapture(captureId);
161    } else if (mode == CAPTURE_VIDEO) {
162        streamCustomerVideo_->ReceiveFrameOff();
163        rc = streamOperator_->CancelCapture(captureId);
164        close(videoFd_);
165        videoFd_ = -1;
166    }
167
168    if (rc != HDI::Camera::V1_0::NO_ERROR) {
169        CAMERA_LOGE("demo test: CaptureOff CancelCapture error mode %{public}d rc == %{public}d", mode, rc);
170        return RC_ERROR;
171    }
172    CAMERA_LOGD("demo test: CaptureOff exit");
173
174    return RC_OK;
175}
176
177RetCode OhosCameraDemo::CreateStream(const int streamId, std::shared_ptr<StreamCustomer> &streamCustomer,
178    StreamIntent intent)
179{
180    int rc = 0;
181    CAMERA_LOGD("demo test: CreateStream enter");
182
183    GetStreamOpt();
184    if (streamOperator_ == nullptr) {
185        CAMERA_LOGE("demo test: CreateStream GetStreamOpt() is nullptr");
186        return RC_ERROR;
187    }
188
189    StreamInfo streamInfo = {0};
190
191    SetStreamInfo(streamInfo, streamCustomer, streamId, intent);
192    if (streamInfo.bufferQueue_->producer_ == nullptr) {
193        CAMERA_LOGE("demo test: CreateStream CreateProducer(); is nullptr");
194        return RC_ERROR;
195    }
196
197    std::vector<StreamInfo> streamInfos;
198    streamInfos.push_back(streamInfo);
199
200    rc = streamOperator_->CreateStreams(streamInfos);
201    if (rc != HDI::Camera::V1_0::NO_ERROR) {
202        CAMERA_LOGE("demo test: CreateStream CreateStreams error");
203        return RC_ERROR;
204    }
205
206    rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_);
207    if (rc != HDI::Camera::V1_0::NO_ERROR) {
208        CAMERA_LOGE("demo test: CreateStream CommitStreams error");
209        std::vector<int> streamIds;
210        streamIds.push_back(streamId);
211        streamOperator_->ReleaseStreams(streamIds);
212        return RC_ERROR;
213    }
214
215    CAMERA_LOGD("demo test: CreateStream exit");
216
217    return RC_OK;
218}
219
220RetCode OhosCameraDemo::InitCameraDevice()
221{
222    int rc = 0;
223
224    CAMERA_LOGD("demo test: InitCameraDevice enter");
225
226    if (demoCameraHost_ == nullptr) {
227        CAMERA_LOGE("demo test: InitCameraDevice demoCameraHost_ == nullptr");
228        return RC_ERROR;
229    }
230
231    (void)demoCameraHost_->GetCameraIds(cameraIds_);
232    if (cameraIds_.empty()) {
233        return RC_ERROR;
234    }
235    const std::string cameraId = cameraIds_.back();
236    demoCameraHost_->GetCameraAbility(cameraId, cameraAbility_);
237
238    MetadataUtils::ConvertVecToMetadata(cameraAbility_, ability_);
239
240    GetFaceDetectMode(ability_);
241    GetFocalLength(ability_);
242    GetAvailableFocusModes(ability_);
243    GetAvailableExposureModes(ability_);
244    GetExposureCompensationRange(ability_);
245    GetExposureCompensationSteps(ability_);
246    GetAvailableMeterModes(ability_);
247    GetAvailableFlashModes(ability_);
248    GetMirrorSupported(ability_);
249    GetStreamBasicConfigurations(ability_);
250    GetFpsRange(ability_);
251    GetCameraPosition(ability_);
252    GetCameraType(ability_);
253    GetCameraConnectionType(ability_);
254    GetFaceDetectMaxNum(ability_);
255
256#ifdef CAMERA_BUILT_ON_OHOS_LITE
257    std::shared_ptr<CameraDeviceCallback> callback = std::make_shared<CameraDeviceCallback>();
258#else
259    sptr<DemoCameraDeviceCallback> callback = new DemoCameraDeviceCallback();
260#endif
261    rc = demoCameraHost_->OpenCamera(cameraIds_.back(), callback, demoCameraDevice_);
262    if (rc != HDI::Camera::V1_0::NO_ERROR || demoCameraDevice_ == nullptr) {
263        CAMERA_LOGE("demo test: InitCameraDevice OpenCamera failed");
264        return RC_ERROR;
265    }
266
267    CAMERA_LOGD("demo test: InitCameraDevice exit");
268
269    return RC_OK;
270}
271
272void OhosCameraDemo::ReleaseCameraDevice()
273{
274    if (demoCameraDevice_ != nullptr) {
275        CAMERA_LOGD("demo test: ReleaseCameraDevice close Device");
276        demoCameraDevice_->Close();
277        demoCameraDevice_ = nullptr;
278    }
279}
280
281RetCode OhosCameraDemo::InitSensors()
282{
283    int rc = 0;
284
285    CAMERA_LOGD("demo test: InitSensors enter");
286
287    if (demoCameraHost_ != nullptr) {
288        return RC_OK;
289    }
290#ifdef CAMERA_BUILT_ON_OHOS_LITE
291    demoCameraHost_ = OHOS::Camera::CameraHost::CreateCameraHost();
292#else
293    constexpr const char* demoServiceName = "camera_service";
294    demoCameraHost_ = ICameraHost::Get(demoServiceName, false);
295#endif
296    if (demoCameraHost_ == nullptr) {
297        CAMERA_LOGE("demo test: ICameraHost::Get error");
298        return RC_ERROR;
299    }
300
301#ifdef CAMERA_BUILT_ON_OHOS_LITE
302    hostCallback_ = std::make_shared<DemoCameraHostCallback>();
303#else
304    hostCallback_ = new DemoCameraHostCallback();
305#endif
306    rc = demoCameraHost_->SetCallback(hostCallback_);
307    if (rc != HDI::Camera::V1_0::NO_ERROR) {
308        CAMERA_LOGE("demo test: demoCameraHost_->SetCallback(hostCallback_) error");
309        return RC_ERROR;
310    }
311
312    CAMERA_LOGD("demo test: InitSensors exit");
313
314    return RC_OK;
315}
316
317void OhosCameraDemo::StoreImage(const void *bufStart, const uint32_t size) const
318{
319    constexpr uint32_t pathLen = 64;
320    char path[pathLen] = {0};
321#ifdef CAMERA_BUILT_ON_OHOS_LITE
322    char prefix[] = "/userdata/photo/";
323#else
324    char prefix[] = "/data/";
325#endif
326
327    int imgFD = 0;
328    int ret;
329
330    struct timeval start = {};
331    gettimeofday(&start, nullptr);
332    if (sprintf_s(path, sizeof(path), "%spicture_%ld.jpeg", prefix, start.tv_usec) < 0) {
333        CAMERA_LOGE("sprintf_s error .....");
334        return;
335    }
336
337    imgFD = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
338    if (imgFD == -1) {
339        CAMERA_LOGE("demo test:open image file error %{public}s.....", strerror(errno));
340        return;
341    }
342
343    CAMERA_LOGD("demo test:StoreImage %{public}s size == %{public}d", path, size);
344
345    ret = write(imgFD, bufStart, size);
346    if (ret == -1) {
347        CAMERA_LOGE("demo test:write image file error %{public}s.....", strerror(errno));
348    }
349
350    close(imgFD);
351}
352
353void OhosCameraDemo::StoreVideo(const void *bufStart, const uint32_t size) const
354{
355    int ret = 0;
356
357    ret = write(videoFd_, bufStart, size);
358    if (ret == -1) {
359        CAMERA_LOGE("demo test:write video file error %{public}s.....", strerror(errno));
360    }
361    CAMERA_LOGD("demo test:StoreVideo size == %{public}d", size);
362}
363
364void OhosCameraDemo::OpenVideoFile()
365{
366    constexpr uint32_t pathLen = 64;
367    char path[pathLen] = {0};
368#ifdef CAMERA_BUILT_ON_OHOS_LITE
369    char prefix[] = "/userdata/video/";
370#else
371    char prefix[] = "/data/";
372#endif
373    auto seconds = time(nullptr);
374    if (sprintf_s(path, sizeof(path), "%svideo%ld.h264", prefix, seconds) < 0) {
375        CAMERA_LOGE("%{public}s: sprintf  failed", __func__);
376        return;
377    }
378    videoFd_ = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
379    if (videoFd_ < 0) {
380        CAMERA_LOGE("demo test: StartVideo open %s %{public}s failed", path, strerror(errno));
381    }
382}
383
384RetCode OhosCameraDemo::CreateStreams(const int streamIdSecond, StreamIntent intent)
385{
386    int rc = 0;
387    std::vector<StreamInfo> streamInfos;
388    std::vector<StreamInfo>().swap(streamInfos);
389
390    CAMERA_LOGD("demo test: CreateStreams streamIdSecond = %{public}d", streamIdSecond);
391    GetStreamOpt();
392    if (streamOperator_ == nullptr) {
393        CAMERA_LOGE("demo test: CreateStreams GetStreamOpt() is nullptr");
394        return RC_ERROR;
395    }
396
397    StreamInfo previewStreamInfo = {0};
398
399    SetStreamInfo(previewStreamInfo, streamCustomerPreview_, STREAM_ID_PREVIEW, PREVIEW);
400    if (previewStreamInfo.bufferQueue_->producer_ == nullptr) {
401        CAMERA_LOGE("demo test: CreateStream CreateProducer(); is nullptr");
402        return RC_ERROR;
403    }
404    streamInfos.push_back(previewStreamInfo);
405
406    StreamInfo secondStreamInfo = {0};
407
408    if (streamIdSecond == STREAM_ID_CAPTURE) {
409        SetStreamInfo(secondStreamInfo, streamCustomerCapture_, STREAM_ID_CAPTURE, intent);
410    } else {
411        SetStreamInfo(secondStreamInfo, streamCustomerVideo_, STREAM_ID_VIDEO, intent);
412    }
413
414    if (secondStreamInfo.bufferQueue_->producer_ == nullptr) {
415        CAMERA_LOGE("demo test: CreateStreams CreateProducer() secondStreamInfo is nullptr");
416        return RC_ERROR;
417    }
418    streamInfos.push_back(secondStreamInfo);
419
420    rc = streamOperator_->CreateStreams(streamInfos);
421    if (rc != HDI::Camera::V1_0::NO_ERROR) {
422        CAMERA_LOGE("demo test: CreateStream CreateStreams error");
423        return RC_ERROR;
424    }
425
426    rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_);
427    if (rc != HDI::Camera::V1_0::NO_ERROR) {
428        CAMERA_LOGE("demo test: CreateStream CommitStreams error");
429        std::vector<int> streamIds = {STREAM_ID_PREVIEW, streamIdSecond};
430        streamOperator_->ReleaseStreams(streamIds);
431        return RC_ERROR;
432    }
433
434    return RC_OK;
435}
436
437RetCode OhosCameraDemo::CaptureOnDualStreams(const int streamIdSecond)
438{
439    int rc = 0;
440    CAMERA_LOGD("demo test: CaptuCaptureOnDualStreamsreON enter");
441
442    CaptureInfo previewCaptureInfo;
443    previewCaptureInfo.streamIds_ = {STREAM_ID_PREVIEW};
444    previewCaptureInfo.captureSetting_ = cameraAbility_;
445    previewCaptureInfo.enableShutterCallback_ = false;
446
447    rc = streamOperator_->Capture(CAPTURE_ID_PREVIEW, previewCaptureInfo, true);
448    if (rc != HDI::Camera::V1_0::NO_ERROR) {
449        CAMERA_LOGE("demo test: CaptureOnDualStreams preview Capture error");
450        streamOperator_->ReleaseStreams(previewCaptureInfo.streamIds_);
451        return RC_ERROR;
452    }
453    streamCustomerPreview_->ReceiveFrameOn(nullptr);
454
455    CaptureInfo secondCaptureInfo;
456    secondCaptureInfo.streamIds_ = {streamIdSecond};
457    secondCaptureInfo.captureSetting_ = cameraAbility_;
458    secondCaptureInfo.enableShutterCallback_ = false;
459
460    if (streamIdSecond == STREAM_ID_CAPTURE) {
461        rc = streamOperator_->Capture(CAPTURE_ID_CAPTURE, secondCaptureInfo, true);
462        if (rc != HDI::Camera::V1_0::NO_ERROR) {
463            CAMERA_LOGE("demo test: CaptureOnDualStreams CAPTURE_ID_CAPTURE error");
464            streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_);
465            return RC_ERROR;
466        }
467
468        streamCustomerCapture_->ReceiveFrameOn([this](void *addr, const uint32_t size) {
469            StoreImage(addr, size);
470        });
471    } else {
472        rc = streamOperator_->Capture(CAPTURE_ID_VIDEO, secondCaptureInfo, true);
473        if (rc != HDI::Camera::V1_0::NO_ERROR) {
474            CAMERA_LOGE("demo test: CaptureOnDualStreams CAPTURE_ID_VIDEO error");
475            streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_);
476            return RC_ERROR;
477        }
478
479        OpenVideoFile();
480        streamCustomerVideo_->ReceiveFrameOn([this](void* addr, const uint32_t size) {
481            StoreVideo(addr, size);
482        });
483    }
484
485    CAMERA_LOGD("demo test: CaptuCaptureOnDualStreamsreON exit");
486
487    return RC_OK;
488}
489
490RetCode OhosCameraDemo::StartDualStreams(const int streamIdSecond)
491{
492    RetCode rc = RC_OK;
493
494    CAMERA_LOGD("demo test: StartDualStreams enter");
495
496    if (streamCustomerPreview_ == nullptr) {
497        streamCustomerPreview_ = std::make_shared<StreamCustomer>();
498    }
499    if (isPreviewOn_ != 0) {
500        return RC_OK;
501    }
502    isPreviewOn_ = 1;
503    if (streamIdSecond == STREAM_ID_CAPTURE) {
504        if (streamCustomerCapture_ == nullptr) {
505            streamCustomerCapture_ = std::make_shared<StreamCustomer>();
506        }
507
508        if (isCaptureOn_ == 0) {
509            isCaptureOn_ = 1;
510            rc = CreateStreams(streamIdSecond, STILL_CAPTURE);
511            if (rc != RC_OK) {
512                CAMERA_LOGE("demo test:StartPreviewStream CreateStreams error");
513                return RC_ERROR;
514            }
515        }
516    } else {
517        if (streamCustomerVideo_ == nullptr) {
518            streamCustomerVideo_ = std::make_shared<StreamCustomer>();
519        }
520
521        if (isVideoOn_ == 0) {
522            isVideoOn_ = 1;
523            rc = CreateStreams(streamIdSecond, VIDEO);
524            if (rc != RC_OK) {
525                CAMERA_LOGE("demo test:StartPreviewStream CreateStreams error");
526                return RC_ERROR;
527            }
528        }
529    }
530
531    CAMERA_LOGD("demo test: StartDualStreams exit");
532
533    return RC_OK;
534}
535
536RetCode OhosCameraDemo::StartCaptureStream()
537{
538    RetCode rc = RC_OK;
539
540    CAMERA_LOGD("demo test: StartCaptureStream enter");
541    if (streamCustomerCapture_ == nullptr) {
542        streamCustomerCapture_ = std::make_shared<StreamCustomer>();
543    }
544
545    if (isCaptureOn_ == 0) {
546        isCaptureOn_ = 1;
547
548        rc = CreateStream(STREAM_ID_CAPTURE, streamCustomerCapture_, STILL_CAPTURE);
549        if (rc != RC_OK) {
550            CAMERA_LOGE("demo test:StartCaptureStream CreateStream error");
551            return RC_ERROR;
552        }
553    }
554
555    CAMERA_LOGD("demo test: StartCaptureStream exit");
556
557    return RC_OK;
558}
559
560RetCode OhosCameraDemo::StartVideoStream()
561{
562    RetCode rc = RC_OK;
563
564    CAMERA_LOGD("demo test: StartVideoStream enter");
565    if (streamCustomerVideo_ == nullptr) {
566        streamCustomerVideo_ = std::make_shared<StreamCustomer>();
567    }
568
569    if (isVideoOn_ == 0) {
570        isVideoOn_ = 1;
571
572        rc = CreateStream(STREAM_ID_VIDEO, streamCustomerVideo_, VIDEO);
573        if (rc != RC_OK) {
574            CAMERA_LOGE("demo test:StartVideoStream CreateStream error");
575            return RC_ERROR;
576        }
577    }
578
579    CAMERA_LOGD("demo test: StartVideoStream exit");
580
581    return RC_OK;
582}
583
584RetCode OhosCameraDemo::StartPreviewStream()
585{
586    RetCode rc = RC_OK;
587
588    CAMERA_LOGD("demo test: StartPreviewStream enter");
589
590    if (streamCustomerPreview_ == nullptr) {
591        streamCustomerPreview_ = std::make_shared<StreamCustomer>();
592    }
593
594    if (isPreviewOn_ == 0) {
595        isPreviewOn_ = 1;
596
597        rc = CreateStream(STREAM_ID_PREVIEW, streamCustomerPreview_, PREVIEW);
598        if (rc != RC_OK) {
599            CAMERA_LOGE("demo test:StartPreviewStream CreateStream error");
600            return RC_ERROR;
601        }
602    }
603
604    CAMERA_LOGD("demo test: StartPreviewStream exit");
605
606    return RC_OK;
607}
608
609RetCode OhosCameraDemo::ReleaseAllStream()
610{
611    std::vector<int> streamIds;
612
613    CAMERA_LOGD("demo test: ReleaseAllStream enter");
614
615    if (isPreviewOn_ != 1) {
616        CAMERA_LOGE("demo test: ReleaseAllStream preview is not running");
617        return RC_ERROR;
618    }
619
620    if (isCaptureOn_ == 1) {
621        CAMERA_LOGD("demo test: ReleaseAllStream STREAM_ID_PREVIEW STREAM_ID_CAPTURE");
622        streamIds = {STREAM_ID_PREVIEW, STREAM_ID_CAPTURE};
623        streamOperator_->ReleaseStreams(streamIds);
624    } else {
625        CAMERA_LOGD("demo test: ReleaseAllStream STREAM_ID_PREVIEW STREAM_ID_VIDEO");
626        streamIds = {STREAM_ID_PREVIEW, STREAM_ID_VIDEO};
627        streamOperator_->ReleaseStreams(streamIds);
628    }
629
630    isPreviewOn_ = 0;
631    isCaptureOn_ = 0;
632    isVideoOn_ = 0;
633
634    CAMERA_LOGD("demo test: ReleaseAllStream exit");
635
636    return RC_OK;
637}
638
639void OhosCameraDemo::QuitDemo()
640{
641    ReleaseCameraDevice();
642    CAMERA_LOGD("demo test: QuitDemo done");
643}
644
645void OhosCameraDemo::SetEnableResult()
646{
647    CAMERA_LOGI("demo test: SetEnableResult enter");
648
649    results_list_.push_back(OHOS_CONTROL_EXPOSURE_MODE);
650    results_list_.push_back(OHOS_CONTROL_FOCUS_MODE);
651    demoCameraDevice_->EnableResult(results_list_);
652
653    CAMERA_LOGI("demo test: SetEnableResult exit");
654}
655
656void OhosCameraDemo::SetAwbMode()
657{
658    int32_t awbMode;
659
660    CAMERA_LOGD("demo test: SetAwbMode enter");
661
662    constexpr size_t entryCapacity = 100;
663    constexpr size_t dataCapacity = 2000;
664
665    std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
666    std::vector<uint8_t> result;
667
668    if (awbStatus_) {
669        awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
670        printf("set auto awb mode on\n");
671    } else {
672        awbMode = OHOS_CAMERA_AWB_MODE_OFF;
673        printf("set auto awb mode off\n");
674    }
675
676    awbStatus_ = !awbStatus_;
677    metaData->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
678
679    const int32_t deviceStreamId = 0;
680    metaData->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
681
682    MetadataUtils::ConvertMetadataToVec(metaData, result);
683    demoCameraDevice_->UpdateSettings(result);
684
685    CAMERA_LOGD("demo test: SetAwbMode exit");
686}
687
688void OhosCameraDemo::SetAfAuto()
689{
690    int32_t afMode;
691
692    CAMERA_LOGD("demo test: SetAfAuto enter");
693
694    constexpr size_t entryCapacity = 100;
695    constexpr size_t dataCapacity = 2000;
696
697    std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
698    std::vector<uint8_t> result;
699
700    if (afStatus_) {
701        afMode = OHOS_CAMERA_FOCUS_MODE_CONTINUOUS_AUTO;
702        printf("set auto focus mode on\n");
703    } else {
704        afMode = OHOS_CAMERA_FOCUS_MODE_MANUAL;
705        printf("set auto focus mode off\n");
706    }
707    afStatus_ = !afStatus_;
708    metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, 1);
709
710    const int32_t deviceStreamId = 0;
711    metaData->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
712
713    MetadataUtils::ConvertMetadataToVec(metaData, result);
714    demoCameraDevice_->UpdateSettings(result);
715
716    CAMERA_LOGD("demo test: SetAfAuto exit");
717}
718
719void OhosCameraDemo::SetAeExpo()
720{
721    int32_t expo;
722
723    CAMERA_LOGD("demo test: SetAeExpo enter");
724
725    constexpr size_t entryCapacity = 100;
726    constexpr size_t dataCapacity = 2000;
727
728    std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
729    std::vector<uint8_t> result;
730
731    if (aeStatus_) {
732        expo = 0xa0;
733    } else {
734        expo = 0x30;
735    }
736    aeStatus_ = !aeStatus_;
737    metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
738
739    const int32_t deviceStreamId = 0;
740    metaData->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
741
742    MetadataUtils::ConvertMetadataToVec(metaData, result);
743    demoCameraDevice_->UpdateSettings(result);
744
745    CAMERA_LOGD("demo test: SetAeExpo exit");
746}
747
748void OhosCameraDemo::SetAeAuto()
749{
750    int32_t expo;
751
752    CAMERA_LOGD("demo test: SetAeAuto enter");
753
754    constexpr size_t entryCapacity = 100;
755    constexpr size_t dataCapacity = 2000;
756
757    std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
758    std::vector<uint8_t> result;
759
760    if (aeAutoStatus_) {
761        expo = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
762        printf("set auto exposure mode on\n");
763    } else {
764        expo = OHOS_CAMERA_EXPOSURE_MODE_MANUAL;
765        printf("set auto exposure mode off\n");
766    }
767    aeAutoStatus_ = !aeAutoStatus_;
768    metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &expo, 1);
769    const int32_t deviceStreamId = 0;
770
771    metaData->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
772
773    MetadataUtils::ConvertMetadataToVec(metaData, result);
774    demoCameraDevice_->UpdateSettings(result);
775
776    CAMERA_LOGD("demo test: SetAeAuto exit");
777}
778
779void OhosCameraDemo::SetAELock()
780{
781    int32_t aeLock;
782
783    CAMERA_LOGD("demo test: SetAELock enter");
784
785    constexpr size_t entryCapacity = 100;
786    constexpr size_t dataCapacity = 2000;
787
788    std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
789    std::vector<uint8_t> result;
790
791    if (aeLockStatus_) {
792        aeLock = OHOS_CAMERA_AE_LOCK_ON;
793        printf("set auto exposure lock on\n");
794    } else {
795        aeLock = OHOS_CAMERA_AE_LOCK_OFF;
796        printf("set auto exposure lock off\n");
797    }
798    aeLockStatus_ = !aeLockStatus_;
799
800    metaData->addEntry(OHOS_CONTROL_AE_LOCK, &aeLock, 1);
801
802    const int32_t deviceStreamId = 0;
803    metaData->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
804
805    MetadataUtils::ConvertMetadataToVec(metaData, result);
806    demoCameraDevice_->UpdateSettings(result);
807
808    CAMERA_LOGD("demo test: SetAELock exit");
809}
810
811void OhosCameraDemo::SetAWBLock()
812{
813    int32_t awbLock;
814
815    CAMERA_LOGD("demo test: SetAWBLock enter");
816
817    constexpr size_t entryCapacity = 100;
818    constexpr size_t dataCapacity = 2000;
819
820    std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
821    std::vector<uint8_t> result;
822
823    if (awbLockStatus_) {
824        awbLock = OHOS_CAMERA_AWB_LOCK_ON;
825        printf("set auto exposure lock on\n");
826    } else {
827        awbLock = OHOS_CAMERA_AWB_LOCK_OFF;
828        printf("set auto exposure lock off\n");
829    }
830    awbLockStatus_ = !awbLockStatus_;
831
832    metaData->addEntry(OHOS_CONTROL_AWB_LOCK, &awbLock, 1);
833
834    const int32_t deviceStreamId = 0;
835    metaData->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, 1);
836
837    MetadataUtils::ConvertMetadataToVec(metaData, result);
838    demoCameraDevice_->UpdateSettings(result);
839
840    CAMERA_LOGD("demo test: SetAWBLock exit");
841}
842
843RetCode OhosCameraDemo::GetFaceDetectMode(std::shared_ptr<CameraAbility> &ability)
844{
845    common_metadata_header_t* data = ability->get();
846    uint8_t faceDetectMode;
847    camera_metadata_item_t entry;
848    int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MODE, &entry);
849    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
850        CAMERA_LOGE("demo test: get OHOS_STATISTICS_FACE_DETECT_MODE error");
851        return RC_ERROR;
852    }
853    faceDetectMode = *(entry.data.u8);
854    CAMERA_LOGD("demo test: faceDetectMode %{public}d\n",  faceDetectMode);
855    return RC_OK;
856}
857
858RetCode OhosCameraDemo::GetFocalLength(std::shared_ptr<CameraAbility> &ability)
859{
860    common_metadata_header_t* data = ability->get();
861    float focalLength = 0.0;
862    camera_metadata_item_t entry;
863    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
864    if (ret != 0 || entry.data.f == nullptr || entry.count <= 0) {
865        CAMERA_LOGE("demo test:  get OHOS_ABILITY_FOCAL_LENGTH error");
866        return RC_ERROR;
867    }
868    focalLength = *(entry.data.f);
869    CAMERA_LOGD("demo test: focalLength %{public}f\n", focalLength);
870    return RC_OK;
871}
872
873RetCode OhosCameraDemo::GetAvailableFocusModes(std::shared_ptr<CameraAbility> &ability)
874{
875    common_metadata_header_t* data = ability->get();
876    std::vector<uint8_t> focusMode;
877    camera_metadata_item_t entry;
878    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
879    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
880        CAMERA_LOGE("demo test: get OHOS_ABILITY_FOCUS_MODES  error");
881        return RC_ERROR;
882    }
883    uint32_t count = entry.count;
884    CAMERA_LOGD("demo test: count  %{public}d\n",  count);
885
886    for (int i = 0 ; i < count; i++) {
887        focusMode.push_back(*(entry.data.u8 + i));
888    }
889
890    for (auto it = focusMode.begin(); it != focusMode.end(); it++) {
891        CAMERA_LOGD("demo test: focusMode : %{public}d \n", *it);
892    }
893    return RC_OK;
894}
895
896RetCode OhosCameraDemo::GetAvailableExposureModes(std::shared_ptr<CameraAbility> &ability)
897{
898    common_metadata_header_t* data = ability->get();
899    std::vector<uint8_t> exposureMode;
900    camera_metadata_item_t entry;
901    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
902    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
903        CAMERA_LOGE("demo test: get OHOS_ABILITY_EXPOSURE_MODES  error");
904        return RC_ERROR;
905    }
906    uint32_t count = entry.count;
907    CAMERA_LOGD("demo test: count  %{public}d\n",  count);
908
909    for (int i = 0 ; i < count; i++) {
910        exposureMode.push_back(*(entry.data.u8 + i));
911    }
912
913    for (auto it = exposureMode.begin(); it != exposureMode.end(); it++) {
914        CAMERA_LOGD("demo test: exposureMode : %{public}d \n", *it);
915    }
916    return RC_OK;
917}
918
919RetCode OhosCameraDemo::GetExposureCompensationRange(std::shared_ptr<CameraAbility> &ability)
920{
921    common_metadata_header_t* data = ability->get();
922    std::vector<int32_t>  exposureCompensationRange;
923    camera_metadata_item_t entry;
924    int ret = FindCameraMetadataItem(data, OHOS_CONTROL_AE_COMPENSATION_RANGE, &entry);
925    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
926        CAMERA_LOGE("demo test: get OHOS_CONTROL_AE_COMPENSATION_RANGE error");
927        return RC_ERROR;
928    }
929
930    uint32_t count = entry.count;
931    CAMERA_LOGD("demo test:  exposureCompensationRange count  %{public}d\n",  count);
932    for (int i = 0 ; i < count; i++) {
933        exposureCompensationRange.push_back(*(entry.data.i32 + i));
934    }
935
936    for (auto it = exposureCompensationRange.begin(); it != exposureCompensationRange.end(); it++) {
937        CAMERA_LOGD("demo test: exposureCompensationRange %{public}d \n", *it);
938    }
939
940    return RC_OK;
941}
942
943RetCode OhosCameraDemo::GetExposureCompensationSteps(std::shared_ptr<CameraAbility> &ability)
944{
945    common_metadata_header_t* data = ability->get();
946    camera_rational_t exposureCompensationSteps;
947    camera_metadata_item_t entry;
948    int ret = FindCameraMetadataItem(data, OHOS_CONTROL_AE_COMPENSATION_STEP, &entry);
949    if (ret != 0 || entry.data.r == nullptr || entry.count <= 0) {
950        CAMERA_LOGE("demo test: get OHOS_CONTROL_AE_COMPENSATION_STEP error");
951        return RC_ERROR;
952    }
953    exposureCompensationSteps.numerator = entry.data.r->numerator;
954    exposureCompensationSteps.denominator = entry.data.r->denominator;
955    CAMERA_LOGD("demo test: steps.numerator %{public}d  and steps.denominator %{public}d \n",
956        exposureCompensationSteps.numerator, exposureCompensationSteps.denominator);
957    return RC_OK;
958}
959
960RetCode OhosCameraDemo::GetAvailableMeterModes(std::shared_ptr<CameraAbility> &ability)
961{
962    common_metadata_header_t* data = ability->get();
963    std::vector<uint8_t> meterModes;
964    camera_metadata_item_t entry;
965    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry);
966    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
967        CAMERA_LOGE("demo test: get OHOS_ABILITY_METER_MODES  error");
968        return RC_ERROR;
969    }
970    uint32_t count = entry.count;
971    CAMERA_LOGD("demo test: count  %{public}d\n",  count);
972
973    for (int i = 0 ; i < count; i++) {
974        meterModes.push_back(*(entry.data.u8 + i));
975    }
976
977    for (auto it = meterModes.begin(); it != meterModes.end(); it++) {
978        CAMERA_LOGD("demo test: meterModes : %{public}d \n", *it);
979    }
980    return RC_OK;
981}
982
983RetCode OhosCameraDemo::GetAvailableFlashModes(std::shared_ptr<CameraAbility> &ability)
984{
985    common_metadata_header_t* data = ability->get();
986    std::vector<uint8_t> flashModes;
987    camera_metadata_item_t entry;
988    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
989    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
990        CAMERA_LOGE("demo test: get OHOS_ABILITY_FLASH_MODES  error");
991        return RC_ERROR;
992    }
993    uint32_t count = entry.count;
994    CAMERA_LOGD("demo test: count  %{public}d\n",  count);
995
996    for (int i = 0 ; i < count; i++) {
997        flashModes.push_back(*(entry.data.u8 + i));
998    }
999
1000    for (auto it = flashModes.begin(); it != flashModes.end(); it++) {
1001        CAMERA_LOGD("demo test: flashModes : %{public}d \n", *it);
1002    }
1003    return RC_OK;
1004}
1005
1006RetCode OhosCameraDemo::GetMirrorSupported(std::shared_ptr<CameraAbility> &ability)
1007{
1008    common_metadata_header_t* data = ability->get();
1009    uint8_t mirrorSupported;
1010    camera_metadata_item_t entry;
1011    int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
1012    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1013        CAMERA_LOGE("demo test: get OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED error");
1014        return RC_ERROR;
1015    }
1016    mirrorSupported = *(entry.data.u8);
1017    CAMERA_LOGD("demo test: mirrorSupported  %{public}d\n",  mirrorSupported);
1018    return RC_OK;
1019}
1020
1021RetCode OhosCameraDemo::GetStreamBasicConfigurations(std::shared_ptr<CameraAbility> &ability)
1022{
1023    common_metadata_header_t* data = ability->get();
1024    std::vector<int32_t>  streamBasicConfigurations;
1025    camera_metadata_item_t entry;
1026    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
1027    if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) {
1028        CAMERA_LOGE("demo test: get OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS error");
1029        return RC_ERROR;
1030    }
1031
1032    uint32_t count = entry.count;
1033    CAMERA_LOGD("demo test: streamBasicConfigurations count  %{public}d\n",  count);
1034    for (int i = 0 ; i < count; i++) {
1035        streamBasicConfigurations.push_back(*(entry.data.i32 + i));
1036    }
1037
1038    for (auto it = streamBasicConfigurations.begin(); it != streamBasicConfigurations.end(); it++) {
1039        CAMERA_LOGD("demo test: streamBasicConfigurations %{public}d \n", *it);
1040    }
1041
1042    return RC_OK;
1043}
1044
1045RetCode OhosCameraDemo::GetFpsRange(std::shared_ptr<CameraAbility> &ability)
1046{
1047    common_metadata_header_t* data = ability->get();
1048    std::vector<int32_t>  fpsRange;
1049    camera_metadata_item_t entry;
1050    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
1051    if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) {
1052        CAMERA_LOGE("demo test: get OHOS_ABILITY_FPS_RANGES error");
1053        return RC_ERROR;
1054    }
1055
1056    uint32_t count = entry.count;
1057    CAMERA_LOGD("demo test: fpsRange count  %{public}d\n",  count);
1058    for (int i = 0 ; i < count; i++) {
1059        fpsRange.push_back(*(entry.data.i32 + i));
1060    }
1061
1062    for (auto it = fpsRange.begin(); it != fpsRange.end(); it++) {
1063        CAMERA_LOGD("demo test: fpsRange %{public}d \n", *it);
1064    }
1065
1066    return RC_OK;
1067}
1068
1069RetCode OhosCameraDemo::GetCameraPosition(std::shared_ptr<CameraAbility> &ability)
1070{
1071    common_metadata_header_t* data = ability->get();
1072    uint8_t  cameraPosition;
1073    camera_metadata_item_t entry;
1074    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
1075    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1076        CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_POSITION error");
1077        return RC_ERROR;
1078    }
1079
1080    cameraPosition= *(entry.data.u8);
1081    CAMERA_LOGD("demo test: cameraPosition  %{public}d\n", cameraPosition);
1082    return RC_OK;
1083}
1084
1085RetCode OhosCameraDemo::GetCameraType(std::shared_ptr<CameraAbility> &ability)
1086{
1087    common_metadata_header_t* data = ability->get();
1088    uint8_t  cameraType;
1089    camera_metadata_item_t entry;
1090    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
1091    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1092        CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_TYPE error");
1093        return RC_ERROR;
1094    }
1095
1096    cameraType= *(entry.data.u8);
1097    CAMERA_LOGD("demo test: cameraType  %{public}d\n", cameraType);
1098    return RC_OK;
1099}
1100
1101RetCode OhosCameraDemo::GetCameraConnectionType(std::shared_ptr<CameraAbility> &ability)
1102{
1103    common_metadata_header_t* data = ability->get();
1104    uint8_t  cameraConnectionType;
1105    camera_metadata_item_t entry;
1106    int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
1107    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1108        CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_CONNECTION_TYPE error");
1109        return RC_ERROR;
1110    }
1111
1112    cameraConnectionType= *(entry.data.u8);
1113    CAMERA_LOGD("demo test: cameraConnectionType  %{public}d\n", cameraConnectionType);
1114    return RC_OK;
1115}
1116
1117RetCode OhosCameraDemo::GetFaceDetectMaxNum(std::shared_ptr<CameraAbility> &ability)
1118{
1119    common_metadata_header_t* data = ability->get();
1120    uint8_t  faceDetectMaxNum;
1121    camera_metadata_item_t entry;
1122    int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MAX_NUM, &entry);
1123    if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1124        CAMERA_LOGE("demo test: get OHOS_STATISTICS_FACE_DETECT_MAX_NUM error");
1125        return RC_ERROR;
1126    }
1127    faceDetectMaxNum = *(entry.data.u8);
1128    CAMERA_LOGD("demo test: faceDetectMaxNum %{public}d \n", faceDetectMaxNum);
1129    return RC_OK;
1130}
1131
1132#ifndef CAMERA_BUILT_ON_OHOS_LITE
1133int32_t DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorCode)
1134{
1135    CAMERA_LOGI("demo test: OnError type : %{public}d, errorCode : %{public}d", type, errorCode);
1136}
1137
1138int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t>& result)
1139{
1140    std::shared_ptr<CameraMetadata> updateSettings;
1141    MetadataUtils::ConvertVecToMetadata(result, updateSettings);
1142    for (auto it = results_list_.cbegin(); it != results_list_.cend(); it++) {
1143        switch (*it) {
1144            case OHOS_CONTROL_FOCUS_MODE: {
1145                common_metadata_header_t* data = updateSettings->get();
1146                uint8_t focusMode;
1147                camera_metadata_item_t entry;
1148                int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_MODE, &entry);
1149                if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1150                    CAMERA_LOGE("demo test: get OHOS_CONTROL_FOCUS_MODE error");
1151                    return RC_ERROR;
1152                }
1153                focusMode = *(entry.data.u8);
1154                CAMERA_LOGI("demo test: focusMode %{public}d\n", focusMode);
1155                break;
1156            }
1157            case OHOS_CONTROL_EXPOSURE_MODE: {
1158                common_metadata_header_t* data = updateSettings->get();
1159                uint8_t exposureMode;
1160                camera_metadata_item_t entry;
1161                int ret = FindCameraMetadataItem(data, OHOS_CONTROL_EXPOSURE_MODE, &entry);
1162                if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) {
1163                    CAMERA_LOGE("demo test: get OHOS_CONTROL_EXPOSURE_MODE error");
1164                    return RC_ERROR;
1165                }
1166                exposureMode = *(entry.data.u8);
1167                CAMERA_LOGI("demo test: exposureMode %{public}d\n", exposureMode);
1168                break;
1169            }
1170            default:
1171                break;
1172        }
1173    }
1174
1175    return RC_OK;
1176}
1177
1178int32_t DemoCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
1179{
1180    (void)cameraId;
1181    CAMERA_LOGI("%{public}s, enter.", __func__);
1182    return RC_OK;
1183}
1184
1185int32_t DemoCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
1186{
1187    CAMERA_LOGI("%{public}s, enter. cameraId = %s, status = %d",
1188        __func__, cameraId.c_str(), static_cast<int>(status));
1189    return RC_OK;
1190}
1191
1192int32_t DemoCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
1193{
1194    CAMERA_LOGI("%{public}s, enter. cameraId = %s, event = %d",
1195        __func__, cameraId.c_str(), static_cast<int>(event));
1196    return RC_OK;
1197}
1198
1199int32_t DemoStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector<int32_t>& streamIds)
1200{
1201    (void)captureId;
1202    CAMERA_LOGI("%{public}s, enter.", __func__);
1203    return RC_OK;
1204}
1205
1206int32_t DemoStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo>& infos)
1207{
1208    (void)captureId;
1209    CAMERA_LOGI("%{public}s, enter.", __func__);
1210    return RC_OK;
1211}
1212
1213int32_t DemoStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo>& infos)
1214{
1215    (void)captureId;
1216    CAMERA_LOGI("%{public}s, enter.", __func__);
1217    return RC_OK;
1218}
1219
1220int32_t DemoStreamOperatorCallback::OnFrameShutter(int32_t captureId,
1221    const std::vector<int32_t>& streamIds, uint64_t timestamp)
1222{
1223    (void)captureId;
1224    (void)timestamp;
1225    CAMERA_LOGI("%{public}s, enter.", __func__);
1226    return RC_OK;
1227}
1228
1229#endif
1230} // namespace OHOS::Camera
1231