1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hcamera_service.h"
17
18 #include <securec.h>
19 #include <unordered_set>
20
21 #include "access_token.h"
22 #include "accesstoken_kit.h"
23 #include "camera_util.h"
24 #include "iservice_registry.h"
25 #include "camera_log.h"
26 #include "system_ability_definition.h"
27 #include "ipc_skeleton.h"
28
29 namespace OHOS {
30 namespace CameraStandard {
31 REGISTER_SYSTEM_ABILITY_BY_ID(HCameraService, CAMERA_SERVICE_ID, true)
32 const std::string OHOS_PERMISSION_CAMERA = "ohos.permission.CAMERA";
33 const std::string OHOS_PERMISSION_MANAGE_CAMERA_CONFIG = "ohos.permission.MANAGE_CAMERA_CONFIG";
HCameraService(int32_t systemAbilityId,bool runOnCreate)34 HCameraService::HCameraService(int32_t systemAbilityId, bool runOnCreate)
35 : SystemAbility(systemAbilityId, runOnCreate),
36 cameraHostManager_(nullptr),
37 streamOperatorCallback_(nullptr),
38 muteMode_(false)
39 {
40 }
41
~HCameraService()42 HCameraService::~HCameraService()
43 {
44 }
45
OnStart()46 void HCameraService::OnStart()
47 {
48 if (cameraHostManager_ == nullptr) {
49 cameraHostManager_ = new(std::nothrow) HCameraHostManager(this);
50 if (cameraHostManager_ == nullptr) {
51 MEDIA_ERR_LOG("HCameraService OnStart failed to create HCameraHostManager obj");
52 return;
53 }
54 }
55 if (cameraHostManager_->Init() != CAMERA_OK) {
56 MEDIA_ERR_LOG("HCameraService OnStart failed to init camera host manager.");
57 }
58 bool res = Publish(this);
59 if (res) {
60 MEDIA_INFO_LOG("HCameraService OnStart res=%{public}d", res);
61 }
62 }
63
OnDump()64 void HCameraService::OnDump()
65 {
66 MEDIA_INFO_LOG("HCameraService::OnDump called");
67 }
68
OnStop()69 void HCameraService::OnStop()
70 {
71 MEDIA_INFO_LOG("HCameraService::OnStop called");
72
73 if (cameraHostManager_) {
74 cameraHostManager_->DeInit();
75 delete cameraHostManager_;
76 cameraHostManager_ = nullptr;
77 }
78 if (streamOperatorCallback_) {
79 streamOperatorCallback_ = nullptr;
80 }
81 }
82
CheckPermission(std::string permissionName,OHOS::Security::AccessToken::AccessTokenID callerToken)83 int32_t CheckPermission(std::string permissionName, OHOS::Security::AccessToken::AccessTokenID callerToken)
84 {
85 int permissionResult
86 = OHOS::Security::AccessToken::TypePermissionState::PERMISSION_DENIED;
87 Security::AccessToken::ATokenTypeEnum tokenType
88 = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(callerToken);
89 if ((tokenType == OHOS::Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE)
90 || (tokenType == OHOS::Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)) {
91 permissionResult = OHOS::Security::AccessToken::AccessTokenKit::VerifyAccessToken(
92 callerToken, permissionName);
93 } else {
94 MEDIA_ERR_LOG("HCameraService::CheckPermission: Unsupported Access Token Type");
95 return CAMERA_INVALID_ARG;
96 }
97
98 if (permissionResult != OHOS::Security::AccessToken::TypePermissionState::PERMISSION_GRANTED) {
99 MEDIA_ERR_LOG("HCameraService::CheckPermission: Permission to Access Camera Denied!!!!");
100 return CAMERA_OPERATION_NOT_ALLOWED;
101 } else {
102 MEDIA_DEBUG_LOG("HCameraService::CheckPermission: Permission to Access Camera Granted!!!!");
103 }
104 return CAMERA_OK;
105 }
106
GetCameras(std::vector<std::string> & cameraIds,std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> & cameraAbilityList)107 int32_t HCameraService::GetCameras(std::vector<std::string> &cameraIds,
108 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> &cameraAbilityList)
109 {
110 CAMERA_SYNC_TRACE;
111 int32_t ret = cameraHostManager_->GetCameras(cameraIds);
112 if (ret != CAMERA_OK) {
113 MEDIA_ERR_LOG("HCameraService::GetCameras failed");
114 return ret;
115 }
116
117 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
118 for (auto id : cameraIds) {
119 ret = cameraHostManager_->GetCameraAbility(id, cameraAbility);
120 if (ret != CAMERA_OK) {
121 MEDIA_ERR_LOG("HCameraService::GetCameraAbility failed");
122 return ret;
123 }
124
125 if (cameraAbility == nullptr) {
126 MEDIA_ERR_LOG("HCameraService::GetCameraAbility return null");
127 return CAMERA_INVALID_ARG;
128 }
129
130 camera_metadata_item_t item;
131 common_metadata_header_t* metadata = cameraAbility->get();
132 camera_position_enum_t cameraPosition = OHOS_CAMERA_POSITION_OTHER;
133 int ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_POSITION, &item);
134 if (ret == CAM_META_SUCCESS) {
135 cameraPosition = static_cast<camera_position_enum_t>(item.data.u8[0]);
136 }
137
138 camera_type_enum_t cameraType = OHOS_CAMERA_TYPE_UNSPECIFIED;
139 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &item);
140 if (ret == CAM_META_SUCCESS) {
141 cameraType = static_cast<camera_type_enum_t>(item.data.u8[0]);
142 }
143
144 camera_connection_type_t connectionType = OHOS_CAMERA_CONNECTION_TYPE_BUILTIN;
145 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
146 if (ret == CAM_META_SUCCESS) {
147 connectionType = static_cast<camera_connection_type_t>(item.data.u8[0]);
148 }
149
150 bool isMirrorSupported = false;
151 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &item);
152 if (ret == CAM_META_SUCCESS) {
153 isMirrorSupported = ((item.data.u8[0] == 1) || (item.data.u8[0] == 0));
154 }
155
156 CAMERA_SYSEVENT_STATISTIC(CreateMsg("CameraManager GetCameras camera ID:%s, Camera position:%d,"
157 " Camera Type:%d, Connection Type:%d, Mirror support:%d", id.c_str(),
158 cameraPosition, cameraType, connectionType, isMirrorSupported));
159 cameraAbilityList.emplace_back(cameraAbility);
160 }
161
162 return ret;
163 }
164
CreateCameraDevice(std::string cameraId,sptr<ICameraDeviceService> & device)165 int32_t HCameraService::CreateCameraDevice(std::string cameraId, sptr<ICameraDeviceService> &device)
166 {
167 CAMERA_SYNC_TRACE;
168 OHOS::Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
169
170 std::string permissionName = OHOS_PERMISSION_CAMERA;
171 int32_t ret = CheckPermission(permissionName, callerToken);
172 if (ret != CAMERA_OK) {
173 return ret;
174 }
175 // if callerToken is invalid, will not call IsAllowedUsingPermission
176 if (IsValidTokenId(callerToken) &&
177 !Security::AccessToken::PrivacyKit::IsAllowedUsingPermission(callerToken, permissionName)) {
178 MEDIA_ERR_LOG("HCameraService::CreateCameraDevice is not allowed!");
179 return CAMERA_ALLOC_ERROR;
180 }
181
182 sptr<HCameraDevice> cameraDevice = new(std::nothrow) HCameraDevice(cameraHostManager_, cameraId, callerToken);
183 if (cameraDevice == nullptr) {
184 MEDIA_ERR_LOG("HCameraService::CreateCameraDevice HCameraDevice allocation failed");
185 return CAMERA_ALLOC_ERROR;
186 }
187
188 // when create camera device, update mute setting truely.
189 if (IsCameraMuteSupported(cameraId)) {
190 if (UpdateMuteSetting(cameraDevice, muteMode_) != CAMERA_OK) {
191 MEDIA_ERR_LOG("HCameraService::CreateCameraDevice UpdateMuteSetting Failed, cameraId: %{public}s",
192 cameraId.c_str());
193 }
194 } else {
195 MEDIA_ERR_LOG("HCameraService::CreateCameraDevice MuteCamera not Supported");
196 }
197 cameraDevice->SetStatusCallback(cameraServiceCallbacks_);
198 devices_[cameraId] = cameraDevice;
199 pid_t pid = IPCSkeleton::GetCallingPid();
200 MEDIA_INFO_LOG("HCameraService::CreateCameraDevice Calling pid = %{public}d, Camera created size = %{public}zu",
201 pid, camerasForPid_[pid].size());
202 camerasForPid_[pid].insert(cameraId);
203 device = cameraDevice;
204 CAMERA_SYSEVENT_STATISTIC(CreateMsg("CameraManager_CreateCameraInput CameraId:%s", cameraId.c_str()));
205 return CAMERA_OK;
206 }
207
CreateCaptureSession(sptr<ICaptureSession> & session)208 int32_t HCameraService::CreateCaptureSession(sptr<ICaptureSession> &session)
209 {
210 CAMERA_SYNC_TRACE;
211 std::lock_guard<std::mutex> lock(mutex_);
212 sptr<HCaptureSession> captureSession;
213 if (streamOperatorCallback_ == nullptr) {
214 streamOperatorCallback_ = new(std::nothrow) StreamOperatorCallback();
215 if (streamOperatorCallback_ == nullptr) {
216 MEDIA_ERR_LOG("HCameraService::CreateCaptureSession streamOperatorCallback_ allocation failed");
217 return CAMERA_ALLOC_ERROR;
218 }
219 }
220
221 OHOS::Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
222 captureSession = new(std::nothrow) HCaptureSession(cameraHostManager_, streamOperatorCallback_, callerToken);
223 if (captureSession == nullptr) {
224 MEDIA_ERR_LOG("HCameraService::CreateCaptureSession HCaptureSession allocation failed");
225 return CAMERA_ALLOC_ERROR;
226 }
227 session = captureSession;
228 return CAMERA_OK;
229 }
230
CreatePhotoOutput(const sptr<OHOS::IBufferProducer> & producer,int32_t format,int32_t width,int32_t height,sptr<IStreamCapture> & photoOutput)231 int32_t HCameraService::CreatePhotoOutput(const sptr<OHOS::IBufferProducer> &producer, int32_t format,
232 int32_t width, int32_t height,
233 sptr<IStreamCapture> &photoOutput)
234 {
235 CAMERA_SYNC_TRACE;
236 if ((producer == nullptr) || (width == 0) || (height == 0)) {
237 MEDIA_ERR_LOG("HCameraService::CreatePhotoOutput producer is null");
238 return CAMERA_INVALID_ARG;
239 }
240 sptr<HStreamCapture> streamCapture = new(std::nothrow) HStreamCapture(producer, format, width, height);
241 if (streamCapture == nullptr) {
242 MEDIA_ERR_LOG("HCameraService::CreatePhotoOutput HStreamCapture allocation failed");
243 return CAMERA_ALLOC_ERROR;
244 }
245 POWERMGR_SYSEVENT_CAMERA_CONFIG(PHOTO, producer->GetDefaultWidth(),
246 producer->GetDefaultHeight());
247 photoOutput = streamCapture;
248 return CAMERA_OK;
249 }
250
CreateDeferredPreviewOutput(int32_t format,int32_t width,int32_t height,sptr<IStreamRepeat> & previewOutput)251 int32_t HCameraService::CreateDeferredPreviewOutput(int32_t format,
252 int32_t width, int32_t height,
253 sptr<IStreamRepeat> &previewOutput)
254 {
255 CAMERA_SYNC_TRACE;
256 sptr<HStreamRepeat> streamDeferredPreview;
257
258 if ((width == 0) || (height == 0)) {
259 MEDIA_ERR_LOG("HCameraService::CreateDeferredPreviewOutput producer is null");
260 return CAMERA_INVALID_ARG;
261 }
262 streamDeferredPreview = new(std::nothrow) HStreamRepeat(nullptr, format, width, height, false);
263 if (streamDeferredPreview == nullptr) {
264 MEDIA_ERR_LOG("HCameraService::CreateDeferredPreviewOutput HStreamRepeat allocation failed");
265 return CAMERA_ALLOC_ERROR;
266 }
267 previewOutput = streamDeferredPreview;
268 return CAMERA_OK;
269 }
270
CreatePreviewOutput(const sptr<OHOS::IBufferProducer> & producer,int32_t format,int32_t width,int32_t height,sptr<IStreamRepeat> & previewOutput)271 int32_t HCameraService::CreatePreviewOutput(const sptr<OHOS::IBufferProducer> &producer, int32_t format,
272 int32_t width, int32_t height,
273 sptr<IStreamRepeat> &previewOutput)
274 {
275 CAMERA_SYNC_TRACE;
276 sptr<HStreamRepeat> streamRepeatPreview;
277
278 if ((producer == nullptr) || (width == 0) || (height == 0)) {
279 MEDIA_ERR_LOG("HCameraService::CreatePreviewOutput producer is null");
280 return CAMERA_INVALID_ARG;
281 }
282 streamRepeatPreview = new(std::nothrow) HStreamRepeat(producer, format, width, height, false);
283 if (streamRepeatPreview == nullptr) {
284 MEDIA_ERR_LOG("HCameraService::CreatePreviewOutput HStreamRepeat allocation failed");
285 return CAMERA_ALLOC_ERROR;
286 }
287 POWERMGR_SYSEVENT_CAMERA_CONFIG(PREVIEW, width, height);
288 previewOutput = streamRepeatPreview;
289 return CAMERA_OK;
290 }
291
CreateMetadataOutput(const sptr<OHOS::IBufferProducer> & producer,int32_t format,sptr<IStreamMetadata> & metadataOutput)292 int32_t HCameraService::CreateMetadataOutput(const sptr<OHOS::IBufferProducer> &producer, int32_t format,
293 sptr<IStreamMetadata> &metadataOutput)
294 {
295 CAMERA_SYNC_TRACE;
296 sptr<HStreamMetadata> streamMetadata;
297
298 if (producer == nullptr) {
299 MEDIA_ERR_LOG("HCameraService::CreateMetadataOutput producer is null");
300 return CAMERA_INVALID_ARG;
301 }
302 streamMetadata = new(std::nothrow) HStreamMetadata(producer, format);
303 if (streamMetadata == nullptr) {
304 MEDIA_ERR_LOG("HCameraService::CreateMetadataOutput HStreamMetadata allocation failed");
305 return CAMERA_ALLOC_ERROR;
306 }
307 POWERMGR_SYSEVENT_CAMERA_CONFIG(METADATA, producer->GetDefaultWidth(),
308 producer->GetDefaultHeight());
309 metadataOutput = streamMetadata;
310 return CAMERA_OK;
311 }
312
CreateVideoOutput(const sptr<OHOS::IBufferProducer> & producer,int32_t format,int32_t width,int32_t height,sptr<IStreamRepeat> & videoOutput)313 int32_t HCameraService::CreateVideoOutput(const sptr<OHOS::IBufferProducer> &producer, int32_t format,
314 int32_t width, int32_t height,
315 sptr<IStreamRepeat> &videoOutput)
316 {
317 CAMERA_SYNC_TRACE;
318 sptr<HStreamRepeat> streamRepeatVideo;
319
320 if ((producer == nullptr) || (width == 0) || (height == 0)) {
321 MEDIA_ERR_LOG("HCameraService::CreateVideoOutput producer is null");
322 return CAMERA_INVALID_ARG;
323 }
324 streamRepeatVideo = new(std::nothrow) HStreamRepeat(producer, format, width, height, true);
325 if (streamRepeatVideo == nullptr) {
326 MEDIA_ERR_LOG("HCameraService::CreateVideoOutput HStreamRepeat allocation failed");
327 return CAMERA_ALLOC_ERROR;
328 }
329 POWERMGR_SYSEVENT_CAMERA_CONFIG(VIDEO, producer->GetDefaultWidth(),
330 producer->GetDefaultHeight());
331 videoOutput = streamRepeatVideo;
332 return CAMERA_OK;
333 }
334
OnCameraStatus(const std::string & cameraId,CameraStatus status)335 void HCameraService::OnCameraStatus(const std::string& cameraId, CameraStatus status)
336 {
337 std::lock_guard<std::mutex> lock(cbMutex_);
338 MEDIA_INFO_LOG("HCameraService::OnCameraStatus "
339 "callbacks.size = %{public}zu, cameraId = %{public}s, status = %{public}d, pid = %{public}d",
340 cameraServiceCallbacks_.size(), cameraId.c_str(), status, IPCSkeleton::GetCallingPid());
341 for (auto it : cameraServiceCallbacks_) {
342 if (it.second == nullptr) {
343 MEDIA_ERR_LOG("HCameraService::OnCameraStatus cameraServiceCallback is null, pid = %{public}d",
344 IPCSkeleton::GetCallingPid());
345 continue;
346 }
347 if (it.second != nullptr) {
348 it.second->OnCameraStatusChanged(cameraId, status);
349 }
350 }
351 }
352
OnFlashlightStatus(const std::string & cameraId,FlashStatus status)353 void HCameraService::OnFlashlightStatus(const std::string& cameraId, FlashStatus status)
354 {
355 std::lock_guard<std::mutex> lock(cbMutex_);
356 MEDIA_INFO_LOG("HCameraService::OnFlashlightStatus "
357 "callbacks.size = %{public}zu, cameraId = %{public}s, status = %{public}d, pid = %{public}d",
358 cameraServiceCallbacks_.size(), cameraId.c_str(), status, IPCSkeleton::GetCallingPid());
359 for (auto it : cameraServiceCallbacks_) {
360 if (it.second == nullptr) {
361 MEDIA_ERR_LOG("HCameraService::OnCameraStatus cameraServiceCallback is null, pid = %{public}d",
362 IPCSkeleton::GetCallingPid());
363 continue;
364 }
365 if (it.second != nullptr) {
366 it.second->OnFlashlightStatusChanged(cameraId, status);
367 }
368 }
369 }
370
SetCallback(sptr<ICameraServiceCallback> & callback)371 int32_t HCameraService::SetCallback(sptr<ICameraServiceCallback> &callback)
372 {
373 std::lock_guard<std::mutex> lock(cbMutex_);
374 pid_t pid = IPCSkeleton::GetCallingPid();
375 MEDIA_INFO_LOG("HCameraService::SetCallback pid = %{public}d", pid);
376 if (callback == nullptr) {
377 MEDIA_ERR_LOG("HCameraService::SetCallback callback is null");
378 return CAMERA_INVALID_ARG;
379 }
380 auto callbackItem = cameraServiceCallbacks_.find(pid);
381 if (callbackItem != cameraServiceCallbacks_.end()) {
382 callbackItem->second = nullptr;
383 (void)cameraServiceCallbacks_.erase(callbackItem);
384 }
385 cameraServiceCallbacks_.insert(std::make_pair(pid, callback));
386 for (auto it : devices_) {
387 MEDIA_INFO_LOG("HCameraService::SetCallback Camera:[%{public}s] SetStatusCallback", it.first.c_str());
388 auto item = it.second.promote();
389 if (item != nullptr) {
390 item->SetStatusCallback(cameraServiceCallbacks_);
391 }
392 }
393 return CAMERA_OK;
394 }
395
CloseCameraForDestory(pid_t pid)396 int32_t HCameraService::CloseCameraForDestory(pid_t pid)
397 {
398 MEDIA_INFO_LOG("HCameraService::CloseCameraForDestory pid = %{public}d, Camera created size = %{public}zu",
399 pid, camerasForPid_[pid].size());
400 auto cameraIds = camerasForPid_[pid];
401 for (std::set<std::string>::iterator itIds = cameraIds.begin(); itIds != cameraIds.end(); itIds++) {
402 for (auto it : devices_) {
403 auto item = it.second.promote();
404 if (it.first != *itIds || item == nullptr) {
405 continue;
406 } else {
407 MEDIA_INFO_LOG("HCameraService::CloseCameraForDestory pid = %{public}d,Camera:[%{public}s] need close",
408 pid, it.first.c_str());
409 item->Close();
410 item = nullptr;
411 }
412 }
413 }
414 cameraIds.clear();
415 size_t eraseSize = camerasForPid_.erase(pid);
416 MEDIA_INFO_LOG("HCameraService::CloseCameraForDestory remove cameraId size = %{public}zu", eraseSize);
417 return CAMERA_OK;
418 }
419
UnSetCallback(pid_t pid)420 int32_t HCameraService::UnSetCallback(pid_t pid)
421 {
422 std::lock_guard<std::mutex> lock(cbMutex_);
423 MEDIA_INFO_LOG("HCameraService::UnSetCallback pid = %{public}d, size = %{public}zu",
424 pid, cameraServiceCallbacks_.size());
425 if (!cameraServiceCallbacks_.empty()) {
426 MEDIA_INFO_LOG("HCameraDevice::SetStatusCallback statusSvcCallbacks_ is not empty, reset it");
427 auto it = cameraServiceCallbacks_.find(pid);
428 if ((it != cameraServiceCallbacks_.end()) && (it->second != nullptr)) {
429 it->second = nullptr;
430 cameraServiceCallbacks_.erase(it);
431 }
432 }
433 MEDIA_INFO_LOG("HCameraService::UnSetCallback after erase pid = %{public}d, size = %{public}zu",
434 pid, cameraServiceCallbacks_.size());
435 for (auto it : devices_) {
436 MEDIA_INFO_LOG("HCameraService::UnSetCallback Camera:[%{public}s] SetStatusCallback", it.first.c_str());
437 auto item = it.second.promote();
438 if (item != nullptr) {
439 item->SetStatusCallback(cameraServiceCallbacks_);
440 }
441 }
442 return CAMERA_OK;
443 }
444
SetMuteCallback(sptr<ICameraMuteServiceCallback> & callback)445 int32_t HCameraService::SetMuteCallback(sptr<ICameraMuteServiceCallback> &callback)
446 {
447 OHOS::Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
448 if (callback == nullptr) {
449 MEDIA_ERR_LOG("HCameraService::SetMuteCallback callback is null");
450 return CAMERA_INVALID_ARG;
451 }
452 cameraMuteServiceCallbacks_.insert(std::make_pair(callerToken, callback));
453 return CAMERA_OK;
454 }
455
IsCameraMuteSupported(std::string cameraId)456 bool HCameraService::IsCameraMuteSupported(std::string cameraId)
457 {
458 bool isMuteSupported = false;
459 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
460 int32_t ret = cameraHostManager_->GetCameraAbility(cameraId, cameraAbility);
461 if (ret != CAMERA_OK) {
462 MEDIA_ERR_LOG("HCameraService::IsCameraMuted GetCameraAbility failed");
463 return false;
464 }
465 camera_metadata_item_t item;
466 common_metadata_header_t* metadata = cameraAbility->get();
467 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_MUTE_MODES, &item);
468 if (ret == CAM_META_SUCCESS) {
469 isMuteSupported = true;
470 } else {
471 isMuteSupported = false;
472 MEDIA_ERR_LOG("HCameraService::IsCameraMuted not find MUTE ability");
473 }
474 MEDIA_DEBUG_LOG("HCameraService::IsCameraMuted supported: %{public}d", isMuteSupported);
475 return isMuteSupported;
476 }
477
UpdateMuteSetting(wptr<HCameraDevice> cameraDevice,bool muteMode)478 int32_t HCameraService::UpdateMuteSetting(wptr<HCameraDevice> cameraDevice, bool muteMode)
479 {
480 constexpr uint8_t MUTE_ON = 1;
481 constexpr uint8_t MUTE_OFF = 0;
482 constexpr int32_t DEFAULT_ITEMS = 1;
483 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
484 std::shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata =
485 std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
486 bool status = false;
487 int32_t ret;
488 int32_t count = 1;
489 uint8_t mode = muteMode ? MUTE_ON : MUTE_OFF;
490 camera_metadata_item_t item;
491
492 MEDIA_DEBUG_LOG("UpdateMuteSetting muteMode: %{public}d", muteMode);
493
494 ret = OHOS::Camera::FindCameraMetadataItem(changedMetadata->get(), OHOS_CONTROL_MUTE_MODE, &item);
495 if (ret == CAM_META_ITEM_NOT_FOUND) {
496 status = changedMetadata->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
497 } else if (ret == CAM_META_SUCCESS) {
498 status = changedMetadata->updateEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
499 }
500 ret = cameraDevice->UpdateSetting(changedMetadata);
501 if (!status || ret != CAMERA_OK) {
502 MEDIA_ERR_LOG("UpdateMuteSetting muteMode Failed");
503 return CAMERA_UNKNOWN_ERROR;
504 }
505 return CAMERA_OK;
506 }
507
MuteCamera(bool muteMode)508 int32_t HCameraService::MuteCamera(bool muteMode)
509 {
510 OHOS::Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
511
512 std::string permissionName = OHOS_PERMISSION_MANAGE_CAMERA_CONFIG;
513 int32_t ret = CheckPermission(permissionName, callerToken);
514 if (ret != CAMERA_OK) {
515 MEDIA_ERR_LOG("HCameraService::MuteCamera failed permission is : %{public}s", permissionName.c_str());
516 return ret;
517 }
518
519 bool oldMuteMode = muteMode_;
520 if (muteMode == oldMuteMode) {
521 return CAMERA_OK;
522 } else {
523 muteMode_ = muteMode;
524 }
525 if (devices_.empty()) {
526 if (!cameraMuteServiceCallbacks_.empty()) {
527 for (auto cb : cameraMuteServiceCallbacks_) {
528 cb.second->OnCameraMute(muteMode);
529 CAMERA_SYSEVENT_BEHAVIOR(CreateMsg("OnCameraMute! current Camera muteMode:%d", muteMode));
530 }
531 }
532 return CAMERA_OK;
533 }
534
535 for (auto it : devices_) {
536 if (!IsCameraMuteSupported(it.first)) {
537 MEDIA_ERR_LOG("HCameraService::MuteCamera not Supported Mute,cameraId: %{public}s", it.first.c_str());
538 break;
539 }
540 auto item = it.second.promote();
541 if (item != nullptr) {
542 ret = UpdateMuteSetting(it.second, muteMode);
543 }
544 if (ret != CAMERA_OK) {
545 MEDIA_ERR_LOG("HCameraService::MuteCamera UpdateMuteSetting Failed, cameraId: %{public}s",
546 it.first.c_str());
547 muteMode_ = oldMuteMode;
548 break;
549 }
550 }
551 if (!cameraMuteServiceCallbacks_.empty() && ret == CAMERA_OK) {
552 for (auto cb : cameraMuteServiceCallbacks_) {
553 if (cb.second) {
554 cb.second->OnCameraMute(muteMode);
555 }
556 CAMERA_SYSEVENT_BEHAVIOR(CreateMsg("OnCameraMute! current Camera muteMode:%d", muteMode));
557 }
558 }
559 return ret;
560 }
561
IsCameraMuted(bool & muteMode)562 int32_t HCameraService::IsCameraMuted(bool &muteMode)
563 {
564 muteMode = muteMode_;
565 MEDIA_DEBUG_LOG("HCameraService::IsCameraMuted success. isMuted: %{public}d", muteMode);
566 return CAMERA_OK;
567 }
568
CameraSummary(std::vector<std::string> cameraIds,std::string & dumpString)569 void HCameraService::CameraSummary(std::vector<std::string> cameraIds,
570 std::string& dumpString)
571 {
572 dumpString += "# Number of Cameras:[" + std::to_string(cameraIds.size()) + "]:\n";
573 dumpString += "# Number of Active Cameras:[" + std::to_string(devices_.size()) + "]:\n";
574 HCaptureSession::CameraSessionSummary(dumpString);
575 }
576
CameraDumpAbility(common_metadata_header_t * metadataEntry,std::string & dumpString)577 void HCameraService::CameraDumpAbility(common_metadata_header_t* metadataEntry,
578 std::string& dumpString)
579 {
580 camera_metadata_item_t item;
581 int ret;
582 dumpString += " ## Camera Ability List: \n";
583
584 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_CAMERA_POSITION, &item);
585 if (ret == CAM_META_SUCCESS) {
586 std::map<int, std::string>::const_iterator iter =
587 g_cameraPos.find(item.data.u8[0]);
588 if (iter != g_cameraPos.end()) {
589 dumpString += " Camera Position:["
590 + iter->second
591 + "]: ";
592 }
593 }
594
595 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_CAMERA_TYPE, &item);
596 if (ret == CAM_META_SUCCESS) {
597 std::map<int, std::string>::const_iterator iter =
598 g_cameraType.find(item.data.u8[0]);
599 if (iter != g_cameraType.end()) {
600 dumpString += "Camera Type:["
601 + iter->second
602 + "]: ";
603 }
604 }
605
606 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
607 if (ret == CAM_META_SUCCESS) {
608 std::map<int, std::string>::const_iterator iter =
609 g_cameraConType.find(item.data.u8[0]);
610 if (iter != g_cameraConType.end()) {
611 dumpString += "Camera Connection Type:["
612 + iter->second
613 + "]:\n";
614 }
615 }
616 }
617
CameraDumpStreaminfo(common_metadata_header_t * metadataEntry,std::string & dumpString)618 void HCameraService::CameraDumpStreaminfo(common_metadata_header_t* metadataEntry,
619 std::string& dumpString)
620 {
621 camera_metadata_item_t item;
622 int ret;
623 constexpr uint32_t unitLen = 3;
624 uint32_t widthOffset = 1;
625 uint32_t heightOffset = 2;
626 dumpString += " ### Camera Available stream configuration List: \n";
627 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry,
628 OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item);
629 if (ret == CAM_META_SUCCESS) {
630 dumpString += " Number Stream Info: "
631 + std::to_string(item.count/unitLen) + "\n";
632 for (uint32_t index = 0; index < item.count; index += unitLen) {
633 std::map<int, std::string>::const_iterator iter =
634 g_cameraFormat.find(item.data.i32[index]);
635 if (iter != g_cameraFormat.end()) {
636 dumpString += " Format:["
637 + iter->second
638 + "]: ";
639 dumpString += "Size:[Width:"
640 + std::to_string(item.data.i32[index + widthOffset])
641 + " Height:"
642 + std::to_string(item.data.i32[index + heightOffset])
643 + "]:\n";
644 }
645 }
646 }
647 }
648
CameraDumpZoom(common_metadata_header_t * metadataEntry,std::string & dumpString)649 void HCameraService::CameraDumpZoom(common_metadata_header_t* metadataEntry,
650 std::string& dumpString)
651 {
652 dumpString += " ## Zoom Related Info: \n";
653 camera_metadata_item_t item;
654 int ret;
655 int32_t minIndex = 0;
656 int32_t maxIndex = 1;
657 uint32_t zoomRangeCount = 2;
658 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_ZOOM_CAP, &item);
659 if ((ret == CAM_META_SUCCESS) && (item.count == zoomRangeCount)) {
660 dumpString += " Available Zoom Capability:["
661 + std::to_string(item.data.i32[minIndex]) + " "
662 + std::to_string(item.data.i32[maxIndex])
663 + "]:\n";
664 }
665
666 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_SCENE_ZOOM_CAP, &item);
667 if ((ret == CAM_META_SUCCESS) && (item.count == zoomRangeCount)) {
668 dumpString += " Available scene Zoom Capability:["
669 + std::to_string(item.data.i32[minIndex]) + " "
670 + std::to_string(item.data.i32[maxIndex])
671 + "]:\n";
672 }
673
674 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_ZOOM_RATIO_RANGE, &item);
675 if ((ret == CAM_META_SUCCESS) && (item.count == zoomRangeCount)) {
676 dumpString += " Available Zoom Ratio Range:["
677 + std::to_string(item.data.f[minIndex])
678 + std::to_string(item.data.f[maxIndex])
679 + "]:\n";
680 }
681
682 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_CONTROL_ZOOM_RATIO, &item);
683 if (ret == CAM_META_SUCCESS) {
684 dumpString += " Set Zoom Ratio:["
685 + std::to_string(item.data.f[0])
686 + "]:\n";
687 }
688 }
689
CameraDumpFlash(common_metadata_header_t * metadataEntry,std::string & dumpString)690 void HCameraService::CameraDumpFlash(common_metadata_header_t* metadataEntry,
691 std::string& dumpString)
692 {
693 camera_metadata_item_t item;
694 int ret;
695 dumpString += " ## Flash Related Info: \n";
696 dumpString += " Available Flash Modes:[";
697 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_FLASH_MODES, &item);
698 if (ret == CAM_META_SUCCESS) {
699 for (uint32_t i = 0; i < item.count; i++) {
700 std::map<int, std::string>::const_iterator iter =
701 g_cameraFlashMode.find(item.data.u8[i]);
702 if (iter != g_cameraFlashMode.end()) {
703 dumpString += " " + iter->second;
704 }
705 }
706 dumpString += "]:\n";
707 }
708
709 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_CONTROL_FLASH_MODE, &item);
710 if (ret == CAM_META_SUCCESS) {
711 std::map<int, std::string>::const_iterator iter =
712 g_cameraFlashMode.find(item.data.u8[0]);
713 if (iter != g_cameraFlashMode.end()) {
714 dumpString += " Set Flash Mode:["
715 + iter->second
716 + "]:\n";
717 }
718 }
719 }
720
CameraDumpAF(common_metadata_header_t * metadataEntry,std::string & dumpString)721 void HCameraService::CameraDumpAF(common_metadata_header_t* metadataEntry,
722 std::string& dumpString)
723 {
724 camera_metadata_item_t item;
725 int ret;
726 dumpString += " ## AF Related Info: \n";
727 dumpString += " Available Focus Modes:[";
728
729 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_FOCUS_MODES, &item);
730 if (ret == CAM_META_SUCCESS) {
731 for (uint32_t i = 0; i < item.count; i++) {
732 std::map<int, std::string>::const_iterator iter =
733 g_cameraFocusMode.find(item.data.u8[i]);
734 if (iter != g_cameraFocusMode.end()) {
735 dumpString += " " + iter->second;
736 }
737 }
738 dumpString += "]:\n";
739 }
740
741 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_CONTROL_FOCUS_MODE, &item);
742 if (ret == CAM_META_SUCCESS) {
743 std::map<int, std::string>::const_iterator iter =
744 g_cameraFocusMode.find(item.data.u8[0]);
745 if (iter != g_cameraFocusMode.end()) {
746 dumpString += " Set Focus Mode:["
747 + iter->second
748 + "]:\n";
749 }
750 }
751 }
752
CameraDumpAE(common_metadata_header_t * metadataEntry,std::string & dumpString)753 void HCameraService::CameraDumpAE(common_metadata_header_t* metadataEntry,
754 std::string& dumpString)
755 {
756 camera_metadata_item_t item;
757 int ret;
758 dumpString += " ## AE Related Info: \n";
759 dumpString += " Available Exposure Modes:[";
760
761 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_EXPOSURE_MODES, &item);
762 if (ret == CAM_META_SUCCESS) {
763 for (uint32_t i = 0; i < item.count; i++) {
764 std::map<int, std::string>::const_iterator iter =
765 g_cameraExposureMode.find(item.data.u8[i]);
766 if (iter != g_cameraExposureMode.end()) {
767 dumpString += " " + iter->second;
768 }
769 }
770 dumpString += "]:\n";
771 }
772
773 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_CONTROL_EXPOSURE_MODE, &item);
774 if (ret == CAM_META_SUCCESS) {
775 std::map<int, std::string>::const_iterator iter =
776 g_cameraExposureMode.find(item.data.u8[0]);
777 if (iter != g_cameraExposureMode.end()) {
778 dumpString += " Set exposure Mode:["
779 + iter->second
780 + "]:\n";
781 }
782 }
783 }
784
CameraDumpSensorInfo(common_metadata_header_t * metadataEntry,std::string & dumpString)785 void HCameraService::CameraDumpSensorInfo(common_metadata_header_t* metadataEntry,
786 std::string& dumpString)
787 {
788 camera_metadata_item_t item;
789 int ret;
790 dumpString += " ## Sensor Info Info: \n";
791 int32_t leftIndex = 0;
792 int32_t topIndex = 1;
793 int32_t rightIndex = 2;
794 int32_t bottomIndex = 3;
795 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &item);
796 if (ret == CAM_META_SUCCESS) {
797 dumpString += " Array:["
798 + std::to_string(item.data.i32[leftIndex]) + " "
799 + std::to_string(item.data.i32[topIndex]) + " "
800 + std::to_string(item.data.i32[rightIndex]) + " "
801 + std::to_string(item.data.i32[bottomIndex])
802 + "]:\n";
803 }
804 }
805
CameraDumpVideoStabilization(common_metadata_header_t * metadataEntry,std::string & dumpString)806 void HCameraService::CameraDumpVideoStabilization(common_metadata_header_t* metadataEntry,
807 std::string& dumpString)
808 {
809 camera_metadata_item_t item;
810 int ret;
811 dumpString += " ## Video Stabilization Related Info: \n";
812 dumpString += " Available Video Stabilization Modes:[";
813
814 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &item);
815 if (ret == CAM_META_SUCCESS) {
816 for (uint32_t i = 0; i < item.count; i++) {
817 std::map<int, std::string>::const_iterator iter =
818 g_cameraVideoStabilizationMode.find(item.data.u8[i]);
819 if (iter != g_cameraVideoStabilizationMode.end()) {
820 dumpString += " " + iter->second;
821 }
822 }
823 dumpString += "]:\n";
824 }
825
826 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &item);
827 if (ret == CAM_META_SUCCESS) {
828 std::map<int, std::string>::const_iterator iter =
829 g_cameraVideoStabilizationMode.find(item.data.u8[0]);
830 if (iter != g_cameraVideoStabilizationMode.end()) {
831 dumpString += " Set Stabilization Mode:["
832 + iter->second
833 + "]:\n";
834 }
835 }
836 }
837
CameraDumpVideoFrameRateRange(common_metadata_header_t * metadataEntry,std::string & dumpString)838 void HCameraService::CameraDumpVideoFrameRateRange(common_metadata_header_t* metadataEntry,
839 std::string& dumpString)
840 {
841 camera_metadata_item_t item;
842 const int32_t FRAME_RATE_RANGE_STEP = 2;
843 int ret;
844 dumpString += " ## Video FrameRateRange Related Info: \n";
845 dumpString += " Available FrameRateRange :\n";
846
847 ret = OHOS::Camera::FindCameraMetadataItem(metadataEntry, OHOS_ABILITY_FPS_RANGES, &item);
848 if (ret == CAM_META_SUCCESS) {
849 for (uint32_t i = 0; i < (item.count - 1); i += FRAME_RATE_RANGE_STEP) {
850 dumpString += " [ " + std::to_string(item.data.i32[i]) + ", " +
851 std::to_string(item.data.i32[i+1]) + " ]\n";
852 }
853 dumpString += "\n";
854 }
855 }
856
Dump(int fd,const std::vector<std::u16string> & args)857 int32_t HCameraService::Dump(int fd, const std::vector<std::u16string>& args)
858 {
859 std::unordered_set<std::u16string> argSets;
860 std::u16string arg1(u"summary");
861 std::u16string arg2(u"ability");
862 std::u16string arg3(u"clientwiseinfo");
863 for (decltype(args.size()) index = 0; index < args.size(); ++index) {
864 argSets.insert(args[index]);
865 }
866 std::string dumpString;
867 std::vector<std::string> cameraIds;
868 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList;
869 int32_t capIdx = 0;
870 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata;
871 int ret;
872
873 ret = GetCameras(cameraIds, cameraAbilityList);
874 if ((ret != CAMERA_OK) || cameraIds.empty()
875 || (cameraAbilityList.empty())) {
876 return CAMERA_INVALID_STATE;
877 }
878 if (args.size() == 0 || argSets.count(arg1) != 0) {
879 dumpString += "-------- Summary -------\n";
880 CameraSummary(cameraIds, dumpString);
881 }
882 if (args.size() == 0 || argSets.count(arg2) != 0) {
883 dumpString += "-------- CameraDevice -------\n";
884 for (auto& it : cameraIds) {
885 metadata = cameraAbilityList[capIdx++];
886 common_metadata_header_t* metadataEntry = metadata->get();
887 dumpString += "# Camera ID:[" + it + "]: \n";
888 CameraDumpAbility(metadataEntry, dumpString);
889 CameraDumpStreaminfo(metadataEntry, dumpString);
890 CameraDumpZoom(metadataEntry, dumpString);
891 CameraDumpFlash(metadataEntry, dumpString);
892 CameraDumpAF(metadataEntry, dumpString);
893 CameraDumpAE(metadataEntry, dumpString);
894 CameraDumpSensorInfo(metadataEntry, dumpString);
895 CameraDumpVideoStabilization(metadataEntry, dumpString);
896 CameraDumpVideoFrameRateRange(metadataEntry, dumpString);
897 }
898 }
899 if (args.size() == 0 || argSets.count(arg3) != 0) {
900 dumpString += "-------- Clientwise Info -------\n";
901 HCaptureSession::dumpSessions(dumpString);
902 }
903
904 if (dumpString.size() == 0) {
905 MEDIA_ERR_LOG("Dump string empty!");
906 return CAMERA_INVALID_STATE;
907 }
908
909 (void)write(fd, dumpString.c_str(), dumpString.size());
910 return CAMERA_OK;
911 }
912 } // namespace CameraStandard
913 } // namespace OHOS
914