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