1 /*
2 * Copyright (c) 2022-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_hdf_demo.h"
17 #include "distributed_hardware_log.h"
18 #include "metadata_utils.h"
19 #include <gtest/gtest.h>
20
21 namespace OHOS {
22 namespace DistributedHardware {
DcameraHdfDemo()23 DcameraHdfDemo::DcameraHdfDemo() {}
~DcameraHdfDemo()24 DcameraHdfDemo::~DcameraHdfDemo() {}
25
26 std::vector<int32_t> results_list_;
27 const int32_t METER_POINT_X = 305;
28 const int32_t METER_POINT_Y = 205;
29 const int32_t AF_REGIONS_X = 400;
30 const int32_t AF_REGIONS_Y = 200;
31 const int32_t FPS_RANGE = 30;
32 constexpr uint32_t CAMERA_PREVIEW_WIDTH = 640;
33 constexpr uint32_t CAMERA_PREVIEW_HEIGHT = 480;
34 constexpr uint32_t CAMERA_CAPTURE_WIDTH = 1280;
35 constexpr uint32_t CAMERA_CAPTURE_HEIGHT = 960;
36 constexpr uint32_t CAMERA_VIDEO_WIDTH = 1280;
37 constexpr uint32_t CAMERA_VIDEO_HEIGHT = 960;
38
SetStreamInfo(StreamInfo & streamInfo,const std::shared_ptr<StreamCustomer> & streamCustomer,const int streamId,const StreamIntent intent)39 void DcameraHdfDemo::SetStreamInfo(StreamInfo& streamInfo,
40 const std::shared_ptr<StreamCustomer> &streamCustomer,
41 const int streamId, const StreamIntent intent)
42 {
43 constexpr uint32_t dataspace = 8;
44 constexpr uint32_t tunneledMode = 5;
45 sptr<OHOS::IBufferProducer> producer;
46
47 if (intent == OHOS::HDI::Camera::V1_0::PREVIEW) {
48 constexpr uint32_t width = CAMERA_PREVIEW_WIDTH;
49 constexpr uint32_t height = CAMERA_PREVIEW_HEIGHT;
50 streamInfo.width_ = width;
51 streamInfo.height_ = height;
52 producer = streamCustomer->CreateProducer(CAPTURE_PREVIEW, nullptr);
53 } else if (intent == OHOS::HDI::Camera::V1_0::STILL_CAPTURE) {
54 constexpr uint32_t width = CAMERA_CAPTURE_WIDTH;
55 constexpr uint32_t height = CAMERA_CAPTURE_HEIGHT;
56 streamInfo.width_ = width;
57 streamInfo.height_ = height;
58 streamInfo.encodeType_ = CAMERA_CAPTURE_ENCODE_TYPE;
59 producer = streamCustomer->CreateProducer(CAPTURE_SNAPSHOT, [this](void* addr, const uint32_t size) {
60 StoreImage((char*)addr, size);
61 });
62 } else {
63 constexpr uint32_t width = CAMERA_VIDEO_WIDTH;
64 constexpr uint32_t height = CAMERA_VIDEO_HEIGHT;
65 streamInfo.width_ = width;
66 streamInfo.height_ = height;
67 streamInfo.encodeType_ = CAMERA_VIDEO_ENCODE_TYPE;
68 OpenVideoFile();
69 producer = streamCustomer->CreateProducer(CAPTURE_VIDEO, [this](void* addr, const uint32_t size) {
70 StoreVideo((char*)addr, size);
71 });
72 }
73
74 streamInfo.streamId_ = streamId;
75 streamInfo.format_ = CAMERA_FORMAT;
76 streamInfo.dataspace_ = dataspace;
77 streamInfo.intent_ = intent;
78 streamInfo.tunneledMode_ = tunneledMode;
79
80 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
81 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
82 }
83
GetStreamOpt()84 void DcameraHdfDemo::GetStreamOpt()
85 {
86 int rc = 0;
87
88 if (streamOperator_ == nullptr) {
89 const sptr<IStreamOperatorCallback> streamOperatorCallback(new DemoStreamOperatorCallback());
90 rc = demoCameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_);
91 if (rc != HDI::Camera::V1_0::NO_ERROR) {
92 DHLOGI("demo test: GetStreamOpt GetStreamOperator fail");
93 streamOperator_ = nullptr;
94 }
95 }
96 }
97
CaptureSet(std::vector<uint8_t> & setNum)98 void DcameraHdfDemo::CaptureSet(std::vector<uint8_t> &setNum)
99 {
100 constexpr double latitude = 27.987500; // dummy data: Qomolangma latitde
101 constexpr double longitude = 86.927500; // dummy data: Qomolangma longituude
102 constexpr double altitude = 8848.86; // dummy data: Qomolangma altitude
103 constexpr size_t entryCapacity = 100;
104 constexpr size_t dataCapacity = 2000;
105 captureSetting_ = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
106 captureQuality_ = OHOS_CAMERA_JPEG_LEVEL_HIGH;
107 captureOrientation_ = OHOS_CAMERA_JPEG_ROTATION_270;
108 mirrorSwitch_ = OHOS_CAMERA_MIRROR_ON;
109 gps_.push_back(latitude);
110 gps_.push_back(longitude);
111 gps_.push_back(altitude);
112 captureSetting_->addEntry(OHOS_JPEG_QUALITY, static_cast<void*>(&captureQuality_),
113 sizeof(captureQuality_));
114 captureSetting_->addEntry(OHOS_JPEG_ORIENTATION, static_cast<void*>(&captureOrientation_),
115 sizeof(captureOrientation_));
116 captureSetting_->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, static_cast<void*>(&mirrorSwitch_),
117 sizeof(mirrorSwitch_));
118 captureSetting_->addEntry(OHOS_JPEG_GPS_COORDINATES, gps_.data(), gps_.size());
119
120 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting_, setNum);
121 }
122
CaptureON(const int streamId,const int captureId,CaptureMode mode)123 RetCode DcameraHdfDemo::CaptureON(const int streamId, const int captureId, CaptureMode mode)
124 {
125 DHLOGI("demo test: CaptureON enter streamId == %{public}d and captureId == %{public}d and mode == %{public}d",
126 streamId, captureId, mode);
127 std::lock_guard<std::mutex> l(metaDatalock_);
128 std::vector<uint8_t> setting;
129 bool iscapture = true;
130
131 if (mode == CAPTURE_SNAPSHOT) {
132 CaptureSet(setting);
133 } else {
134 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting_, setting);
135 }
136
137 captureInfo_.streamIds_ = {streamId};
138 if (mode == CAPTURE_SNAPSHOT) {
139 captureInfo_.captureSetting_ = setting;
140 iscapture = false;
141 } else {
142 captureInfo_.captureSetting_ = cameraAbility_;
143 iscapture = true;
144 }
145 captureInfo_.enableShutterCallback_ = false;
146 int rc = streamOperator_->Capture(captureId, captureInfo_, iscapture);
147 if (rc != HDI::Camera::V1_0::NO_ERROR) {
148 DHLOGI("demo test: CaptureStart Capture error");
149 streamOperator_->ReleaseStreams(captureInfo_.streamIds_);
150 return RC_ERROR;
151 }
152
153 DHLOGI("demo test: CaptureON exit");
154 return RC_OK;
155 }
156
CaptureOff(const int captureId,const CaptureMode mode)157 RetCode DcameraHdfDemo::CaptureOff(const int captureId, const CaptureMode mode)
158 {
159 int rc = 0;
160 DHLOGI("demo test: CaptureOff enter mode == %{public}d", mode);
161
162 if (streamOperator_ == nullptr) {
163 DHLOGI("demo test: CaptureOff streamOperator_ is nullptr");
164 return RC_ERROR;
165 }
166
167 if (mode == CAPTURE_PREVIEW) {
168 rc = streamOperator_->CancelCapture(captureId);
169 } else if (mode == CAPTURE_SNAPSHOT) {
170 rc = streamOperator_->CancelCapture(captureId);
171 } else if (mode == CAPTURE_VIDEO) {
172 rc = streamOperator_->CancelCapture(captureId);
173 close(videoFd_);
174 videoFd_ = -1;
175 }
176
177 if (rc != HDI::Camera::V1_0::NO_ERROR) {
178 DHLOGI("demo test: CaptureOff CancelCapture error mode %{public}d rc == %{public}d", mode, rc);
179 return RC_ERROR;
180 }
181 DHLOGI("demo test: CaptureOff exit");
182 return RC_OK;
183 }
184
CreateStreamInfo(const int streamId,std::shared_ptr<StreamCustomer> & streamCustomer,StreamIntent intent)185 RetCode DcameraHdfDemo::CreateStreamInfo(const int streamId, std::shared_ptr<StreamCustomer> &streamCustomer,
186 StreamIntent intent)
187 {
188 DHLOGI("demo test: CreateStream enter");
189 GetStreamOpt();
190 if (streamOperator_ == nullptr) {
191 DHLOGI("demo test: CreateStream GetStreamOpt() is nullptr");
192 return RC_ERROR;
193 }
194
195 StreamInfo streamInfo = {0};
196 SetStreamInfo(streamInfo, streamCustomer, streamId, intent);
197 if (streamInfo.bufferQueue_->producer_ == nullptr) {
198 DHLOGI("demo test: CreateStream CreateProducer(); is nullptr");
199 return RC_ERROR;
200 }
201 streamInfos_.push_back(streamInfo);
202 streamIds_.push_back(streamId);
203 return RC_OK;
204 }
205
CreateStream()206 RetCode DcameraHdfDemo::CreateStream()
207 {
208 int rc = 0;
209 DHLOGI("demo test: CreateStreams start");
210 rc = streamOperator_->CreateStreams(streamInfos_);
211 if (rc != HDI::Camera::V1_0::NO_ERROR) {
212 DHLOGI("demo test: CreateStream CreateStreams error");
213 return RC_ERROR;
214 }
215 DHLOGI("demo test: CommitStreams start");
216 rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_);
217 if (rc != HDI::Camera::V1_0::NO_ERROR) {
218 DHLOGI("demo test: CreateStream CommitStreams error");
219 streamOperator_->ReleaseStreams(streamIds_);
220 return RC_ERROR;
221 }
222
223 DHLOGI("demo test: CreateStream exit");
224 return RC_OK;
225 }
226
InitCameraDevice()227 RetCode DcameraHdfDemo::InitCameraDevice()
228 {
229 int rc = 0;
230 DHLOGI("demo test: InitCameraDevice enter");
231
232 if (demoCameraHost_ == nullptr) {
233 DHLOGI("demo test: InitCameraDevice demoCameraHost_ == nullptr");
234 return RC_ERROR;
235 }
236
237 (void)demoCameraHost_->GetCameraIds(cameraIds_);
238 if (cameraIds_.empty()) {
239 return RC_ERROR;
240 }
241
242 const std::string cameraId = cameraIds_.front();
243 demoCameraHost_->GetCameraAbility(cameraId, cameraAbility_);
244 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(cameraAbility_, ability_);
245
246 GetFaceDetectMode(ability_);
247 GetFocalLength(ability_);
248 GetAvailableFocusModes(ability_);
249 GetAvailableExposureModes(ability_);
250 GetExposureCompensationRange(ability_);
251 GetExposureCompensationSteps(ability_);
252 GetAvailableMeterModes(ability_);
253 GetAvailableFlashModes(ability_);
254 GetMirrorSupported(ability_);
255 GetStreamBasicConfigurations(ability_);
256 GetFpsRange(ability_);
257 GetCameraPosition(ability_);
258 GetCameraType(ability_);
259 GetCameraConnectionType(ability_);
260 GetFaceDetectMaxNum(ability_);
261
262 sptr<DemoCameraDeviceCallback> callback(new DemoCameraDeviceCallback());
263 rc = demoCameraHost_->OpenCamera(cameraIds_.front(), callback, demoCameraDevice_);
264 if (rc != HDI::Camera::V1_0::NO_ERROR || demoCameraDevice_ == nullptr) {
265 DHLOGI("demo test: InitCameraDevice OpenCamera failed");
266 return RC_ERROR;
267 }
268
269 DHLOGI("demo test: InitCameraDevice exit");
270 return RC_OK;
271 }
272
ReleaseCameraDevice()273 void DcameraHdfDemo::ReleaseCameraDevice()
274 {
275 if (demoCameraDevice_ != nullptr) {
276 DHLOGI("demo test: ReleaseCameraDevice close Device");
277 demoCameraDevice_->Close();
278 demoCameraDevice_ = nullptr;
279 }
280 }
281
InitSensors()282 void DcameraHdfDemo::InitSensors()
283 {
284 int rc = -1;
285 DHLOGI("demo test: InitSensors enter");
286 constexpr const char *demoServiceName = "distributed_camera_service";
287 if (demoCameraHost_ == nullptr) {
288 demoCameraHost_ = ICameraHost::Get(demoServiceName, false);
289 if (demoCameraHost_ == nullptr) {
290 DHLOGI("demo test: ICameraHost::Get error");
291 } else {
292 DHLOGI("demo test: ICameraHost::Get success");
293 }
294 }
295
296 hostCallback_ = new DemoCameraHostCallback();
297 rc = demoCameraHost_->SetCallback(hostCallback_);
298 if (rc != HDI::Camera::V1_0::NO_ERROR) {
299 DHLOGI("demo test: demoCameraHost_->SetCallback(hostCallback_) error");
300 return;
301 }
302
303 demoCameraHost_->GetCameraIds(cameraIds_);
304 if (cameraIds_.size() == 0) {
305 DHLOGI("camera device list empty");
306 GTEST_SKIP() << "No Camera Available" << std::endl;
307 return;
308 }
309 }
310
InitDemo()311 void DcameraHdfDemo::InitDemo()
312 {
313 demoCameraHost_->GetCameraIds(cameraIds_);
314 if (cameraIds_.size() == 0) {
315 DHLOGI("camera device list empty");
316 GTEST_SKIP() << "No Camera Available" << std::endl;
317 return;
318 }
319 }
320
StoreImage(const char * bufStart,const uint32_t size) const321 void DcameraHdfDemo::StoreImage(const char *bufStart, const uint32_t size) const
322 {
323 DHLOGI("demo test:StoreImage size == %{public}" PRIu32, size);
324 constexpr uint32_t pathLen = 64;
325 char path[pathLen] = {0};
326 char prefix[] = "/data/";
327
328 int imgFD = 0;
329 int ret;
330 struct timeval start = {};
331 gettimeofday(&start, nullptr);
332 if (sprintf_s(path, sizeof(path), "%spicture_%ld.jpeg", prefix, start.tv_usec) < 0) {
333 DHLOGI("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 DHLOGI("demo test:open image file error %{public}s.....", strerror(errno));
340 return;
341 }
342
343 ret = write(imgFD, bufStart, size);
344 if (ret == -1) {
345 DHLOGI("demo test:write image file error %{public}s.....", strerror(errno));
346 }
347
348 close(imgFD);
349 DHLOGI("demo test:StoreImage save success");
350 }
351
StoreVideo(const char * bufStart,const uint32_t size) const352 void DcameraHdfDemo::StoreVideo(const char *bufStart, const uint32_t size) const
353 {
354 int ret = 0;
355
356 ret = write(videoFd_, bufStart, size);
357 if (ret == -1) {
358 DHLOGI("demo test:write video file error %{public}s.....", strerror(errno));
359 }
360 DHLOGI("demo test:StoreVideo size == %{public}" PRIu32, size);
361 }
362
OpenVideoFile()363 void DcameraHdfDemo::OpenVideoFile()
364 {
365 constexpr uint32_t pathLen = 64;
366 char path[pathLen] = {0};
367 char prefix[] = "/data/";
368 auto seconds = time(nullptr);
369 if (sprintf_s(path, sizeof(path), "%svideo%ld.h264", prefix, seconds) < 0) {
370 DHLOGI("%{public}s: sprintf failed", __func__);
371 return;
372 }
373 videoFd_ = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
374 if (videoFd_ < 0) {
375 DHLOGI("demo test: StartVideo open %{public}s %{public}s failed", path, strerror(errno));
376 }
377 }
378
CreateStreams(const int streamIdSecond,StreamIntent intent)379 RetCode DcameraHdfDemo::CreateStreams(const int streamIdSecond, StreamIntent intent)
380 {
381 int rc = 0;
382 std::vector<StreamInfo> streamInfos;
383 std::vector<StreamInfo>().swap(streamInfos);
384
385 DHLOGI("demo test: CreateStreams streamIdSecond = %{public}d", streamIdSecond);
386 GetStreamOpt();
387 if (streamOperator_ == nullptr) {
388 DHLOGI("demo test: CreateStreams GetStreamOpt() is nullptr");
389 return RC_ERROR;
390 }
391
392 StreamInfo previewStreamInfo = {0};
393 SetStreamInfo(previewStreamInfo, streamCustomerPreview_, STREAM_ID_PREVIEW, OHOS::HDI::Camera::V1_0::PREVIEW);
394 if (previewStreamInfo.bufferQueue_->producer_ == nullptr) {
395 DHLOGI("demo test: CreateStream CreateProducer(); is nullptr");
396 return RC_ERROR;
397 }
398 streamInfos.push_back(previewStreamInfo);
399
400 StreamInfo secondStreamInfo = {0};
401 if (streamIdSecond == STREAM_ID_CAPTURE) {
402 SetStreamInfo(secondStreamInfo, streamCustomerCapture_, STREAM_ID_CAPTURE, intent);
403 } else {
404 SetStreamInfo(secondStreamInfo, streamCustomerVideo_, STREAM_ID_VIDEO, intent);
405 }
406
407 if (secondStreamInfo.bufferQueue_->producer_ == nullptr) {
408 DHLOGI("demo test: CreateStreams CreateProducer() secondStreamInfo is nullptr");
409 return RC_ERROR;
410 }
411 streamInfos.push_back(secondStreamInfo);
412
413 rc = streamOperator_->CreateStreams(streamInfos);
414 if (rc != HDI::Camera::V1_0::NO_ERROR) {
415 DHLOGI("demo test: CreateStream CreateStreams error");
416 return RC_ERROR;
417 }
418
419 rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_);
420 if (rc != HDI::Camera::V1_0::NO_ERROR) {
421 DHLOGI("demo test: CreateStream CommitStreams error");
422 std::vector<int> streamIds = {STREAM_ID_PREVIEW, streamIdSecond};
423 streamOperator_->ReleaseStreams(streamIds);
424 return RC_ERROR;
425 }
426 return RC_OK;
427 }
428
CaptureOnDualStreams(const int streamIdSecond)429 RetCode DcameraHdfDemo::CaptureOnDualStreams(const int streamIdSecond)
430 {
431 int rc = 0;
432 DHLOGI("demo test: CaptuCaptureOnDualStreamsreON enter");
433
434 CaptureInfo previewCaptureInfo;
435 previewCaptureInfo.streamIds_ = {STREAM_ID_PREVIEW};
436 previewCaptureInfo.captureSetting_ = cameraAbility_;
437 previewCaptureInfo.enableShutterCallback_ = false;
438
439 rc = streamOperator_->Capture(CAPTURE_ID_PREVIEW, previewCaptureInfo, true);
440 if (rc != HDI::Camera::V1_0::NO_ERROR) {
441 DHLOGI("demo test: CaptureOnDualStreams preview Capture error");
442 streamOperator_->ReleaseStreams(previewCaptureInfo.streamIds_);
443 return RC_ERROR;
444 }
445
446 CaptureInfo secondCaptureInfo;
447 secondCaptureInfo.streamIds_ = {streamIdSecond};
448 secondCaptureInfo.captureSetting_ = cameraAbility_;
449 previewCaptureInfo.enableShutterCallback_ = false;
450
451 if (streamIdSecond == STREAM_ID_CAPTURE) {
452 rc = streamOperator_->Capture(CAPTURE_ID_CAPTURE, secondCaptureInfo, true);
453 if (rc != HDI::Camera::V1_0::NO_ERROR) {
454 DHLOGI("demo test: CaptureOnDualStreams CAPTURE_ID_CAPTURE error");
455 streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_);
456 return RC_ERROR;
457 }
458 } else {
459 rc = streamOperator_->Capture(CAPTURE_ID_VIDEO, secondCaptureInfo, true);
460 if (rc != HDI::Camera::V1_0::NO_ERROR) {
461 DHLOGI("demo test: CaptureOnDualStreams CAPTURE_ID_VIDEO error");
462 streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_);
463 return RC_ERROR;
464 }
465 }
466
467 DHLOGI("demo test: CaptuCaptureOnDualStreamsreON exit");
468 return RC_OK;
469 }
470
StartDualStreams(const int streamIdSecond)471 RetCode DcameraHdfDemo::StartDualStreams(const int streamIdSecond)
472 {
473 RetCode rc = RC_OK;
474 DHLOGI("demo test: StartDualStreams enter");
475
476 if (streamCustomerPreview_ == nullptr) {
477 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
478 }
479 if (isPreviewOn_ != 0) {
480 return RC_OK;
481 }
482 isPreviewOn_ = 1;
483 if (streamIdSecond == STREAM_ID_CAPTURE) {
484 if (streamCustomerCapture_ == nullptr) {
485 streamCustomerCapture_ = std::make_shared<StreamCustomer>();
486 }
487
488 if (isCaptureOn_ == 0) {
489 isCaptureOn_ = 1;
490 rc = CreateStreams(streamIdSecond, OHOS::HDI::Camera::V1_0::STILL_CAPTURE);
491 if (rc != RC_OK) {
492 DHLOGI("demo test:StartPreviewStream CreateStreams error");
493 return RC_ERROR;
494 }
495 }
496 } else {
497 if (streamCustomerVideo_ == nullptr) {
498 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
499 }
500
501 if (isVideoOn_ == 0) {
502 isVideoOn_ = 1;
503 rc = CreateStreams(streamIdSecond, OHOS::HDI::Camera::V1_0::VIDEO);
504 if (rc != RC_OK) {
505 DHLOGI("demo test:StartPreviewStream CreateStreams error");
506 return RC_ERROR;
507 }
508 }
509 }
510
511 DHLOGI("demo test: StartDualStreams exit");
512 return RC_OK;
513 }
514
StartCaptureStream()515 RetCode DcameraHdfDemo::StartCaptureStream()
516 {
517 RetCode rc = RC_OK;
518
519 DHLOGI("demo test: StartCaptureStream enter");
520 if (streamCustomerCapture_ == nullptr) {
521 streamCustomerCapture_ = std::make_shared<StreamCustomer>();
522 }
523
524 if (isCaptureOn_ == 0) {
525 isCaptureOn_ = 1;
526
527 rc = CreateStreamInfo(STREAM_ID_CAPTURE, streamCustomerCapture_, OHOS::HDI::Camera::V1_0::STILL_CAPTURE);
528 if (rc != RC_OK) {
529 DHLOGI("demo test:StartCaptureStream CreateStream error");
530 return RC_ERROR;
531 }
532 }
533
534 DHLOGI("demo test: StartCaptureStream exit");
535 return RC_OK;
536 }
537
StartVideoStream()538 RetCode DcameraHdfDemo::StartVideoStream()
539 {
540 RetCode rc = RC_OK;
541 DHLOGI("demo test: StartVideoStream enter");
542 if (streamCustomerVideo_ == nullptr) {
543 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
544 }
545
546 if (isVideoOn_ == 0) {
547 isVideoOn_ = 1;
548
549 rc = CreateStreamInfo(STREAM_ID_VIDEO, streamCustomerVideo_, OHOS::HDI::Camera::V1_0::VIDEO);
550 if (rc != RC_OK) {
551 DHLOGI("demo test:StartVideoStream CreateStream error");
552 return RC_ERROR;
553 }
554 }
555
556 DHLOGI("demo test: StartVideoStream exit");
557 return RC_OK;
558 }
559
StartPreviewStream()560 RetCode DcameraHdfDemo::StartPreviewStream()
561 {
562 RetCode rc = RC_OK;
563 DHLOGI("demo test: StartPreviewStream enter");
564
565 if (streamCustomerPreview_ == nullptr) {
566 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
567 }
568
569 if (isPreviewOn_ == 0) {
570 isPreviewOn_ = 1;
571
572 rc = CreateStreamInfo(STREAM_ID_PREVIEW, streamCustomerPreview_, OHOS::HDI::Camera::V1_0::PREVIEW);
573 if (rc != RC_OK) {
574 DHLOGI("demo test:StartPreviewStream CreateStream error");
575 return RC_ERROR;
576 }
577 }
578
579 DHLOGI("demo test: StartPreviewStream exit");
580 return RC_OK;
581 }
582
ReleaseAllStream()583 RetCode DcameraHdfDemo::ReleaseAllStream()
584 {
585 std::vector<int> streamIds;
586 DHLOGI("demo test: ReleaseAllStream enter");
587
588 if (isPreviewOn_ != 1) {
589 DHLOGI("demo test: ReleaseAllStream preview is not running");
590 return RC_ERROR;
591 }
592
593 if (isCaptureOn_ == 1) {
594 DHLOGI("demo test: ReleaseAllStream STREAM_ID_PREVIEW STREAM_ID_CAPTURE");
595 streamIds = {STREAM_ID_PREVIEW, STREAM_ID_CAPTURE};
596 streamOperator_->ReleaseStreams(streamIds);
597 } else {
598 DHLOGI("demo test: ReleaseAllStream STREAM_ID_PREVIEW STREAM_ID_VIDEO");
599 streamIds = {STREAM_ID_PREVIEW, STREAM_ID_VIDEO};
600 streamOperator_->ReleaseStreams(streamIds);
601 }
602
603 streamInfos_.clear();
604 streamIds_.clear();
605
606 isPreviewOn_ = 0;
607 isCaptureOn_ = 0;
608 isVideoOn_ = 0;
609
610 DHLOGI("demo test: ReleaseAllStream exit");
611 return RC_OK;
612 }
613
QuitDemo()614 void DcameraHdfDemo::QuitDemo()
615 {
616 ReleaseCameraDevice();
617 DHLOGI("demo test: QuitDemo done");
618 }
619
SetEnableResult()620 void DcameraHdfDemo::SetEnableResult()
621 {
622 DHLOGI("demo test: SetEnableResult enter");
623
624 if (cameraIds_.empty()) {
625 DHLOGI("demo test: camera device list empty");
626 return;
627 }
628 results_list_.push_back(OHOS_CONTROL_EXPOSURE_MODE);
629 results_list_.push_back(OHOS_CONTROL_FOCUS_MODE);
630 if (demoCameraDevice_ != nullptr) {
631 demoCameraDevice_->EnableResult(results_list_);
632 }
633
634 DHLOGI("demo test: SetEnableResult exit");
635 }
636
SetAwbMode(const int mode) const637 RetCode DcameraHdfDemo::SetAwbMode(const int mode) const
638 {
639 DHLOGI("demo test: SetAwbMode enter");
640
641 if (mode < 0 || mode > OHOS_CAMERA_AWB_MODE_INCANDESCENT) {
642 DHLOGI("demo test: SetAwbMode mode error");
643 return RC_ERROR;
644 }
645
646 constexpr size_t entryCapacity = 100;
647 constexpr size_t dataCapacity = 2000;
648
649 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
650 std::vector<uint8_t> result;
651
652 const uint8_t awbMode = mode;
653 metaData->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
654 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
655 if (demoCameraDevice_ != nullptr) {
656 demoCameraDevice_->UpdateSettings(result);
657 }
658
659 DHLOGI("demo test: SetAwbMode exit");
660 return RC_OK;
661 }
662
SetAeExpo()663 RetCode DcameraHdfDemo::SetAeExpo()
664 {
665 int32_t expo;
666 DHLOGI("demo test: SetAeExpo enter");
667
668 constexpr size_t entryCapacity = 100;
669 constexpr size_t dataCapacity = 2000;
670
671 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
672 std::vector<uint8_t> result;
673
674 if (aeStatus_) {
675 expo = 0xa0;
676 } else {
677 expo = 0x30;
678 }
679 aeStatus_ = !aeStatus_;
680 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
681 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
682 if (demoCameraDevice_ != nullptr) {
683 demoCameraDevice_->UpdateSettings(result);
684 }
685
686 DHLOGI("demo test: SetAeExpo exit");
687 return RC_OK;
688 }
689
SetMetadataMeter(uint8_t mode)690 RetCode DcameraHdfDemo::SetMetadataMeter(uint8_t mode)
691 {
692 DHLOGI("demo test: SetMetadata enter");
693 constexpr size_t entryCapacity = 100;
694 constexpr size_t dataCapacity = 2000;
695 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
696
697 // awb
698 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
699
700 // ae
701 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
702 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
703
704 int64_t exposureTime = 400;
705 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
706
707 int32_t aeExposureCompensation = 4;
708 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
709
710 // meter
711 std::vector<int32_t> meterPoint;
712 meterPoint.push_back(METER_POINT_X);
713 meterPoint.push_back(METER_POINT_Y);
714 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
715
716 uint8_t meterMode = mode;
717 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
718
719 // flash
720 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
721 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
722
723 // mirror
724 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
725 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
726
727 // fps
728 std::vector<int32_t> fpsRange;
729 fpsRange.push_back(FPS_RANGE);
730 fpsRange.push_back(FPS_RANGE);
731 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
732
733 // jpeg
734 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
735 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
736
737 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
738 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
739
740 // af
741 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
742 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
743
744 std::vector<int32_t> afRegions;
745 afRegions.push_back(AF_REGIONS_X);
746 afRegions.push_back(AF_REGIONS_Y);
747 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
748
749 // face
750 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
751 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
752
753 std::vector<uint8_t> result;
754 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
755 if (demoCameraDevice_ != nullptr) {
756 demoCameraDevice_->UpdateSettings(result);
757 }
758
759 DHLOGI("demo test: SetMetadata exit");
760 return RC_OK;
761 }
762
SetMetadataAe(uint8_t mode)763 RetCode DcameraHdfDemo::SetMetadataAe(uint8_t mode)
764 {
765 DHLOGI("demo test: SetMetadata enter");
766 constexpr size_t entryCapacity = 100;
767 constexpr size_t dataCapacity = 2000;
768 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
769
770 // awb
771 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
772
773 // ae
774 uint8_t aeMode = mode;
775 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
776
777 int64_t exposureTime = 400;
778 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
779
780 int32_t aeExposureCompensation = 4;
781 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
782
783 // meter
784 std::vector<int32_t> meterPoint;
785 meterPoint.push_back(METER_POINT_X);
786 meterPoint.push_back(METER_POINT_Y);
787 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
788
789 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
790 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
791
792 // flash
793 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
794 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
795
796 // mirror
797 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
798 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
799
800 // fps
801 std::vector<int32_t> fpsRange;
802 fpsRange.push_back(FPS_RANGE);
803 fpsRange.push_back(FPS_RANGE);
804 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
805
806 // jpeg
807 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
808 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
809
810 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
811 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
812
813 // af
814 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
815 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
816
817 std::vector<int32_t> afRegions;
818 afRegions.push_back(AF_REGIONS_X);
819 afRegions.push_back(AF_REGIONS_Y);
820 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
821
822 // face
823 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
824 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
825
826 std::vector<uint8_t> result;
827 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
828 if (demoCameraDevice_ != nullptr) {
829 demoCameraDevice_->UpdateSettings(result);
830 }
831
832 DHLOGI("demo test: SetMetadata exit");
833 return RC_OK;
834 }
835
SetMetadataFlash(uint8_t mode)836 RetCode DcameraHdfDemo::SetMetadataFlash(uint8_t mode)
837 {
838 DHLOGI("demo test: SetMetadata enter");
839 constexpr size_t entryCapacity = 100;
840 constexpr size_t dataCapacity = 2000;
841 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
842
843 // awb
844 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
845
846 // ae
847 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
848 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
849
850 int64_t exposureTime = 400;
851 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
852
853 int32_t aeExposureCompensation = 4;
854 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
855
856 // meter
857 std::vector<int32_t> meterPoint;
858 meterPoint.push_back(METER_POINT_X);
859 meterPoint.push_back(METER_POINT_Y);
860 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
861
862 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
863 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
864
865 // flash
866 uint8_t flashMode = mode;
867 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
868
869 // mirror
870 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
871 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
872
873 // fps
874 std::vector<int32_t> fpsRange;
875 fpsRange.push_back(FPS_RANGE);
876 fpsRange.push_back(FPS_RANGE);
877 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
878
879 // jpeg
880 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
881 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
882
883 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
884 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
885
886 // af
887 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
888 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
889
890 std::vector<int32_t> afRegions;
891 afRegions.push_back(AF_REGIONS_X);
892 afRegions.push_back(AF_REGIONS_Y);
893 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
894
895 // face
896 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
897 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
898
899 std::vector<uint8_t> result;
900 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
901 if (demoCameraDevice_ != nullptr) {
902 demoCameraDevice_->UpdateSettings(result);
903 }
904
905 DHLOGI("demo test: SetMetadata exit");
906 return RC_OK;
907 }
908
SetMetadataMirror(uint8_t mode)909 RetCode DcameraHdfDemo::SetMetadataMirror(uint8_t mode)
910 {
911 DHLOGI("demo test: SetMetadata enter");
912 constexpr size_t entryCapacity = 100;
913 constexpr size_t dataCapacity = 2000;
914 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
915
916 // awb
917 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
918
919 // ae
920 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
921 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
922
923 int64_t exposureTime = 400;
924 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
925
926 int32_t aeExposureCompensation = 4;
927 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
928
929 // meter
930 std::vector<int32_t> meterPoint;
931 meterPoint.push_back(METER_POINT_X);
932 meterPoint.push_back(METER_POINT_Y);
933 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
934
935 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
936 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
937
938 // flash
939 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
940 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
941
942 // mirror
943 uint8_t mirror = mode;
944 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
945
946 // fps
947 std::vector<int32_t> fpsRange;
948 fpsRange.push_back(FPS_RANGE);
949 fpsRange.push_back(FPS_RANGE);
950 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
951
952 // jpeg
953 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
954 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
955
956 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
957 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
958
959 // af
960 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
961 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
962
963 std::vector<int32_t> afRegions;
964 afRegions.push_back(AF_REGIONS_X);
965 afRegions.push_back(AF_REGIONS_Y);
966 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
967
968 // face
969 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
970 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
971
972 std::vector<uint8_t> result;
973 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
974 if (demoCameraDevice_ != nullptr) {
975 demoCameraDevice_->UpdateSettings(result);
976 }
977
978 DHLOGI("demo test: SetMetadata exit");
979 return RC_OK;
980 }
981
SetMetadataJpeg(uint8_t mode)982 RetCode DcameraHdfDemo::SetMetadataJpeg(uint8_t mode)
983 {
984 DHLOGI("demo test: SetMetadata enter");
985 constexpr size_t entryCapacity = 100;
986 constexpr size_t dataCapacity = 2000;
987 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
988
989 // awb
990 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
991
992 // ae
993 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
994 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
995
996 int64_t exposureTime = 400;
997 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
998
999 int32_t aeExposureCompensation = 4;
1000 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1001
1002 // meter
1003 std::vector<int32_t> meterPoint;
1004 meterPoint.push_back(METER_POINT_X);
1005 meterPoint.push_back(METER_POINT_Y);
1006 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1007
1008 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1009 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1010
1011 // flash
1012 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1013 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1014
1015 // mirror
1016 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1017 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1018
1019 // fps
1020 std::vector<int32_t> fpsRange;
1021 fpsRange.push_back(FPS_RANGE);
1022 fpsRange.push_back(FPS_RANGE);
1023 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1024
1025 // jpeg
1026 int32_t orientation = mode;
1027 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1028
1029 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1030 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1031
1032 // af
1033 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1034 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1035
1036 std::vector<int32_t> afRegions;
1037 afRegions.push_back(AF_REGIONS_X);
1038 afRegions.push_back(AF_REGIONS_Y);
1039 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1040
1041 // face
1042 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1043 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1044
1045 std::vector<uint8_t> result;
1046 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1047 if (demoCameraDevice_ != nullptr) {
1048 demoCameraDevice_->UpdateSettings(result);
1049 }
1050
1051 DHLOGI("demo test: SetMetadata exit");
1052 return RC_OK;
1053 }
1054
SetMetadataAf(uint8_t mode)1055 RetCode DcameraHdfDemo::SetMetadataAf(uint8_t mode)
1056 {
1057 DHLOGI("demo test: SetMetadata enter");
1058 constexpr size_t entryCapacity = 100;
1059 constexpr size_t dataCapacity = 2000;
1060 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
1061
1062 // awb
1063 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
1064
1065 // ae
1066 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
1067 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
1068
1069 int64_t exposureTime = 400;
1070 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
1071
1072 int32_t aeExposureCompensation = 4;
1073 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1074
1075 // meter
1076 std::vector<int32_t> meterPoint;
1077 meterPoint.push_back(METER_POINT_X);
1078 meterPoint.push_back(METER_POINT_Y);
1079 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1080
1081 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1082 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1083
1084 // flash
1085 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1086 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1087
1088 // mirror
1089 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1090 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1091
1092 // fps
1093 std::vector<int32_t> fpsRange;
1094 fpsRange.push_back(FPS_RANGE);
1095 fpsRange.push_back(FPS_RANGE);
1096 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1097
1098 // jpeg
1099 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
1100 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1101
1102 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1103 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1104
1105 // af
1106 uint8_t afMode = mode;
1107 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1108
1109 std::vector<int32_t> afRegions;
1110 afRegions.push_back(AF_REGIONS_X);
1111 afRegions.push_back(AF_REGIONS_Y);
1112 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1113
1114 // face
1115 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1116 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1117
1118 std::vector<uint8_t> result;
1119 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1120 if (demoCameraDevice_ != nullptr) {
1121 demoCameraDevice_->UpdateSettings(result);
1122 }
1123
1124 DHLOGI("demo test: SetMetadata exit");
1125 return RC_OK;
1126 }
1127
SetMetadataFace(uint8_t mode)1128 RetCode DcameraHdfDemo::SetMetadataFace(uint8_t mode)
1129 {
1130 DHLOGI("demo test: SetMetadata enter");
1131 constexpr size_t entryCapacity = 100;
1132 constexpr size_t dataCapacity = 2000;
1133 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
1134
1135 // awb
1136 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
1137
1138 // ae
1139 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
1140 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
1141
1142 int64_t exposureTime = 400;
1143 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
1144
1145 int32_t aeExposureCompensation = 4;
1146 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1147
1148 // meter
1149 std::vector<int32_t> meterPoint;
1150 meterPoint.push_back(METER_POINT_X);
1151 meterPoint.push_back(METER_POINT_Y);
1152 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1153
1154 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1155 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1156
1157 // flash
1158 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1159 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1160
1161 // mirror
1162 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1163 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1164
1165 // fps
1166 std::vector<int32_t> fpsRange;
1167 fpsRange.push_back(FPS_RANGE);
1168 fpsRange.push_back(FPS_RANGE);
1169 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1170
1171 // jpeg
1172 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
1173 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1174
1175 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1176 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1177
1178 // af
1179 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1180 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1181
1182 std::vector<int32_t> afRegions;
1183 afRegions.push_back(AF_REGIONS_X);
1184 afRegions.push_back(AF_REGIONS_Y);
1185 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1186
1187 // face
1188 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1189 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1190
1191 std::vector<uint8_t> result;
1192 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1193 if (demoCameraDevice_ != nullptr) {
1194 demoCameraDevice_->UpdateSettings(result);
1195 }
1196
1197 DHLOGI("demo test: SetMetadata exit");
1198 return RC_OK;
1199 }
1200
SetMetadata()1201 RetCode DcameraHdfDemo::SetMetadata()
1202 {
1203 DHLOGI("demo test: SetMetadata enter");
1204 constexpr size_t entryCapacity = 100;
1205 constexpr size_t dataCapacity = 2000;
1206 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
1207
1208 // awb
1209 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
1210
1211 // ae
1212 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
1213 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
1214
1215 int64_t exposureTime = 400;
1216 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
1217
1218 int32_t aeExposureCompensation = 4;
1219 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1220
1221 // meter
1222 std::vector<int32_t> meterPoint;
1223 meterPoint.push_back(METER_POINT_X);
1224 meterPoint.push_back(METER_POINT_Y);
1225 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1226
1227 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1228 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1229
1230 // flash
1231 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1232 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1233
1234 // mirror
1235 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1236 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1237
1238 // fps
1239 std::vector<int32_t> fpsRange;
1240 fpsRange.push_back(FPS_RANGE);
1241 fpsRange.push_back(FPS_RANGE);
1242 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1243
1244 // jpeg
1245 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
1246 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1247
1248 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1249 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1250
1251 // af
1252 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1253 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1254
1255 std::vector<int32_t> afRegions;
1256 afRegions.push_back(AF_REGIONS_X);
1257 afRegions.push_back(AF_REGIONS_Y);
1258 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1259
1260 // face
1261 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1262 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1263
1264 std::vector<uint8_t> result;
1265 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1266 if (demoCameraDevice_ != nullptr) {
1267 demoCameraDevice_->UpdateSettings(result);
1268 }
1269
1270 DHLOGI("demo test: SetMetadata exit");
1271 return RC_OK;
1272 }
1273
FlashlightOnOff(bool onOff)1274 void DcameraHdfDemo::FlashlightOnOff(bool onOff)
1275 {
1276 DHLOGI("demo test: FlashlightOnOff enter");
1277
1278 if (demoCameraHost_ == nullptr) {
1279 DHLOGI("demo test: FlashlightOnOff demoCameraHost_ == nullptr");
1280 return;
1281 }
1282
1283 demoCameraHost_->SetFlashlight(cameraIds_.front(), onOff);
1284
1285 DHLOGI("demo test: FlashlightOnOff exit ");
1286 }
1287
StreamOffline(const int streamId)1288 RetCode DcameraHdfDemo::StreamOffline(const int streamId)
1289 {
1290 int rc = 0;
1291 constexpr size_t offlineDelayTime = 4;
1292 DHLOGI("demo test: StreamOffline enter");
1293 sptr<IStreamOperatorCallback> streamOperatorCallback(new DemoStreamOperatorCallback());
1294 sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
1295 std::vector<int> streamIds;
1296 streamIds.push_back(streamId);
1297 rc = streamOperator_->ChangeToOfflineStream(streamIds, streamOperatorCallback, offlineStreamOperator);
1298 if (rc != CamRetCode::METHOD_NOT_SUPPORTED) {
1299 DHLOGI("demo test: StreamOffline ChangeToOfflineStream error");
1300 return RC_ERROR;
1301 }
1302
1303 CaptureOff(CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1304 CaptureOff(CAPTURE_ID_CAPTURE, CAPTURE_SNAPSHOT);
1305 sleep(1);
1306 ReleaseAllStream();
1307 ReleaseCameraDevice();
1308 sleep(offlineDelayTime);
1309
1310 DHLOGI("demo test: begin to release offlne stream");
1311 if (offlineStreamOperator != nullptr) {
1312 rc = offlineStreamOperator->CancelCapture(CAPTURE_ID_CAPTURE);
1313 if (rc != CamRetCode::METHOD_NOT_SUPPORTED) {
1314 DHLOGI("demo test: StreamOffline offlineStreamOperator->CancelCapture error");
1315 return RC_ERROR;
1316 }
1317
1318 rc = offlineStreamOperator->Release();
1319 if (rc != CamRetCode::METHOD_NOT_SUPPORTED) {
1320 DHLOGI("demo test: StreamOffline offlineStreamOperator->Release() error");
1321 return RC_ERROR;
1322 }
1323 }
1324
1325 DHLOGI("demo test: StreamOffline exit");
1326 return RC_OK;
1327 }
1328
GetFaceDetectMode(std::shared_ptr<CameraAbility> & ability)1329 RetCode DcameraHdfDemo::GetFaceDetectMode(std::shared_ptr<CameraAbility> &ability)
1330 {
1331 common_metadata_header_t* data = ability->get();
1332 uint8_t faceDetectMode;
1333 camera_metadata_item_t entry;
1334 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MODE, &entry);
1335 if (ret != 0) {
1336 DHLOGI("demo test: get OHOS_STATISTICS_FACE_DETECT_MODE error");
1337 return RC_ERROR;
1338 }
1339 faceDetectMode = *(entry.data.u8);
1340 DHLOGI("demo test: faceDetectMode %{public}" PRIu8, faceDetectMode);
1341 return RC_OK;
1342 }
1343
GetFocalLength(std::shared_ptr<CameraAbility> & ability)1344 RetCode DcameraHdfDemo::GetFocalLength(std::shared_ptr<CameraAbility> &ability)
1345 {
1346 common_metadata_header_t* data = ability->get();
1347 float focalLength = 0.0;
1348 camera_metadata_item_t entry;
1349 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
1350 if (ret != 0) {
1351 DHLOGI("demo test: get OHOS_ABILITY_FOCAL_LENGTH error");
1352 return RC_ERROR;
1353 }
1354 focalLength = *(entry.data.f);
1355 DHLOGI("demo test: focalLength %{public}f", focalLength);
1356 return RC_OK;
1357 }
1358
GetAvailableFocusModes(std::shared_ptr<CameraAbility> & ability)1359 RetCode DcameraHdfDemo::GetAvailableFocusModes(std::shared_ptr<CameraAbility> &ability)
1360 {
1361 common_metadata_header_t* data = ability->get();
1362 std::vector<uint8_t> focusMode;
1363 camera_metadata_item_t entry;
1364 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
1365 if (ret != 0) {
1366 DHLOGI("demo test: get OHOS_ABILITY_FOCUS_MODES error");
1367 return RC_ERROR;
1368 }
1369 uint32_t count = entry.count;
1370 DHLOGI("demo test: count %{public}" PRIu32, count);
1371
1372 for (uint32_t i = 0 ; i < count; i++) {
1373 focusMode.push_back(*(entry.data.u8 + i));
1374 }
1375
1376 for (auto it = focusMode.begin(); it != focusMode.end(); it++) {
1377 DHLOGI("demo test: focusMode : %{public}" PRIu8" ", *it);
1378 }
1379 return RC_OK;
1380 }
1381
GetAvailableExposureModes(std::shared_ptr<CameraAbility> & ability)1382 RetCode DcameraHdfDemo::GetAvailableExposureModes(std::shared_ptr<CameraAbility> &ability)
1383 {
1384 common_metadata_header_t* data = ability->get();
1385 std::vector<uint8_t> exposureMode;
1386 camera_metadata_item_t entry;
1387 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
1388 if (ret != 0) {
1389 DHLOGI("demo test: get OHOS_ABILITY_EXPOSURE_MODES error");
1390 return RC_ERROR;
1391 }
1392 uint32_t count = entry.count;
1393 DHLOGI("demo test: count %{public}" PRIu32, count);
1394
1395 for (uint32_t i = 0 ; i < count; i++) {
1396 exposureMode.push_back(*(entry.data.u8 + i));
1397 }
1398
1399 for (auto it = exposureMode.begin(); it != exposureMode.end(); it++) {
1400 DHLOGI("demo test: exposureMode : %{public}" PRIu8" ", *it);
1401 }
1402 return RC_OK;
1403 }
1404
GetExposureCompensationRange(std::shared_ptr<CameraAbility> & ability)1405 RetCode DcameraHdfDemo::GetExposureCompensationRange(std::shared_ptr<CameraAbility> &ability)
1406 {
1407 common_metadata_header_t* data = ability->get();
1408 std::vector<int32_t> exposureCompensationRange;
1409 camera_metadata_item_t entry;
1410 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_AE_COMPENSATION_RANGE, &entry);
1411 if (ret != 0) {
1412 DHLOGI("demo test: get OHOS_ABILITY_AE_COMPENSATION_RANGE error");
1413 return RC_ERROR;
1414 }
1415
1416 uint32_t count = entry.count;
1417 DHLOGI("demo test: exposureCompensationRange count %{public}" PRIu32, count);
1418 for (uint32_t i = 0 ; i < count; i++) {
1419 exposureCompensationRange.push_back(*(entry.data.i32 + i));
1420 }
1421
1422 for (auto it = exposureCompensationRange.begin(); it != exposureCompensationRange.end(); it++) {
1423 DHLOGI("demo test: exposureCompensationRange %{public}d ", *it);
1424 }
1425
1426 return RC_OK;
1427 }
1428
GetExposureCompensationSteps(std::shared_ptr<CameraAbility> & ability)1429 RetCode DcameraHdfDemo::GetExposureCompensationSteps(std::shared_ptr<CameraAbility> &ability)
1430 {
1431 common_metadata_header_t* data = ability->get();
1432 camera_rational_t exposureCompensationSteps;
1433 camera_metadata_item_t entry;
1434 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_AE_COMPENSATION_STEP, &entry);
1435 if (ret != 0) {
1436 DHLOGI("demo test: get OHOS_ABILITY_AE_COMPENSATION_STEP error");
1437 return RC_ERROR;
1438 }
1439 exposureCompensationSteps.numerator = entry.data.r->numerator;
1440 exposureCompensationSteps.denominator = entry.data.r->denominator;
1441 DHLOGI("demo test: steps.numerator %{public}d and steps.denominator %{public}d ",
1442 exposureCompensationSteps.numerator, exposureCompensationSteps.denominator);
1443 return RC_OK;
1444 }
1445
GetAvailableMeterModes(std::shared_ptr<CameraAbility> & ability)1446 RetCode DcameraHdfDemo::GetAvailableMeterModes(std::shared_ptr<CameraAbility> &ability)
1447 {
1448 common_metadata_header_t* data = ability->get();
1449 std::vector<uint8_t> meterModes;
1450 camera_metadata_item_t entry;
1451 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry);
1452 if (ret != 0) {
1453 DHLOGI("demo test: get OHOS_ABILITY_METER_MODES error");
1454 return RC_ERROR;
1455 }
1456 uint32_t count = entry.count;
1457 DHLOGI("demo test: count %{public}" PRIu32, count);
1458
1459 for (uint32_t i = 0 ; i < count; i++) {
1460 meterModes.push_back(*(entry.data.u8 + i));
1461 }
1462
1463 for (auto it = meterModes.begin(); it != meterModes.end(); it++) {
1464 DHLOGI("demo test: meterModes : %{public}" PRIu8" ", *it);
1465 }
1466 return RC_OK;
1467 }
1468
GetAvailableFlashModes(std::shared_ptr<CameraAbility> & ability)1469 RetCode DcameraHdfDemo::GetAvailableFlashModes(std::shared_ptr<CameraAbility> &ability)
1470 {
1471 common_metadata_header_t* data = ability->get();
1472 std::vector<uint8_t> flashModes;
1473 camera_metadata_item_t entry;
1474 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
1475 if (ret != 0) {
1476 DHLOGI("demo test: get OHOS_ABILITY_FLASH_MODES error");
1477 return RC_ERROR;
1478 }
1479 uint32_t count = entry.count;
1480 DHLOGI("demo test: count %{public}" PRIu32, count);
1481
1482 for (uint32_t i = 0 ; i < count; i++) {
1483 flashModes.push_back(*(entry.data.u8 + i));
1484 }
1485
1486 for (auto it = flashModes.begin(); it != flashModes.end(); it++) {
1487 DHLOGI("demo test: flashModes : %{public}" PRIu8" ", *it);
1488 }
1489 return RC_OK;
1490 }
1491
GetMirrorSupported(std::shared_ptr<CameraAbility> & ability)1492 RetCode DcameraHdfDemo::GetMirrorSupported(std::shared_ptr<CameraAbility> &ability)
1493 {
1494 common_metadata_header_t* data = ability->get();
1495 uint8_t mirrorSupported;
1496 camera_metadata_item_t entry;
1497 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
1498 if (ret != 0) {
1499 DHLOGI("demo test: get OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED error");
1500 return RC_ERROR;
1501 }
1502 mirrorSupported = *(entry.data.u8);
1503 DHLOGI("demo test: mirrorSupported %{public}" PRIu8, mirrorSupported);
1504 return RC_OK;
1505 }
1506
GetStreamBasicConfigurations(std::shared_ptr<CameraAbility> & ability)1507 RetCode DcameraHdfDemo::GetStreamBasicConfigurations(std::shared_ptr<CameraAbility> &ability)
1508 {
1509 common_metadata_header_t* data = ability->get();
1510 std::vector<int32_t> streamBasicConfigurations;
1511 camera_metadata_item_t entry;
1512 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
1513 if (ret != 0) {
1514 DHLOGI("demo test: get OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS error");
1515 return RC_ERROR;
1516 }
1517
1518 uint32_t count = entry.count;
1519 DHLOGI("demo test: streamBasicConfigurations count %{public}" PRIu32, count);
1520 for (uint32_t i = 0 ; i < count; i++) {
1521 streamBasicConfigurations.push_back(*(entry.data.i32 + i));
1522 }
1523
1524 for (auto it = streamBasicConfigurations.begin(); it != streamBasicConfigurations.end(); it++) {
1525 DHLOGI("demo test: streamBasicConfigurations %{public}d ", *it);
1526 }
1527
1528 return RC_OK;
1529 }
1530
GetFpsRange(std::shared_ptr<CameraAbility> & ability)1531 RetCode DcameraHdfDemo::GetFpsRange(std::shared_ptr<CameraAbility> &ability)
1532 {
1533 common_metadata_header_t* data = ability->get();
1534 std::vector<int32_t> fpsRange;
1535 camera_metadata_item_t entry;
1536 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
1537 if (ret != 0) {
1538 DHLOGI("demo test: get OHOS_ABILITY_FPS_RANGES error");
1539 return RC_ERROR;
1540 }
1541
1542 uint32_t count = entry.count;
1543 DHLOGI("demo test: fpsRange count %{public}" PRIu32, count);
1544 for (uint32_t i = 0 ; i < count; i++) {
1545 fpsRange.push_back(*(entry.data.i32 + i));
1546 }
1547
1548 for (auto it = fpsRange.begin(); it != fpsRange.end(); it++) {
1549 DHLOGI("demo test: fpsRange %{public}d ", *it);
1550 }
1551
1552 return RC_OK;
1553 }
1554
GetCameraPosition(std::shared_ptr<CameraAbility> & ability)1555 RetCode DcameraHdfDemo::GetCameraPosition(std::shared_ptr<CameraAbility> &ability)
1556 {
1557 common_metadata_header_t* data = ability->get();
1558 uint8_t cameraPosition;
1559 camera_metadata_item_t entry;
1560 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
1561 if (ret != 0) {
1562 DHLOGI("demo test: get OHOS_ABILITY_CAMERA_POSITION error");
1563 return RC_ERROR;
1564 }
1565
1566 cameraPosition= *(entry.data.u8);
1567 DHLOGI("demo test: cameraPosition %{public}" PRIu8, cameraPosition);
1568 return RC_OK;
1569 }
1570
GetCameraType(std::shared_ptr<CameraAbility> & ability)1571 RetCode DcameraHdfDemo::GetCameraType(std::shared_ptr<CameraAbility> &ability)
1572 {
1573 common_metadata_header_t* data = ability->get();
1574 uint8_t cameraType;
1575 camera_metadata_item_t entry;
1576 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
1577 if (ret != 0) {
1578 DHLOGI("demo test: get OHOS_ABILITY_CAMERA_TYPE error");
1579 return RC_ERROR;
1580 }
1581
1582 cameraType= *(entry.data.u8);
1583 DHLOGI("demo test: cameraType %{public}" PRIu8, cameraType);
1584 return RC_OK;
1585 }
1586
GetCameraConnectionType(std::shared_ptr<CameraAbility> & ability)1587 RetCode DcameraHdfDemo::GetCameraConnectionType(std::shared_ptr<CameraAbility> &ability)
1588 {
1589 common_metadata_header_t* data = ability->get();
1590 uint8_t cameraConnectionType;
1591 camera_metadata_item_t entry;
1592 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
1593 if (ret != 0) {
1594 DHLOGI("demo test: get OHOS_ABILITY_CAMERA_CONNECTION_TYPE error");
1595 return RC_ERROR;
1596 }
1597
1598 cameraConnectionType= *(entry.data.u8);
1599 DHLOGI("demo test: cameraConnectionType %{public}" PRIu8, cameraConnectionType);
1600 return RC_OK;
1601 }
1602
GetFaceDetectMaxNum(std::shared_ptr<CameraAbility> & ability)1603 RetCode DcameraHdfDemo::GetFaceDetectMaxNum(std::shared_ptr<CameraAbility> &ability)
1604 {
1605 common_metadata_header_t* data = ability->get();
1606 uint8_t faceDetectMaxNum;
1607 camera_metadata_item_t entry;
1608 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MAX_NUM, &entry);
1609 if (ret != 0) {
1610 DHLOGI("demo test: get OHOS_STATISTICS_FACE_DETECT_MAX_NUM error");
1611 return RC_ERROR;
1612 }
1613 faceDetectMaxNum = *(entry.data.u8);
1614 DHLOGI("demo test: faceDetectMaxNum %{public}" PRIu8, faceDetectMaxNum);
1615 return RC_OK;
1616 }
1617
OnError(ErrorType type,int32_t errorCode)1618 int32_t DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorCode)
1619 {
1620 DHLOGI("demo test: OnError type : %{public}d, errorCode : %{public}d", type, errorCode);
1621 return RC_OK;
1622 }
1623
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)1624 int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t>& result)
1625 {
1626 DHLOGI("demo test: OnResult timestamp : %{public}" PRIu64, timestamp);
1627 std::shared_ptr<OHOS::Camera::CameraMetadata> updateSettings;
1628
1629 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, updateSettings);
1630 for (auto it = results_list_.cbegin(); it != results_list_.cend(); it++) {
1631 switch (*it) {
1632 case OHOS_CONTROL_FOCUS_MODE: {
1633 common_metadata_header_t* data = updateSettings->get();
1634 uint8_t focusMode;
1635 camera_metadata_item_t entry;
1636 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_MODE, &entry);
1637 if (ret != 0) {
1638 DHLOGI("demo test: get OHOS_CONTROL_FOCUS_MODE error");
1639 return RC_ERROR;
1640 }
1641 focusMode = *(entry.data.u8);
1642 DHLOGI("demo test: focusMode %{public}" PRIu8, focusMode);
1643 break;
1644 }
1645 case OHOS_CONTROL_EXPOSURE_MODE: {
1646 common_metadata_header_t* data = updateSettings->get();
1647 uint8_t exposureMode;
1648 camera_metadata_item_t entry;
1649 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_EXPOSURE_MODE, &entry);
1650 if (ret != 0) {
1651 return RC_ERROR;
1652 }
1653 exposureMode = *(entry.data.u8);
1654 DHLOGI("demo test: exposureMode %{public}" PRIu8, exposureMode);
1655 break;
1656 }
1657 default:
1658 return RC_ERROR;
1659 }
1660 }
1661
1662 return RC_OK;
1663 }
1664
OnCameraStatus(const std::string & cameraId,CameraStatus status)1665 int32_t DemoCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
1666 {
1667 DHLOGI("%{public}s, enter. cameraId = %{public}s, status = %{public}d",
1668 __func__, cameraId.c_str(), static_cast<int>(status));
1669 return RC_OK;
1670 }
1671
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)1672 int32_t DemoCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
1673 {
1674 DHLOGI("%{public}s, enter. cameraId = %{public}s, status = %{public}d",
1675 __func__, cameraId.c_str(), static_cast<int>(status));
1676 return RC_OK;
1677 }
1678
OnCameraEvent(const std::string & cameraId,CameraEvent event)1679 int32_t DemoCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
1680 {
1681 DHLOGI("%{public}s, enter. cameraId = %{public}s, event = %{public}d",
1682 __func__, cameraId.c_str(), static_cast<int>(event));
1683 return RC_OK;
1684 }
1685
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamIds)1686 int32_t DemoStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector<int32_t>& streamIds)
1687 {
1688 DHLOGI("%{public}s, enter. captureId = %{public}d, streamIds size = %{public}zu", __func__,
1689 captureId, streamIds.size());
1690 return RC_OK;
1691 }
1692
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)1693 int32_t DemoStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo>& infos)
1694 {
1695 DHLOGI("%{public}s, enter. captureId = %{public}d, infos size = %{public}zu", __func__, captureId, infos.size());
1696 return RC_OK;
1697 }
1698
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)1699 int32_t DemoStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo>& infos)
1700 {
1701 DHLOGI("%{public}s, enter. captureId = %{public}d, infos size = %{public}zu", __func__, captureId, infos.size());
1702 return RC_OK;
1703 }
1704
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)1705 int32_t DemoStreamOperatorCallback::OnFrameShutter(int32_t captureId,
1706 const std::vector<int32_t>& streamIds, uint64_t timestamp)
1707 {
1708 DHLOGI("%{public}s, enter. captureId = %{public}d, streamIds size = %{public}zu, timestamp = %{public}" PRIu64,
1709 __func__, captureId, streamIds.size(), timestamp);
1710 return RC_OK;
1711 }
1712
PreviewOn(int mode,const std::shared_ptr<DcameraHdfDemo> & mainDemo)1713 RetCode PreviewOn(int mode, const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1714 {
1715 RetCode rc = RC_OK;
1716 DHLOGI("main test: PreviewOn enter");
1717
1718 if (mode != 0 || mainDemo == nullptr) {
1719 DHLOGI("main test: mainDemo is nullptr or mode is 0");
1720 return RC_ERROR;
1721 }
1722
1723 rc = mainDemo->StartPreviewStream();
1724 if (rc != RC_OK) {
1725 DHLOGI("main test: PreviewOn StartPreviewStream error");
1726 return RC_ERROR;
1727 }
1728 DHLOGI("main test: StartPreviewStream enter");
1729 if (mode == 0) {
1730 rc = mainDemo->StartCaptureStream();
1731 if (rc != RC_OK) {
1732 DHLOGI("main test: PreviewOn StartCaptureStream error");
1733 return RC_ERROR;
1734 }
1735 DHLOGI("main test: StartCaptureStream enter");
1736 } else {
1737 rc = mainDemo->StartVideoStream();
1738 if (rc != RC_OK) {
1739 DHLOGI("main test: PreviewOn StartVideoStream error");
1740 return RC_ERROR;
1741 }
1742 DHLOGI("main test: StartVideoStream enter");
1743 }
1744 rc = mainDemo->CreateStream();
1745 rc = mainDemo->CaptureON(STREAM_ID_PREVIEW, CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1746 if (rc != RC_OK) {
1747 DHLOGI("main test: PreviewOn mainDemo->CaptureON() preview error");
1748 return RC_ERROR;
1749 }
1750
1751 DHLOGI("main test: PreviewOn exit");
1752 return RC_OK;
1753 }
1754
PreviewOff(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1755 void PreviewOff(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1756 {
1757 DHLOGI("main test: PreviewOff enter");
1758
1759 mainDemo->CaptureOff(CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1760 mainDemo->ReleaseAllStream();
1761
1762 DHLOGI("main test: PreviewOff exit");
1763 }
1764
FlashLightTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1765 RetCode FlashLightTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1766 {
1767 constexpr size_t delayTime = 5;
1768
1769 if (mainDemo == nullptr) {
1770 DHLOGI("main test: FlashLightTest mainDemo is nullptr");
1771 return RC_ERROR;
1772 }
1773
1774 PreviewOff(mainDemo);
1775 mainDemo->ReleaseCameraDevice();
1776 sleep(1);
1777 mainDemo->FlashlightOnOff(true);
1778 sleep(delayTime);
1779 mainDemo->FlashlightOnOff(false);
1780 mainDemo->InitCameraDevice();
1781 PreviewOn(0, mainDemo);
1782 return RC_OK;
1783 }
1784
OfflineTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1785 RetCode OfflineTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1786 {
1787 RetCode rc = RC_OK;
1788 int32_t dalayTime = 5;
1789
1790 if (mainDemo == nullptr) {
1791 DHLOGI("main test: OfflineTest mainDemo is nullptr");
1792 return RC_ERROR;
1793 }
1794
1795 PreviewOff(mainDemo);
1796
1797 mainDemo->StartDualStreams(STREAM_ID_CAPTURE);
1798 mainDemo->CaptureOnDualStreams(STREAM_ID_CAPTURE);
1799 sleep(1);
1800
1801 rc = mainDemo->StreamOffline(STREAM_ID_CAPTURE);
1802 if (rc != RC_OK) {
1803 DHLOGI("main test: mainDemo->StreamOffline error");
1804 return RC_ERROR;
1805 }
1806
1807 sleep(dalayTime);
1808 mainDemo->InitCameraDevice();
1809 rc = PreviewOn(0, mainDemo);
1810 if (rc != RC_OK) {
1811 DHLOGI("main test: PreviewOn() error");
1812 return RC_ERROR;
1813 }
1814 return RC_OK;
1815 }
1816
CaptureTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1817 RetCode CaptureTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1818 {
1819 RetCode rc = RC_OK;
1820 constexpr size_t delayTime = 5;
1821
1822 if (mainDemo == nullptr) {
1823 DHLOGI("main test: CaptureTest mainDemo is nullptr");
1824 return RC_ERROR;
1825 }
1826
1827 rc = mainDemo->CaptureON(STREAM_ID_CAPTURE, CAPTURE_ID_CAPTURE, CAPTURE_SNAPSHOT);
1828 if (rc != RC_OK) {
1829 DHLOGI("main test: mainDemo->CaptureON() capture error");
1830 return RC_ERROR;
1831 }
1832
1833 sleep(delayTime);
1834 rc = mainDemo->CaptureOff(CAPTURE_ID_CAPTURE, CAPTURE_SNAPSHOT);
1835 if (rc != RC_OK) {
1836 DHLOGI("main test: mainDemo->CaptureOff() capture error");
1837 return RC_ERROR;
1838 }
1839 DHLOGI("main test: CaptureON success");
1840 return RC_OK;
1841 }
1842
VideoTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1843 RetCode VideoTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1844 {
1845 RetCode rc = RC_OK;
1846 constexpr size_t delayTime = 5;
1847
1848 if (mainDemo == nullptr) {
1849 DHLOGI("main test: VideoTest mainDemo is nullptr");
1850 return RC_ERROR;
1851 }
1852
1853 PreviewOff(mainDemo);
1854 mainDemo->StartDualStreams(STREAM_ID_VIDEO);
1855 mainDemo->CaptureOnDualStreams(STREAM_ID_VIDEO);
1856
1857 sleep(delayTime);
1858 mainDemo->CaptureOff(CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1859 mainDemo->CaptureOff(CAPTURE_ID_VIDEO, CAPTURE_VIDEO);
1860 mainDemo->ReleaseAllStream();
1861
1862 rc = PreviewOn(0, mainDemo);
1863 if (rc != RC_OK) {
1864 DHLOGI("main test: video PreviewOn() error please -q exit demo");
1865 return RC_ERROR;
1866 }
1867 return RC_OK;
1868 }
1869 }
1870 } // namespace OHOS::Camera
1871