1 /*
2  * Copyright (c) 2021-2023 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 <cstdint>
19 #include <memory>
20 #include <mutex>
21 #include <vector>
22 
23 #include "camera_device_ability_items.h"
24 #include "camera_error_code.h"
25 #include "camera_log.h"
26 #include "camera_fwk_metadata_utils.h"
27 #include "camera_metadata_info.h"
28 #include "camera_metadata_operator.h"
29 #include "camera_service_ipc_interface_code.h"
30 #include "camera_util.h"
31 #include "display_manager.h"
32 #include "hcamera_device_manager.h"
33 #include "ipc_skeleton.h"
34 #include "ipc_types.h"
35 #ifdef MEMMGR_OVERRID
36 #include "mem_mgr_client.h"
37 #include "mem_mgr_constant.h"
38 #endif
39 #include "metadata_utils.h"
40 #include "v1_0/types.h"
41 #include "os_account_manager.h"
42 #include "deferred_processing_service.h"
43 #include "iservice_registry.h"
44 #include "system_ability_definition.h"
45 #include "camera_timer.h"
46 #include "camera_report_uitls.h"
47 #include "common_event_manager.h"
48 #include "common_event_support.h"
49 #include "common_event_data.h"
50 #include "want.h"
51 
52 namespace OHOS {
53 namespace CameraStandard {
54 using namespace OHOS::HDI::Camera::V1_0;
55 std::mutex HCameraDevice::g_deviceOpenCloseMutex_;
56 static const int32_t DEFAULT_SETTING_ITEM_COUNT = 100;
57 static const int32_t DEFAULT_SETTING_ITEM_LENGTH = 100;
58 static const float SMOOTH_ZOOM_DIVISOR = 100.0f;
59 static const std::vector<camera_device_metadata_tag> DEVICE_OPEN_LIFECYCLE_TAGS = { OHOS_CONTROL_MUTE_MODE };
60 sptr<OHOS::Rosen::DisplayManager::IFoldStatusListener> listener;
61 CallerInfo caller_;
62 
63 const std::vector<std::tuple<uint32_t, std::string, std::string>> HCameraDevice::reportTagInfos_ = {
64     {OHOS_CONTROL_FLASH_MODE, "OHOS_CONTROL_FLASH_MODE", DFX_UB_SET_FLASHMODE},
65     {OHOS_CONTROL_FOCUS_MODE, "OHOS_CONTROL_FOCUS_MODE", DFX_UB_SET_FOCUSMODE},
66     {OHOS_CONTROL_QUALITY_PRIORITIZATION, "OHOS_CONTROL_QUALITY_PRIORITIZATION", DFX_UB_SET_QUALITY_PRIORITIZATION},
67     {OHOS_CONTROL_EXPOSURE_MODE, "OHOS_CONTROL_EXPOSURE_MODE", DFX_UB_SET_EXPOSUREMODE},
68     {OHOS_CONTROL_VIDEO_STABILIZATION_MODE, "OHOS_CONTROL_VIDEO_STABILIZATION_MODE", DFX_UB_SET_VIDEOSTABILIZATIONMODE},
69     {OHOS_CONTROL_FILTER_TYPE, "OHOS_CONTROL_FILTER_TYPE", DFX_UB_SET_FILTER},
70     {OHOS_CONTROL_PORTRAIT_EFFECT_TYPE, "OHOS_CONTROL_PORTRAIT_EFFECT_TYPE", DFX_UB_SET_PORTRAITEFFECT},
71     {OHOS_CONTROL_BEAUTY_AUTO_VALUE, "OHOS_CONTROL_BEAUTY_AUTO_VALUE", DFX_UB_SET_BEAUTY_AUTOVALUE},
72     {OHOS_CONTROL_BEAUTY_SKIN_SMOOTH_VALUE, "OHOS_CONTROL_BEAUTY_SKIN_SMOOTH_VALUE", DFX_UB_SET_BEAUTY_SKINSMOOTH},
73     {OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE, "OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE", DFX_UB_SET_BEAUTY_FACESLENDER},
74     {OHOS_CONTROL_BEAUTY_SKIN_TONE_VALUE, "OHOS_CONTROL_BEAUTY_SKIN_TONE_VALUE", DFX_UB_SET_BEAUTY_SKINTONE},
75     {OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, "OHOS_CONTROL_AE_EXPOSURE_COMPENSATION", DFX_UB_SET_EXPOSUREBIAS},
76     {OHOS_CONTROL_FPS_RANGES, "OHOS_CONTROL_FPS_RANGES", DFX_UB_SET_FRAMERATERANGE},
77     {OHOS_CONTROL_ZOOM_RATIO, "OHOS_CONTROL_ZOOM_RATIO", DFX_UB_SET_ZOOMRATIO},
78     {OHOS_CONTROL_BEAUTY_TYPE, "OHOS_CONTROL_BEAUTY_TYPE", DFX_UB_NOT_REPORT},
79     {OHOS_CONTROL_LIGHT_PAINTING_TYPE, "OHOS_CONTROL_LIGHT_PAINTING_TYPE", DFX_UB_NOT_REPORT},
80     {OHOS_CONTROL_LIGHT_PAINTING_FLASH, "OHOS_CONTROL_LIGHT_PAINTING_FLASH", DFX_UB_NOT_REPORT},
81     {OHOS_CONTROL_MANUAL_EXPOSURE_TIME, "OHOS_CONTROL_MANUAL_EXPOSURE_TIME", DFX_UB_NOT_REPORT},
82     {OHOS_CONTROL_CAMERA_USED_AS_POSITION, "OHOS_CONTROL_CAMERA_USED_AS_POSITION", DFX_UB_NOT_REPORT},
83 };
84 
85 class HCameraDevice::FoldScreenListener : public OHOS::Rosen::DisplayManager::IFoldStatusListener {
86 public:
FoldScreenListener(sptr<HCameraHostManager> & cameraHostManager,const std::string cameraId)87     explicit FoldScreenListener(sptr<HCameraHostManager> &cameraHostManager, const std::string cameraId)
88         : cameraHostManager_(cameraHostManager), cameraId_(cameraId)
89     {
90         MEDIA_DEBUG_LOG("FoldScreenListener enter");
91     }
92 
93     virtual ~FoldScreenListener() = default;
OnFoldStatusChanged(OHOS::Rosen::FoldStatus foldStatus)94     void OnFoldStatusChanged(OHOS::Rosen::FoldStatus foldStatus) override
95     {
96         FoldStatus currentFoldStatus = FoldStatus::UNKNOWN_FOLD;
97         if (foldStatus == OHOS::Rosen::FoldStatus::HALF_FOLD) {
98             currentFoldStatus = FoldStatus::EXPAND;
99         }
100         if (cameraHostManager_ == nullptr || mLastFoldStatus == currentFoldStatus) {
101             MEDIA_DEBUG_LOG("no need set fold status");
102             return;
103         }
104         mLastFoldStatus = currentFoldStatus;
105         MEDIA_INFO_LOG("OnFoldStatusChanged, foldStatus: %{public}d", foldStatus);
106         cameraHostManager_->NotifyDeviceStateChangeInfo(DeviceType::FOLD_TYPE, (int)currentFoldStatus);
107     }
108 private:
109     sptr<HCameraHostManager> cameraHostManager_;
110     std::string cameraId_;
111     FoldStatus mLastFoldStatus = FoldStatus::UNKNOWN_FOLD;
112 };
113 
HCameraDevice(sptr<HCameraHostManager> & cameraHostManager,std::string cameraID,const uint32_t callingTokenId)114 HCameraDevice::HCameraDevice(
115     sptr<HCameraHostManager>& cameraHostManager, std::string cameraID, const uint32_t callingTokenId)
116     : cachedSettings_(
117           std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_SETTING_ITEM_COUNT, DEFAULT_SETTING_ITEM_LENGTH)),
118       cameraHostManager_(cameraHostManager), cameraID_(cameraID), callerToken_(callingTokenId),
119       deviceOpenLifeCycleSettings_(std::make_shared<OHOS::Camera::CameraMetadata>(
120       DEVICE_OPEN_LIFECYCLE_TAGS.size(), DEFAULT_SETTING_ITEM_LENGTH)), clientUserId_(0), zoomTimerId_(0),
121       deviceMuteMode_(false), isHasOpenSecure(false)
122 {
123     MEDIA_INFO_LOG("HCameraDevice::HCameraDevice Contructor Camera: %{public}s", cameraID.c_str());
124     isOpenedCameraDevice_.store(false);
125     sptr<CameraPrivacy> cameraPrivacy = new CameraPrivacy(this, callingTokenId, IPCSkeleton::GetCallingPid());
126     SetCameraPrivacy(cameraPrivacy);
127 }
128 
~HCameraDevice()129 HCameraDevice::~HCameraDevice()
130 {
131     UnPrepareZoom();
132     CameraTimer::GetInstance().Unregister(zoomTimerId_);
133     SetCameraPrivacy(nullptr);
134     {
135         std::lock_guard<std::mutex> lock(movingPhotoStartTimeCallbackLock_);
136         movingPhotoStartTimeCallback_ = nullptr;
137     }
138     {
139         std::lock_guard<std::mutex> lock(movingPhotoEndTimeCallbackLock_);
140         movingPhotoEndTimeCallback_ = nullptr;
141     }
142     MEDIA_INFO_LOG("HCameraDevice::~HCameraDevice Destructor Camera: %{public}s", cameraID_.c_str());
143 }
144 
GetCameraId()145 std::string HCameraDevice::GetCameraId()
146 {
147     return cameraID_;
148 }
149 
GetCameraType()150 int32_t HCameraDevice::GetCameraType()
151 {
152     if (clientName_ == SYSTEM_CAMERA) {
153         return SYSTEM;
154     }
155     return OTHER;
156 }
157 
IsOpenedCameraDevice()158 bool HCameraDevice::IsOpenedCameraDevice()
159 {
160     return isOpenedCameraDevice_.load();
161 }
162 
SetDeviceMuteMode(bool muteMode)163 void HCameraDevice::SetDeviceMuteMode(bool muteMode)
164 {
165     deviceMuteMode_ = muteMode;
166 }
167 
GetDeviceMuteMode()168 bool HCameraDevice::GetDeviceMuteMode()
169 {
170     return deviceMuteMode_;
171 }
172 
EnableMovingPhoto(bool isMovingPhotoEnabled)173 void HCameraDevice::EnableMovingPhoto(bool isMovingPhotoEnabled)
174 {
175     isMovingPhotoEnabled_ = isMovingPhotoEnabled;
176 }
177 
CreateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)178 void HCameraDevice::CreateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
179 {
180     constexpr int32_t DEFAULT_ITEMS = 1;
181     constexpr int32_t DEFAULT_DATA_LENGTH = 1;
182     int32_t count = 1;
183     uint8_t mode = OHOS_CAMERA_MUTE_MODE_SOLID_COLOR_BLACK;
184     settings = std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
185     settings->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
186 }
187 
ResetDeviceSettings()188 int32_t HCameraDevice::ResetDeviceSettings()
189 {
190     CAMERA_SYNC_TRACE;
191     sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
192     MEDIA_INFO_LOG("HCameraDevice::ResetDeviceSettings enter");
193     {
194         std::lock_guard<std::mutex> lock(opMutex_);
195         CHECK_ERROR_RETURN_RET(hdiCameraDevice_ == nullptr, CAMERA_OK);
196         hdiCameraDeviceV1_2 = HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
197     }
198     if (hdiCameraDeviceV1_2 != nullptr) {
199         int32_t errCode = hdiCameraDeviceV1_2->Reset();
200         CHECK_ERROR_RETURN_RET_LOG(errCode != HDI::Camera::V1_0::CamRetCode::NO_ERROR, CAMERA_UNKNOWN_ERROR,
201             "HCameraDevice::ResetDeviceSettings occur error");
202         ResetCachedSettings();
203         if (deviceMuteMode_) {
204             std::shared_ptr<OHOS::Camera::CameraMetadata> settings = nullptr;
205             CreateMuteSetting(settings);
206             UpdateSetting(settings);
207         }
208     }
209     MEDIA_INFO_LOG("HCameraDevice::ResetDeviceSettings end");
210     return CAMERA_OK;
211 }
212 
DispatchDefaultSettingToHdi()213 int32_t HCameraDevice::DispatchDefaultSettingToHdi()
214 {
215     CAMERA_SYNC_TRACE;
216     MEDIA_INFO_LOG("HCameraDevice::DispatchDefaultSettingToHdi enter");
217 
218     std::shared_ptr<OHOS::Camera::CameraMetadata> lifeCycleSettings;
219     {
220         std::lock_guard<std::mutex> lifeLock(deviceOpenLifeCycleMutex_);
221         if (deviceOpenLifeCycleSettings_->get()->item_count == 0) {
222             MEDIA_INFO_LOG("HCameraDevice::DispatchDefaultSettingToHdi skip, data is empty");
223             return CAMERA_OK;
224         }
225         lifeCycleSettings = CameraFwkMetadataUtils::CopyMetadata(deviceOpenLifeCycleSettings_);
226     }
227 
228     if (IsCameraDebugOn()) {
229         auto metadataHeader = lifeCycleSettings->get();
230         for (uint32_t index = 0; index < metadataHeader->item_count; index++) {
231             camera_metadata_item_t item;
232             int32_t result = OHOS::Camera::GetCameraMetadataItem(metadataHeader, index, &item);
233             if (result == CAM_META_SUCCESS) {
234                 MEDIA_INFO_LOG("HCameraDevice::DispatchDefaultSettingToHdi tag:%{public}d", item.item);
235             } else {
236                 MEDIA_ERR_LOG(
237                     "HCameraDevice::DispatchDefaultSettingToHdi tag:%{public}d error:%{public}d", item.item, result);
238             }
239         }
240     }
241 
242     std::lock_guard<std::mutex> lock(opMutex_);
243     CHECK_ERROR_RETURN_RET(hdiCameraDevice_ == nullptr, CAMERA_INVALID_STATE);
244     std::vector<uint8_t> hdiMetadata;
245     bool isSuccess = OHOS::Camera::MetadataUtils::ConvertMetadataToVec(lifeCycleSettings, hdiMetadata);
246     CHECK_ERROR_RETURN_RET_LOG(!isSuccess, CAMERA_UNKNOWN_ERROR,
247         "HCameraDevice::DispatchDefaultSettingToHdi metadata ConvertMetadataToVec fail");
248     ReportMetadataDebugLog(lifeCycleSettings);
249     CamRetCode rc = (CamRetCode)hdiCameraDevice_->UpdateSettings(hdiMetadata);
250     if (rc != HDI::Camera::V1_0::NO_ERROR) {
251         MEDIA_ERR_LOG("HCameraDevice::DispatchDefaultSettingToHdi UpdateSettings error: %{public}d", rc);
252         CameraReportUtils::ReportCameraError(
253             "HCameraDevice::DispatchDefaultSettingToHdi", rc, true, CameraReportUtils::GetCallerInfo());
254         return HdiToServiceError(rc);
255     }
256     return CAMERA_OK;
257 }
258 
ResetCachedSettings()259 void HCameraDevice::ResetCachedSettings()
260 {
261     std::lock_guard<std::mutex> cachedLock(cachedSettingsMutex_);
262     cachedSettings_ =
263         std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_SETTING_ITEM_COUNT, DEFAULT_SETTING_ITEM_LENGTH);
264 }
265 
CloneCachedSettings()266 std::shared_ptr<OHOS::Camera::CameraMetadata> HCameraDevice::CloneCachedSettings()
267 {
268     std::lock_guard<std::mutex> cachedLock(cachedSettingsMutex_);
269     return CameraFwkMetadataUtils::CopyMetadata(cachedSettings_);
270 }
271 
GetDeviceAbility()272 std::shared_ptr<OHOS::Camera::CameraMetadata> HCameraDevice::GetDeviceAbility()
273 {
274     CAMERA_SYNC_TRACE;
275     std::lock_guard<std::mutex> lock(deviceAbilityMutex_);
276     CHECK_ERROR_RETURN_RET(deviceAbility_ != nullptr, deviceAbility_);
277     int32_t errCode = cameraHostManager_->GetCameraAbility(cameraID_, deviceAbility_);
278     CHECK_ERROR_RETURN_RET_LOG(errCode != CAMERA_OK, nullptr,
279         "HCameraDevice::GetSettings Failed to get Camera Ability: %{public}d", errCode);
280     return deviceAbility_;
281 }
282 
Open()283 int32_t HCameraDevice::Open()
284 {
285     CAMERA_SYNC_TRACE;
286     std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
287     CHECK_ERROR_PRINT_LOG(isOpenedCameraDevice_.load(), "HCameraDevice::Open failed, camera is busy");
288     CHECK_ERROR_RETURN_RET_LOG(!IsInForeGround(callerToken_), CAMERA_ALLOC_ERROR,
289         "HCameraDevice::Open IsAllowedUsingPermission failed");
290     MEDIA_INFO_LOG("HCameraDevice::Open Camera:[%{public}s]", cameraID_.c_str());
291     int32_t result = OpenDevice();
292     return result;
293 }
294 
OpenSecureCamera(uint64_t * secureSeqId)295 int32_t HCameraDevice::OpenSecureCamera(uint64_t* secureSeqId)
296 {
297     CAMERA_SYNC_TRACE;
298     std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
299     CHECK_ERROR_PRINT_LOG(isOpenedCameraDevice_.load(), "HCameraDevice::Open failed, camera is busy");
300     CHECK_ERROR_RETURN_RET_LOG(!IsInForeGround(callerToken_), CAMERA_ALLOC_ERROR,
301         "HCameraDevice::Open IsAllowedUsingPermission failed");
302     MEDIA_INFO_LOG("HCameraDevice::OpenSecureCamera Camera:[%{public}s]", cameraID_.c_str());
303     int32_t errCode = OpenDevice(true);
304     auto hdiCameraDeviceV1_3 = HDI::Camera::V1_3::ICameraDevice::CastFrom(hdiCameraDevice_);
305     if (hdiCameraDeviceV1_3 != nullptr) {
306         errCode = hdiCameraDeviceV1_3->GetSecureCameraSeq(*secureSeqId);
307         CHECK_ERROR_RETURN_RET_LOG(errCode != HDI::Camera::V1_0::CamRetCode::NO_ERROR, CAMERA_UNKNOWN_ERROR,
308             "HCameraDevice::GetSecureCameraSeq occur error");
309         mSecureCameraSeqId = *secureSeqId;
310         isHasOpenSecure = true;
311     }  else {
312         MEDIA_INFO_LOG("V1_3::ICameraDevice::CastFrom failed");
313     }
314     MEDIA_INFO_LOG("CaptureSession::OpenSecureCamera secureSeqId = %{public}" PRIu64, *secureSeqId);
315     return errCode;
316 }
317 
GetSecureCameraSeq(uint64_t * secureSeqId)318 int64_t HCameraDevice::GetSecureCameraSeq(uint64_t* secureSeqId)
319 {
320     if (!isHasOpenSecure) {
321         *secureSeqId = 0;
322         return CAMERA_OK;
323     }
324     auto hdiCameraDeviceV1_3 = HDI::Camera::V1_3::ICameraDevice::CastFrom(hdiCameraDevice_);
325     if (hdiCameraDeviceV1_3 != nullptr) {
326         *secureSeqId = mSecureCameraSeqId;
327         MEDIA_DEBUG_LOG("CaptureSession::GetSecureCameraSeq secureSeqId = %{public}" PRId64, *secureSeqId);
328         return CAMERA_UNKNOWN_ERROR;
329     }  else {
330         MEDIA_INFO_LOG("V1_3::ICameraDevice::CastFrom failed");
331     }
332     return CAMERA_OK;
333 }
334 
Close()335 int32_t HCameraDevice::Close()
336 {
337     CAMERA_SYNC_TRACE;
338     std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
339     MEDIA_INFO_LOG("HCameraDevice::Close Closing camera device: %{public}s", cameraID_.c_str());
340     int32_t result = CloseDevice();
341     return result;
342 }
343 
OpenDevice(bool isEnableSecCam)344 int32_t HCameraDevice::OpenDevice(bool isEnableSecCam)
345 {
346     MEDIA_INFO_LOG("HCameraDevice::OpenDevice start cameraId: %{public}s", cameraID_.c_str());
347     CAMERA_SYNC_TRACE;
348     int32_t errorCode = CheckPermissionBeforeOpenDevice();
349     CHECK_AND_RETURN_RET(errorCode == CAMERA_OK, errorCode);
350     bool canOpenDevice = CanOpenCamera();
351     CHECK_ERROR_RETURN_RET_LOG(!canOpenDevice, CAMERA_DEVICE_CONFLICT, "HCameraDevice::Refuse to turn on the camera");
352     CHECK_ERROR_RETURN_RET_LOG(!HandlePrivacyBeforeOpenDevice(), CAMERA_OPERATION_NOT_ALLOWED, "privacy not allow!");
353     int pid = IPCSkeleton::GetCallingPid();
354     int uid = IPCSkeleton::GetCallingUid();
355     AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(uid, clientUserId_);
356     clientName_ = GetClientBundle(uid);
357 #ifdef MEMMGR_OVERRID
358     RequireMemory(Memory::CAMERA_START);
359 #endif
360     CameraReportUtils::GetInstance().SetOpenCamPerfStartInfo(cameraID_.c_str(), CameraReportUtils::GetCallerInfo());
361     errorCode = cameraHostManager_->OpenCameraDevice(cameraID_, this, hdiCameraDevice_, isEnableSecCam);
362     if (errorCode != CAMERA_OK) {
363         MEDIA_ERR_LOG("HCameraDevice::OpenDevice Failed to open camera");
364         HandlePrivacyWhenOpenDeviceFail();
365         return CAMERA_UNKNOWN_ERROR;
366     } else {
367         ResetHdiStreamId();
368         isOpenedCameraDevice_.store(true);
369         HCameraDeviceManager::GetInstance()->AddDevice(IPCSkeleton::GetCallingPid(), this);
370     }
371     errorCode = InitStreamOperator();
372     CHECK_ERROR_RETURN_RET_LOG(errorCode != CAMERA_OK, errorCode,
373         "HCameraDevice::OpenDevice InitStreamOperator fail err code is:%{public}d", errorCode);
374     std::lock_guard<std::mutex> lockSetting(opMutex_);
375     if (hdiCameraDevice_ != nullptr) {
376         cameraHostManager_->AddCameraDevice(cameraID_, this);
377         if (updateSettings_ != nullptr || deviceMuteMode_) {
378             if (deviceMuteMode_) {
379                 CreateMuteSetting(updateSettings_);
380             }
381             errorCode = UpdateDeviceSetting();
382             CHECK_AND_RETURN_RET(errorCode == CAMERA_OK, errorCode);
383             errorCode = HdiToServiceError((CamRetCode)(hdiCameraDevice_->SetResultMode(ON_CHANGED)));
384         }
385     }
386     HandleFoldableDevice();
387     POWERMGR_SYSEVENT_CAMERA_CONNECT(pid, uid, cameraID_.c_str(), clientName_);
388     NotifyCameraSessionStatus(true);
389     NotifyCameraStatus(CAMERA_OPEN);
390     MEDIA_INFO_LOG("HCameraDevice::OpenDevice end cameraId: %{public}s", cameraID_.c_str());
391     return errorCode;
392 }
393 
394 #ifdef MEMMGR_OVERRID
RequireMemory(const std::string & reason)395 int32_t HCameraDevice::RequireMemory(const std::string& reason)
396 {
397     int32_t pid = getpid();
398     int32_t requiredMemSizeKB = 0;
399     int32_t ret = Memory::MemMgrClient::GetInstance().RequireBigMem(pid, reason,
400         requiredMemSizeKB, clientName_);
401     MEDIA_INFO_LOG("HCameraDevice::RequireMemory reason:%{public}s, clientName:%{public}s, ret:%{public}d",
402         reason.c_str(), clientName_.c_str(), ret);
403     return ret;
404 }
405 #endif
406 
CheckPermissionBeforeOpenDevice()407 int32_t HCameraDevice::CheckPermissionBeforeOpenDevice()
408 {
409     MEDIA_DEBUG_LOG("enter checkPermissionBeforeOpenDevice");
410     if (IsHapTokenId(callerToken_)) {
411         auto cameraPrivacy = GetCameraPrivacy();
412         CHECK_ERROR_RETURN_RET_LOG(cameraPrivacy == nullptr, CAMERA_OPERATION_NOT_ALLOWED, "cameraPrivacy is null");
413         CHECK_ERROR_RETURN_RET_LOG(!cameraPrivacy->IsAllowUsingCamera(), CAMERA_OPERATION_NOT_ALLOWED,
414             "OpenDevice is not allowed!");
415     }
416     return CAMERA_OK;
417 }
418 
HandlePrivacyBeforeOpenDevice()419 bool HCameraDevice::HandlePrivacyBeforeOpenDevice()
420 {
421     MEDIA_INFO_LOG("enter HandlePrivacyBeforeOpenDevice");
422     CHECK_ERROR_RETURN_RET_LOG(!IsHapTokenId(callerToken_), true, "system ability called not need privacy");
423     auto cameraPrivacy = GetCameraPrivacy();
424     CHECK_ERROR_RETURN_RET_LOG(cameraPrivacy == nullptr, false, "cameraPrivacy is null");
425     CHECK_ERROR_RETURN_RET_LOG(!cameraPrivacy->StartUsingPermissionCallback(), false, "start using permission failed");
426     CHECK_ERROR_RETURN_RET_LOG(!cameraPrivacy->RegisterPermissionCallback(), false, "register permission failed");
427     CHECK_ERROR_RETURN_RET_LOG(!cameraPrivacy->AddCameraPermissionUsedRecord(), false, "add permission record failed");
428     return true;
429 }
430 
HandlePrivacyWhenOpenDeviceFail()431 void HCameraDevice::HandlePrivacyWhenOpenDeviceFail()
432 {
433     MEDIA_INFO_LOG("enter HandlePrivacyWhenOpenDeviceFail");
434     auto cameraPrivacy = GetCameraPrivacy();
435     if (cameraPrivacy != nullptr) {
436         cameraPrivacy->StopUsingPermissionCallback();
437         cameraPrivacy->UnregisterPermissionCallback();
438     }
439 }
440 
HandlePrivacyAfterCloseDevice()441 void HCameraDevice::HandlePrivacyAfterCloseDevice()
442 {
443     MEDIA_INFO_LOG("enter HandlePrivacyAfterCloseDevice");
444     auto cameraPrivacy = GetCameraPrivacy();
445     if (cameraPrivacy != nullptr) {
446         cameraPrivacy->StopUsingPermissionCallback();
447         cameraPrivacy->UnregisterPermissionCallback();
448     }
449 }
450 
UpdateDeviceSetting()451 int32_t HCameraDevice::UpdateDeviceSetting()
452 {
453     std::vector<uint8_t> setting;
454     OHOS::Camera::MetadataUtils::ConvertMetadataToVec(updateSettings_, setting);
455     ReportMetadataDebugLog(updateSettings_);
456     CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(setting));
457     CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
458         "HCameraDevice::OpenDevice Update setting failed with error Code: %{public}d", rc);
459     updateSettings_ = nullptr;
460     MEDIA_DEBUG_LOG("HCameraDevice::Open Updated device settings");
461     return CAMERA_OK;
462 }
463 
HandleFoldableDevice()464 void HCameraDevice::HandleFoldableDevice()
465 {
466     bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
467     MEDIA_DEBUG_LOG("HCameraDevice::OpenDevice isFoldable is %d", isFoldable);
468     if (isFoldable) {
469         RegisterFoldStatusListener();
470     }
471 }
472 
CloseDevice()473 int32_t HCameraDevice::CloseDevice()
474 {
475     MEDIA_DEBUG_LOG("HCameraDevice::CloseDevice start");
476     CAMERA_SYNC_TRACE;
477     {
478         std::lock_guard<std::mutex> lock(opMutex_);
479         CHECK_ERROR_RETURN_RET_LOG(!isOpenedCameraDevice_.load(), CAMERA_OK,
480             "HCameraDevice::CloseDevice device has benn closed");
481         bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
482         if (isFoldable) {
483             UnRegisterFoldStatusListener();
484         }
485         if (hdiCameraDevice_ != nullptr) {
486             isOpenedCameraDevice_.store(false);
487             MEDIA_INFO_LOG("Closing camera device: %{public}s start", cameraID_.c_str());
488             hdiCameraDevice_->Close();
489             ResetCachedSettings();
490             ResetDeviceOpenLifeCycleSettings();
491             HCameraDeviceManager::GetInstance()->RemoveDevice();
492             MEDIA_INFO_LOG("Closing camera device: %{public}s end", cameraID_.c_str());
493             hdiCameraDevice_ = nullptr;
494             HandlePrivacyAfterCloseDevice();
495         } else {
496             MEDIA_INFO_LOG("hdiCameraDevice is null");
497         }
498         if (streamOperator_) {
499             streamOperator_ = nullptr;
500         }
501         SetStreamOperatorCallback(nullptr);
502     }
503     if (cameraHostManager_) {
504         cameraHostManager_->RemoveCameraDevice(cameraID_);
505         cameraHostManager_->UpdateRestoreParamCloseTime(clientName_, cameraID_);
506     }
507     {
508         std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
509         deviceSvcCallback_ = nullptr;
510     }
511     POWERMGR_SYSEVENT_CAMERA_DISCONNECT(cameraID_.c_str());
512     MEDIA_DEBUG_LOG("HCameraDevice::CloseDevice end");
513     NotifyCameraSessionStatus(false);
514     NotifyCameraStatus(CAMERA_CLOSE);
515 #ifdef MEMMGR_OVERRID
516     RequireMemory(Memory::CAMERA_END);
517 #endif
518     return CAMERA_OK;
519 }
520 
Release()521 int32_t HCameraDevice::Release()
522 {
523     Close();
524     return CAMERA_OK;
525 }
526 
GetEnabledResults(std::vector<int32_t> & results)527 int32_t HCameraDevice::GetEnabledResults(std::vector<int32_t> &results)
528 {
529     std::lock_guard<std::mutex> lock(opMutex_);
530     CHECK_ERROR_RETURN_RET_LOG(!hdiCameraDevice_, CAMERA_UNKNOWN_ERROR,
531         "HCameraDevice::GetEnabledResults GetEnabledResults hdiCameraDevice_ is nullptr");
532     CamRetCode rc = (CamRetCode)(hdiCameraDevice_->GetEnabledResults(results));
533     CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
534         "HCameraDevice::GetEnabledResults failed with error Code:%{public}d", rc);
535     return CAMERA_OK;
536 }
537 
CheckZoomChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)538 void HCameraDevice::CheckZoomChange(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
539 {
540     int32_t ret;
541     camera_metadata_item_t item;
542     ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_PREPARE_ZOOM, &item);
543     if (ret == CAM_META_SUCCESS) {
544         if (item.data.u8[0] == OHOS_CAMERA_ZOOMSMOOTH_PREPARE_ENABLE) {
545             MEDIA_ERR_LOG("OHOS_CAMERA_ZOOMSMOOTH_PREPARE_ENABLE");
546             inPrepareZoom_ = true;
547             ResetZoomTimer();
548         } else if (item.data.u8[0] == OHOS_CAMERA_ZOOMSMOOTH_PREPARE_DISABLE) {
549             MEDIA_ERR_LOG("OHOS_CAMERA_ZOOMSMOOTH_PREPARE_DISABLE");
550             inPrepareZoom_ = false;
551             ResetZoomTimer();
552         }
553         return;
554     }
555     ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
556     if (ret != CAM_META_SUCCESS) {
557         ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_SMOOTH_ZOOM_RATIOS, &item);
558     }
559     if (ret == CAM_META_SUCCESS && inPrepareZoom_) {
560         ResetZoomTimer();
561     }
562     return;
563 }
564 
CheckMovingPhotoSupported(int32_t mode)565 bool HCameraDevice::CheckMovingPhotoSupported(int32_t mode)
566 {
567     std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
568     int32_t ret = cameraHostManager_->GetCameraAbility(cameraID_, cameraAbility);
569     CHECK_AND_RETURN_RET(cameraAbility != nullptr, false);
570     camera_metadata_item_t metadataItem;
571     std::vector<int32_t> modes = {};
572     ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(), OHOS_ABILITY_MOVING_PHOTO,
573         &metadataItem);
574     if (ret == CAM_META_SUCCESS && metadataItem.count > 0) {
575         uint32_t step = 3;
576         for (uint32_t index = 0; index < metadataItem.count - 1;) {
577             if (metadataItem.data.i32[index + 1] == 1) {
578                 modes.push_back(metadataItem.data.i32[index]);
579             }
580             MEDIA_DEBUG_LOG("IsMovingPhotoSupported mode:%{public}d", metadataItem.data.i32[index]);
581             index += step;
582         }
583     }
584     return std::find(modes.begin(), modes.end(), mode) != modes.end();
585 }
586 
ResetZoomTimer()587 void HCameraDevice::ResetZoomTimer()
588 {
589     CameraTimer::GetInstance().Unregister(zoomTimerId_);
590     if (!inPrepareZoom_) {
591         return;
592     }
593     MEDIA_INFO_LOG("register zoom timer callback");
594     uint32_t waitMs = 5 * 1000;
595     auto thisPtr = wptr<HCameraDevice>(this);
596     zoomTimerId_ = CameraTimer::GetInstance().Register([thisPtr]() {
597         auto devicePtr = thisPtr.promote();
598         if (devicePtr != nullptr) {
599             devicePtr->UnPrepareZoom();
600         }
601     }, waitMs, true);
602 }
603 
UnPrepareZoom()604 void HCameraDevice::UnPrepareZoom()
605 {
606     MEDIA_INFO_LOG("entered.");
607     std::lock_guard<std::mutex> lock(unPrepareZoomMutex_);
608     if (inPrepareZoom_) {
609         inPrepareZoom_ = false;
610         uint32_t count = 1;
611         uint32_t prepareZoomType = OHOS_CAMERA_ZOOMSMOOTH_PREPARE_DISABLE;
612         std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = std::make_shared<OHOS::Camera::CameraMetadata>(1, 1);
613         metadata->addEntry(OHOS_CONTROL_PREPARE_ZOOM, &prepareZoomType, count);
614         UpdateSetting(metadata);
615     }
616 }
617 
UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)618 int32_t HCameraDevice::UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
619 {
620     CAMERA_SYNC_TRACE;
621     MEDIA_INFO_LOG("HCameraDevice::UpdateSetting prepare execute");
622     CHECK_ERROR_RETURN_RET_LOG(settings == nullptr, CAMERA_INVALID_ARG, "settings is null");
623     CheckZoomChange(settings);
624 
625     uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(settings->get());
626     CHECK_ERROR_RETURN_RET_LOG(!count, CAMERA_OK, "Nothing to update");
627     std::lock_guard<std::mutex> lock(opMutex_);
628     if (updateSettings_ == nullptr || !CameraFwkMetadataUtils::MergeMetadata(settings, updateSettings_)) {
629         updateSettings_ = settings;
630     }
631     MEDIA_INFO_LOG("Updated device settings  hdiCameraDevice_(%{public}d)", hdiCameraDevice_ != nullptr);
632     if (hdiCameraDevice_ != nullptr) {
633         std::vector<uint8_t> hdiSettings;
634         OHOS::Camera::MetadataUtils::ConvertMetadataToVec(updateSettings_, hdiSettings);
635         ReportMetadataDebugLog(updateSettings_);
636         CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(hdiSettings));
637         CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
638             "Failed with error Code: %{public}d", rc);
639         UpdateDeviceOpenLifeCycleSettings(updateSettings_);
640         {
641             std::lock_guard<std::mutex> cachedLock(cachedSettingsMutex_);
642             CameraFwkMetadataUtils::MergeMetadata(settings, cachedSettings_);
643         }
644         updateSettings_ = nullptr;
645     }
646     MEDIA_INFO_LOG("HCameraDevice::UpdateSetting execute success");
647     return CAMERA_OK;
648 }
649 
SetUsedAsPosition(uint8_t value)650 int32_t HCameraDevice::SetUsedAsPosition(uint8_t value)
651 {
652     MEDIA_INFO_LOG("HCameraDevice::SetUsedAsPosition as %{public}d", value);
653     usedAsPosition_ = value;
654     // lockforControl
655     return CAMERA_OK;
656 }
657 
GetUsedAsPosition()658 uint8_t HCameraDevice::GetUsedAsPosition()
659 {
660     MEDIA_INFO_LOG("HCameraDevice::GetUsedAsPosition success");
661     return usedAsPosition_;
662 }
663 
UpdateSettingOnce(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)664 int32_t HCameraDevice::UpdateSettingOnce(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
665 {
666     CAMERA_SYNC_TRACE;
667     MEDIA_INFO_LOG("HCameraDevice::UpdateSettingOnce prepare execute");
668     CHECK_ERROR_RETURN_RET_LOG(settings == nullptr, CAMERA_INVALID_ARG, "settings is null");
669     CheckZoomChange(settings);
670 
671     uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(settings->get());
672     CHECK_ERROR_RETURN_RET_LOG(!count, CAMERA_OK, "Nothing to update");
673     std::lock_guard<std::mutex> lock(opMutex_);
674     MEDIA_INFO_LOG("Updated device settings once hdiCameraDevice_(%{public}d)", hdiCameraDevice_ != nullptr);
675     if (hdiCameraDevice_ != nullptr) {
676         std::vector<uint8_t> hdiSettings;
677         OHOS::Camera::MetadataUtils::ConvertMetadataToVec(settings, hdiSettings);
678         ReportMetadataDebugLog(settings);
679         CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(hdiSettings));
680         CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
681             "Failed with error Code: %{public}d", rc);
682     }
683     MEDIA_INFO_LOG("HCameraDevice::UpdateSettingOnce execute success");
684     return CAMERA_OK;
685 }
686 
GetStatus(std::shared_ptr<OHOS::Camera::CameraMetadata> & metaIn,std::shared_ptr<OHOS::Camera::CameraMetadata> & metaOut)687 int32_t HCameraDevice::GetStatus(std::shared_ptr<OHOS::Camera::CameraMetadata> &metaIn,
688     std::shared_ptr<OHOS::Camera::CameraMetadata> &metaOut)
689 {
690     CAMERA_SYNC_TRACE;
691     CHECK_ERROR_RETURN_RET_LOG(metaIn == nullptr, CAMERA_INVALID_ARG, "HCameraDevice::GetStatus metaIn is null");
692     uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(metaIn->get());
693     CHECK_ERROR_RETURN_RET_LOG(!count, CAMERA_OK, "HCameraDevice::GetStatus Nothing to query");
694 
695     sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
696     if (cameraHostManager_->GetVersionByCamera(cameraID_) >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) {
697         MEDIA_DEBUG_LOG("HCameraDevice::GetStatus ICameraDevice cast to V1_2");
698         hdiCameraDeviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
699         if (hdiCameraDeviceV1_2 == nullptr) {
700             MEDIA_ERR_LOG("HCameraDevice::GetStatus ICameraDevice cast to V1_2 error");
701             hdiCameraDeviceV1_2 = static_cast<OHOS::HDI::Camera::V1_2::ICameraDevice *>(hdiCameraDevice_.GetRefPtr());
702         }
703     }
704 
705     MEDIA_DEBUG_LOG("HCameraDevice::GetStatus hdiCameraDeviceV1_2(%{public}d)", hdiCameraDeviceV1_2 != nullptr);
706     if (hdiCameraDeviceV1_2 != nullptr) {
707         std::vector<uint8_t> hdiMetaIn;
708         std::vector<uint8_t> hdiMetaOut;
709         OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaIn, hdiMetaIn);
710         CamRetCode rc = (CamRetCode)(hdiCameraDeviceV1_2->GetStatus(hdiMetaIn, hdiMetaOut));
711         CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
712             "HCameraDevice::GetStatus Failed with error Code: %{public}d", rc);
713         if (hdiMetaOut.size() != 0) {
714             OHOS::Camera::MetadataUtils::ConvertVecToMetadata(hdiMetaOut, metaOut);
715         }
716     }
717     return CAMERA_OK;
718 }
719 
ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)720 void HCameraDevice::ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
721 {
722     caller_ = CameraReportUtils::GetCallerInfo();
723     for (const auto &tagInfo : reportTagInfos_) {
724         std::string tagName, dfxUbStr;
725         uint32_t tag;
726         std::tie(tag, tagName, dfxUbStr) = tagInfo;
727         DebugLogTag(settings, tag, tagName, dfxUbStr);
728     }
729 
730     DebugLogForSmoothZoom(settings, OHOS_CONTROL_SMOOTH_ZOOM_RATIOS);
731     DebugLogForAfRegions(settings, OHOS_CONTROL_AF_REGIONS);
732     DebugLogForAeRegions(settings, OHOS_CONTROL_AE_REGIONS);
733 }
734 
DebugLogTag(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag,std::string tagName,std::string dfxUbStr)735 void HCameraDevice::DebugLogTag(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings,
736                                 uint32_t tag, std::string tagName, std::string dfxUbStr)
737 {
738     camera_metadata_item_t item;
739     int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
740     if (ret != CAM_META_SUCCESS || item.count <= 0) {
741         MEDIA_DEBUG_LOG("Failed to find %{public}s tag", tagName.c_str());
742         return;
743     }
744     uint32_t dataType = item.data_type;
745     std::string valueStr;
746     if (dataType == META_TYPE_BYTE) {
747         valueStr = std::to_string(item.data.u8[0]);
748     } else if (dataType == META_TYPE_INT32) {
749         valueStr = std::to_string(item.data.i32[0]);
750     } else if (dataType == META_TYPE_UINT32) {
751         valueStr = std::to_string(item.data.ui32[0]);
752     } else if (dataType == META_TYPE_FLOAT) {
753         valueStr = std::to_string(item.data.f[0]);
754     } else if (dataType == META_TYPE_INT64) {
755         valueStr = std::to_string(item.data.i64[0]);
756     } else if (dataType == META_TYPE_DOUBLE) {
757         valueStr = std::to_string(item.data.d[0]);
758     } else {
759         MEDIA_ERR_LOG("unknown dataType");
760         return;
761     }
762     MEDIA_DEBUG_LOG("Find %{public}s value = %{public}s", tagName.c_str(), valueStr.c_str());
763 
764     if (dfxUbStr != DFX_UB_NOT_REPORT) {
765         CameraReportUtils::GetInstance().ReportUserBehavior(dfxUbStr, valueStr, caller_);
766     }
767 }
768 
DebugLogForSmoothZoom(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag)769 void HCameraDevice::DebugLogForSmoothZoom(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag)
770 {
771     // debug log for smooth zoom
772     camera_metadata_item_t item;
773     int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
774     if (ret != CAM_META_SUCCESS) {
775         MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_SMOOTH_ZOOM_RATIOS tag");
776     } else {
777         MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_SMOOTH_ZOOM_RATIOS count = %{public}d", item.count);
778         if (item.count > 1) {
779             uint32_t targetZoom = item.data.ui32[item.count - 2];
780             float zoomRatio = targetZoom / SMOOTH_ZOOM_DIVISOR;
781             MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_SMOOTH_ZOOM_RATIOS value = %{public}f", zoomRatio);
782             CameraReportUtils::GetInstance().ReportUserBehavior(DFX_UB_SET_SMOOTHZOOM,
783                 std::to_string(zoomRatio), caller_);
784         }
785     }
786 }
787 
DebugLogForAfRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag)788 void HCameraDevice::DebugLogForAfRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag)
789 {
790     // debug log for af regions
791     camera_metadata_item_t item;
792     int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
793     if (ret != CAM_META_SUCCESS) {
794         MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AF_REGIONS tag");
795     } else {
796         std::stringstream ss;
797         ss << "x=" << item.data.f[0] << " y=" << item.data.f[1];
798         std::string str = ss.str();
799         MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AF_REGIONS %{public}s", str.c_str());
800         CameraReportUtils::GetInstance().ReportUserBehavior(DFX_UB_SET_FOCUSPOINT, str, caller_);
801     }
802 }
803 
DebugLogForAeRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag)804 void HCameraDevice::DebugLogForAeRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag)
805 {
806     // debug log for ae regions
807     camera_metadata_item_t item;
808     int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
809     if (ret != CAM_META_SUCCESS) {
810         MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AE_REGIONS tag");
811     } else {
812         std::stringstream ss;
813         ss << "x=" << item.data.f[0] << " y=" << item.data.f[1];
814         std::string str = ss.str();
815         MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AE_REGIONS %{public}s", str.c_str());
816         CameraReportUtils::GetInstance().ReportUserBehavior(DFX_UB_SET_METERINGPOINT, str, caller_);
817     }
818 }
819 
RegisterFoldStatusListener()820 void HCameraDevice::RegisterFoldStatusListener()
821 {
822     listener = new FoldScreenListener(cameraHostManager_, cameraID_);
823     if (cameraHostManager_) {
824         int foldStatus = (int)OHOS::Rosen::DisplayManager::GetInstance().GetFoldStatus();
825         cameraHostManager_->NotifyDeviceStateChangeInfo(DeviceType::FOLD_TYPE, foldStatus);
826     }
827     auto ret = OHOS::Rosen::DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
828     if (ret != OHOS::Rosen::DMError::DM_OK) {
829         MEDIA_DEBUG_LOG("HCameraDevice::RegisterFoldStatusListener failed");
830         listener = nullptr;
831     } else {
832         MEDIA_DEBUG_LOG("HCameraDevice::RegisterFoldStatusListener success");
833     }
834 }
835 
UnRegisterFoldStatusListener()836 void HCameraDevice::UnRegisterFoldStatusListener()
837 {
838     if (listener == nullptr) {
839         MEDIA_ERR_LOG("HCameraDevice::unRegisterFoldStatusListener  listener is null");
840         return;
841     }
842     auto ret = OHOS::Rosen::DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
843     if (ret != OHOS::Rosen::DMError::DM_OK) {
844         MEDIA_DEBUG_LOG("HCameraDevice::UnRegisterFoldStatusListener failed");
845     }
846 }
847 
EnableResult(std::vector<int32_t> & results)848 int32_t HCameraDevice::EnableResult(std::vector<int32_t> &results)
849 {
850     CHECK_ERROR_RETURN_RET_LOG(results.empty(), CAMERA_INVALID_ARG, "HCameraDevice::EnableResult results is empty");
851     std::lock_guard<std::mutex> lock(opMutex_);
852     CHECK_ERROR_RETURN_RET_LOG(hdiCameraDevice_ == nullptr, CAMERA_UNKNOWN_ERROR,
853         "HCameraDevice::hdiCameraDevice_ is null");
854 
855     CamRetCode rc = (CamRetCode)(hdiCameraDevice_->EnableResult(results));
856     CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
857         "HCameraDevice::EnableResult failed with error Code:%{public}d", rc);
858     return CAMERA_OK;
859 }
860 
DisableResult(std::vector<int32_t> & results)861 int32_t HCameraDevice::DisableResult(std::vector<int32_t> &results)
862 {
863     CHECK_ERROR_RETURN_RET_LOG(results.empty(), CAMERA_INVALID_ARG, "HCameraDevice::DisableResult results is empty");
864     std::lock_guard<std::mutex> lock(opMutex_);
865     CHECK_ERROR_RETURN_RET_LOG(hdiCameraDevice_ == nullptr, CAMERA_UNKNOWN_ERROR,
866         "HCameraDevice::hdiCameraDevice_ is null");
867 
868     CamRetCode rc = (CamRetCode)(hdiCameraDevice_->DisableResult(results));
869     CHECK_ERROR_RETURN_RET_LOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
870         "HCameraDevice::DisableResult failed with error Code:%{public}d", rc);
871     return CAMERA_OK;
872 }
873 
SetCallback(sptr<ICameraDeviceServiceCallback> & callback)874 int32_t HCameraDevice::SetCallback(sptr<ICameraDeviceServiceCallback>& callback)
875 {
876     if (callback == nullptr) {
877         MEDIA_WARNING_LOG("HCameraDevice::SetCallback callback is null");
878     }
879     std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
880     deviceSvcCallback_ = callback;
881     return CAMERA_OK;
882 }
883 
GetDeviceServiceCallback()884 sptr<ICameraDeviceServiceCallback> HCameraDevice::GetDeviceServiceCallback()
885 {
886     std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
887     return deviceSvcCallback_;
888 }
889 
UpdateDeviceOpenLifeCycleSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> changedSettings)890 void HCameraDevice::UpdateDeviceOpenLifeCycleSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> changedSettings)
891 {
892     if (changedSettings == nullptr) {
893         return;
894     }
895     std::lock_guard<std::mutex> lock(deviceOpenLifeCycleMutex_);
896     for (auto itemTag : DEVICE_OPEN_LIFECYCLE_TAGS) {
897         camera_metadata_item_t item;
898         int32_t result = OHOS::Camera::FindCameraMetadataItem(changedSettings->get(), itemTag, &item);
899         if (result != CAM_META_SUCCESS) {
900             continue;
901         }
902         bool updateSuccess = CameraFwkMetadataUtils::UpdateMetadataTag(item, deviceOpenLifeCycleSettings_);
903         if (!updateSuccess) {
904             MEDIA_ERR_LOG("HCameraDevice::UpdateDeviceOpenLifeCycleSettings tag:%{public}d fail", itemTag);
905         } else {
906             MEDIA_INFO_LOG("HCameraDevice::UpdateDeviceOpenLifeCycleSettings tag:%{public}d success", itemTag);
907         }
908     }
909 }
910 
ResetDeviceOpenLifeCycleSettings()911 void HCameraDevice::ResetDeviceOpenLifeCycleSettings()
912 {
913     MEDIA_INFO_LOG("HCameraDevice::ResetDeviceOpenLifeCycleSettings");
914     std::lock_guard<std::mutex> lock(deviceOpenLifeCycleMutex_);
915     deviceOpenLifeCycleSettings_ =
916         std::make_shared<OHOS::Camera::CameraMetadata>(DEVICE_OPEN_LIFECYCLE_TAGS.size(), DEFAULT_SETTING_ITEM_LENGTH);
917 }
918 
InitStreamOperator()919 int32_t HCameraDevice::InitStreamOperator()
920 {
921     std::lock_guard<std::mutex> lock(opMutex_);
922     CHECK_ERROR_RETURN_RET_LOG(hdiCameraDevice_ == nullptr, CAMERA_UNKNOWN_ERROR,
923         "HCameraDevice::InitStreamOperator hdiCameraDevice_ is null");
924     CamRetCode rc;
925     sptr<OHOS::HDI::Camera::V1_1::ICameraDevice> hdiCameraDeviceV1_1;
926     sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
927     sptr<OHOS::HDI::Camera::V1_3::ICameraDevice> hdiCameraDeviceV1_3;
928     int32_t versionRes = cameraHostManager_->GetVersionByCamera(cameraID_);
929     if (versionRes >= GetVersionId(HDI_VERSION_1, HDI_VERSION_3)) {
930         MEDIA_DEBUG_LOG("HCameraDevice::InitStreamOperator ICameraDevice cast to V1_3");
931         hdiCameraDeviceV1_3 = OHOS::HDI::Camera::V1_3::ICameraDevice::CastFrom(hdiCameraDevice_);
932     } else if (versionRes >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) {
933         MEDIA_DEBUG_LOG("HCameraDevice::InitStreamOperator ICameraDevice cast to V1_2");
934         hdiCameraDeviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
935     } else if (versionRes == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) {
936         MEDIA_DEBUG_LOG("HCameraDevice::InitStreamOperator ICameraDevice cast to V1_1");
937         hdiCameraDeviceV1_1 = OHOS::HDI::Camera::V1_1::ICameraDevice::CastFrom(hdiCameraDevice_);
938         if (hdiCameraDeviceV1_1 == nullptr) {
939             MEDIA_ERR_LOG("HCameraDevice::InitStreamOperator ICameraDevice cast to V1_1 error");
940             hdiCameraDeviceV1_1 = static_cast<OHOS::HDI::Camera::V1_1::ICameraDevice*>(hdiCameraDevice_.GetRefPtr());
941         }
942     }
943 
944     if (hdiCameraDeviceV1_3 != nullptr && versionRes >= GetVersionId(HDI_VERSION_1, HDI_VERSION_3)) {
945         sptr<OHOS::HDI::Camera::V1_3::IStreamOperator> streamOperator_v1_3;
946         rc = (CamRetCode)(hdiCameraDeviceV1_3->GetStreamOperator_V1_3(this, streamOperator_v1_3));
947         streamOperator_ = streamOperator_v1_3;
948     } else if (hdiCameraDeviceV1_2 != nullptr && versionRes >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) {
949         MEDIA_DEBUG_LOG("HCameraDevice::InitStreamOperator ICameraDevice V1_2");
950         sptr<OHOS::HDI::Camera::V1_2::IStreamOperator> streamOperator_v1_2;
951         rc = (CamRetCode)(hdiCameraDeviceV1_2->GetStreamOperator_V1_2(this, streamOperator_v1_2));
952         streamOperator_ = streamOperator_v1_2;
953     } else if (hdiCameraDeviceV1_1 != nullptr && versionRes == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) {
954         MEDIA_DEBUG_LOG("HCameraDevice::InitStreamOperator ICameraDevice V1_1");
955         sptr<OHOS::HDI::Camera::V1_1::IStreamOperator> streamOperator_v1_1;
956         rc = (CamRetCode)(hdiCameraDeviceV1_1->GetStreamOperator_V1_1(this, streamOperator_v1_1));
957         streamOperator_ = streamOperator_v1_1;
958     } else {
959         MEDIA_DEBUG_LOG("HCameraDevice::InitStreamOperator ICameraDevice V1_0");
960         rc = (CamRetCode)(hdiCameraDevice_->GetStreamOperator(this, streamOperator_));
961     }
962     if (rc != HDI::Camera::V1_0::NO_ERROR) {
963         MEDIA_ERR_LOG("HCameraDevice::InitStreamOperator failed with error Code:%{public}d", rc);
964         CameraReportUtils::ReportCameraError(
965             "HCameraDevice::InitStreamOperator", rc, true, CameraReportUtils::GetCallerInfo());
966         streamOperator_ = nullptr;
967         return HdiToServiceError(rc);
968     }
969     return CAMERA_OK;
970 }
971 
ReleaseStreams(std::vector<int32_t> & releaseStreamIds)972 int32_t HCameraDevice::ReleaseStreams(std::vector<int32_t>& releaseStreamIds)
973 {
974     CAMERA_SYNC_TRACE;
975     std::lock_guard<std::mutex> lock(opMutex_);
976     if (streamOperator_ != nullptr && !releaseStreamIds.empty()) {
977         MEDIA_INFO_LOG("HCameraDevice::ReleaseStreams %{public}s",
978             Container2String(releaseStreamIds.begin(), releaseStreamIds.end()).c_str());
979         int32_t rc = streamOperator_->ReleaseStreams(releaseStreamIds);
980         if (rc != HDI::Camera::V1_0::NO_ERROR) {
981             MEDIA_ERR_LOG("HCameraDevice::ClearStreamOperator ReleaseStreams fail, error Code:%{public}d", rc);
982             CameraReportUtils::ReportCameraError(
983                 "HCameraDevice::ReleaseStreams", rc, true, CameraReportUtils::GetCallerInfo());
984         }
985     }
986     return CAMERA_OK;
987 }
988 
GetStreamOperator()989 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> HCameraDevice::GetStreamOperator()
990 {
991     std::lock_guard<std::mutex> lock(opMutex_);
992     return streamOperator_;
993 }
994 
OnError(const OHOS::HDI::Camera::V1_0::ErrorType type,const int32_t errorMsg)995 int32_t HCameraDevice::OnError(const OHOS::HDI::Camera::V1_0::ErrorType type, const int32_t errorMsg)
996 {
997     auto errType = static_cast<OHOS::HDI::Camera::V1_3::ErrorType>(type);
998     NotifyCameraStatus(HdiToCameraErrorType(errType));
999     auto callback = GetDeviceServiceCallback();
1000     if (callback != nullptr) {
1001         int32_t errorType;
1002         if (type == OHOS::HDI::Camera::V1_0::REQUEST_TIMEOUT) {
1003             errorType = CAMERA_DEVICE_REQUEST_TIMEOUT;
1004         } else if (type == OHOS::HDI::Camera::V1_0::DEVICE_PREEMPT) {
1005             errorType = CAMERA_DEVICE_PREEMPTED;
1006         } else if (type == DEVICE_DISCONNECT) {
1007             errorType = CAMERA_DEVICE_CLOSED;
1008         } else {
1009             errorType = CAMERA_UNKNOWN_ERROR;
1010         }
1011         callback->OnError(errorType, errorMsg);
1012         CAMERA_SYSEVENT_FAULT(CreateMsg("CameraDeviceServiceCallback::OnError() is called!, errorType: %d,"
1013                                         "errorMsg: %d",
1014             errorType, errorMsg));
1015     }
1016     return CAMERA_OK;
1017 }
1018 
CheckOnResultData(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)1019 void HCameraDevice::CheckOnResultData(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)
1020 {
1021     if (cameraResult == nullptr) {
1022         MEDIA_ERR_LOG("HCameraDevice::OnResult cameraResult is nullptr");
1023         return;
1024     }
1025     camera_metadata_item_t item;
1026     common_metadata_header_t* metadata = cameraResult->get();
1027     int ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASH_MODE, &item);
1028     if (ret == 0) {
1029         MEDIA_DEBUG_LOG("Flash mode: %{public}d", item.data.u8[0]);
1030     }
1031     ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASH_STATE, &item);
1032     if (ret == 0) {
1033         MEDIA_DEBUG_LOG("Flash state: %{public}d", item.data.u8[0]);
1034     }
1035     ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_MODE, &item);
1036     if (ret == CAM_META_SUCCESS) {
1037         MEDIA_DEBUG_LOG("Focus mode: %{public}d", item.data.u8[0]);
1038     }
1039     ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_QUALITY_PRIORITIZATION, &item);
1040     if (ret == CAM_META_SUCCESS) {
1041         MEDIA_DEBUG_LOG("quality prioritization: %{public}d", item.data.u8[0]);
1042     }
1043     ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_STATE, &item);
1044     if (ret == CAM_META_SUCCESS) {
1045         MEDIA_DEBUG_LOG("Focus state: %{public}d", item.data.u8[0]);
1046     }
1047     ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_STATISTICS_FACE_RECTANGLES, &item);
1048     if (ret != CAM_META_SUCCESS) {
1049         MEDIA_ERR_LOG("cannot find OHOS_STATISTICS_FACE_RECTANGLES: %{public}d", ret);
1050     }
1051     MEDIA_DEBUG_LOG("ProcessFaceRectangles: %{public}d count: %{public}d", item.item, item.count);
1052     constexpr int32_t rectangleUnitLen = 4;
1053 
1054     if (item.count % rectangleUnitLen) {
1055         MEDIA_DEBUG_LOG("Metadata item: %{public}d count: %{public}d is invalid", item.item, item.count);
1056     }
1057     const int32_t offsetX = 0;
1058     const int32_t offsetY = 1;
1059     const int32_t offsetW = 2;
1060     const int32_t offsetH = 3;
1061     float* start = item.data.f;
1062     float* end = item.data.f + item.count;
1063     for (; start < end; start += rectangleUnitLen) {
1064         MEDIA_DEBUG_LOG("Metadata item: %{public}f, %{public}f, %{public}f, %{public}f", start[offsetX], start[offsetY],
1065             start[offsetW], start[offsetH]);
1066     }
1067 }
1068 
OnResult(const uint64_t timestamp,const std::vector<uint8_t> & result)1069 int32_t HCameraDevice::OnResult(const uint64_t timestamp, const std::vector<uint8_t>& result)
1070 {
1071     CHECK_ERROR_RETURN_RET_LOG(result.size() == 0, CAMERA_INVALID_ARG, "onResult get null meta from HAL");
1072     std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult = nullptr;
1073     OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, cameraResult);
1074     if (cameraResult == nullptr) {
1075         cameraResult = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
1076     }
1077     if (IsCameraDebugOn()) {
1078         CameraFwkMetadataUtils::DumpMetadataInfo(cameraResult);
1079     }
1080     auto callback = GetDeviceServiceCallback();
1081     if (callback != nullptr) {
1082         callback->OnResult(timestamp, cameraResult);
1083     }
1084     if (IsCameraDebugOn()) {
1085         CheckOnResultData(cameraResult);
1086     }
1087     if (isMovingPhotoEnabled_) {
1088         GetMovingPhotoStartAndEndTime(cameraResult);
1089     }
1090     return CAMERA_OK;
1091 }
1092 
OnResult(int32_t streamId,const std::vector<uint8_t> & result)1093 int32_t HCameraDevice::OnResult(int32_t streamId, const std::vector<uint8_t>& result)
1094 {
1095     CHECK_ERROR_RETURN_RET_LOG(result.size() == 0, CAMERA_INVALID_ARG, "onResult get null meta from HAL");
1096     std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult = nullptr;
1097     OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, cameraResult);
1098     if (cameraResult == nullptr) {
1099         cameraResult = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
1100     }
1101     auto streamOperatorCallback = GetStreamOperatorCallback();
1102     if (streamOperatorCallback != nullptr) {
1103         streamOperatorCallback->OnResult(streamId, result);
1104     }
1105     if (IsCameraDebugOn()) {
1106         CheckOnResultData(cameraResult);
1107     }
1108     return CAMERA_OK;
1109 }
1110 
GetMovingPhotoStartAndEndTime(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)1111 void HCameraDevice::GetMovingPhotoStartAndEndTime(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)
1112 {
1113     MEDIA_DEBUG_LOG("HCameraDevice::GetMovingPhotoStartAndEndTime enter.");
1114     {
1115         std::lock_guard<std::mutex> lock(movingPhotoStartTimeCallbackLock_);
1116         if (movingPhotoStartTimeCallback_) {
1117             camera_metadata_item_t item;
1118             int ret = OHOS::Camera::FindCameraMetadataItem(cameraResult->get(), OHOS_MOVING_PHOTO_START, &item);
1119             if (ret == CAM_META_SUCCESS && item.count != 0) {
1120                 int64_t captureId = item.data.i64[0];
1121                 int64_t startTime = item.data.i64[1];
1122                 movingPhotoStartTimeCallback_(static_cast<int32_t>(captureId), startTime);
1123             }
1124         }
1125     }
1126     std::lock_guard<std::mutex> lock(movingPhotoEndTimeCallbackLock_);
1127     if (movingPhotoEndTimeCallback_) {
1128         camera_metadata_item_t item;
1129         int ret = OHOS::Camera::FindCameraMetadataItem(cameraResult->get(), OHOS_MOVING_PHOTO_END, &item);
1130         if (ret == CAM_META_SUCCESS && item.count != 0) {
1131             int64_t captureId = item.data.i64[0];
1132             int64_t endTime = item.data.i64[1];
1133             movingPhotoEndTimeCallback_(static_cast<int32_t>(captureId), endTime);
1134         }
1135     }
1136 }
1137 
SetMovingPhotoStartTimeCallback(std::function<void (int64_t,int64_t)> callback)1138 void HCameraDevice::SetMovingPhotoStartTimeCallback(std::function<void(int64_t, int64_t)> callback)
1139 {
1140     std::lock_guard<std::mutex> lock(movingPhotoStartTimeCallbackLock_);
1141     movingPhotoStartTimeCallback_ = callback;
1142 }
1143 
SetMovingPhotoEndTimeCallback(std::function<void (int64_t,int64_t)> callback)1144 void HCameraDevice::SetMovingPhotoEndTimeCallback(std::function<void(int64_t, int64_t)> callback)
1145 {
1146     std::lock_guard<std::mutex> lock(movingPhotoEndTimeCallbackLock_);
1147     movingPhotoEndTimeCallback_ = callback;
1148 }
1149 
GetCallerToken()1150 int32_t HCameraDevice::GetCallerToken()
1151 {
1152     return callerToken_;
1153 }
1154 
CreateStreams(std::vector<HDI::Camera::V1_1::StreamInfo_V1_1> & streamInfos)1155 int32_t HCameraDevice::CreateStreams(std::vector<HDI::Camera::V1_1::StreamInfo_V1_1>& streamInfos)
1156 {
1157     CamRetCode hdiRc = HDI::Camera::V1_0::NO_ERROR;
1158     uint32_t major;
1159     uint32_t minor;
1160     CHECK_ERROR_RETURN_RET_LOG(streamInfos.empty(), CAMERA_OK, "HCameraDevice::CreateStreams streamInfos is empty!");
1161     std::lock_guard<std::mutex> lock(opMutex_);
1162     sptr<OHOS::HDI::Camera::V1_1::IStreamOperator> streamOperatorV1_1;
1163     sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator = streamOperator_;
1164     CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr, CAMERA_UNKNOWN_ERROR,
1165         "HCameraDevice::CreateStreams GetStreamOperator is null!");
1166     // get higher streamOperator version
1167     streamOperator->GetVersion(major, minor);
1168     MEDIA_INFO_LOG("streamOperator GetVersion major:%{public}d, minor:%{public}d", major, minor);
1169     if (major >= HDI_VERSION_1 && minor >= HDI_VERSION_1) {
1170         streamOperatorV1_1 = OHOS::HDI::Camera::V1_1::IStreamOperator::CastFrom(streamOperator);
1171         if (streamOperatorV1_1 == nullptr) {
1172             MEDIA_ERR_LOG("HCameraDevice::CreateStreams IStreamOperator cast to V1_1 error");
1173             streamOperatorV1_1 = static_cast<OHOS::HDI::Camera::V1_1::IStreamOperator*>(streamOperator.GetRefPtr());
1174         }
1175     }
1176     if (streamOperatorV1_1 != nullptr) {
1177         MEDIA_INFO_LOG("HCameraDevice::CreateStreams streamOperator V1_1");
1178         for (auto streamInfo : streamInfos) {
1179             if (streamInfo.extendedStreamInfos.size() > 0) {
1180                 MEDIA_INFO_LOG("HCameraDevice::CreateStreams streamOperator V1_1 type %{public}d",
1181                     streamInfo.extendedStreamInfos[0].type);
1182             }
1183         }
1184         hdiRc = (CamRetCode)(streamOperatorV1_1->CreateStreams_V1_1(streamInfos));
1185     } else {
1186         MEDIA_INFO_LOG("HCameraDevice::CreateStreams streamOperator V1_0");
1187         std::vector<StreamInfo> streamInfos_V1_0;
1188         for (auto streamInfo : streamInfos) {
1189             streamInfos_V1_0.emplace_back(streamInfo.v1_0);
1190         }
1191         hdiRc = (CamRetCode)(streamOperator->CreateStreams(streamInfos_V1_0));
1192     }
1193     if (hdiRc != HDI::Camera::V1_0::NO_ERROR) {
1194         MEDIA_ERR_LOG("HCameraDevice::CreateStreams(), Failed to commit %{public}d", hdiRc);
1195         CameraReportUtils::ReportCameraError(
1196             "HCameraDevice::CreateStreams", hdiRc, true, CameraReportUtils::GetCallerInfo());
1197         std::vector<int32_t> streamIds;
1198         for (auto& streamInfo : streamInfos) {
1199             streamIds.emplace_back(streamInfo.v1_0.streamId_);
1200         }
1201         CHECK_ERROR_PRINT_LOG(!streamIds.empty() &&
1202             streamOperator->ReleaseStreams(streamIds) != HDI::Camera::V1_0::NO_ERROR,
1203             "HCameraDevice::CreateStreams(), Failed to release streams");
1204     }
1205     for (auto& info : streamInfos) {
1206         MEDIA_INFO_LOG("HCameraDevice::CreateStreams stream id is:%{public}d", info.v1_0.streamId_);
1207     }
1208     return HdiToServiceError(hdiRc);
1209 }
1210 
CommitStreams(std::shared_ptr<OHOS::Camera::CameraMetadata> & deviceSettings,int32_t operationMode)1211 int32_t HCameraDevice::CommitStreams(
1212     std::shared_ptr<OHOS::Camera::CameraMetadata>& deviceSettings, int32_t operationMode)
1213 {
1214     CamRetCode hdiRc = HDI::Camera::V1_0::NO_ERROR;
1215     uint32_t major;
1216     uint32_t minor;
1217     sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator;
1218     sptr<OHOS::HDI::Camera::V1_1::IStreamOperator> streamOperatorV1_1;
1219     std::lock_guard<std::mutex> lock(opMutex_);
1220     streamOperator = streamOperator_;
1221     CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr, CAMERA_UNKNOWN_ERROR,
1222         "HCameraDevice::CommitStreams GetStreamOperator is null!");
1223     // get higher streamOperator version
1224     streamOperator->GetVersion(major, minor);
1225     MEDIA_INFO_LOG(
1226         "HCameraDevice::CommitStreams streamOperator GetVersion major:%{public}d, minor:%{public}d", major, minor);
1227     if (major >= HDI_VERSION_1 && minor >= HDI_VERSION_1) {
1228         MEDIA_DEBUG_LOG("HCameraDevice::CommitStreams IStreamOperator cast to V1_1");
1229         streamOperatorV1_1 = OHOS::HDI::Camera::V1_1::IStreamOperator::CastFrom(streamOperator);
1230         if (streamOperatorV1_1 == nullptr) {
1231             MEDIA_ERR_LOG("HCameraDevice::CommitStreams IStreamOperator cast to V1_1 error");
1232             streamOperatorV1_1 = static_cast<OHOS::HDI::Camera::V1_1::IStreamOperator*>(streamOperator.GetRefPtr());
1233         }
1234     }
1235 
1236     std::vector<uint8_t> setting;
1237     OHOS::Camera::MetadataUtils::ConvertMetadataToVec(deviceSettings, setting);
1238     MEDIA_INFO_LOG("HCameraDevice::CommitStreams, commit mode %{public}d", operationMode);
1239     if (streamOperatorV1_1 != nullptr) {
1240         MEDIA_DEBUG_LOG("HCameraDevice::CommitStreams IStreamOperator V1_1");
1241         hdiRc = (CamRetCode)(streamOperatorV1_1->CommitStreams_V1_1(
1242             static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(operationMode), setting));
1243     } else {
1244         MEDIA_DEBUG_LOG("HCameraDevice::CommitStreams IStreamOperator V1_0");
1245         OperationMode opMode = OperationMode::NORMAL;
1246         hdiRc = (CamRetCode)(streamOperator->CommitStreams(opMode, setting));
1247     }
1248     if (hdiRc != HDI::Camera::V1_0::NO_ERROR) {
1249         MEDIA_ERR_LOG("HCameraDevice::CommitStreams failed with error Code:%d", hdiRc);
1250         CameraReportUtils::ReportCameraError(
1251             "HCameraDevice::CommitStreams", hdiRc, true, CameraReportUtils::GetCallerInfo());
1252     }
1253     MEDIA_DEBUG_LOG("HCameraDevice::CommitStreams end");
1254     return HdiToServiceError(hdiRc);
1255 }
1256 
CreateAndCommitStreams(std::vector<HDI::Camera::V1_1::StreamInfo_V1_1> & streamInfos,std::shared_ptr<OHOS::Camera::CameraMetadata> & deviceSettings,int32_t operationMode)1257 int32_t HCameraDevice::CreateAndCommitStreams(std::vector<HDI::Camera::V1_1::StreamInfo_V1_1>& streamInfos,
1258     std::shared_ptr<OHOS::Camera::CameraMetadata>& deviceSettings, int32_t operationMode)
1259 {
1260     int retCode = CreateStreams(streamInfos);
1261     CHECK_AND_RETURN_RET(retCode == CAMERA_OK, retCode);
1262     return CommitStreams(deviceSettings, operationMode);
1263 }
1264 
CanOpenCamera()1265 bool HCameraDevice::CanOpenCamera()
1266 {
1267     sptr<HCameraDevice> cameraNeedEvict;
1268     bool ret = HCameraDeviceManager::GetInstance()->GetConflictDevices(cameraNeedEvict, this);
1269     if (cameraNeedEvict != nullptr) {
1270         MEDIA_DEBUG_LOG("HCameraDevice::CanOpenCamera open current device need to close other devices");
1271         cameraNeedEvict->OnError(DEVICE_PREEMPT, 0);
1272         cameraNeedEvict->CloseDevice();
1273     }
1274     return ret;
1275 }
1276 
UpdateStreams(std::vector<StreamInfo_V1_1> & streamInfos)1277 int32_t HCameraDevice::UpdateStreams(std::vector<StreamInfo_V1_1>& streamInfos)
1278 {
1279     sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator;
1280     sptr<OHOS::HDI::Camera::V1_2::IStreamOperator> streamOperatorV1_2;
1281     streamOperator = GetStreamOperator();
1282     CHECK_ERROR_RETURN_RET_LOG(streamOperator == nullptr, CAMERA_UNKNOWN_ERROR,
1283         "HCameraDevice::UpdateStreamInfos GetStreamOperator is null!");
1284     uint32_t major;
1285     uint32_t minor;
1286     streamOperator->GetVersion(major, minor);
1287     MEDIA_INFO_LOG("UpdateStreamInfos: streamOperator GetVersion major:%{public}d, minor:%{public}d", major, minor);
1288     if (major >= HDI_VERSION_1 && minor >= HDI_VERSION_2) {
1289         streamOperatorV1_2 = OHOS::HDI::Camera::V1_2::IStreamOperator::CastFrom(streamOperator);
1290         if (streamOperatorV1_2 == nullptr) {
1291             MEDIA_ERR_LOG("HCaptureSession::UpdateStreamInfos IStreamOperator cast to V1_2 error");
1292             streamOperatorV1_2 = static_cast<OHOS::HDI::Camera::V1_2::IStreamOperator*>(streamOperator.GetRefPtr());
1293         }
1294     }
1295     CamRetCode hdiRc = HDI::Camera::V1_0::CamRetCode::NO_ERROR;
1296     if (streamOperatorV1_2 != nullptr) {
1297         MEDIA_DEBUG_LOG("HCaptureSession::UpdateStreamInfos streamOperator V1_2");
1298         hdiRc = (CamRetCode)(streamOperatorV1_2->UpdateStreams(streamInfos));
1299     } else {
1300         MEDIA_DEBUG_LOG("HCaptureSession::UpdateStreamInfos failed, streamOperator V1_2 is null.");
1301         return CAMERA_UNKNOWN_ERROR;
1302     }
1303     return HdiToServiceError(hdiRc);
1304 }
1305 
OperatePermissionCheck(uint32_t interfaceCode)1306 int32_t HCameraDevice::OperatePermissionCheck(uint32_t interfaceCode)
1307 {
1308     uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
1309     int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
1310     if (errCode != CAMERA_OK) {
1311         return errCode;
1312     }
1313     switch (static_cast<CameraDeviceInterfaceCode>(interfaceCode)) {
1314         case CameraDeviceInterfaceCode::CAMERA_DEVICE_OPEN:
1315         case CameraDeviceInterfaceCode::CAMERA_DEVICE_CLOSE:
1316         case CameraDeviceInterfaceCode::CAMERA_DEVICE_RELEASE:
1317         case CameraDeviceInterfaceCode::CAMERA_DEVICE_SET_CALLBACK:
1318         case CameraDeviceInterfaceCode::CAMERA_DEVICE_UPDATE_SETTNGS:
1319         case CameraDeviceInterfaceCode::CAMERA_DEVICE_SET_USED_POS:
1320         case CameraDeviceInterfaceCode::CAMERA_DEVICE_GET_ENABLED_RESULT:
1321         case CameraDeviceInterfaceCode::CAMERA_DEVICE_ENABLED_RESULT:
1322         case CameraDeviceInterfaceCode::CAMERA_DEVICE_DISABLED_RESULT: {
1323             if (callerToken_ != callerToken) {
1324                 MEDIA_ERR_LOG("HCameraDevice::OperatePermissionCheck fail, callerToken not legal");
1325                 return CAMERA_OPERATION_NOT_ALLOWED;
1326             }
1327             break;
1328         }
1329         default:
1330             break;
1331     }
1332     return CAMERA_OK;
1333 }
1334 
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamIds)1335 int32_t HCameraDevice::OnCaptureStarted(int32_t captureId, const std::vector<int32_t>& streamIds)
1336 {
1337     auto streamOperatorCallback = GetStreamOperatorCallback();
1338     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1339     return streamOperatorCallback->OnCaptureStarted(captureId, streamIds);
1340 }
1341 
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<OHOS::HDI::Camera::V1_2::CaptureStartedInfo> & infos)1342 int32_t HCameraDevice::OnCaptureStarted_V1_2(
1343     int32_t captureId, const std::vector<OHOS::HDI::Camera::V1_2::CaptureStartedInfo>& infos)
1344 {
1345     auto streamOperatorCallback = GetStreamOperatorCallback();
1346     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1347     return streamOperatorCallback->OnCaptureStarted_V1_2(captureId, infos);
1348 }
1349 
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)1350 int32_t HCameraDevice::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo>& infos)
1351 {
1352     auto streamOperatorCallback = GetStreamOperatorCallback();
1353     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1354     return streamOperatorCallback->OnCaptureEnded(captureId, infos);
1355 }
1356 
OnCaptureEndedExt(int32_t captureId,const std::vector<OHOS::HDI::Camera::V1_3::CaptureEndedInfoExt> & infos)1357 int32_t HCameraDevice::OnCaptureEndedExt(int32_t captureId,
1358     const std::vector<OHOS::HDI::Camera::V1_3::CaptureEndedInfoExt>& infos)
1359 {
1360     auto streamOperatorCallback = GetStreamOperatorCallback();
1361     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1362     return streamOperatorCallback->OnCaptureEndedExt(captureId, infos);
1363 }
1364 
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)1365 int32_t HCameraDevice::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo>& infos)
1366 {
1367     auto streamOperatorCallback = GetStreamOperatorCallback();
1368     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1369     return streamOperatorCallback->OnCaptureError(captureId, infos);
1370 }
1371 
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)1372 int32_t HCameraDevice::OnFrameShutter(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp)
1373 {
1374     auto streamOperatorCallback = GetStreamOperatorCallback();
1375     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1376     return streamOperatorCallback->OnFrameShutter(captureId, streamIds, timestamp);
1377 }
1378 
OnFrameShutterEnd(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)1379 int32_t HCameraDevice::OnFrameShutterEnd(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp)
1380 {
1381     auto streamOperatorCallback = GetStreamOperatorCallback();
1382     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1383     return streamOperatorCallback->OnFrameShutterEnd(captureId, streamIds, timestamp);
1384 }
1385 
OnCaptureReady(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)1386 int32_t HCameraDevice::OnCaptureReady(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp)
1387 {
1388     auto streamOperatorCallback = GetStreamOperatorCallback();
1389     CHECK_AND_RETURN_RET(streamOperatorCallback != nullptr, CAMERA_INVALID_STATE);
1390     return streamOperatorCallback->OnCaptureReady(captureId, streamIds, timestamp);
1391 }
1392 
NotifyCameraSessionStatus(bool running)1393 void HCameraDevice::NotifyCameraSessionStatus(bool running)
1394 {
1395     bool isSystemCamera = (clientName_ == SYSTEM_CAMERA);
1396     DeferredProcessing::DeferredProcessingService::GetInstance().NotifyCameraSessionStatus(clientUserId_, cameraID_,
1397         running, isSystemCamera);
1398     return;
1399 }
1400 
RemoveResourceWhenHostDied()1401 void HCameraDevice::RemoveResourceWhenHostDied()
1402 {
1403     MEDIA_DEBUG_LOG("HCameraDevice::RemoveResourceWhenHostDied start");
1404     CAMERA_SYNC_TRACE;
1405     bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
1406     if (isFoldable) {
1407         UnRegisterFoldStatusListener();
1408     }
1409     HCameraDeviceManager::GetInstance()->RemoveDevice();
1410     if (cameraHostManager_) {
1411         cameraHostManager_->RemoveCameraDevice(cameraID_);
1412         cameraHostManager_->UpdateRestoreParamCloseTime(clientName_, cameraID_);
1413     }
1414     POWERMGR_SYSEVENT_CAMERA_DISCONNECT(cameraID_.c_str());
1415     NotifyCameraSessionStatus(false);
1416     NotifyCameraStatus(CAMERA_CLOSE);
1417     HandlePrivacyAfterCloseDevice();
1418 #ifdef MEMMGR_OVERRID
1419     RequireMemory(Memory::CAMERA_END);
1420 #endif
1421     MEDIA_DEBUG_LOG("HCameraDevice::RemoveResourceWhenHostDied end");
1422 }
1423 
NotifyCameraStatus(int32_t state)1424 void HCameraDevice::NotifyCameraStatus(int32_t state)
1425 {
1426     OHOS::AAFwk::Want want;
1427     MEDIA_DEBUG_LOG("HCameraDevice::NotifyCameraStatus strat");
1428     want.SetAction(COMMON_EVENT_CAMERA_STATUS);
1429     want.SetParam(CLIENT_USER_ID, clientUserId_);
1430     want.SetParam(CAMERA_ID, cameraID_);
1431     want.SetParam(CAMERA_STATE, state);
1432     int32_t type = GetCameraType();
1433     want.SetParam(IS_SYSTEM_CAMERA, type);
1434     MEDIA_DEBUG_LOG(
1435         "OnCameraStatusChanged userId: %{public}d, cameraId: %{public}s, state: %{public}d, cameraType: %{public}d: ",
1436         clientUserId_, cameraID_.c_str(), state, type);
1437     EventFwk::CommonEventData CommonEventData { want };
1438     EventFwk::CommonEventPublishInfo publishInfo;
1439     std::vector<std::string> permissionVec { OHOS_PERMISSION_MANAGE_CAMERA_CONFIG };
1440     publishInfo.SetSubscriberPermissions(permissionVec);
1441     EventFwk::CommonEventManager::PublishCommonEvent(CommonEventData, publishInfo);
1442     MEDIA_DEBUG_LOG("HCameraDevice::NotifyCameraStatus end");
1443 }
1444 } // namespace CameraStandard
1445 } // namespace OHOS
1446