1 /*
2 * Copyright (c) 2021-2022 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 "hcamera_device.h"
17
18 #include "camera_util.h"
19 #include "camera_log.h"
20 #include "ipc_skeleton.h"
21 #include "metadata_utils.h"
22
23 namespace OHOS {
24 namespace CameraStandard {
HCameraDevice(sptr<HCameraHostManager> & cameraHostManager,std::string cameraID,const uint32_t callingTokenId)25 HCameraDevice::HCameraDevice(sptr<HCameraHostManager> &cameraHostManager,
26 std::string cameraID,
27 const uint32_t callingTokenId)
28 {
29 cameraHostManager_ = cameraHostManager;
30 cameraID_ = cameraID;
31 streamOperator_ = nullptr;
32 isReleaseCameraDevice_ = false;
33 isOpenedCameraDevice_ = false;
34 callerToken_ = callingTokenId;
35 }
36
~HCameraDevice()37 HCameraDevice::~HCameraDevice()
38 {
39 hdiCameraDevice_ = nullptr;
40 streamOperator_ = nullptr;
41 if (cameraHostManager_) {
42 cameraHostManager_ = nullptr;
43 }
44 deviceHDICallback_ = nullptr;
45 deviceSvcCallback_ = nullptr;
46 }
47
GetCameraId()48 std::string HCameraDevice::GetCameraId()
49 {
50 return cameraID_;
51 }
52
SetReleaseCameraDevice(bool isRelease)53 int32_t HCameraDevice::SetReleaseCameraDevice(bool isRelease)
54 {
55 isReleaseCameraDevice_ = isRelease;
56 return CAMERA_OK;
57 }
58
IsReleaseCameraDevice()59 bool HCameraDevice::IsReleaseCameraDevice()
60 {
61 return isReleaseCameraDevice_;
62 }
63
IsOpenedCameraDevice()64 bool HCameraDevice::IsOpenedCameraDevice()
65 {
66 return isOpenedCameraDevice_;
67 }
68
GetSettings()69 std::shared_ptr<OHOS::Camera::CameraMetadata> HCameraDevice::GetSettings()
70 {
71 int32_t errCode;
72 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = nullptr;
73 errCode = cameraHostManager_->GetCameraAbility(cameraID_, ability);
74 if (errCode != CAMERA_OK) {
75 MEDIA_ERR_LOG("HCameraDevice::GetSettings Failed to get Camera Ability: %{public}d", errCode);
76 return nullptr;
77 }
78
79 if (!videoFrameRateRange_.empty() && ability != nullptr) {
80 bool status = false;
81 camera_metadata_item_t item;
82 int ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_CONTROL_FPS_RANGES, &item);
83 if (ret == CAM_META_ITEM_NOT_FOUND) {
84 status = ability->addEntry(OHOS_CONTROL_FPS_RANGES,
85 videoFrameRateRange_.data(), videoFrameRateRange_.size());
86 } else if (ret == CAM_META_SUCCESS) {
87 status = ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
88 videoFrameRateRange_.data(), videoFrameRateRange_.size());
89 }
90 if (!status) {
91 MEDIA_ERR_LOG("HCameraDevice::Set fps renges Failed");
92 }
93 }
94 return ability;
95 }
96
Open()97 int32_t HCameraDevice::Open()
98 {
99 CAMERA_SYNC_TRACE;
100 int32_t errorCode;
101 if (isOpenedCameraDevice_) {
102 MEDIA_ERR_LOG("HCameraDevice::Open failed, camera is busy");
103 }
104 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
105 if (callerToken_ != callerToken) {
106 MEDIA_ERR_LOG("Failed to Open camera, createCamera token is : %{public}d, now token is %{public}d",
107 callerToken_, callerToken);
108 return CAMERA_OPERATION_NOT_ALLOWED;
109 }
110 if (deviceHDICallback_ == nullptr) {
111 deviceHDICallback_ = new(std::nothrow) CameraDeviceCallback(this);
112 if (deviceHDICallback_ == nullptr) {
113 MEDIA_ERR_LOG("HCameraDevice::Open CameraDeviceCallback allocation failed");
114 return CAMERA_ALLOC_ERROR;
115 }
116 }
117 bool isAllowed = true;
118 if (IsValidTokenId(callerToken)) {
119 isAllowed = Security::AccessToken::PrivacyKit::IsAllowedUsingPermission(callerToken, OHOS_PERMISSION_CAMERA);
120 }
121 if (!isAllowed) {
122 MEDIA_ERR_LOG("HCameraDevice::Open IsAllowedUsingPermission failed");
123 return CAMERA_ALLOC_ERROR;
124 }
125
126 auto conflictDevices = cameraHostManager_->CameraConflictDetection(cameraID_);
127 // Destory conflict devices
128 for (auto &i : conflictDevices) {
129 i->Close();
130 }
131 MEDIA_INFO_LOG("HCameraDevice::Open Opening camera device: %{public}s", cameraID_.c_str());
132 errorCode = cameraHostManager_->OpenCameraDevice(cameraID_, deviceHDICallback_, hdiCameraDevice_);
133 if (errorCode == CAMERA_OK) {
134 errorCode = OpenHdiCamera();
135 } else {
136 MEDIA_ERR_LOG("HCameraDevice::Open Failed to open camera");
137 }
138 return errorCode;
139 }
140
OpenHdiCamera()141 int32_t HCameraDevice::OpenHdiCamera()
142 {
143 int32_t errorCode = CAMERA_OK;
144 isOpenedCameraDevice_ = true;
145 if (updateSettings_ != nullptr && hdiCameraDevice_ != nullptr) {
146 std::vector<uint8_t> setting;
147 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(updateSettings_, setting);
148 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(setting));
149 if (rc != HDI::Camera::V1_0::NO_ERROR) {
150 MEDIA_ERR_LOG("HCameraDevice::Open Update setting failed with error Code: %{public}d", rc);
151 return HdiToServiceError(rc);
152 }
153 updateSettings_ = nullptr;
154 MEDIA_DEBUG_LOG("HCameraDevice::Open Updated device settings");
155 }
156 if (hdiCameraDevice_) {
157 errorCode = HdiToServiceError((CamRetCode)(hdiCameraDevice_->SetResultMode(ON_CHANGED)));
158 cameraHostManager_->AddCameraDevice(cameraID_, this);
159 (void)OnCameraStatus(cameraID_, CAMERA_STATUS_UNAVAILABLE);
160 }
161 return errorCode;
162 }
163
Close()164 int32_t HCameraDevice::Close()
165 {
166 CAMERA_SYNC_TRACE;
167 std::lock_guard<std::mutex> lock(deviceLock_);
168 if (hdiCameraDevice_ != nullptr) {
169 MEDIA_INFO_LOG("HCameraDevice::Close Closing camera device: %{public}s", cameraID_.c_str());
170 hdiCameraDevice_->Close();
171 (void)OnCameraStatus(cameraID_, CAMERA_STATUS_AVAILABLE);
172 }
173 isOpenedCameraDevice_ = false;
174 hdiCameraDevice_ = nullptr;
175 if (streamOperator_) {
176 streamOperator_ = nullptr;
177 }
178 if (cameraHostManager_) {
179 cameraHostManager_->RemoveCameraDevice(cameraID_);
180 }
181 deviceHDICallback_ = nullptr;
182 deviceSvcCallback_ = nullptr;
183 return CAMERA_OK;
184 }
185
Release()186 int32_t HCameraDevice::Release()
187 {
188 if (hdiCameraDevice_ != nullptr) {
189 Close();
190 }
191 return CAMERA_OK;
192 }
193
GetEnabledResults(std::vector<int32_t> & results)194 int32_t HCameraDevice::GetEnabledResults(std::vector<int32_t> &results)
195 {
196 if (hdiCameraDevice_) {
197 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->GetEnabledResults(results));
198 if (rc != HDI::Camera::V1_0::NO_ERROR) {
199 MEDIA_ERR_LOG("HCameraDevice::GetEnabledResults failed with error Code:%{public}d", rc);
200 return HdiToServiceError(rc);
201 }
202 } else {
203 MEDIA_ERR_LOG("HCameraDevice::GetEnabledResults GetEnabledResults hdiCameraDevice_ is nullptr");
204 return CAMERA_UNKNOWN_ERROR;
205 }
206 return CAMERA_OK;
207 }
208
UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)209 int32_t HCameraDevice::UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
210 {
211 CAMERA_SYNC_TRACE;
212 if (settings == nullptr) {
213 MEDIA_ERR_LOG("HCameraDevice::UpdateSetting settings is null");
214 return CAMERA_INVALID_ARG;
215 }
216
217 uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(settings->get());
218 if (!count) {
219 MEDIA_DEBUG_LOG("HCameraDevice::UpdateSetting Nothing to update");
220 return CAMERA_OK;
221 }
222 if (updateSettings_) {
223 camera_metadata_item_t metadataItem;
224 for (uint32_t index = 0; index < count; index++) {
225 int ret = OHOS::Camera::GetCameraMetadataItem(settings->get(), index, &metadataItem);
226 if (ret != CAM_META_SUCCESS) {
227 MEDIA_ERR_LOG("HCameraDevice::UpdateSetting Failed to get metadata item at index: %{public}d", index);
228 return CAMERA_INVALID_ARG;
229 }
230 bool status = false;
231 uint32_t currentIndex;
232 ret = OHOS::Camera::FindCameraMetadataItemIndex(updateSettings_->get(), metadataItem.item, ¤tIndex);
233 if (ret == CAM_META_ITEM_NOT_FOUND) {
234 status = updateSettings_->addEntry(metadataItem.item, metadataItem.data.u8, metadataItem.count);
235 } else if (ret == CAM_META_SUCCESS) {
236 status = updateSettings_->updateEntry(metadataItem.item, metadataItem.data.u8, metadataItem.count);
237 }
238 if (!status) {
239 MEDIA_ERR_LOG("HCameraDevice::UpdateSetting Failed to update metadata item: %{public}d",
240 metadataItem.item);
241 return CAMERA_UNKNOWN_ERROR;
242 }
243 }
244 } else {
245 updateSettings_ = settings;
246 }
247 if (hdiCameraDevice_ != nullptr) {
248 std::vector<uint8_t> setting;
249 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(updateSettings_, setting);
250 ReportMetadataDebugLog(updateSettings_);
251 GetFrameRateSetting(updateSettings_);
252
253 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(setting));
254 if (rc != HDI::Camera::V1_0::NO_ERROR) {
255 MEDIA_ERR_LOG("HCameraDevice::UpdateSetting failed with error Code: %{public}d", rc);
256 return HdiToServiceError(rc);
257 }
258 ReportFlashEvent(updateSettings_);
259 updateSettings_ = nullptr;
260 }
261 MEDIA_DEBUG_LOG("HCameraDevice::UpdateSetting Updated device settings");
262 return CAMERA_OK;
263 }
264
ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)265 void HCameraDevice::ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
266 {
267 // debug log for focus mode
268 camera_metadata_item_t item;
269 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_FOCUS_MODE, &item);
270 if (ret != CAM_META_SUCCESS) {
271 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_FOCUS_MODE tag");
272 } else {
273 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_FOCUS_MODE value = %{public}d", item.data.u8[0]);
274 }
275
276 // debug log for af regions
277 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_AF_REGIONS, &item);
278 if (ret != CAM_META_SUCCESS) {
279 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AF_REGIONS tag");
280 } else {
281 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AF_REGIONS x = %{public}f, y = %{public}f",
282 item.data.f[0], item.data.f[1]);
283 }
284
285 // debug log for af regions
286 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(),
287 OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &item);
288 if (ret != CAM_META_SUCCESS) {
289 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_VIDEO_STABILIZATION_MODE tag");
290 } else {
291 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_VIDEO_STABILIZATION_MODE value = %{public}d",
292 item.data.u8[0]);
293 }
294
295 // debug log for exposure mode
296 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_EXPOSURE_MODE, &item);
297 if (ret != CAM_META_SUCCESS) {
298 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_EXPOSURE_MODE tag");
299 } else {
300 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_EXPOSURE_MODE value = %{public}d", item.data.u8[0]);
301 }
302
303 // debug log for ae regions
304 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_AE_REGIONS, &item);
305 if (ret != CAM_META_SUCCESS) {
306 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AE_REGIONS tag");
307 } else {
308 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AE_REGIONS x = %{public}f, y = %{public}f",
309 item.data.f[0], item.data.f[1]);
310 }
311
312 // debug log for ae exposure compensation
313 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(),
314 OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &item);
315 if (ret != CAM_META_SUCCESS) {
316 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AE_EXPOSURE_COMPENSATION tag");
317 } else {
318 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AE_EXPOSURE_COMPENSATION value = %{public}d",
319 item.data.u8[0]);
320 }
321 }
322
GetFrameRateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)323 void HCameraDevice::GetFrameRateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
324 {
325 camera_metadata_item_t item;
326 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_FPS_RANGES, &item);
327 if (ret != CAM_META_SUCCESS) {
328 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_FPS_RANGES tag");
329 } else {
330 videoFrameRateRange_ = {item.data.i32[0], item.data.i32[1]};
331 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_FPS_RANGES min = %{public}d, max = %{public}d",
332 item.data.i32[0], item.data.i32[1]);
333 }
334 }
335
ReportFlashEvent(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)336 void HCameraDevice::ReportFlashEvent(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
337 {
338 camera_metadata_item_t item;
339 camera_flash_mode_enum_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
340 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_FLASH_MODE, &item);
341 if (ret == CAM_META_SUCCESS) {
342 flashMode = static_cast<camera_flash_mode_enum_t>(item.data.u8[0]);
343 } else {
344 MEDIA_ERR_LOG("CameraInput::GetFlashMode Failed with return code %{public}d", ret);
345 }
346
347 if (flashMode == OHOS_CAMERA_FLASH_MODE_CLOSE) {
348 POWERMGR_SYSEVENT_FLASH_OFF();
349 } else {
350 POWERMGR_SYSEVENT_FLASH_ON();
351 }
352 }
353
EnableResult(std::vector<int32_t> & results)354 int32_t HCameraDevice::EnableResult(std::vector<int32_t> &results)
355 {
356 if (results.empty()) {
357 MEDIA_ERR_LOG("HCameraDevice::EnableResult results vector empty");
358 return CAMERA_INVALID_ARG;
359 }
360
361 if (hdiCameraDevice_ == nullptr) {
362 MEDIA_ERR_LOG("HCameraDevice::hdiCameraDevice_ is null");
363 return CAMERA_UNKNOWN_ERROR;
364 }
365
366 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->EnableResult(results));
367 if (rc != HDI::Camera::V1_0::NO_ERROR) {
368 MEDIA_ERR_LOG("HCameraDevice::EnableResult failed with error Code:%{public}d", rc);
369 return HdiToServiceError(rc);
370 }
371
372 return CAMERA_OK;
373 }
374
DisableResult(std::vector<int32_t> & results)375 int32_t HCameraDevice::DisableResult(std::vector<int32_t> &results)
376 {
377 if (results.empty()) {
378 MEDIA_ERR_LOG("HCameraDevice::DisableResult results vector empty");
379 return CAMERA_INVALID_ARG;
380 }
381
382 if (hdiCameraDevice_ == nullptr) {
383 MEDIA_ERR_LOG("HCameraDevice::hdiCameraDevice_ is null");
384 return CAMERA_UNKNOWN_ERROR;
385 }
386
387 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->DisableResult(results));
388 if (rc != HDI::Camera::V1_0::NO_ERROR) {
389 MEDIA_ERR_LOG("HCameraDevice::DisableResult failed with error Code:%{public}d", rc);
390 return HdiToServiceError(rc);
391 }
392 return CAMERA_OK;
393 }
394
SetCallback(sptr<ICameraDeviceServiceCallback> & callback)395 int32_t HCameraDevice::SetCallback(sptr<ICameraDeviceServiceCallback> &callback)
396 {
397 if (callback == nullptr) {
398 MEDIA_ERR_LOG("HCameraDevice::SetCallback callback is null");
399 return CAMERA_INVALID_ARG;
400 }
401 deviceSvcCallback_ = callback;
402 return CAMERA_OK;
403 }
404
SetStatusCallback(std::map<int32_t,sptr<ICameraServiceCallback>> & callbacks)405 int32_t HCameraDevice::SetStatusCallback(std::map<int32_t, sptr<ICameraServiceCallback>> &callbacks)
406 {
407 std::lock_guard<std::mutex> lock(statusCbLock_);
408 MEDIA_INFO_LOG("HCameraDevice::SetStatusCallback callbacks size = %{public}zu",
409 callbacks.size());
410 if (!statusSvcCallbacks_.empty()) {
411 MEDIA_ERR_LOG("HCameraDevice::SetStatusCallback statusSvcCallbacks_ is not empty, reset it");
412 statusSvcCallbacks_.clear();
413 }
414 for (auto it : callbacks) {
415 statusSvcCallbacks_[it.first] = it.second;
416 }
417 MEDIA_INFO_LOG("HCameraDevice::SetStatusCallback statusSvcCallbacks_ size = %{public}zu",
418 statusSvcCallbacks_.size());
419 return CAMERA_OK;
420 }
421
GetStreamOperator(sptr<IStreamOperatorCallback> callback,sptr<IStreamOperator> & streamOperator)422 int32_t HCameraDevice::GetStreamOperator(sptr<IStreamOperatorCallback> callback,
423 sptr<IStreamOperator> &streamOperator)
424 {
425 if (callback == nullptr) {
426 MEDIA_ERR_LOG("HCameraDevice::GetStreamOperator callback is null");
427 return CAMERA_INVALID_ARG;
428 }
429
430 if (hdiCameraDevice_ == nullptr) {
431 MEDIA_ERR_LOG("HCameraDevice::hdiCameraDevice_ is null");
432 return CAMERA_UNKNOWN_ERROR;
433 }
434
435 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->GetStreamOperator(callback, streamOperator));
436 if (rc != HDI::Camera::V1_0::NO_ERROR) {
437 MEDIA_ERR_LOG("HCameraDevice::GetStreamOperator failed with error Code:%{public}d", rc);
438 return HdiToServiceError(rc);
439 }
440 streamOperator_ = streamOperator;
441 return CAMERA_OK;
442 }
443
GetStreamOperator()444 sptr<IStreamOperator> HCameraDevice::GetStreamOperator()
445 {
446 return streamOperator_;
447 }
448
OnError(const ErrorType type,const int32_t errorMsg)449 int32_t HCameraDevice::OnError(const ErrorType type, const int32_t errorMsg)
450 {
451 if (deviceSvcCallback_ != nullptr) {
452 int32_t errorType;
453 if (type == REQUEST_TIMEOUT) {
454 errorType = CAMERA_DEVICE_REQUEST_TIMEOUT;
455 } else if (type == DEVICE_PREEMPT) {
456 errorType = CAMERA_DEVICE_PREEMPTED;
457 } else {
458 errorType = CAMERA_UNKNOWN_ERROR;
459 }
460 deviceSvcCallback_->OnError(errorType, errorMsg);
461 CAMERA_SYSEVENT_FAULT(CreateMsg("CameraDeviceServiceCallback::OnError() is called!, errorType: %d,"
462 "errorMsg: %d", errorType, errorMsg));
463 }
464 return CAMERA_OK;
465 }
466
OnCameraStatus(const std::string & cameraId,CameraStatus status)467 int32_t HCameraDevice::OnCameraStatus(const std::string& cameraId, CameraStatus status)
468 {
469 std::lock_guard<std::mutex> lock(statusCbLock_);
470 MEDIA_INFO_LOG("HCameraDevice::OnCameraStatus statusSvcCallbacks_ size = %{public}zu",
471 statusSvcCallbacks_.size());
472 std::string callbackPids = "[";
473 for (auto it : statusSvcCallbacks_) {
474 auto item = it.second.promote();
475 if (item != nullptr) {
476 callbackPids += " " + std::to_string((int)it.first);
477 item->OnCameraStatusChanged(cameraId, status);
478 }
479 }
480 callbackPids += " ]";
481 MEDIA_INFO_LOG("HCameraDevice::OnCameraStatus OnCameraStatusChanged callbackPids = %{public}s, "
482 "cameraId = %{public}s, cameraStatus = %{public}d",
483 callbackPids.c_str(), cameraId.c_str(), status);
484 return CAMERA_OK;
485 }
486
OnResult(const uint64_t timestamp,const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)487 int32_t HCameraDevice::OnResult(const uint64_t timestamp,
488 const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
489 {
490 if (deviceSvcCallback_ != nullptr) {
491 deviceSvcCallback_->OnResult(timestamp, result);
492 }
493 camera_metadata_item_t item;
494 common_metadata_header_t* metadata = result->get();
495 int ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASH_MODE, &item);
496 if (ret == 0) {
497 MEDIA_INFO_LOG("CameraDeviceServiceCallback::OnResult() OHOS_CONTROL_FLASH_MODE is %{public}d",
498 item.data.u8[0]);
499 }
500 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASH_STATE, &item);
501 if (ret == 0) {
502 MEDIA_INFO_LOG("CameraDeviceServiceCallback::OnResult() OHOS_CONTROL_FLASH_STATE is %{public}d",
503 item.data.u8[0]);
504 }
505
506 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_MODE, &item);
507 if (ret == CAM_META_SUCCESS) {
508 MEDIA_DEBUG_LOG("Focus mode: %{public}d", item.data.u8[0]);
509 }
510 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_STATE, &item);
511 if (ret == CAM_META_SUCCESS) {
512 MEDIA_INFO_LOG("Focus state: %{public}d", item.data.u8[0]);
513 }
514 return CAMERA_OK;
515 }
516
CameraDeviceCallback(sptr<HCameraDevice> hCameraDevice)517 CameraDeviceCallback::CameraDeviceCallback(sptr<HCameraDevice> hCameraDevice)
518 {
519 hCameraDevice_ = hCameraDevice;
520 }
521
OnError(const ErrorType type,const int32_t errorCode)522 int32_t CameraDeviceCallback::OnError(const ErrorType type, const int32_t errorCode)
523 {
524 auto item = hCameraDevice_.promote();
525 if (item != nullptr) {
526 item->OnError(type, errorCode);
527 }
528 return CAMERA_OK;
529 }
530
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)531 int32_t CameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t>& result)
532 {
533 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult;
534 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, cameraResult);
535 auto item = hCameraDevice_.promote();
536 if (item != nullptr) {
537 item->OnResult(timestamp, cameraResult);
538 }
539 return CAMERA_OK;
540 }
541 } // namespace CameraStandard
542 } // namespace OHOS
543