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