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