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 <nlohmann/json.hpp>
22 #include <vector>
23 #include <parameters.h>
24 #include <parameter.h>
25
26 #include "camera_common_event_manager.h"
27 #include "camera_device_ability_items.h"
28 #include "camera_log.h"
29 #include "camera_fwk_metadata_utils.h"
30 #include "camera_metadata_info.h"
31 #include "camera_metadata_operator.h"
32 #include "camera_util.h"
33 #include "device_protection_ability_connection.h"
34 #include "display_manager.h"
35 #include "extension_manager_client.h"
36 #include "hcamera_device_manager.h"
37 #include "ipc_skeleton.h"
38 #include "ipc_types.h"
39 #ifdef MEMMGR_OVERRID
40 #include "mem_mgr_client.h"
41 #include "mem_mgr_constant.h"
42 #endif
43 #include "metadata_utils.h"
44 #include "v1_0/types.h"
45 #include "os_account_manager.h"
46 #include "deferred_processing_service.h"
47 #include "camera_timer.h"
48 #include "camera_report_uitls.h"
49 #include "common_event_manager.h"
50 #include "common_event_data.h"
51 #include "want.h"
52 #include "parameters.h"
53 #include "res_type.h"
54 #include "res_sched_client.h"
55 #include "camera_xcollie.h"
56 #ifdef HOOK_CAMERA_OPERATOR
57 #include "camera_rotate_plugin.h"
58 #endif
59 #include "camera_dialog_manager.h"
60
61 namespace OHOS {
62 namespace CameraStandard {
63 using namespace OHOS::HDI::Camera::V1_0;
64 std::mutex HCameraDevice::g_deviceOpenCloseMutex_;
65 static const int32_t DEFAULT_SETTING_ITEM_COUNT = 100;
66 static const int32_t DEFAULT_SETTING_ITEM_LENGTH = 100;
67 static const int32_t CAMERA_QOS_LEVEL = 7;
68 static const float SMOOTH_ZOOM_DIVISOR = 100.0f;
69 static const std::vector<camera_device_metadata_tag> DEVICE_OPEN_LIFECYCLE_TAGS = { OHOS_CONTROL_MUTE_MODE };
70 constexpr int32_t DEFAULT_USER_ID = -1;
71 static const uint32_t DEVICE_EJECT_LIMIT = 5;
72 static const uint32_t DEVICE_EJECT_INTERVAL = 1000;
73 static const uint32_t SYSDIALOG_ZORDER_UPPER = 2;
74 static const uint32_t DEVICE_DROP_INTERVAL = 600000;
75 static std::mutex g_cameraHostManagerMutex;
76 static sptr<HCameraHostManager> g_cameraHostManager = nullptr;
77 static int64_t g_lastDeviceDropTime = 0;
78 CallerInfo caller_;
79 constexpr int32_t BASE_DEGREE = 360;
80
81 const std::vector<std::tuple<uint32_t, std::string, DFX_UB_NAME>> HCameraDevice::reportTagInfos_ = {
82 {OHOS_CONTROL_FLASH_MODE, "OHOS_CONTROL_FLASH_MODE", DFX_UB_SET_FLASHMODE},
83 {OHOS_CONTROL_FOCUS_MODE, "OHOS_CONTROL_FOCUS_MODE", DFX_UB_SET_FOCUSMODE},
84 {OHOS_CONTROL_QUALITY_PRIORITIZATION, "OHOS_CONTROL_QUALITY_PRIORITIZATION", DFX_UB_SET_QUALITY_PRIORITIZATION},
85 {OHOS_CONTROL_EXPOSURE_MODE, "OHOS_CONTROL_EXPOSURE_MODE", DFX_UB_SET_EXPOSUREMODE},
86 {OHOS_CONTROL_VIDEO_STABILIZATION_MODE, "OHOS_CONTROL_VIDEO_STABILIZATION_MODE", DFX_UB_SET_VIDEOSTABILIZATIONMODE},
87 {OHOS_CONTROL_FILTER_TYPE, "OHOS_CONTROL_FILTER_TYPE", DFX_UB_SET_FILTER},
88 {OHOS_CONTROL_PORTRAIT_EFFECT_TYPE, "OHOS_CONTROL_PORTRAIT_EFFECT_TYPE", DFX_UB_SET_PORTRAITEFFECT},
89 {OHOS_CONTROL_BEAUTY_AUTO_VALUE, "OHOS_CONTROL_BEAUTY_AUTO_VALUE", DFX_UB_SET_BEAUTY_AUTOVALUE},
90 {OHOS_CONTROL_BEAUTY_SKIN_SMOOTH_VALUE, "OHOS_CONTROL_BEAUTY_SKIN_SMOOTH_VALUE", DFX_UB_SET_BEAUTY_SKINSMOOTH},
91 {OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE, "OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE", DFX_UB_SET_BEAUTY_FACESLENDER},
92 {OHOS_CONTROL_BEAUTY_SKIN_TONE_VALUE, "OHOS_CONTROL_BEAUTY_SKIN_TONE_VALUE", DFX_UB_SET_BEAUTY_SKINTONE},
93 {OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, "OHOS_CONTROL_AE_EXPOSURE_COMPENSATION", DFX_UB_SET_EXPOSUREBIAS},
94 {OHOS_CONTROL_FPS_RANGES, "OHOS_CONTROL_FPS_RANGES", DFX_UB_SET_FRAMERATERANGE},
95 {OHOS_CONTROL_ZOOM_RATIO, "OHOS_CONTROL_ZOOM_RATIO", DFX_UB_SET_ZOOMRATIO},
96 {OHOS_CONTROL_BEAUTY_TYPE, "OHOS_CONTROL_BEAUTY_TYPE", DFX_UB_NOT_REPORT},
97 {OHOS_CONTROL_LIGHT_PAINTING_TYPE, "OHOS_CONTROL_LIGHT_PAINTING_TYPE", DFX_UB_NOT_REPORT},
98 {OHOS_CONTROL_LIGHT_PAINTING_FLASH, "OHOS_CONTROL_LIGHT_PAINTING_FLASH", DFX_UB_NOT_REPORT},
99 {OHOS_CONTROL_MANUAL_EXPOSURE_TIME, "OHOS_CONTROL_MANUAL_EXPOSURE_TIME", DFX_UB_NOT_REPORT},
100 {OHOS_CONTROL_CAMERA_USED_AS_POSITION, "OHOS_CONTROL_CAMERA_USED_AS_POSITION", DFX_UB_NOT_REPORT},
101 {OHOS_CONTROL_CHANGETO_OFFLINE_STREAM_OPEATOR, "OHOS_CONTROL_CHANGETO_OFFLINE_STREAM_OPEATOR", DFX_UB_NOT_REPORT},
102 {OHOS_CONTROL_ROTATE_ANGLE, "OHOS_CONTROL_ROTATE_ANGLE", DFX_UB_NOT_REPORT},
103 };
104
105 const std::unordered_map<DeviceProtectionStatus, CamServiceError> g_deviceProtectionToServiceError_ = {
106 {OHOS_DEVICE_SWITCH_FREQUENT, CAMERA_DEVICE_SWITCH_FREQUENT},
107 {OHOS_DEVICE_FALL_PROTECTION, CAMERA_DEVICE_LENS_RETRACTED}
108 };
109
110 const std::unordered_map<DeviceProtectionStatus, DeviceProtectionAbilityCallBack> g_deviceProtectionToCallBack_ = {
111 {OHOS_DEVICE_EXTERNAL_PRESS, HCameraDevice::DeviceFaultCallBack},
112 {OHOS_DEVICE_EJECT_BLOCK, HCameraDevice::DeviceEjectCallBack}
113 };
114
115 class HCameraDevice::FoldScreenListener : public OHOS::Rosen::DisplayManager::IFoldStatusListener {
116 public:
FoldScreenListener(sptr<HCameraDevice> cameraDevice,sptr<HCameraHostManager> & cameraHostManager,const std::string cameraId)117 explicit FoldScreenListener(sptr<HCameraDevice> cameraDevice, sptr<HCameraHostManager> &cameraHostManager,
118 const std::string cameraId)
119 : cameraDevice_(cameraDevice), cameraHostManager_(cameraHostManager), cameraId_(cameraId)
120 {
121 MEDIA_DEBUG_LOG("FoldScreenListener enter, cameraID: %{public}s", cameraId_.c_str());
122 }
123
124 virtual ~FoldScreenListener() = default;
125 using FoldStatusRosen = OHOS::Rosen::FoldStatus;
OnFoldStatusChanged(FoldStatusRosen foldStatus)126 void OnFoldStatusChanged(FoldStatusRosen foldStatus) override
127 {
128 FoldStatusRosen currentFoldStatus = foldStatus;
129 CHECK_EXECUTE(currentFoldStatus == FoldStatusRosen::HALF_FOLD, currentFoldStatus = FoldStatusRosen::EXPAND);
130 CHECK_RETURN_DLOG(
131 (cameraHostManager_ == nullptr || mLastFoldStatus == currentFoldStatus || cameraDevice_ == nullptr),
132 "no need set fold status");
133 OHOS::Rosen::FoldDisplayMode displayMode = OHOS::Rosen::DisplayManager::GetInstance().GetFoldDisplayMode();
134 auto foldScreenType = system::GetParameter("const.window.foldscreen.type", "");
135 int32_t position = cameraDevice_->GetCameraPosition();
136 MEDIA_INFO_LOG("OnFoldStatusChanged %{public}s, %{public}d, %{public}d, %{public}d,",
137 foldScreenType.c_str(), position, mLastFoldStatus, currentFoldStatus);
138 if (foldScreenType[0] == '6' && position == OHOS_CAMERA_POSITION_FRONT &&
139 currentFoldStatus == FoldStatusRosen::EXPAND) {
140 MEDIA_DEBUG_LOG("HCameraDevice::OnFoldStatusChanged dialog start");
141 NoFrontCameraDialog::GetInstance()->ShowCameraDialog();
142 }
143 bool exeUpdate = foldStatus == FoldStatusRosen::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND ||
144 mLastFoldStatus == FoldStatusRosen::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND;
145 if (exeUpdate) {
146 std::vector<int32_t> fpsRanges;
147 bool isRestDegree = (mLastFoldStatus == FoldStatusRosen::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
148 cameraDevice_->UpdateCameraRotateAngleAndZoom(fpsRanges, isRestDegree);
149 }
150 mLastFoldStatus = currentFoldStatus;
151 MEDIA_INFO_LOG("OnFoldStatusChanged, foldStatus: %{public}d displayMode: %{public}d ", foldStatus, displayMode);
152 cameraHostManager_->NotifyDeviceStateChangeInfo(DeviceType::FOLD_TYPE, (int)currentFoldStatus);
153 }
154 private:
155 sptr<HCameraDevice> cameraDevice_;
156 sptr<HCameraHostManager> cameraHostManager_;
157 std::string cameraId_;
158 FoldStatusRosen mLastFoldStatus = FoldStatusRosen::UNKNOWN;
159 };
160
HCameraDevice(sptr<HCameraHostManager> & cameraHostManager,std::string cameraID,const uint32_t callingTokenId)161 HCameraDevice::HCameraDevice(
162 sptr<HCameraHostManager>& cameraHostManager, std::string cameraID, const uint32_t callingTokenId)
163 : cachedSettings_(
164 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_SETTING_ITEM_COUNT, DEFAULT_SETTING_ITEM_LENGTH)),
165 cameraHostManager_(cameraHostManager), cameraID_(cameraID), callerToken_(callingTokenId),
166 deviceOpenLifeCycleSettings_(std::make_shared<OHOS::Camera::CameraMetadata>(
167 DEVICE_OPEN_LIFECYCLE_TAGS.size(), DEFAULT_SETTING_ITEM_LENGTH)), clientUserId_(0), zoomTimerId_(0),
168 deviceMuteMode_(false), isHasOpenSecure(false)
169 {
170 MEDIA_INFO_LOG("HCameraDevice::HCameraDevice Contructor Camera: %{public}s", cameraID.c_str());
171 isOpenedCameraDevice_.store(false);
172 sptr<CameraPrivacy> cameraPrivacy = new CameraPrivacy(callingTokenId, IPCSkeleton::GetCallingPid());
173 SetCameraPrivacy(cameraPrivacy);
174 cameraPid_ = IPCSkeleton::GetCallingPid();
175
176 {
177 std::lock_guard<std::mutex> lock(g_cameraHostManagerMutex);
178 g_cameraHostManager = cameraHostManager;
179 }
180 }
181
~HCameraDevice()182 HCameraDevice::~HCameraDevice()
183 {
184 UnPrepareZoom();
185 CameraTimer::GetInstance().Unregister(zoomTimerId_);
186 SetCameraPrivacy(nullptr);
187 {
188 std::lock_guard<std::mutex> lock(movingPhotoStartTimeCallbackLock_);
189 movingPhotoStartTimeCallback_ = nullptr;
190 }
191 {
192 std::lock_guard<std::mutex> lock(movingPhotoEndTimeCallbackLock_);
193 movingPhotoEndTimeCallback_ = nullptr;
194 }
195 MEDIA_INFO_LOG("HCameraDevice::~HCameraDevice Destructor Camera: %{public}s", cameraID_.c_str());
196 }
197
GetCameraId()198 std::string HCameraDevice::GetCameraId()
199 {
200 return cameraID_;
201 }
202
GetCameraType()203 int32_t HCameraDevice::GetCameraType()
204 {
205 CHECK_RETURN_RET(clientName_ == SYSTEM_CAMERA, SYSTEM);
206 return OTHER;
207 }
208
GetCameraConnectType()209 int32_t HCameraDevice::GetCameraConnectType()
210 {
211 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = GetDeviceAbility();
212 CHECK_RETURN_RET(ability == nullptr, 0);
213 camera_metadata_item_t item;
214 int32_t ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
215 uint32_t connectionType = 0;
216 if (ret == CAM_META_SUCCESS && item.count > 0) {
217 connectionType = static_cast<uint32_t>(item.data.u8[0]);
218 }
219 return connectionType;
220 }
221
GetClientName()222 std::string HCameraDevice::GetClientName()
223 {
224 return clientName_;
225 }
226
GetCameraPosition()227 int32_t HCameraDevice::GetCameraPosition()
228 {
229 camera_metadata_item_t item;
230 auto ability = GetDeviceAbility();
231 CHECK_RETURN_RET_ELOG(ability == nullptr, 0,
232 "HCameraDevice::GetCameraPosition deviceAbility_ is nullptr");
233 int ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_POSITION, &item);
234 CHECK_RETURN_RET_ELOG(
235 ret != CAM_META_SUCCESS || item.count <= 0, 0, "HCameraDevice::GetCameraPosition failed");
236 return static_cast<int32_t>(item.data.u8[0]);
237 }
238
GetSensorOrientation()239 int32_t HCameraDevice::GetSensorOrientation()
240 {
241 camera_metadata_item_t item;
242 auto ability = GetDeviceAbility();
243 CHECK_RETURN_RET_ELOG(ability == nullptr, 0,
244 "HCameraDevice::GetSensorOrientation deviceAbility_ is nullptr");
245 int ret = OHOS::Camera::FindCameraMetadataItem(deviceAbility_->get(), OHOS_SENSOR_ORIENTATION, &item);
246 CHECK_RETURN_RET_ELOG(
247 ret != CAM_META_SUCCESS || item.count <= 0, 0, "HCameraDevice::GetSensorOrientation failed");
248 return item.data.i32[0];
249 }
250
IsOpenedCameraDevice()251 bool HCameraDevice::IsOpenedCameraDevice()
252 {
253 return isOpenedCameraDevice_.load();
254 }
255
SetDeviceMuteMode(bool muteMode)256 void HCameraDevice::SetDeviceMuteMode(bool muteMode)
257 {
258 deviceMuteMode_ = muteMode;
259 }
260
GetDeviceMuteMode()261 bool HCameraDevice::GetDeviceMuteMode()
262 {
263 return deviceMuteMode_;
264 }
265
GetZoomRatio()266 float HCameraDevice::GetZoomRatio()
267 {
268 return zoomRatio_;
269 }
270
GetFocusMode()271 int32_t HCameraDevice::GetFocusMode()
272 {
273 return focusMode_;
274 }
275
GetVideoStabilizationMode()276 int32_t HCameraDevice::GetVideoStabilizationMode()
277 {
278 return videoStabilizationMode_;
279 }
280
EnableMovingPhoto(bool isMovingPhotoEnabled)281 void HCameraDevice::EnableMovingPhoto(bool isMovingPhotoEnabled)
282 {
283 isMovingPhotoEnabled_ = isMovingPhotoEnabled;
284 }
285
CreateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)286 void HCameraDevice::CreateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
287 {
288 constexpr int32_t DEFAULT_ITEMS = 1;
289 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
290 int32_t count = 1;
291 uint8_t mode = OHOS_CAMERA_MUTE_MODE_SOLID_COLOR_BLACK;
292 settings = std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
293 settings->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
294 }
295
ResetDeviceSettings()296 int32_t HCameraDevice::ResetDeviceSettings()
297 {
298 CAMERA_SYNC_TRACE;
299 sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
300 MEDIA_INFO_LOG("HCameraDevice::ResetDeviceSettings enter");
301 {
302 std::lock_guard<std::mutex> lock(opMutex_);
303 CHECK_RETURN_RET(hdiCameraDevice_ == nullptr, CAMERA_OK);
304 hdiCameraDeviceV1_2 = HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
305 }
306 if (hdiCameraDeviceV1_2 != nullptr) {
307 int32_t errCode = hdiCameraDeviceV1_2->Reset();
308 CHECK_RETURN_RET_ELOG(errCode != HDI::Camera::V1_0::CamRetCode::NO_ERROR, CAMERA_UNKNOWN_ERROR,
309 "HCameraDevice::ResetDeviceSettings occur error");
310 ResetCachedSettings();
311 if (deviceMuteMode_) {
312 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = nullptr;
313 CreateMuteSetting(settings);
314 UpdateSetting(settings);
315 }
316 }
317 MEDIA_INFO_LOG("HCameraDevice::ResetDeviceSettings end");
318 return CAMERA_OK;
319 }
320
DispatchDefaultSettingToHdi()321 int32_t HCameraDevice::DispatchDefaultSettingToHdi()
322 {
323 CAMERA_SYNC_TRACE;
324 MEDIA_INFO_LOG("HCameraDevice::DispatchDefaultSettingToHdi enter");
325
326 std::shared_ptr<OHOS::Camera::CameraMetadata> lifeCycleSettings;
327 {
328 std::lock_guard<std::mutex> lifeLock(deviceOpenLifeCycleMutex_);
329 if (deviceOpenLifeCycleSettings_->get()->item_count == 0) {
330 MEDIA_INFO_LOG("HCameraDevice::DispatchDefaultSettingToHdi skip, data is empty");
331 return CAMERA_OK;
332 }
333 lifeCycleSettings = CameraFwkMetadataUtils::CopyMetadata(deviceOpenLifeCycleSettings_);
334 }
335
336 if (IsCameraDebugOn()) {
337 auto metadataHeader = lifeCycleSettings->get();
338 for (uint32_t index = 0; index < metadataHeader->item_count; index++) {
339 camera_metadata_item_t item;
340 int32_t result = OHOS::Camera::GetCameraMetadataItem(metadataHeader, index, &item);
341 if (result == CAM_META_SUCCESS) {
342 MEDIA_INFO_LOG("HCameraDevice::DispatchDefaultSettingToHdi tag:%{public}d", item.item);
343 } else {
344 MEDIA_ERR_LOG(
345 "HCameraDevice::DispatchDefaultSettingToHdi tag:%{public}d error:%{public}d", item.item, result);
346 }
347 }
348 }
349
350 std::lock_guard<std::mutex> lock(opMutex_);
351 CHECK_RETURN_RET(hdiCameraDevice_ == nullptr, CAMERA_INVALID_STATE);
352 std::vector<uint8_t> hdiMetadata;
353 bool isSuccess = OHOS::Camera::MetadataUtils::ConvertMetadataToVec(lifeCycleSettings, hdiMetadata);
354 CHECK_RETURN_RET_ELOG(!isSuccess, CAMERA_UNKNOWN_ERROR,
355 "HCameraDevice::DispatchDefaultSettingToHdi metadata ConvertMetadataToVec fail");
356 ReportMetadataDebugLog(lifeCycleSettings);
357 CamRetCode rc = (CamRetCode)hdiCameraDevice_->UpdateSettings(hdiMetadata);
358 if (rc != HDI::Camera::V1_0::NO_ERROR) {
359 MEDIA_ERR_LOG("HCameraDevice::DispatchDefaultSettingToHdi UpdateSettings error: %{public}d", rc);
360 CameraReportUtils::ReportCameraError(
361 "HCameraDevice::DispatchDefaultSettingToHdi", rc, true, CameraReportUtils::GetCallerInfo());
362 return HdiToServiceError(rc);
363 }
364 return CAMERA_OK;
365 }
366
ResetCachedSettings()367 void HCameraDevice::ResetCachedSettings()
368 {
369 std::lock_guard<std::mutex> cachedLock(cachedSettingsMutex_);
370 cachedSettings_ =
371 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_SETTING_ITEM_COUNT, DEFAULT_SETTING_ITEM_LENGTH);
372 }
373
CloneCachedSettings()374 std::shared_ptr<OHOS::Camera::CameraMetadata> HCameraDevice::CloneCachedSettings()
375 {
376 std::lock_guard<std::mutex> cachedLock(cachedSettingsMutex_);
377 return CameraFwkMetadataUtils::CopyMetadata(cachedSettings_);
378 }
379
GetDeviceAbility()380 std::shared_ptr<OHOS::Camera::CameraMetadata> HCameraDevice::GetDeviceAbility()
381 {
382 CAMERA_SYNC_TRACE;
383 std::lock_guard<std::mutex> lock(deviceAbilityMutex_);
384 CHECK_RETURN_RET(deviceAbility_ != nullptr, deviceAbility_);
385 int32_t errCode = cameraHostManager_->GetCameraAbility(cameraID_, deviceAbility_);
386 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, nullptr,
387 "HCameraDevice::GetSettings Failed to get Camera Ability: %{public}d", errCode);
388 return deviceAbility_;
389 }
390
Open()391 int32_t HCameraDevice::Open()
392 {
393 CAMERA_SYNC_TRACE;
394 CameraXCollie cameraXCollie("HandleOpenSecureCameraResults");
395 std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
396 CHECK_PRINT_ELOG(isOpenedCameraDevice_.load(), "HCameraDevice::Open failed, camera is busy");
397 CHECK_RETURN_RET_ELOG(!IsInForeGround(callerToken_), CAMERA_ALLOC_ERROR,
398 "HCameraDevice::Open IsAllowedUsingPermission failed");
399 MEDIA_INFO_LOG("HCameraDevice::Open Camera:[%{public}s]", cameraID_.c_str());
400 int32_t result = OpenDevice();
401 int32_t position = GetCameraPosition();
402 auto foldStatus = OHOS::Rosen::DisplayManager::GetInstance().GetFoldStatus();
403 auto foldScreenType = system::GetParameter("const.window.foldscreen.type", "");
404 MEDIA_INFO_LOG("HCameraDevice::Open %{public}d, %{public}d", position, foldStatus);
405 if (foldScreenType[0] == '6' && position == OHOS_CAMERA_POSITION_FRONT &&
406 foldStatus == OHOS::Rosen::FoldStatus::EXPAND) {
407 MEDIA_DEBUG_LOG("HCameraDevice::Open dialog start");
408 NoFrontCameraDialog::GetInstance()->ShowCameraDialog();
409 }
410 return result;
411 }
412
OpenSecureCamera(uint64_t & secureSeqId)413 int32_t HCameraDevice::OpenSecureCamera(uint64_t& secureSeqId)
414 {
415 CAMERA_SYNC_TRACE;
416 CameraXCollie cameraXCollie("HandleOpenSecureCameraResults");
417 CHECK_PRINT_ELOG(isOpenedCameraDevice_.load(), "HCameraDevice::Open failed, camera is busy");
418 CHECK_RETURN_RET_ELOG(!IsInForeGround(callerToken_), CAMERA_ALLOC_ERROR,
419 "HCameraDevice::Open IsAllowedUsingPermission failed");
420 MEDIA_INFO_LOG("HCameraDevice::OpenSecureCamera Camera:[%{public}s]", cameraID_.c_str());
421 int32_t errCode = OpenDevice(true);
422 CHECK_RETURN_RET_ELOG(hdiCameraDevice_ == nullptr, CAMERA_INVALID_ARG,
423 "HCameraDevice::OpenSecureCamera hdiCameraDevice_ is nullptr.");
424 auto hdiCameraDeviceV1_3 = HDI::Camera::V1_3::ICameraDevice::CastFrom(hdiCameraDevice_);
425 // LCOV_EXCL_START
426 if (hdiCameraDeviceV1_3 != nullptr) {
427 errCode = hdiCameraDeviceV1_3->GetSecureCameraSeq(secureSeqId);
428 CHECK_RETURN_RET_ELOG(errCode != HDI::Camera::V1_0::CamRetCode::NO_ERROR, CAMERA_UNKNOWN_ERROR,
429 "HCameraDevice::GetSecureCameraSeq occur error");
430 mSecureCameraSeqId = secureSeqId;
431 isHasOpenSecure = true;
432 } else {
433 MEDIA_INFO_LOG("V1_3::ICameraDevice::CastFrom failed");
434 }
435 // LCOV_EXCL_STOP
436 MEDIA_INFO_LOG("HCameraDevice::OpenSecureCamera secureSeqId = %{public}" PRIu64, secureSeqId);
437 return errCode;
438 }
439
GetSecureCameraSeq(uint64_t * secureSeqId)440 int64_t HCameraDevice::GetSecureCameraSeq(uint64_t* secureSeqId)
441 {
442 // LCOV_EXCL_START
443 if (!isHasOpenSecure) {
444 *secureSeqId = 0;
445 return CAMERA_OK;
446 }
447 auto hdiCameraDeviceV1_3 = HDI::Camera::V1_3::ICameraDevice::CastFrom(hdiCameraDevice_);
448 if (hdiCameraDeviceV1_3 != nullptr) {
449 *secureSeqId = mSecureCameraSeqId;
450 MEDIA_DEBUG_LOG("CaptureSession::GetSecureCameraSeq secureSeqId = %{public}" PRId64, *secureSeqId);
451 return CAMERA_UNKNOWN_ERROR;
452 } else {
453 MEDIA_INFO_LOG("V1_3::ICameraDevice::CastFrom failed");
454 }
455 // LCOV_EXCL_STOP
456 return CAMERA_OK;
457 }
458
Close()459 int32_t HCameraDevice::Close()
460 {
461 CAMERA_SYNC_TRACE;
462 CameraXCollie cameraXCollie("HCameraDeviceStub::Close");
463 std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
464 MEDIA_INFO_LOG("HCameraDevice::Close Closing camera device: %{public}s", cameraID_.c_str());
465 int32_t result = CloseDevice();
466 return result;
467 }
468
closeDelayed()469 int32_t HCameraDevice::closeDelayed()
470 {
471 CAMERA_SYNC_TRACE;
472 CameraXCollie cameraXCollie("HCameraDeviceStub::delayedClose");
473 CHECK_RETURN_RET_ELOG(
474 !CheckSystemApp(), CAMERA_NO_PERMISSION, "HCameraDevice::closeDelayed:SystemApi is called");
475 std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
476 MEDIA_INFO_LOG("HCameraDevice::closeDelayed Closing camera device: %{public}s", cameraID_.c_str());
477 int32_t result = closeDelayedDevice();
478 return result;
479 }
480
ConfigQosParam(const char * bundleName,int32_t qosLevel,std::unordered_map<std::string,std::string> & qosParamMap)481 void HCameraDevice::ConfigQosParam(const char *bundleName, int32_t qosLevel,
482 std::unordered_map<std::string, std::string> &qosParamMap)
483 {
484 std::string strBundleName = bundleName;
485 std::string strPid = std::to_string(getpid());
486 std::string strTid = std::to_string(gettid());
487 std::string strQos = std::to_string(qosLevel);
488
489 qosParamMap["pid"] = strPid;
490 qosParamMap[strTid] = strQos;
491 qosParamMap["bundleName"] = strBundleName;
492 MEDIA_INFO_LOG("camera service qosParam: pid: %{public}s. tid: %{public}s, qos: %{public}s",
493 strPid.c_str(), strTid.c_str(), strQos.c_str());
494 }
495
CameraHostMgrOpenCamera(bool isEnableSecCam)496 int32_t HCameraDevice::CameraHostMgrOpenCamera(bool isEnableSecCam)
497 {
498 CameraReportUtils::GetInstance().SetOpenCamPerfStartInfo(cameraID_.c_str(), CameraReportUtils::GetCallerInfo());
499 int32_t errorCode = cameraHostManager_->OpenCameraDevice(cameraID_, this, hdiCameraDevice_, isEnableSecCam);
500 if (errorCode != CAMERA_OK) {
501 MEDIA_ERR_LOG("HCameraDevice::OpenDevice Failed to open camera");
502 #ifdef MEMMGR_OVERRID
503 RequireMemory(Memory::CAMERA_END);
504 #endif
505 HandlePrivacyWhenOpenDeviceFail();
506 return CAMERA_UNKNOWN_ERROR;
507 } else {
508 isOpenedCameraDevice_.store(true);
509 HCameraDeviceManager::GetInstance()->AddDevice(IPCSkeleton::GetCallingPid(), this);
510 g_lastDeviceDropTime = 0;
511 RegisterSensorCallback();
512 return CAMERA_OK;
513 }
514 }
515
OpenDevice(bool isEnableSecCam)516 int32_t HCameraDevice::OpenDevice(bool isEnableSecCam)
517 {
518 std::unordered_map<std::string, std::string> qosParamMap;
519 ConfigQosParam("camera_service", CAMERA_QOS_LEVEL, qosParamMap);
520 OHOS::ResourceSchedule::ResSchedClient::GetInstance().ReportData(
521 OHOS::ResourceSchedule::ResType::RES_TYPE_THREAD_QOS_CHANGE, 0, qosParamMap);
522
523 MEDIA_INFO_LOG("HCameraDevice::OpenDevice start cameraId: %{public}s", cameraID_.c_str());
524 CAMERA_SYNC_TRACE;
525 int32_t errorCode = CheckPermissionBeforeOpenDevice();
526 CHECK_RETURN_RET(errorCode != CAMERA_OK, errorCode);
527 bool canOpenDevice = CanOpenCamera();
528 CHECK_RETURN_RET_ELOG(!canOpenDevice, CAMERA_DEVICE_CONFLICT, "HCameraDevice::Refuse to turn on the camera");
529 CHECK_RETURN_RET_ELOG(!HandlePrivacyBeforeOpenDevice(), CAMERA_OPERATION_NOT_ALLOWED, "privacy not allow!");
530 int pid = IPCSkeleton::GetCallingPid();
531 int uid = IPCSkeleton::GetCallingUid();
532 AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(uid, clientUserId_);
533 int tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
534 clientName_ = GetClientNameByToken(tokenId);
535 cameraPrivacy_->SetClientName(clientName_);
536 #ifdef MEMMGR_OVERRID
537 RequireMemory(Memory::CAMERA_START);
538 #endif
539 errorCode = CameraHostMgrOpenCamera(isEnableSecCam);
540 CHECK_RETURN_RET_ELOG(errorCode != CAMERA_OK, errorCode,
541 "HCameraDevice::OpenDevice InitStreamOperator fail err code is:%{public}d", errorCode);
542 std::lock_guard<std::mutex> lockSetting(opMutex_);
543 if (hdiCameraDevice_ != nullptr) {
544 cameraHostManager_->AddCameraDevice(cameraID_, this);
545 if (updateSettings_ != nullptr || deviceMuteMode_) {
546 CHECK_EXECUTE(deviceMuteMode_, CreateMuteSetting(updateSettings_));
547 errorCode = UpdateDeviceSetting();
548 CHECK_RETURN_RET(errorCode != CAMERA_OK, errorCode);
549 errorCode = HdiToServiceError((CamRetCode)(hdiCameraDevice_->SetResultMode(ON_CHANGED)));
550 }
551 }
552 HandleFoldableDevice();
553 POWERMGR_SYSEVENT_CAMERA_CONNECT(pid, uid, cameraID_.c_str(), clientName_);
554 NotifyCameraStatus(CAMERA_OPEN);
555 #ifdef HOOK_CAMERA_OPERATOR
556 if (!CameraRotatePlugin::GetInstance()->HookOpenDeviceForRotate(clientName_, GetDeviceAbility(), cameraID_)) {
557 MEDIA_ERR_LOG("HCameraDevice::OpenDevice HookOpenDevice is failed");
558 }
559 #endif
560 MEDIA_INFO_LOG("HCameraDevice::OpenDevice end cameraId: %{public}s", cameraID_.c_str());
561 return errorCode;
562 }
563
564 #ifdef MEMMGR_OVERRID
RequireMemory(const std::string & reason)565 int32_t HCameraDevice::RequireMemory(const std::string& reason)
566 {
567 int32_t pid = getpid();
568 int32_t requiredMemSizeKB = 0;
569 int32_t ret = Memory::MemMgrClient::GetInstance().RequireBigMem(pid, reason,
570 requiredMemSizeKB, clientName_);
571 MEDIA_INFO_LOG("HCameraDevice::RequireMemory reason:%{public}s, clientName:%{public}s, ret:%{public}d",
572 reason.c_str(), clientName_.c_str(), ret);
573 return ret;
574 }
575 #endif
576
CheckPermissionBeforeOpenDevice()577 int32_t HCameraDevice::CheckPermissionBeforeOpenDevice()
578 {
579 MEDIA_DEBUG_LOG("enter checkPermissionBeforeOpenDevice");
580 if (IsHapTokenId(callerToken_)) {
581 auto cameraPrivacy = GetCameraPrivacy();
582 CHECK_RETURN_RET_ELOG(cameraPrivacy == nullptr, CAMERA_OPERATION_NOT_ALLOWED, "cameraPrivacy is null");
583 CHECK_RETURN_RET_ELOG(!cameraPrivacy->IsAllowUsingCamera(), CAMERA_OPERATION_NOT_ALLOWED,
584 "OpenDevice is not allowed!");
585 }
586 return CAMERA_OK;
587 }
588
HandlePrivacyBeforeOpenDevice()589 bool HCameraDevice::HandlePrivacyBeforeOpenDevice()
590 {
591 MEDIA_INFO_LOG("enter HandlePrivacyBeforeOpenDevice");
592 CHECK_RETURN_RET_ELOG(!IsHapTokenId(callerToken_), true, "system ability called not need privacy");
593 std::vector<sptr<HCameraDeviceHolder>> holders =
594 HCameraDeviceManager::GetInstance()->GetCameraHolderByPid(cameraPid_);
595 CHECK_RETURN_RET_ELOG(!holders.empty(), true, "current pid has active clients, no action is required");
596 auto cameraPrivacy = GetCameraPrivacy();
597 CHECK_RETURN_RET_ELOG(cameraPrivacy == nullptr, false, "cameraPrivacy is null");
598 if (HCameraDeviceManager::GetInstance()->IsMultiCameraActive(cameraPid_) == false) {
599 MEDIA_INFO_LOG("do StartUsingPermissionCallback");
600 CHECK_RETURN_RET_ELOG(!cameraPrivacy->StartUsingPermissionCallback(), false,
601 "start using permission failed");
602 }
603 CHECK_RETURN_RET_ELOG(!cameraPrivacy->RegisterPermissionCallback(), false, "register permission failed");
604 CHECK_RETURN_RET_ELOG(!cameraPrivacy->AddCameraPermissionUsedRecord(), false, "add permission record failed");
605 return true;
606 }
607
HandlePrivacyWhenOpenDeviceFail()608 void HCameraDevice::HandlePrivacyWhenOpenDeviceFail()
609 {
610 MEDIA_INFO_LOG("enter HandlePrivacyWhenOpenDeviceFail");
611 auto cameraPrivacy = GetCameraPrivacy();
612 CHECK_RETURN(cameraPrivacy == nullptr);
613 if (HCameraDeviceManager::GetInstance()->IsMultiCameraActive(cameraPid_) == false) {
614 MEDIA_INFO_LOG("do StopUsingPermissionCallback");
615 cameraPrivacy->StopUsingPermissionCallback();
616 }
617 cameraPrivacy->UnregisterPermissionCallback();
618 }
619
HandlePrivacyAfterCloseDevice()620 void HCameraDevice::HandlePrivacyAfterCloseDevice()
621 {
622 MEDIA_INFO_LOG("enter HandlePrivacyAfterCloseDevice");
623 std::vector<sptr<HCameraDeviceHolder>> holders =
624 HCameraDeviceManager::GetInstance()->GetCameraHolderByPid(cameraPid_);
625 CHECK_PRINT_ELOG(!holders.empty(), "current pid has active clients, no action is required");
626 auto cameraPrivacy = GetCameraPrivacy();
627 if (cameraPrivacy != nullptr) {
628 if (HCameraDeviceManager::GetInstance()->IsMultiCameraActive(cameraPid_) == false) {
629 MEDIA_INFO_LOG("do StopUsingPermissionCallback");
630 cameraPrivacy->StopUsingPermissionCallback();
631 }
632 cameraPrivacy->UnregisterPermissionCallback();
633 }
634 }
635
UpdateDeviceSetting()636 int32_t HCameraDevice::UpdateDeviceSetting()
637 {
638 std::vector<uint8_t> setting;
639 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(updateSettings_, setting);
640 ReportMetadataDebugLog(updateSettings_);
641 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(setting));
642 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
643 "HCameraDevice::OpenDevice Update setting failed with error Code: %{public}d", rc);
644 updateSettings_ = nullptr;
645 MEDIA_DEBUG_LOG("HCameraDevice::Open Updated device settings");
646 return CAMERA_OK;
647 }
648
ReportDeviceProtectionStatus(const std::shared_ptr<OHOS::Camera::CameraMetadata> & metadata)649 void HCameraDevice::ReportDeviceProtectionStatus(const std::shared_ptr<OHOS::Camera::CameraMetadata> &metadata)
650 {
651 CHECK_RETURN_ELOG(metadata == nullptr, "metadata is null");
652 camera_metadata_item_t item;
653 int ret = OHOS::Camera::FindCameraMetadataItem(metadata->get(), OHOS_DEVICE_PROTECTION_STATE, &item);
654 CHECK_RETURN(ret != CAM_META_SUCCESS || item.count == 0);
655 int32_t status = item.data.i32[0];
656 MEDIA_INFO_LOG("HCameraDevice::ReportDeviceProtectionStatus status: %{public}d", status);
657 CHECK_RETURN(!CanReportDeviceProtectionStatus(status));
658 if (clientName_ == SYSTEM_CAMERA) {
659 auto callback = GetDeviceServiceCallback();
660 auto itr = g_deviceProtectionToServiceError_.find(static_cast<DeviceProtectionStatus>(status));
661 if (itr != g_deviceProtectionToServiceError_.end()) {
662 callback->OnError(itr->second, 0);
663 }
664 }
665 if (CameraCommonEventManager::GetInstance()->IsScreenLocked()) {
666 return;
667 }
668 ShowDeviceProtectionDialog(static_cast<DeviceProtectionStatus>(status));
669 }
670
CanReportDeviceProtectionStatus(int32_t status)671 bool HCameraDevice::CanReportDeviceProtectionStatus(int32_t status)
672 {
673 std::lock_guard<std::mutex> lock(deviceProtectionStatusMutex_);
674 bool ret = (status != lastDeviceProtectionStatus_);
675 lastDeviceProtectionStatus_ = status;
676 return ret;
677 }
678
DeviceEjectCallBack()679 void HCameraDevice::DeviceEjectCallBack()
680 {
681 MEDIA_INFO_LOG("HCameraDevice::DeviceEjectCallBack enter");
682 uint8_t value = 1;
683 uint32_t count = 1;
684 constexpr int32_t DEFAULT_ITEMS = 1;
685 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
686 std::shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata =
687 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
688 bool status = changedMetadata->addEntry(OHOS_CONTROL_EJECT_RETRY, &value, count);
689 CHECK_RETURN_ELOG(!status, "HCameraDevice::DropDetectionCallback Failed to set fall protection");
690
691 std::vector<sptr<HCameraDeviceHolder>> deviceHolderVector =
692 HCameraDeviceManager::GetInstance()->GetActiveCameraHolders();
693 for (sptr<HCameraDeviceHolder> activeDeviceHolder : deviceHolderVector) {
694 sptr<HCameraDevice> activeDevice = activeDeviceHolder->GetDevice();
695 if (activeDevice != nullptr && activeDevice->IsOpenedCameraDevice()) {
696 activeDevice->lastDeviceEjectTime_ = GetTimestamp();
697 activeDevice->UpdateSetting(changedMetadata);
698 MEDIA_INFO_LOG("HCameraService::DeviceEjectCallBack UpdateSetting");
699 }
700 }
701 }
702
DeviceFaultCallBack()703 void HCameraDevice::DeviceFaultCallBack()
704 {
705 MEDIA_INFO_LOG("HCameraDevice::DeviceFaultCallBack enter");
706 }
707
ShowDeviceProtectionDialog(DeviceProtectionStatus status)708 bool HCameraDevice::ShowDeviceProtectionDialog(DeviceProtectionStatus status)
709 {
710 if (status == OHOS_DEVICE_EJECT_BLOCK) {
711 int64_t timestamp = GetTimestamp();
712 if (timestamp - lastDeviceEjectTime_ < DEVICE_EJECT_INTERVAL) {
713 deviceEjectTimes_.operator++();
714 } else {
715 deviceEjectTimes_.store(0);
716 }
717 if (deviceEjectTimes_ >= DEVICE_EJECT_LIMIT) {
718 status = OHOS_DEVICE_EXTERNAL_PRESS;
719 deviceEjectTimes_.store(0);
720 }
721 }
722
723 AAFwk::Want want;
724 std::string bundleName = "com.ohos.sceneboard";
725 std::string abilityName = "com.ohos.sceneboard.systemdialog";
726 want.SetElementName(bundleName, abilityName);
727
728 const int32_t code = 4;
729 std::string commandStr = BuildDeviceProtectionDialogCommand(status);
730 auto itr = g_deviceProtectionToCallBack_.find(static_cast<DeviceProtectionStatus>(status));
731 CHECK_RETURN_RET(itr == g_deviceProtectionToCallBack_.end(), false);
732 DeviceProtectionAbilityCallBack callback = itr->second;
733
734 sptr<DeviceProtectionAbilityConnection> connection = sptr<DeviceProtectionAbilityConnection> (new (std::nothrow)
735 DeviceProtectionAbilityConnection(commandStr, code, callback));
736 CHECK_RETURN_RET_ELOG(connection == nullptr, false, "connection is nullptr");
737 std::string identity = IPCSkeleton::ResetCallingIdentity();
738 auto connectResult = AAFwk::ExtensionManagerClient::GetInstance().ConnectServiceExtensionAbility(want,
739 connection, nullptr, DEFAULT_USER_ID);
740 IPCSkeleton::SetCallingIdentity(identity);
741 CHECK_RETURN_RET_ELOG(connectResult != 0, false, "ConnectServiceExtensionAbility Failed!");
742 return true;
743 }
744
BuildDeviceProtectionDialogCommand(DeviceProtectionStatus status)745 std::string HCameraDevice::BuildDeviceProtectionDialogCommand(DeviceProtectionStatus status)
746 {
747 nlohmann::json extraInfo;
748 switch (static_cast<int32_t>(status)) {
749 // 按压受阻
750 case OHOS_DEVICE_EJECT_BLOCK:
751 extraInfo["title"] = "camera_device_eject_lab";
752 extraInfo["content"] = "camera_device_eject_desc";
753 extraInfo["button"] = "camera_use_continue";
754 break;
755 // 故障上报弹窗
756 case OHOS_DEVICE_EXTERNAL_PRESS:
757 extraInfo["title"] = "camera_device_block_lab";
758 extraInfo["content"] = "camera_device_block_desc";
759 extraInfo["button"] = "camera_device_block_confirm";
760 break;
761 }
762 nlohmann::json dialogInfo;
763 dialogInfo["sysDialogZOrder"] = SYSDIALOG_ZORDER_UPPER;
764 dialogInfo["extraInfo"] = extraInfo;
765 std::string commandStr = dialogInfo.dump();
766 MEDIA_INFO_LOG("BuildDeviceProtectionDialogCommand, commandStr = %{public}s", commandStr.c_str());
767 return commandStr;
768 }
769
RegisterSensorCallback()770 void HCameraDevice::RegisterSensorCallback()
771 {
772 std::lock_guard<std::mutex> lock(sensorLock_);
773 MEDIA_INFO_LOG("HCameraDevice::RegisterDropDetectionListener start");
774 CHECK_RETURN_ELOG(!OHOS::Rosen::LoadMotionSensor(), "RegisterDropDetectionListener LoadMotionSensor fail");
775 CHECK_RETURN_ELOG(!OHOS::Rosen::SubscribeCallback(OHOS::Rosen::MOTION_TYPE_DROP_DETECTION,
776 DropDetectionDataCallbackImpl), "RegisterDropDetectionListener SubscribeCallback fail");
777 }
778
UnRegisterSensorCallback()779 void HCameraDevice::UnRegisterSensorCallback()
780 {
781 std::lock_guard<std::mutex> lock(sensorLock_);
782 CHECK_RETURN_ELOG(!UnsubscribeCallback(OHOS::Rosen::MOTION_TYPE_DROP_DETECTION, DropDetectionDataCallbackImpl),
783 "UnRegisterDropDetectionListener fail");
784 }
785
DropDetectionDataCallbackImpl(const OHOS::Rosen::MotionSensorEvent & motionData)786 void HCameraDevice::DropDetectionDataCallbackImpl(const OHOS::Rosen::MotionSensorEvent &motionData)
787 {
788 MEDIA_INFO_LOG("HCameraDevice::DropDetectionCallback type = %{public}d, status = %{public}d",
789 motionData.type, motionData.status);
790 {
791 if ((GetTimestamp() - g_lastDeviceDropTime < DEVICE_DROP_INTERVAL) ||
792 (g_cameraHostManager == nullptr)) {
793 return;
794 }
795 g_cameraHostManager->NotifyDeviceStateChangeInfo(
796 DeviceType::FALLING_TYPE, FallingState::FALLING_STATE);
797 }
798 }
799
HandleFoldableDevice()800 void HCameraDevice::HandleFoldableDevice()
801 {
802 bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
803 MEDIA_DEBUG_LOG("HCameraDevice::OpenDevice isFoldable is %d", isFoldable);
804 CHECK_EXECUTE(isFoldable, RegisterFoldStatusListener());
805 }
806
ReleaseSessionBeforeCloseDevice()807 void HCameraDevice::ReleaseSessionBeforeCloseDevice()
808 {
809 std::lock_guard<std::mutex> lock(cameraCloseListenerMutex_);
810 for (wptr<IHCameraCloseListener> cameraCloseListener : cameraCloseListenerVec_) {
811 auto cameraCloseListenerTemp = cameraCloseListener.promote();
812 if (cameraCloseListenerTemp == nullptr) {
813 continue;
814 }
815 cameraCloseListenerTemp->BeforeDeviceClose();
816 }
817 }
818
CloseDevice()819 int32_t HCameraDevice::CloseDevice()
820 {
821 MEDIA_INFO_LOG("HCameraDevice::CloseDevice start");
822 CAMERA_SYNC_TRACE;
823 ReleaseSessionBeforeCloseDevice();
824 bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
825 CHECK_EXECUTE(isFoldable, UnregisterFoldStatusListener());
826 {
827 std::lock_guard<std::mutex> lock(opMutex_);
828 CHECK_RETURN_RET_ELOG(!isOpenedCameraDevice_.load(), CAMERA_OK,
829 "HCameraDevice::CloseDevice device has benn closed");
830 if (hdiCameraDevice_ != nullptr) {
831 isOpenedCameraDevice_.store(false);
832 MEDIA_INFO_LOG("Closing camera device: %{public}s start", cameraID_.c_str());
833 hdiCameraDevice_->Close();
834 ResetCachedSettings();
835 ResetDeviceOpenLifeCycleSettings();
836 HCameraDeviceManager::GetInstance()->RemoveDevice(cameraID_);
837 MEDIA_INFO_LOG("Closing camera device: %{public}s end", cameraID_.c_str());
838 hdiCameraDevice_ = nullptr;
839 HandlePrivacyAfterCloseDevice();
840 } else {
841 MEDIA_INFO_LOG("hdiCameraDevice is null");
842 }
843 SetStreamOperatorCallback(nullptr);
844 EnableDeviceOpenedByConcurrent(false);
845 }
846 if (cameraHostManager_) {
847 cameraHostManager_->RemoveCameraDevice(cameraID_);
848 cameraHostManager_->UpdateRestoreParamCloseTime(clientName_, cameraID_);
849 }
850 {
851 std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
852 deviceSvcCallback_ = nullptr;
853 }
854 POWERMGR_SYSEVENT_CAMERA_DISCONNECT(cameraID_.c_str());
855 MEDIA_DEBUG_LOG("HCameraDevice::CloseDevice end");
856 NotifyCameraStatus(CAMERA_CLOSE);
857 #ifdef MEMMGR_OVERRID
858 RequireMemory(Memory::CAMERA_END);
859 #endif
860 UnRegisterSensorCallback();
861 #ifdef HOOK_CAMERA_OPERATOR
862 if (!CameraRotatePlugin::GetInstance()->HookCloseDeviceForRotate(clientName_, deviceAbility_, cameraID_)) {
863 MEDIA_ERR_LOG("HCameraDevice::CloseDevice HookCloseDevice is failed");
864 }
865 #endif
866 return CAMERA_OK;
867 }
868
869 // LCOV_EXCL_STAR
closeDelayedDevice()870 int32_t HCameraDevice::closeDelayedDevice()
871 {
872 MEDIA_INFO_LOG("HCameraDevice::closeDelayedDevice start");
873 CAMERA_SYNC_TRACE;
874 sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
875 {
876 std::lock_guard<std::mutex> lock(opMutex_);
877 CHECK_RETURN_RET(hdiCameraDevice_ == nullptr, CAMERA_OK);
878 hdiCameraDeviceV1_2 = HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
879 }
880 if (hdiCameraDeviceV1_2 != nullptr) {
881 int32_t errCode = hdiCameraDeviceV1_2->Reset();
882 CHECK_RETURN_RET_ELOG(errCode != HDI::Camera::V1_0::CamRetCode::NO_ERROR, CAMERA_UNKNOWN_ERROR,
883 "HCameraDevice::closeDelayedDevice ResetDevice error");
884 ResetCachedSettings();
885 }
886 MEDIA_INFO_LOG("HCameraDevice::closeDelayedDevice end");
887 return CAMERA_OK;
888 }
889 // LCOV_EXCL_STOP
890
Release()891 int32_t HCameraDevice::Release()
892 {
893 CameraXCollie cameraXCollie("HCameraDeviceStub::Release");
894 Close();
895 return CAMERA_OK;
896 }
897
GetEnabledResults(std::vector<int32_t> & results)898 int32_t HCameraDevice::GetEnabledResults(std::vector<int32_t> &results)
899 {
900 std::lock_guard<std::mutex> lock(opMutex_);
901 CHECK_RETURN_RET_ELOG(!hdiCameraDevice_, CAMERA_UNKNOWN_ERROR,
902 "HCameraDevice::GetEnabledResults GetEnabledResults hdiCameraDevice_ is nullptr");
903 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->GetEnabledResults(results));
904 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
905 "HCameraDevice::GetEnabledResults failed with error Code:%{public}d", rc);
906 return CAMERA_OK;
907 }
908
CheckZoomChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)909 void HCameraDevice::CheckZoomChange(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
910 {
911 int32_t ret;
912 camera_metadata_item_t item;
913 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_PREPARE_ZOOM, &item);
914 if (ret == CAM_META_SUCCESS && item.count > 0) {
915 if (item.data.u8[0] == OHOS_CAMERA_ZOOMSMOOTH_PREPARE_ENABLE) {
916 MEDIA_ERR_LOG("OHOS_CAMERA_ZOOMSMOOTH_PREPARE_ENABLE");
917 inPrepareZoom_ = true;
918 ResetZoomTimer();
919 } else if (item.data.u8[0] == OHOS_CAMERA_ZOOMSMOOTH_PREPARE_DISABLE) {
920 MEDIA_ERR_LOG("OHOS_CAMERA_ZOOMSMOOTH_PREPARE_DISABLE");
921 inPrepareZoom_ = false;
922 ResetZoomTimer();
923 }
924 return;
925 }
926 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
927 if (ret != CAM_META_SUCCESS) {
928 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_SMOOTH_ZOOM_RATIOS, &item);
929 }
930 CHECK_EXECUTE(ret == CAM_META_SUCCESS && inPrepareZoom_, ResetZoomTimer());
931 return;
932 }
933
CheckFocusChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)934 void HCameraDevice::CheckFocusChange(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
935 {
936 std::unique_lock<std::shared_mutex> lock(zoomInfoCallbackLock_);
937 CHECK_RETURN(!zoomInfoCallback_);
938 int32_t ret;
939 camera_metadata_item_t item;
940 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_AF_REGIONS, &item);
941 bool focusStatus = (ret == CAM_META_SUCCESS);
942
943 int32_t focusMode = focusMode_;
944 ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_FOCUS_MODE, &item);
945 if (ret == CAM_META_SUCCESS && item.count != 0) {
946 focusMode = static_cast<int32_t>(item.data.u8[0]);
947 }
948
949 if (focusMode_!= focusMode || focusStatus_ != focusStatus) {
950 ZoomInfo zoomInfo;
951 zoomInfo.zoomValue = zoomRatio_;
952 zoomInfo.focusStatus = focusStatus;
953 zoomInfo.focusMode = focusMode;
954 zoomInfo.videoStabilizationMode = videoStabilizationMode_;
955 zoomInfoCallback_(zoomInfo);
956 }
957
958 focusMode_ = focusMode;
959 focusStatus_ = focusStatus;
960 }
961
CheckVideoStabilizationChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)962 void HCameraDevice::CheckVideoStabilizationChange(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
963 {
964 std::shared_lock<std::shared_mutex> lock(zoomInfoCallbackLock_);
965 CHECK_RETURN(!zoomInfoCallback_);
966 camera_metadata_item_t item;
967
968 int32_t ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &item);
969 CHECK_RETURN(ret != CAM_META_SUCCESS || item.count == 0);
970 int32_t videoStabilizationMode = static_cast<int32_t>(item.data.u8[0]);
971
972 if (videoStabilizationMode_ != videoStabilizationMode) {
973 ZoomInfo zoomInfo;
974 zoomInfo.zoomValue = zoomRatio_;
975 zoomInfo.focusStatus = focusStatus_;
976 zoomInfo.focusMode = focusMode_;
977 zoomInfo.videoStabilizationMode = videoStabilizationMode;
978 zoomInfoCallback_(zoomInfo);
979 }
980 videoStabilizationMode_ = videoStabilizationMode;
981 }
982
CheckMovingPhotoSupported(int32_t mode)983 bool HCameraDevice::CheckMovingPhotoSupported(int32_t mode)
984 {
985 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
986 int32_t ret = cameraHostManager_->GetCameraAbility(cameraID_, cameraAbility);
987 CHECK_RETURN_RET(cameraAbility == nullptr, false);
988 camera_metadata_item_t metadataItem;
989 std::vector<int32_t> modes = {};
990 ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(), OHOS_ABILITY_MOVING_PHOTO,
991 &metadataItem);
992 if (ret == CAM_META_SUCCESS && metadataItem.count > 0) {
993 uint32_t step = 3;
994 for (uint32_t index = 0; index < metadataItem.count - 1;) {
995 CHECK_EXECUTE(metadataItem.data.i32[index + 1] == 1, modes.push_back(metadataItem.data.i32[index]));
996 MEDIA_DEBUG_LOG("CheckMovingPhotoSupported mode:%{public}d", metadataItem.data.i32[index]);
997 index += step;
998 }
999 }
1000 return std::find(modes.begin(), modes.end(), mode) != modes.end();
1001 }
1002
ResetZoomTimer()1003 void HCameraDevice::ResetZoomTimer()
1004 {
1005 CameraTimer::GetInstance().Unregister(zoomTimerId_);
1006 CHECK_RETURN(!inPrepareZoom_);
1007 MEDIA_INFO_LOG("register zoom timer callback");
1008 uint32_t waitMs = 5 * 1000;
1009 auto thisPtr = wptr<HCameraDevice>(this);
1010 zoomTimerId_ = CameraTimer::GetInstance().Register([thisPtr]() {
1011 auto devicePtr = thisPtr.promote();
1012 CHECK_EXECUTE(devicePtr != nullptr, devicePtr->UnPrepareZoom());
1013 }, waitMs, true);
1014 }
1015
UnPrepareZoom()1016 void HCameraDevice::UnPrepareZoom()
1017 {
1018 MEDIA_INFO_LOG("entered.");
1019 std::lock_guard<std::mutex> lock(unPrepareZoomMutex_);
1020 CHECK_RETURN(!inPrepareZoom_);
1021 inPrepareZoom_ = false;
1022 uint32_t count = 1;
1023 uint32_t prepareZoomType = OHOS_CAMERA_ZOOMSMOOTH_PREPARE_DISABLE;
1024 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = std::make_shared<OHOS::Camera::CameraMetadata>(1, 1);
1025 metadata->addEntry(OHOS_CONTROL_PREPARE_ZOOM, &prepareZoomType, count);
1026 UpdateSetting(metadata);
1027 }
1028
UpdateCameraRotateAngleAndZoom(std::vector<int32_t> & frameRateRange,bool isResetDegree)1029 void HCameraDevice::UpdateCameraRotateAngleAndZoom(std::vector<int32_t> &frameRateRange, bool isResetDegree)
1030 {
1031 CameraRotateStrategyInfo strategyInfo;
1032 CHECK_RETURN_ELOG(!GetSigleStrategyInfo(strategyInfo), "Update roteta angle not supported");
1033 auto flag = false;
1034 CHECK_EXECUTE(strategyInfo.fps <= 0, flag = true);
1035 CHECK_EXECUTE(strategyInfo.fps > 0 && frameRateRange.size() > 1 &&
1036 strategyInfo.fps == frameRateRange[1], flag = true);
1037 CHECK_RETURN(!flag);
1038 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = std::make_shared<OHOS::Camera::CameraMetadata>(1, 1);
1039 int32_t rotateDegree = GetCameraPosition() == OHOS_CAMERA_POSITION_BACK ?
1040 BASE_DEGREE - strategyInfo.rotateDegree : strategyInfo.rotateDegree;
1041 CHECK_EXECUTE(isResetDegree, rotateDegree = 0);
1042 MEDIA_DEBUG_LOG("HCameraDevice::UpdateCameraRotateAngleAndZoom rotateDegree: %{public}d.", rotateDegree);
1043 CHECK_EXECUTE(rotateDegree >= 0, settings->addEntry(OHOS_CONTROL_ROTATE_ANGLE, &rotateDegree, 1));
1044 float zoom = strategyInfo.wideValue;
1045 MEDIA_DEBUG_LOG("HCameraDevice::UpdateCameraRotateAngleAndZoom zoom: %{public}f.", zoom);
1046 CHECK_EXECUTE(zoom >= 0, settings->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoom, 1));
1047 UpdateSettingOnce(settings);
1048 MEDIA_INFO_LOG("UpdateCameraRotateAngleAndZoom success.");
1049 }
1050
GetSigleStrategyInfo(CameraRotateStrategyInfo & strategyInfo)1051 bool HCameraDevice::GetSigleStrategyInfo(CameraRotateStrategyInfo &strategyInfo)
1052 {
1053 auto infos = GetCameraRotateStrategyInfos();
1054 if (bundleName_ == "") {
1055 int uid = IPCSkeleton::GetCallingUid();
1056 bundleName_ = GetClientBundle(uid);
1057 }
1058 CHECK_EXECUTE(bundleName_ == "", { int uid = IPCSkeleton::GetCallingUid();
1059 bundleName_ = GetClientBundle(uid);});
1060 std::string bundleName = bundleName_;
1061 auto it = std::find_if(infos.begin(), infos.end(), [&bundleName](const auto &info) {
1062 return info.bundleName == bundleName;
1063 });
1064 CHECK_RETURN_RET_ELOG(it == infos.end(), false, "Update roteta angle not supported");
1065 strategyInfo = *it;
1066 return true;
1067 }
1068
SetCameraRotateStrategyInfos(std::vector<CameraRotateStrategyInfo> infos)1069 void HCameraDevice::SetCameraRotateStrategyInfos(std::vector<CameraRotateStrategyInfo> infos)
1070 {
1071 std::lock_guard<std::mutex> lock(cameraRotateStrategyInfosLock_);
1072 cameraRotateStrategyInfos_ = infos;
1073 }
1074
GetCameraRotateStrategyInfos()1075 std::vector<CameraRotateStrategyInfo> HCameraDevice::GetCameraRotateStrategyInfos()
1076 {
1077 std::lock_guard<std::mutex> lock(cameraRotateStrategyInfosLock_);
1078 return cameraRotateStrategyInfos_;
1079 }
1080
UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)1081 int32_t HCameraDevice::UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
1082 {
1083 CAMERA_SYNC_TRACE;
1084 CHECK_RETURN_RET_ELOG(settings == nullptr, CAMERA_INVALID_ARG,
1085 "HCameraDevice::UpdateSetting settings is null");
1086 CheckZoomChange(settings);
1087 CheckFocusChange(settings);
1088 CheckVideoStabilizationChange(settings);
1089
1090 uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(settings->get());
1091 CHECK_RETURN_RET_ELOG(!count, CAMERA_OK, "HCameraDevice::UpdateSetting Nothing to update");
1092 std::lock_guard<std::mutex> lock(opMutex_);
1093 if (updateSettings_ == nullptr || !CameraFwkMetadataUtils::MergeMetadata(settings, updateSettings_)) {
1094 updateSettings_ = settings;
1095 }
1096 MEDIA_INFO_LOG("HCameraDevice::UpdateSetting Updated device settings hdiCameraDevice_(%{public}d)",
1097 hdiCameraDevice_ != nullptr);
1098 if (hdiCameraDevice_ != nullptr) {
1099 std::vector<uint8_t> hdiSettings;
1100 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(updateSettings_, hdiSettings);
1101 ReportMetadataDebugLog(updateSettings_);
1102 DumpMetadata(updateSettings_);
1103 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(hdiSettings));
1104 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
1105 "HCameraDevice::UpdateSetting Failed with error Code: %{public}d", rc);
1106 UpdateDeviceOpenLifeCycleSettings(updateSettings_);
1107 {
1108 std::lock_guard<std::mutex> cachedLock(cachedSettingsMutex_);
1109 CameraFwkMetadataUtils::MergeMetadata(settings, cachedSettings_);
1110 }
1111 updateSettings_ = nullptr;
1112 }
1113 MEDIA_INFO_LOG("HCameraDevice::UpdateSetting execute success");
1114 return CAMERA_OK;
1115 }
1116
SetUsedAsPosition(uint8_t value)1117 int32_t HCameraDevice::SetUsedAsPosition(uint8_t value)
1118 {
1119 MEDIA_INFO_LOG("HCameraDevice::SetUsedAsPosition as %{public}d", value);
1120 CHECK_RETURN_RET_ELOG(
1121 !CheckSystemApp(), CAMERA_NO_PERMISSION, "HCameraDevice::SetUsedAsPosition:SystemApi is called");
1122 usedAsPosition_ = value;
1123 // lockforcontrol
1124 return CAMERA_OK;
1125 }
1126
GetUsedAsPosition()1127 uint8_t HCameraDevice::GetUsedAsPosition()
1128 {
1129 MEDIA_INFO_LOG("HCameraDevice::GetUsedAsPosition success");
1130 return usedAsPosition_;
1131 }
1132
UpdateSettingOnce(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)1133 int32_t HCameraDevice::UpdateSettingOnce(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings)
1134 {
1135 CAMERA_SYNC_TRACE;
1136 MEDIA_INFO_LOG("HCameraDevice::UpdateSettingOnce prepare execute");
1137 CHECK_RETURN_RET_ELOG(settings == nullptr, CAMERA_INVALID_ARG, "settings is null");
1138 CheckZoomChange(settings);
1139
1140 uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(settings->get());
1141 CHECK_RETURN_RET_ELOG(!count, CAMERA_OK, "Nothing to update");
1142 std::lock_guard<std::mutex> lock(opMutex_);
1143 MEDIA_INFO_LOG("Updated device settings once hdiCameraDevice_(%{public}d)", hdiCameraDevice_ != nullptr);
1144 if (hdiCameraDevice_ != nullptr) {
1145 std::vector<uint8_t> hdiSettings;
1146 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(settings, hdiSettings);
1147 ReportMetadataDebugLog(settings);
1148 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->UpdateSettings(hdiSettings));
1149 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
1150 "Failed with error Code: %{public}d", rc);
1151 }
1152 MEDIA_INFO_LOG("HCameraDevice::UpdateSettingOnce execute success");
1153 return CAMERA_OK;
1154 }
1155
GetStatus(const std::shared_ptr<OHOS::Camera::CameraMetadata> & metaIn,std::shared_ptr<OHOS::Camera::CameraMetadata> & metaOut)1156 int32_t HCameraDevice::GetStatus(const std::shared_ptr<OHOS::Camera::CameraMetadata> &metaIn,
1157 std::shared_ptr<OHOS::Camera::CameraMetadata> &metaOut)
1158 {
1159 CAMERA_SYNC_TRACE;
1160 CHECK_RETURN_RET_ELOG(metaIn == nullptr, CAMERA_INVALID_ARG, "HCameraDevice::GetStatus metaIn is null");
1161 uint32_t count = OHOS::Camera::GetCameraMetadataItemCount(metaIn->get());
1162 CHECK_RETURN_RET_ELOG(!count, CAMERA_OK, "HCameraDevice::GetStatus Nothing to query");
1163
1164 sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
1165 if (cameraHostManager_->GetVersionByCamera(cameraID_) >= HDI_VERSION_ID_1_2) {
1166 MEDIA_DEBUG_LOG("HCameraDevice::GetStatus ICameraDevice cast to V1_2");
1167 hdiCameraDeviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
1168 if (hdiCameraDeviceV1_2 == nullptr) {
1169 MEDIA_ERR_LOG("HCameraDevice::GetStatus ICameraDevice cast to V1_2 error");
1170 hdiCameraDeviceV1_2 = static_cast<OHOS::HDI::Camera::V1_2::ICameraDevice *>(hdiCameraDevice_.GetRefPtr());
1171 }
1172 }
1173
1174 MEDIA_DEBUG_LOG("HCameraDevice::GetStatus hdiCameraDeviceV1_2(%{public}d)", hdiCameraDeviceV1_2 != nullptr);
1175 if (hdiCameraDeviceV1_2 != nullptr) {
1176 std::vector<uint8_t> hdiMetaIn;
1177 std::vector<uint8_t> hdiMetaOut;
1178 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaIn, hdiMetaIn);
1179 CamRetCode rc = (CamRetCode)(hdiCameraDeviceV1_2->GetStatus(hdiMetaIn, hdiMetaOut));
1180 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
1181 "HCameraDevice::GetStatus Failed with error Code: %{public}d", rc);
1182 CHECK_EXECUTE(hdiMetaOut.size() != 0, OHOS::Camera::MetadataUtils::ConvertVecToMetadata(hdiMetaOut, metaOut));
1183 }
1184 return CAMERA_OK;
1185 }
1186
ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings)1187 void HCameraDevice::ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings)
1188 {
1189 caller_ = CameraReportUtils::GetCallerInfo();
1190 for (const auto &tagInfo : reportTagInfos_) {
1191 std::string tagName;
1192 DFX_UB_NAME dfxUbStr;
1193 uint32_t tag;
1194 std::tie(tag, tagName, dfxUbStr) = tagInfo;
1195 DebugLogTag(settings, tag, tagName, dfxUbStr);
1196 }
1197
1198 DebugLogForSmoothZoom(settings, OHOS_CONTROL_SMOOTH_ZOOM_RATIOS);
1199 DebugLogForAfRegions(settings, OHOS_CONTROL_AF_REGIONS);
1200 DebugLogForAeRegions(settings, OHOS_CONTROL_AE_REGIONS);
1201 }
1202
DebugLogTag(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag,std::string tagName,DFX_UB_NAME dfxUbStr)1203 void HCameraDevice::DebugLogTag(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings,
1204 uint32_t tag, std::string tagName, DFX_UB_NAME dfxUbStr)
1205 {
1206 camera_metadata_item_t item;
1207 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
1208 if (ret != CAM_META_SUCCESS || item.count <= 0) {
1209 MEDIA_DEBUG_LOG("Failed to find %{public}s tag", tagName.c_str());
1210 return;
1211 }
1212 uint32_t dataType = item.data_type;
1213 std::string valueStr;
1214 if (dataType == META_TYPE_BYTE) {
1215 valueStr = std::to_string(item.data.u8[0]);
1216 } else if (dataType == META_TYPE_INT32) {
1217 valueStr = std::to_string(item.data.i32[0]);
1218 } else if (dataType == META_TYPE_UINT32) {
1219 valueStr = std::to_string(item.data.ui32[0]);
1220 } else if (dataType == META_TYPE_FLOAT) {
1221 valueStr = std::to_string(item.data.f[0]);
1222 } else if (dataType == META_TYPE_INT64) {
1223 valueStr = std::to_string(item.data.i64[0]);
1224 } else if (dataType == META_TYPE_DOUBLE) {
1225 valueStr = std::to_string(item.data.d[0]);
1226 } else {
1227 MEDIA_ERR_LOG("unknown dataType");
1228 return;
1229 }
1230 MEDIA_DEBUG_LOG("Find %{public}s value = %{public}s", tagName.c_str(), valueStr.c_str());
1231
1232 CHECK_EXECUTE(dfxUbStr != DFX_UB_NOT_REPORT,
1233 CameraReportUtils::GetInstance().ReportUserBehavior(dfxUbStr, valueStr, caller_));
1234 }
1235
DebugLogForSmoothZoom(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag)1236 void HCameraDevice::DebugLogForSmoothZoom(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag)
1237 {
1238 // debug log for smooth zoom
1239 camera_metadata_item_t item;
1240 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
1241 if (ret != CAM_META_SUCCESS || item.count <= 0) {
1242 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_SMOOTH_ZOOM_RATIOS tag");
1243 } else {
1244 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_SMOOTH_ZOOM_RATIOS count = %{public}d", item.count);
1245 if (item.count > 1) {
1246 uint32_t targetZoom = item.data.ui32[item.count - 2];
1247 float zoomRatio = targetZoom / SMOOTH_ZOOM_DIVISOR;
1248 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_SMOOTH_ZOOM_RATIOS value = %{public}f", zoomRatio);
1249 CameraReportUtils::GetInstance().ReportUserBehavior(DFX_UB_SET_SMOOTHZOOM,
1250 std::to_string(zoomRatio), caller_);
1251 }
1252 }
1253 }
1254
DebugLogForAfRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag)1255 void HCameraDevice::DebugLogForAfRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag)
1256 {
1257 // debug log for af regions
1258 camera_metadata_item_t item;
1259 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
1260 if (ret != CAM_META_SUCCESS || item.count <= 0) {
1261 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AF_REGIONS tag");
1262 } else {
1263 std::stringstream ss;
1264 ss << "x=" << item.data.f[0] << " y=" << item.data.f[1];
1265 std::string str = ss.str();
1266 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AF_REGIONS %{public}s", str.c_str());
1267 CameraReportUtils::GetInstance().ReportUserBehavior(DFX_UB_SET_FOCUSPOINT, str, caller_);
1268 }
1269 }
1270
DebugLogForAeRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> & settings,uint32_t tag)1271 void HCameraDevice::DebugLogForAeRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag)
1272 {
1273 // debug log for ae regions
1274 camera_metadata_item_t item;
1275 int ret = OHOS::Camera::FindCameraMetadataItem(settings->get(), tag, &item);
1276 if (ret != CAM_META_SUCCESS || item.count <= 0) {
1277 MEDIA_DEBUG_LOG("HCameraDevice::Failed to find OHOS_CONTROL_AE_REGIONS tag");
1278 } else {
1279 std::stringstream ss;
1280 ss << "x=" << item.data.f[0] << " y=" << item.data.f[1];
1281 std::string str = ss.str();
1282 MEDIA_DEBUG_LOG("HCameraDevice::find OHOS_CONTROL_AE_REGIONS %{public}s", str.c_str());
1283 CameraReportUtils::GetInstance().ReportUserBehavior(DFX_UB_SET_METERINGPOINT, str, caller_);
1284 }
1285 }
1286
RegisterFoldStatusListener()1287 void HCameraDevice::RegisterFoldStatusListener()
1288 {
1289 std::lock_guard<std::mutex> lock(foldStateListenerMutex_);
1290 listener_ = new FoldScreenListener(this, cameraHostManager_, cameraID_);
1291 if (cameraHostManager_) {
1292 int foldStatus = static_cast<int>(OHOS::Rosen::DisplayManager::GetInstance().GetFoldStatus());
1293 if (foldStatus == static_cast<int>(FoldStatus::HALF_FOLD)) {
1294 foldStatus = static_cast<int>(FoldStatus::EXPAND);
1295 }
1296 cameraHostManager_->NotifyDeviceStateChangeInfo(DeviceType::FOLD_TYPE, foldStatus);
1297 }
1298 auto ret = OHOS::Rosen::DisplayManager::GetInstance().RegisterFoldStatusListener(listener_);
1299 if (ret != OHOS::Rosen::DMError::DM_OK) {
1300 MEDIA_DEBUG_LOG("HCameraDevice::RegisterFoldStatusListener failed");
1301 listener_ = nullptr;
1302 } else {
1303 MEDIA_DEBUG_LOG("HCameraDevice::RegisterFoldStatusListener success");
1304 }
1305 }
1306
UnregisterFoldStatusListener()1307 void HCameraDevice::UnregisterFoldStatusListener()
1308 {
1309 std::lock_guard<std::mutex> lock(foldStateListenerMutex_);
1310 CHECK_RETURN_ELOG(listener_ == nullptr, "HCameraDevice::unRegisterFoldStatusListener listener is null");
1311 auto ret = OHOS::Rosen::DisplayManager::GetInstance().UnregisterFoldStatusListener(listener_);
1312 if (ret != OHOS::Rosen::DMError::DM_OK) {
1313 MEDIA_DEBUG_LOG("HCameraDevice::UnregisterFoldStatusListener failed");
1314 }
1315 listener_ = nullptr;
1316 }
1317
EnableResult(const std::vector<int32_t> & results)1318 int32_t HCameraDevice::EnableResult(const std::vector<int32_t> &results)
1319 {
1320 CHECK_RETURN_RET_ELOG(results.empty(), CAMERA_INVALID_ARG, "HCameraDevice::EnableResult results is empty");
1321 std::lock_guard<std::mutex> lock(opMutex_);
1322 CHECK_RETURN_RET_ELOG(hdiCameraDevice_ == nullptr, CAMERA_UNKNOWN_ERROR,
1323 "HCameraDevice::hdiCameraDevice_ is null");
1324
1325 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->EnableResult(results));
1326 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
1327 "HCameraDevice::EnableResult failed with error Code:%{public}d", rc);
1328 return CAMERA_OK;
1329 }
1330
SetDeviceRetryTime()1331 int32_t HCameraDevice::SetDeviceRetryTime()
1332 {
1333 MEDIA_INFO_LOG("HCameraDevice::SetDeviceRetryTime");
1334 g_lastDeviceDropTime = GetTimestamp();
1335 return CAMERA_OK;
1336 }
1337
DisableResult(const std::vector<int32_t> & results)1338 int32_t HCameraDevice::DisableResult(const std::vector<int32_t> &results)
1339 {
1340 CHECK_RETURN_RET_ELOG(results.empty(), CAMERA_INVALID_ARG, "HCameraDevice::DisableResult results is empty");
1341 std::lock_guard<std::mutex> lock(opMutex_);
1342 CHECK_RETURN_RET_ELOG(hdiCameraDevice_ == nullptr, CAMERA_UNKNOWN_ERROR,
1343 "HCameraDevice::hdiCameraDevice_ is null");
1344
1345 CamRetCode rc = (CamRetCode)(hdiCameraDevice_->DisableResult(results));
1346 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
1347 "HCameraDevice::DisableResult failed with error Code:%{public}d", rc);
1348 return CAMERA_OK;
1349 }
1350
SetCallback(const sptr<ICameraDeviceServiceCallback> & callback)1351 int32_t HCameraDevice::SetCallback(const sptr<ICameraDeviceServiceCallback>& callback)
1352 {
1353 if (callback == nullptr) {
1354 MEDIA_WARNING_LOG("HCameraDevice::SetCallback callback is null");
1355 }
1356 std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
1357 deviceSvcCallback_ = callback;
1358 return CAMERA_OK;
1359 }
1360
UnSetCallback()1361 int32_t HCameraDevice::UnSetCallback()
1362 {
1363 std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
1364 deviceSvcCallback_ = nullptr;
1365 return CAMERA_OK;
1366 }
1367
GetDeviceServiceCallback()1368 sptr<ICameraDeviceServiceCallback> HCameraDevice::GetDeviceServiceCallback()
1369 {
1370 std::lock_guard<std::mutex> lock(deviceSvcCbMutex_);
1371 return deviceSvcCallback_;
1372 }
1373
UpdateDeviceOpenLifeCycleSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> changedSettings)1374 void HCameraDevice::UpdateDeviceOpenLifeCycleSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> changedSettings)
1375 {
1376 CHECK_RETURN(changedSettings == nullptr);
1377 std::lock_guard<std::mutex> lock(deviceOpenLifeCycleMutex_);
1378 for (auto itemTag : DEVICE_OPEN_LIFECYCLE_TAGS) {
1379 camera_metadata_item_t item;
1380 int32_t result = OHOS::Camera::FindCameraMetadataItem(changedSettings->get(), itemTag, &item);
1381 if (result != CAM_META_SUCCESS || item.count <= 0) {
1382 continue;
1383 }
1384 bool updateSuccess = CameraFwkMetadataUtils::UpdateMetadataTag(item, deviceOpenLifeCycleSettings_);
1385 if (!updateSuccess) {
1386 MEDIA_ERR_LOG("HCameraDevice::UpdateDeviceOpenLifeCycleSettings tag:%{public}d fail", itemTag);
1387 } else {
1388 MEDIA_INFO_LOG("HCameraDevice::UpdateDeviceOpenLifeCycleSettings tag:%{public}d success", itemTag);
1389 }
1390 }
1391 }
1392
ResetDeviceOpenLifeCycleSettings()1393 void HCameraDevice::ResetDeviceOpenLifeCycleSettings()
1394 {
1395 MEDIA_INFO_LOG("HCameraDevice::ResetDeviceOpenLifeCycleSettings");
1396 std::lock_guard<std::mutex> lock(deviceOpenLifeCycleMutex_);
1397 deviceOpenLifeCycleSettings_ =
1398 std::make_shared<OHOS::Camera::CameraMetadata>(DEVICE_OPEN_LIFECYCLE_TAGS.size(), DEFAULT_SETTING_ITEM_LENGTH);
1399 }
1400
GetStreamOperator(const sptr<IStreamOperatorCallback> & callbackObj,sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> & streamOperator)1401 int32_t HCameraDevice::GetStreamOperator(const sptr<IStreamOperatorCallback> &callbackObj,
1402 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> &streamOperator)
1403 {
1404 std::lock_guard<std::mutex> lock(opMutex_);
1405 proxyStreamOperatorCallback_ = callbackObj;
1406 CHECK_RETURN_RET_ELOG(hdiCameraDevice_ == nullptr, CAMERA_UNKNOWN_ERROR,
1407 "HCameraDevice::GetStreamOperator hdiCameraDevice_ is null");
1408 CamRetCode rc;
1409 sptr<OHOS::HDI::Camera::V1_1::ICameraDevice> hdiCameraDeviceV1_1;
1410 sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiCameraDeviceV1_2;
1411 sptr<OHOS::HDI::Camera::V1_3::ICameraDevice> hdiCameraDeviceV1_3;
1412 int32_t versionRes = cameraHostManager_->GetVersionByCamera(cameraID_);
1413 if (versionRes >= HDI_VERSION_ID_1_3) {
1414 MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice cast to V1_3");
1415 hdiCameraDeviceV1_3 = OHOS::HDI::Camera::V1_3::ICameraDevice::CastFrom(hdiCameraDevice_);
1416 } else if (versionRes >= HDI_VERSION_ID_1_2) {
1417 MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice cast to V1_2");
1418 hdiCameraDeviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_);
1419 } else if (versionRes == HDI_VERSION_ID_1_1) {
1420 MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice cast to V1_1");
1421 hdiCameraDeviceV1_1 = OHOS::HDI::Camera::V1_1::ICameraDevice::CastFrom(hdiCameraDevice_);
1422 if (hdiCameraDeviceV1_1 == nullptr) {
1423 MEDIA_ERR_LOG("HCameraDevice::GetStreamOperator ICameraDevice cast to V1_1 error");
1424 hdiCameraDeviceV1_1 = static_cast<OHOS::HDI::Camera::V1_1::ICameraDevice*>(hdiCameraDevice_.GetRefPtr());
1425 }
1426 }
1427
1428 if (hdiCameraDeviceV1_3 != nullptr && versionRes >= HDI_VERSION_ID_1_3) {
1429 sptr<OHOS::HDI::Camera::V1_3::IStreamOperator> streamOperator_v1_3;
1430 rc = (CamRetCode)(hdiCameraDeviceV1_3->GetStreamOperator_V1_3(callbackObj, streamOperator_v1_3));
1431 streamOperator = streamOperator_v1_3;
1432 } else if (hdiCameraDeviceV1_2 != nullptr && versionRes >= HDI_VERSION_ID_1_2) {
1433 MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice V1_2");
1434 sptr<OHOS::HDI::Camera::V1_2::IStreamOperator> streamOperator_v1_2;
1435 rc = (CamRetCode)(hdiCameraDeviceV1_2->GetStreamOperator_V1_2(callbackObj, streamOperator_v1_2));
1436 streamOperator = streamOperator_v1_2;
1437 } else if (hdiCameraDeviceV1_1 != nullptr && versionRes == HDI_VERSION_ID_1_1) {
1438 MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice V1_1");
1439 sptr<OHOS::HDI::Camera::V1_1::IStreamOperator> streamOperator_v1_1;
1440 rc = (CamRetCode)(hdiCameraDeviceV1_1->GetStreamOperator_V1_1(callbackObj, streamOperator_v1_1));
1441 streamOperator = streamOperator_v1_1;
1442 } else {
1443 MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice V1_0");
1444 rc = (CamRetCode)(hdiCameraDevice_->GetStreamOperator(callbackObj, streamOperator));
1445 }
1446 if (rc != HDI::Camera::V1_0::NO_ERROR) {
1447 MEDIA_ERR_LOG("HCameraDevice::GetStreamOperator failed with error Code:%{public}d", rc);
1448 CameraReportUtils::ReportCameraError(
1449 "HCameraDevice::GetStreamOperator", rc, true, CameraReportUtils::GetCallerInfo());
1450 return HdiToServiceError(rc);
1451 }
1452 return CAMERA_OK;
1453 }
1454
OnError(const OHOS::HDI::Camera::V1_0::ErrorType type,const int32_t errorMsg)1455 int32_t HCameraDevice::OnError(const OHOS::HDI::Camera::V1_0::ErrorType type, const int32_t errorMsg)
1456 {
1457 auto errType = static_cast<OHOS::HDI::Camera::V1_3::ErrorType>(type);
1458 MEDIA_ERR_LOG("CameraDeviceCallback::OnError() is called!, type: %{public}d,"
1459 "cameraID_: %{public}s, cameraPid: %{public}d.",
1460 type, cameraID_.c_str(), cameraPid_);
1461 if (errType == OHOS::HDI::Camera::V1_3::SENSOR_DATA_ERROR) {
1462 NotifyCameraStatus(HdiToCameraErrorType(errType), errorMsg);
1463 return CAMERA_OK;
1464 }
1465 NotifyCameraStatus(HdiToCameraErrorType(errType));
1466 auto callback = GetDeviceServiceCallback();
1467 if (callback != nullptr) {
1468 int32_t errorType;
1469 if (type == OHOS::HDI::Camera::V1_0::REQUEST_TIMEOUT) {
1470 errorType = CAMERA_DEVICE_REQUEST_TIMEOUT;
1471 } else if (type == OHOS::HDI::Camera::V1_0::DEVICE_PREEMPT) {
1472 errorType = CAMERA_DEVICE_PREEMPTED;
1473 } else if (type == DEVICE_DISCONNECT) {
1474 errorType = CAMERA_DEVICE_CLOSED;
1475 } else {
1476 errorType = CAMERA_UNKNOWN_ERROR;
1477 }
1478 callback->OnError(errorType, errorMsg);
1479 CAMERA_SYSEVENT_FAULT(CreateMsg("CameraDeviceServiceCallback::OnError() is called!, errorType: %d,"
1480 "errorMsg: %d",
1481 errorType, errorMsg));
1482 }
1483 return CAMERA_OK;
1484 }
1485
CheckOnResultData(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)1486 void HCameraDevice::CheckOnResultData(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)
1487 {
1488 CHECK_RETURN_ELOG(cameraResult == nullptr, "HCameraDevice::OnResult cameraResult is nullptr");
1489 camera_metadata_item_t item;
1490 common_metadata_header_t* metadata = cameraResult->get();
1491 int ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASH_MODE, &item);
1492 if (ret == 0 && item.count > 0) {
1493 MEDIA_DEBUG_LOG("Flash mode: %{public}d", item.data.u8[0]);
1494 }
1495 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FLASH_STATE, &item);
1496 if (ret == 0 && item.count > 0) {
1497 MEDIA_DEBUG_LOG("Flash state: %{public}d", item.data.u8[0]);
1498 }
1499 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_MODE, &item);
1500 if (ret == CAM_META_SUCCESS && item.count > 0) {
1501 MEDIA_DEBUG_LOG("Focus mode: %{public}d", item.data.u8[0]);
1502 }
1503 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_QUALITY_PRIORITIZATION, &item);
1504 if (ret == CAM_META_SUCCESS && item.count > 0) {
1505 MEDIA_DEBUG_LOG("quality prioritization: %{public}d", item.data.u8[0]);
1506 }
1507 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_STATE, &item);
1508 if (ret == CAM_META_SUCCESS && item.count > 0) {
1509 MEDIA_DEBUG_LOG("Focus state: %{public}d", item.data.u8[0]);
1510 }
1511 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_STATISTICS_FACE_RECTANGLES, &item);
1512 CHECK_PRINT_ELOG(
1513 ret != CAM_META_SUCCESS || item.count <= 0, "cannot find OHOS_STATISTICS_FACE_RECTANGLES: %{public}d", ret);
1514 MEDIA_DEBUG_LOG("ProcessFaceRectangles: %{public}d count: %{public}d", item.item, item.count);
1515 constexpr int32_t rectangleUnitLen = 4;
1516
1517 if (item.count % rectangleUnitLen) {
1518 MEDIA_DEBUG_LOG("Metadata item: %{public}d count: %{public}d is invalid", item.item, item.count);
1519 }
1520 const int32_t offsetX = 0;
1521 const int32_t offsetY = 1;
1522 const int32_t offsetW = 2;
1523 const int32_t offsetH = 3;
1524 float* start = item.data.f;
1525 float* end = item.data.f + item.count;
1526 for (; start < end; start += rectangleUnitLen) {
1527 MEDIA_DEBUG_LOG("Metadata item: %{public}f, %{public}f, %{public}f, %{public}f", start[offsetX], start[offsetY],
1528 start[offsetW], start[offsetH]);
1529 }
1530 }
1531
OnResult(const uint64_t timestamp,const std::vector<uint8_t> & result)1532 int32_t HCameraDevice::OnResult(const uint64_t timestamp, const std::vector<uint8_t>& result)
1533 {
1534 CHECK_RETURN_RET_ELOG(result.size() == 0, CAMERA_INVALID_ARG, "onResult get null meta from HAL");
1535 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult = nullptr;
1536 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, cameraResult);
1537 if (cameraResult == nullptr) {
1538 cameraResult = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
1539 }
1540 CHECK_EXECUTE(IsCameraDebugOn(), CameraFwkMetadataUtils::DumpMetadataInfo(cameraResult));
1541 auto callback = GetDeviceServiceCallback();
1542 CHECK_EXECUTE(callback != nullptr, callback->OnResult(timestamp, cameraResult));
1543 ReportDeviceProtectionStatus(cameraResult);
1544 CHECK_EXECUTE(IsCameraDebugOn(), CheckOnResultData(cameraResult));
1545 CHECK_EXECUTE(isMovingPhotoEnabled_, GetMovingPhotoStartAndEndTime(cameraResult));
1546 ReportZoomInfos(cameraResult);
1547 return CAMERA_OK;
1548 }
1549
GetMovingPhotoStartAndEndTime(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)1550 void HCameraDevice::GetMovingPhotoStartAndEndTime(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)
1551 {
1552 MEDIA_DEBUG_LOG("HCameraDevice::GetMovingPhotoStartAndEndTime enter.");
1553 {
1554 std::lock_guard<std::mutex> lock(movingPhotoStartTimeCallbackLock_);
1555 if (movingPhotoStartTimeCallback_) {
1556 camera_metadata_item_t item;
1557 int ret = OHOS::Camera::FindCameraMetadataItem(cameraResult->get(), OHOS_MOVING_PHOTO_START, &item);
1558 if (ret == CAM_META_SUCCESS && item.count != 0) {
1559 int64_t captureId = item.data.i64[0];
1560 int64_t startTime = item.data.i64[1];
1561 movingPhotoStartTimeCallback_(static_cast<int32_t>(captureId), startTime);
1562 }
1563 }
1564 }
1565 std::lock_guard<std::mutex> lock(movingPhotoEndTimeCallbackLock_);
1566 if (movingPhotoEndTimeCallback_) {
1567 camera_metadata_item_t item;
1568 int ret = OHOS::Camera::FindCameraMetadataItem(cameraResult->get(), OHOS_MOVING_PHOTO_END, &item);
1569 if (ret == CAM_META_SUCCESS && item.count != 0) {
1570 int64_t captureId = item.data.i64[0];
1571 int64_t endTime = item.data.i64[1];
1572 movingPhotoEndTimeCallback_(static_cast<int32_t>(captureId), endTime);
1573 }
1574 }
1575 }
1576
SetMovingPhotoStartTimeCallback(std::function<void (int64_t,int64_t)> callback)1577 void HCameraDevice::SetMovingPhotoStartTimeCallback(std::function<void(int64_t, int64_t)> callback)
1578 {
1579 std::lock_guard<std::mutex> lock(movingPhotoStartTimeCallbackLock_);
1580 movingPhotoStartTimeCallback_ = callback;
1581 }
1582
SetMovingPhotoEndTimeCallback(std::function<void (int64_t,int64_t)> callback)1583 void HCameraDevice::SetMovingPhotoEndTimeCallback(std::function<void(int64_t, int64_t)> callback)
1584 {
1585 std::lock_guard<std::mutex> lock(movingPhotoEndTimeCallbackLock_);
1586 movingPhotoEndTimeCallback_ = callback;
1587 }
1588
ReportZoomInfos(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)1589 void HCameraDevice::ReportZoomInfos(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult)
1590 {
1591 std::shared_lock<std::shared_mutex> lock(zoomInfoCallbackLock_);
1592 CHECK_RETURN(!zoomInfoCallback_);
1593 float zoomRatio = 1.0;
1594 camera_metadata_item_t item;
1595 int ret = OHOS::Camera::FindCameraMetadataItem(cameraResult->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
1596 CHECK_RETURN(ret != CAM_META_SUCCESS || item.count == 0);
1597 zoomRatio = item.data.f[0];
1598 MEDIA_DEBUG_LOG("ReportZoomInfos zoomRatio: %{public}f", zoomRatio);
1599 if (zoomRatio != zoomRatio_) {
1600 ZoomInfo zoomInfo;
1601 zoomInfo.zoomValue = zoomRatio;
1602 zoomInfo.focusStatus = focusStatus_;
1603 zoomInfo.focusMode = focusMode_;
1604 zoomInfo.videoStabilizationMode = videoStabilizationMode_;
1605 zoomInfoCallback_(zoomInfo);
1606 }
1607 zoomRatio_ = zoomRatio;
1608 }
1609
SetZoomInfoCallback(std::function<void (ZoomInfo)> callback)1610 void HCameraDevice::SetZoomInfoCallback(std::function<void(ZoomInfo)> callback)
1611 {
1612 MEDIA_DEBUG_LOG("HCameraDevice::SetZoomInfoCallback enter.");
1613 std::unique_lock<std::shared_mutex> lock(zoomInfoCallbackLock_);
1614 zoomInfoCallback_ = callback;
1615 }
1616
GetCallerToken()1617 int32_t HCameraDevice::GetCallerToken()
1618 {
1619 return callerToken_;
1620 }
1621
CanOpenCamera()1622 bool HCameraDevice::CanOpenCamera()
1623 {
1624 int32_t cost;
1625 std::set<std::string> conflicting;
1626 if (GetCameraResourceCost(cost, conflicting)) {
1627 int32_t uidOfRequestProcess = IPCSkeleton::GetCallingUid();
1628 int32_t pidOfRequestProcess = IPCSkeleton::GetCallingPid();
1629 uint32_t accessTokenIdOfRequestProc = IPCSkeleton::GetCallingTokenID();
1630 uint32_t firstTokenIdOfRequestProcess = IPCSkeleton::GetFirstTokenID();
1631
1632 sptr<HCameraDeviceHolder> cameraRequestOpen = new HCameraDeviceHolder(
1633 pidOfRequestProcess, uidOfRequestProcess, 0, 0, this, accessTokenIdOfRequestProc, cost, conflicting,
1634 firstTokenIdOfRequestProcess);
1635
1636 std::vector<sptr<HCameraDeviceHolder>> evictedClients;
1637 bool ret = HCameraDeviceManager::GetInstance()->HandleCameraEvictions(evictedClients, cameraRequestOpen);
1638 // close evicted clients
1639 for (auto &camera : evictedClients) {
1640 MEDIA_DEBUG_LOG("HCameraDevice::CanOpenCamera open current device need to close");
1641 camera->GetDevice()->OnError(DEVICE_PREEMPT, 0);
1642 camera->GetDevice()->CloseDevice();
1643 }
1644 return ret;
1645 }
1646 std::vector<sptr<HCameraDevice>> cameraNeedEvict;
1647 bool ret = HCameraDeviceManager::GetInstance()->GetConflictDevices(cameraNeedEvict, this, cameraConcurrentType_);
1648 if (cameraNeedEvict.size() != 0) {
1649 MEDIA_DEBUG_LOG("HCameraDevice::CanOpenCamera open current device need to close other devices");
1650 for (auto deviceItem : cameraNeedEvict) {
1651 deviceItem->OnError(DEVICE_PREEMPT, 0);
1652 deviceItem->CloseDevice();
1653 }
1654 }
1655 return ret;
1656 }
1657
GetCameraResourceCost(int32_t & cost,std::set<std::string> & conflicting)1658 bool HCameraDevice::GetCameraResourceCost(int32_t &cost, std::set<std::string> &conflicting)
1659 {
1660 OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost resourceCost;
1661 int32_t errorCode = cameraHostManager_->GetCameraResourceCost(cameraID_, resourceCost);
1662 CHECK_RETURN_RET_ELOG(errorCode != CAMERA_OK, false, "GetCameraResourceCost failed");
1663 cost = static_cast<int32_t>(resourceCost.resourceCost_);
1664 for (size_t i = 0; i < resourceCost.conflictingDevices_.size(); i++) {
1665 conflicting.emplace(resourceCost.conflictingDevices_[i]);
1666 }
1667 return true;
1668 }
1669
OperatePermissionCheck(uint32_t interfaceCode)1670 int32_t HCameraDevice::OperatePermissionCheck(uint32_t interfaceCode)
1671 {
1672 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
1673 int32_t errCode = CheckPermission(OHOS_PERMISSION_CAMERA, callerToken);
1674 CHECK_RETURN_RET(errCode != CAMERA_OK, errCode);
1675 switch (static_cast<ICameraDeviceServiceIpcCode>(interfaceCode)) {
1676 case ICameraDeviceServiceIpcCode::COMMAND_OPEN:
1677 case ICameraDeviceServiceIpcCode::COMMAND_CLOSE:
1678 case ICameraDeviceServiceIpcCode::COMMAND_RELEASE:
1679 case ICameraDeviceServiceIpcCode::COMMAND_SET_CALLBACK:
1680 case ICameraDeviceServiceIpcCode::COMMAND_UN_SET_CALLBACK:
1681 case ICameraDeviceServiceIpcCode::COMMAND_UPDATE_SETTING:
1682 case ICameraDeviceServiceIpcCode::COMMAND_SET_USED_AS_POSITION:
1683 case ICameraDeviceServiceIpcCode::COMMAND_GET_ENABLED_RESULTS:
1684 case ICameraDeviceServiceIpcCode::COMMAND_ENABLE_RESULT:
1685 case ICameraDeviceServiceIpcCode::COMMAND_DISABLE_RESULT: {
1686 CHECK_RETURN_RET_ELOG(callerToken_ != callerToken, CAMERA_OPERATION_NOT_ALLOWED,
1687 "HCameraDevice::OperatePermissionCheck fail, callerToken_ is : %{public}d, now token "
1688 "is %{public}d", callerToken_, callerToken);
1689 break;
1690 }
1691 default:
1692 break;
1693 }
1694 return CAMERA_OK;
1695 }
1696
CallbackEnter(uint32_t code)1697 int32_t HCameraDevice::CallbackEnter([[maybe_unused]] uint32_t code)
1698 {
1699 MEDIA_DEBUG_LOG("start, code:%{public}u", code);
1700 DisableJeMalloc();
1701 int32_t errCode = OperatePermissionCheck(code);
1702 CHECK_RETURN_RET_ELOG(errCode != CAMERA_OK, errCode, "HCameraDevice::OperatePermissionCheck fail");
1703 return CAMERA_OK;
1704 }
CallbackExit(uint32_t code,int32_t result)1705 int32_t HCameraDevice::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result)
1706 {
1707 MEDIA_DEBUG_LOG("leave, code:%{public}u, result:%{public}d", code, result);
1708 return CAMERA_OK;
1709 }
RemoveResourceWhenHostDied()1710 void HCameraDevice::RemoveResourceWhenHostDied()
1711 {
1712 MEDIA_DEBUG_LOG("HCameraDevice::RemoveResourceWhenHostDied start");
1713 CAMERA_SYNC_TRACE;
1714 bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
1715 CHECK_EXECUTE(isFoldable, UnregisterFoldStatusListener());
1716 HCameraDeviceManager::GetInstance()->RemoveDevice(cameraID_);
1717 if (cameraHostManager_) {
1718 cameraHostManager_->RemoveCameraDevice(cameraID_);
1719 cameraHostManager_->UpdateRestoreParamCloseTime(clientName_, cameraID_);
1720 }
1721 POWERMGR_SYSEVENT_CAMERA_DISCONNECT(cameraID_.c_str());
1722 NotifyCameraStatus(CAMERA_CLOSE);
1723 #ifdef MEMMGR_OVERRID
1724 RequireMemory(Memory::CAMERA_END);
1725 #endif
1726 HandlePrivacyAfterCloseDevice();
1727 MEDIA_DEBUG_LOG("HCameraDevice::RemoveResourceWhenHostDied end");
1728 }
1729
NotifyCameraStatus(int32_t state,int32_t msg)1730 void HCameraDevice::NotifyCameraStatus(int32_t state, int32_t msg)
1731 {
1732 OHOS::AAFwk::Want want;
1733 MEDIA_DEBUG_LOG("HCameraDevice::NotifyCameraStatus strat");
1734 want.SetAction(COMMON_EVENT_CAMERA_STATUS);
1735 want.SetParam(CLIENT_USER_ID, clientUserId_);
1736 want.SetParam(CAMERA_ID, cameraID_);
1737 want.SetParam(CAMERA_STATE, state);
1738 int32_t type = GetCameraType();
1739 want.SetParam(IS_SYSTEM_CAMERA, type);
1740 want.SetParam(CAMERA_MSG, msg);
1741 want.SetParam(CLIENT_NAME, clientName_);
1742 MEDIA_DEBUG_LOG(
1743 "OnCameraStatusChanged userId: %{public}d, cameraId: %{public}s, state: %{public}d, "
1744 "cameraType: %{public}d, msg: %{public}d, clientName: %{public}s",
1745 clientUserId_, cameraID_.c_str(), state, type, msg, clientName_.c_str());
1746 EventFwk::CommonEventData CommonEventData { want };
1747 EventFwk::CommonEventPublishInfo publishInfo;
1748 std::vector<std::string> permissionVec { OHOS_PERMISSION_MANAGE_CAMERA_CONFIG };
1749 publishInfo.SetSubscriberPermissions(permissionVec);
1750 EventFwk::CommonEventManager::PublishCommonEvent(CommonEventData, publishInfo);
1751 MEDIA_DEBUG_LOG("HCameraDevice::NotifyCameraStatus end");
1752 }
1753
Open(int32_t concurrentType)1754 int32_t HCameraDevice::Open(int32_t concurrentType)
1755 {
1756 CAMERA_SYNC_TRACE;
1757 CameraXCollie cameraXCollie("HandleOpenConcurrent");
1758 std::lock_guard<std::mutex> lock(g_deviceOpenCloseMutex_);
1759 CHECK_PRINT_ELOG(isOpenedCameraDevice_.load(), "HCameraDevice::Open failed, camera is busy");
1760 CHECK_RETURN_RET_ELOG(!IsInForeGround(callerToken_), CAMERA_ALLOC_ERROR,
1761 "HCameraDevice::Open IsAllowedUsingPermission failed");
1762 MEDIA_INFO_LOG(
1763 "HCameraDevice::Open Camera width concurrent:[%{public}s, %{public}d]", cameraID_.c_str(), concurrentType);
1764 SetCameraConcurrentType(concurrentType);
1765 EnableDeviceOpenedByConcurrent(true);
1766 int32_t result = OpenDevice();
1767 return result;
1768 }
1769
GetConcurrentDevicesTable()1770 std::vector<std::vector<std::int32_t>> HCameraDevice::GetConcurrentDevicesTable()
1771 {
1772 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = GetDeviceAbility();
1773 std::vector<std::vector<std::int32_t>> resultTable;
1774 CHECK_RETURN_RET(ability == nullptr, resultTable);
1775 std::vector<std::int32_t> concurrentList;
1776 int32_t ret;
1777 camera_metadata_item_t item;
1778 ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CONCURRENT_SUPPORTED_CAMERAS, &item);
1779 if (ret == CAM_META_SUCCESS && item.count > 0) {
1780 for (uint32_t index = 0; index < item.count; index++) {
1781 int32_t cameraId = item.data.i32[index];
1782 if (cameraId == -1) {
1783 resultTable.push_back(concurrentList);
1784 concurrentList.clear();
1785 } else {
1786 concurrentList.push_back(cameraId);
1787 }
1788 }
1789 }
1790 resultTable.push_back(concurrentList);
1791 concurrentList.clear();
1792 MEDIA_INFO_LOG("HCameraDevice::GetConcurrentDevicesTable device id : %{public}s"
1793 "find concurrent table size: %{public}zu", cameraID_.c_str(), resultTable.size());
1794 return resultTable;
1795 }
1796 } // namespace CameraStandard
1797 } // namespace OHOS
1798