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_stub.h"
17
18 #include <cinttypes>
19
20 #include "camera_log.h"
21 #include "camera_service_ipc_interface_code.h"
22 #include "camera_util.h"
23 #include "camera_xcollie.h"
24 #include "hcapture_session.h"
25 #include "input/i_standard_camera_listener.h"
26 #include "ipc_skeleton.h"
27 #include "metadata_utils.h"
28 #ifdef MEMMGR_OVERRID
29 #endif
30
31 namespace OHOS {
32 namespace CameraStandard {
HCameraServiceStub()33 HCameraServiceStub::HCameraServiceStub()
34 {
35 MEDIA_DEBUG_LOG("0x%{public}06" PRIXPTR " Instances create", (POINTER_MASK & reinterpret_cast<uintptr_t>(this)));
36 }
37
~HCameraServiceStub()38 HCameraServiceStub::~HCameraServiceStub()
39 {
40 MEDIA_DEBUG_LOG("0x%{public}06" PRIXPTR " Instances destroy", (POINTER_MASK & reinterpret_cast<uintptr_t>(this)));
41 }
42
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)43 int HCameraServiceStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
44 {
45 DisableJeMalloc();
46 int errCode = -1;
47 CHECK_ERROR_RETURN_RET(data.ReadInterfaceToken() != GetDescriptor(), errCode);
48 CameraXCollie cameraXCollie = CameraXCollie("CameraServiceStub " + std::to_string(code));
49 switch (code) {
50 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEVICE):
51 errCode = HCameraServiceStub::HandleCreateCameraDevice(data, reply);
52 break;
53 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_CAMERA_CALLBACK):
54 errCode = HCameraServiceStub::HandleSetCameraCallback(data, reply);
55 break;
56 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_UNSET_CAMERA_CALLBACK):
57 errCode = UnSetCameraCallback();
58 break;
59 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_MUTE_CALLBACK):
60 errCode = HCameraServiceStub::HandleSetMuteCallback(data, reply);
61 break;
62 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_UNSET_MUTE_CALLBACK):
63 errCode = UnSetMuteCallback();
64 break;
65 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_TORCH_CALLBACK):
66 errCode = HCameraServiceStub::HandleSetTorchCallback(data, reply);
67 break;
68 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_UNSET_TORCH_CALLBACK):
69 errCode = UnSetTorchCallback();
70 break;
71 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_FOLD_CALLBACK):
72 errCode = HCameraServiceStub::HandleSetFoldStatusCallback(data, reply);
73 break;
74 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_UNSET_FOLD_CALLBACK):
75 errCode = UnSetFoldStatusCallback();
76 break;
77 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_CAMERAS):
78 errCode = HCameraServiceStub::HandleGetCameras(data, reply);
79 break;
80 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_CAMERA_IDS):
81 errCode = HCameraServiceStub::HandleGetCameraIds(data, reply);
82 break;
83 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_CAMERA_ABILITY):
84 errCode = HCameraServiceStub::HandleGetCameraAbility(data, reply);
85 break;
86 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_CAPTURE_SESSION):
87 errCode = HCameraServiceStub::HandleCreateCaptureSession(data, reply);
88 break;
89 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEFERRED_PHOTO_PROCESSING_SESSION):
90 errCode = HCameraServiceStub::HandleCreateDeferredPhotoProcessingSession(data, reply);
91 break;
92 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEFERRED_VIDEO_PROCESSING_SESSION):
93 errCode = HCameraServiceStub::HandleCreateDeferredVideoProcessingSession(data, reply);
94 break;
95 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_PHOTO_OUTPUT):
96 errCode = HCameraServiceStub::HandleCreatePhotoOutput(data, reply);
97 break;
98 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_PREVIEW_OUTPUT):
99 errCode = HCameraServiceStub::HandleCreatePreviewOutput(data, reply);
100 break;
101 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEFERRED_PREVIEW_OUTPUT):
102 errCode = HCameraServiceStub::HandleCreateDeferredPreviewOutput(data, reply);
103 break;
104 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEPTH_DATA_OUTPUT):
105 errCode = HCameraServiceStub::HandleCreateDepthDataOutput(data, reply);
106 break;
107 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_VIDEO_OUTPUT):
108 errCode = HCameraServiceStub::HandleCreateVideoOutput(data, reply);
109 break;
110 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_LISTENER_OBJ):
111 errCode = HCameraServiceStub::SetListenerObject(data, reply);
112 break;
113 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_METADATA_OUTPUT):
114 errCode = HCameraServiceStub::HandleCreateMetadataOutput(data, reply);
115 break;
116 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_MUTE_CAMERA):
117 errCode = HCameraServiceStub::HandleMuteCamera(data, reply);
118 break;
119 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_MUTE_CAMERA_PERSIST):
120 errCode = HCameraServiceStub::HandleMuteCameraPersist(data, reply);
121 break;
122 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_IS_TORCH_SUPPORTED):
123 errCode = HCameraServiceStub::HandleIsTorchSupported(data, reply);
124 break;
125 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_IS_MUTE_SUPPORTED):
126 errCode = HCameraServiceStub::HandleIsCameraMuteSupported(data, reply);
127 break;
128 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_IS_CAMERA_MUTED):
129 cameraXCollie.CancelCameraXCollie();
130 errCode = HCameraServiceStub::HandleIsCameraMuted(data, reply);
131 break;
132 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_TORCH_STATUS):
133 errCode = HCameraServiceStub::HandleGetTorchStatus(data, reply);
134 break;
135 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_PRE_LAUNCH_CAMERA):
136 errCode = HCameraServiceStub::HandlePrelaunchCamera(data, reply);
137 break;
138 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_PRE_LAUNCH_CAMERA):
139 errCode = HCameraServiceStub::HandleSetPrelaunchConfig(data, reply);
140 break;
141 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_TORCH_LEVEL):
142 errCode = HCameraServiceStub::HandleSetTorchLevel(data, reply);
143 break;
144 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_PRE_SWITCH_CAMERA):
145 errCode = HCameraServiceStub::HandlePreSwitchCamera(data, reply);
146 break;
147 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_DESTROY_STUB_OBJ):
148 errCode = HCameraServiceStub::DestroyStubObj();
149 break;
150 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_PROXY_FOR_FREEZE):
151 errCode = HCameraServiceStub::HandleProxyForFreeze(data, reply);
152 break;
153 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_RESET_ALL_FREEZE_STATUS):
154 errCode = HCameraServiceStub::HandleResetAllFreezeStatus(data, reply);
155 break;
156 case static_cast<uint32_t>(CameraServiceDHInterfaceCode::CAMERA_SERVICE_ALLOW_OPEN_BY_OHSIDE):
157 errCode = HCameraServiceStub::HandleAllowOpenByOHSide(data, reply);
158 break;
159 case static_cast<uint32_t>(CameraServiceDHInterfaceCode::CAMERA_SERVICE_NOTIFY_CAMERA_STATE):
160 errCode = HCameraServiceStub::HandleNotifyCameraState(data);
161 break;
162 case static_cast<uint32_t>(CameraServiceDHInterfaceCode::CAMERA_SERVICE_SET_PEER_CALLBACK):
163 errCode = HCameraServiceStub::HandleSetPeerCallback(data);
164 break;
165 case static_cast<uint32_t>(CameraServiceDHInterfaceCode::CAMERA_SERVICE_UNSET_PEER_CALLBACK):
166 errCode = HCameraServiceStub::HandleUnsetPeerCallback(data);
167 break;
168 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_DM_DEVICE_INFOS):
169 errCode = HCameraServiceStub::HandleGetDmDeviceInfo(data, reply);
170 break;
171 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_CAMERA_OUTPUT_STATUS):
172 errCode = HCameraServiceStub::HandleGetCameraOutputStatus(data, reply);
173 break;
174 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_REQUIRE_MEMORY_SIZE):
175 errCode = HCameraServiceStub::HandleRequireMemorySize(data, reply);
176 break;
177 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GETID_FOR_CONCURRENT):
178 errCode = HCameraServiceStub::HandleGetIdforCameraConcurrentType(data, reply);
179 break;
180 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_GET_CONCURRENT_CAMERA_ABILITY):
181 errCode = HCameraServiceStub::HandleGetConcurrentCameraAbility(data, reply);
182 break;
183 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CHECK_WHITE_LIST):
184 errCode = HCameraServiceStub::HandleCheckWhiteList(data, reply);
185 break;
186 default:
187 MEDIA_ERR_LOG("HCameraServiceStub request code %{public}d not handled", code);
188 errCode = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
189 break;
190 }
191
192 return errCode;
193 }
194
HandleGetCameras(MessageParcel & data,MessageParcel & reply)195 int HCameraServiceStub::HandleGetCameras(MessageParcel& data, MessageParcel& reply)
196 {
197 std::vector<std::string> cameraIds;
198 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList;
199
200 int ret = GetCameras(cameraIds, cameraAbilityList);
201 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteStringVector(cameraIds), IPC_STUB_WRITE_PARCEL_ERR,
202 "HCameraServiceStub HandleGetCameras WriteStringVector failed");
203
204 int count = static_cast<int>(cameraAbilityList.size());
205 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteInt32(count), IPC_STUB_WRITE_PARCEL_ERR,
206 "HCameraServiceStub HandleGetCameras Write vector size failed");
207
208 for (auto cameraAbility : cameraAbilityList) {
209 bool result = OHOS::Camera::MetadataUtils::EncodeCameraMetadata(cameraAbility, reply);
210 CHECK_ERROR_RETURN_RET_LOG(!result, IPC_STUB_WRITE_PARCEL_ERR,
211 "HCameraServiceStub HandleGetCameras write ability failed");
212 }
213
214 return ret;
215 }
216
HandleGetCameraIds(MessageParcel & data,MessageParcel & reply)217 int HCameraServiceStub::HandleGetCameraIds(MessageParcel& data, MessageParcel& reply)
218 {
219 std::vector<std::string> cameraIds;
220 int ret = GetCameraIds(cameraIds);
221 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteStringVector(cameraIds), IPC_STUB_WRITE_PARCEL_ERR,
222 "HCameraServiceStub HandleGetCameras WriteStringVector failed");
223
224 int count = static_cast<int>(cameraIds.size());
225 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteInt32(count), IPC_STUB_WRITE_PARCEL_ERR,
226 "HCameraServiceStub HandleGetCameras Write vector size failed");
227
228 return ret;
229 }
230
HandleGetCameraAbility(MessageParcel & data,MessageParcel & reply)231 int HCameraServiceStub::HandleGetCameraAbility(MessageParcel& data, MessageParcel& reply)
232 {
233 std::string cameraId = data.ReadString();
234 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
235 int ret = GetCameraAbility(cameraId, cameraAbility);
236 bool result = OHOS::Camera::MetadataUtils::EncodeCameraMetadata(cameraAbility, reply);
237 CHECK_ERROR_RETURN_RET_LOG(!result, IPC_STUB_WRITE_PARCEL_ERR,
238 "HCameraServiceStub HandleGetCameraAbility write ability failed");
239
240 return ret;
241 }
242
HandleCreateCameraDevice(MessageParcel & data,MessageParcel & reply)243 int HCameraServiceStub::HandleCreateCameraDevice(MessageParcel& data, MessageParcel& reply)
244 {
245 std::string cameraId = data.ReadString();
246 sptr<ICameraDeviceService> device = nullptr;
247
248 int ret = CreateCameraDevice(cameraId, device);
249 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
250 "HCameraServiceStub HandleCreateCameraDevice Create camera device failed : %{public}d", ret);
251
252 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(device->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
253 "HCameraServiceStub HandleCreateCameraDevice Write CameraDevice obj failed");
254
255 return ret;
256 }
257
HandleIsTorchSupported(MessageParcel & data,MessageParcel & reply)258 int HCameraServiceStub::HandleIsTorchSupported(MessageParcel &data, MessageParcel &reply)
259 {
260 bool isTorchSupported = false;
261 int32_t ret = IsTorchSupported(isTorchSupported);
262 MEDIA_INFO_LOG("HCameraServiceStub HandleIsTorchSupported result: %{public}d, isTorchSupported: %{public}d",
263 ret, isTorchSupported);
264 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteBool(isTorchSupported), IPC_STUB_WRITE_PARCEL_ERR,
265 "HCameraServiceStub HandleIsTorchSupported Write isTorchSupported failed");
266 return ret;
267 }
268
HandleIsCameraMuteSupported(MessageParcel & data,MessageParcel & reply)269 int HCameraServiceStub::HandleIsCameraMuteSupported(MessageParcel &data, MessageParcel &reply)
270 {
271 bool isCameraMuteSupported = false;
272 int32_t ret = IsCameraMuteSupported(isCameraMuteSupported);
273 MEDIA_INFO_LOG("HCameraServiceStub isCameraMuteSupported result: %{public}d, isTorchSupported: %{public}d",
274 ret, isCameraMuteSupported);
275 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteBool(isCameraMuteSupported), IPC_STUB_WRITE_PARCEL_ERR,
276 "HCameraServiceStub HandleIsCameraMuteSupported Write isCameraMuteSupported failed");
277 return ret;
278 }
279
HandleMuteCamera(MessageParcel & data,MessageParcel & reply)280 int HCameraServiceStub::HandleMuteCamera(MessageParcel& data, MessageParcel& reply)
281 {
282 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
283
284 bool muteMode = data.ReadBool();
285 MEDIA_DEBUG_LOG("HCameraServiceStub HandleMuteCamera read muteMode : %{public}d", muteMode);
286
287 int32_t ret = MuteCamera(muteMode);
288 MEDIA_INFO_LOG("HCameraServiceStub HandleMuteCamera MuteCamera result: %{public}d", ret);
289
290 return ret;
291 }
292
HandleMuteCameraPersist(MessageParcel & data,MessageParcel & reply)293 int HCameraServiceStub::HandleMuteCameraPersist(MessageParcel& data, MessageParcel& reply)
294 {
295 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
296
297 int32_t policyType = data.ReadInt32();
298 MEDIA_DEBUG_LOG("HCameraServiceStub HandleMuteCameraPersist read policyType : %{public}d", policyType);
299 bool muteMode = data.ReadBool();
300 MEDIA_DEBUG_LOG("HCameraServiceStub HandleMuteCameraPersist read muteMode : %{public}d", muteMode);
301
302 int32_t ret = MuteCameraPersist(static_cast<PolicyType>(policyType), muteMode);
303 MEDIA_INFO_LOG("HCameraServiceStub HandleMuteCameraPersist MuteCamera result: %{public}d", ret);
304
305 return ret;
306 }
307
HandlePrelaunchCamera(MessageParcel & data,MessageParcel & reply)308 int HCameraServiceStub::HandlePrelaunchCamera(MessageParcel& data, MessageParcel& reply)
309 {
310 MEDIA_DEBUG_LOG("HCameraServiceStub HandlePrelaunchCamera enter");
311 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
312
313 int32_t ret = PrelaunchCamera();
314 MEDIA_INFO_LOG("HCameraServiceStub HandlePrelaunchCamera result: %{public}d", ret);
315
316 return ret;
317 }
318
HandlePreSwitchCamera(MessageParcel & data,MessageParcel & reply)319 int HCameraServiceStub::HandlePreSwitchCamera(MessageParcel& data, MessageParcel& reply)
320 {
321 MEDIA_DEBUG_LOG("HCameraServiceStub HandlePreSwitchCamera enter");
322 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
323
324 auto cameraId = data.ReadString();
325 CHECK_ERROR_RETURN_RET(cameraId.empty() || cameraId.length() > PATH_MAX, CAMERA_INVALID_ARG);
326
327 int32_t ret = PreSwitchCamera(cameraId);
328 MEDIA_INFO_LOG("HCameraServiceStub HandlePreSwitchCamera result: %{public}d", ret);
329
330 return ret;
331 }
332
HandleSetPrelaunchConfig(MessageParcel & data,MessageParcel & reply)333 int HCameraServiceStub::HandleSetPrelaunchConfig(MessageParcel& data, MessageParcel& reply)
334 {
335 MEDIA_DEBUG_LOG("HCameraServiceStub HandleSetPrelaunchConfig enter");
336 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
337
338 std::string cameraId = data.ReadString();
339 RestoreParamTypeOhos restoreTypeParam = static_cast<RestoreParamTypeOhos>(data.ReadUint32());
340 int32_t activeTime = static_cast<int32_t>(data.ReadUint32());
341 EffectParam effectParam;
342 effectParam.skinSmoothLevel = static_cast<int>(data.ReadUint32());
343 effectParam.faceSlender = static_cast<int32_t>(data.ReadUint32());
344 effectParam.skinTone = static_cast<int32_t>(data.ReadUint32());
345 int32_t ret = SetPrelaunchConfig(cameraId, restoreTypeParam, activeTime, effectParam);
346 MEDIA_INFO_LOG("HCameraServiceStub HandleSetPrelaunchConfig result: %{public}d", ret);
347
348 return ret;
349 }
350
HandleIsCameraMuted(MessageParcel & data,MessageParcel & reply)351 int HCameraServiceStub::HandleIsCameraMuted(MessageParcel& data, MessageParcel& reply)
352 {
353 bool isMuted = false;
354 int32_t ret = IsCameraMuted(isMuted);
355 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
356 "HCameraServiceStub HandleIsCameraMuted result: %{public}d, isMuted: %{public}d", ret, isMuted);
357 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteBool(isMuted), IPC_STUB_WRITE_PARCEL_ERR,
358 "HCameraServiceStub HandleIsCameraMuted Write isMuted failed");
359
360 return ret;
361 }
362
HandleGetTorchStatus(MessageParcel & data,MessageParcel & reply)363 int HCameraServiceStub::HandleGetTorchStatus(MessageParcel& data, MessageParcel& reply)
364 {
365 int32_t status = 0;
366 int32_t ret = GetTorchStatus(status);
367 MEDIA_INFO_LOG("HCameraServiceStub HandleGetTorchStatus result: %{public}d, status: %{public}d", ret, status);
368 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteInt32(status), IPC_STUB_WRITE_PARCEL_ERR,
369 "HCameraServiceStub HandleGetTorchStatus Write status failed");
370 return ret;
371 }
372
HandleSetCameraCallback(MessageParcel & data,MessageParcel & reply)373 int HCameraServiceStub::HandleSetCameraCallback(MessageParcel& data, MessageParcel& reply)
374 {
375 auto remoteObject = data.ReadRemoteObject();
376 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
377 "HCameraServiceStub HandleSetCameraCallback CameraServiceCallback is null");
378
379 auto callback = iface_cast<ICameraServiceCallback>(remoteObject);
380 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
381 "HCameraServiceStub HandleSetCameraCallback callback is null");
382
383 return SetCameraCallback(callback);
384 }
385
HandleSetMuteCallback(MessageParcel & data,MessageParcel & reply)386 int HCameraServiceStub::HandleSetMuteCallback(MessageParcel& data, MessageParcel& reply)
387 {
388 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
389
390 auto remoteObject = data.ReadRemoteObject();
391 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
392 "HCameraServiceStub HandleSetMuteCallback CameraMuteServiceCallback is null");
393
394 auto callback = iface_cast<ICameraMuteServiceCallback>(remoteObject);
395 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
396 "HCameraServiceStub HandleSetMuteCallback callback is null");
397
398 return SetMuteCallback(callback);
399 }
400
HandleSetTorchCallback(MessageParcel & data,MessageParcel & reply)401 int HCameraServiceStub::HandleSetTorchCallback(MessageParcel& data, MessageParcel& reply)
402 {
403 auto remoteObject = data.ReadRemoteObject();
404 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
405 "HCameraServiceStub HandleSetTorchCallback TorchServiceCallback is null");
406
407 auto callback = iface_cast<ITorchServiceCallback>(remoteObject);
408 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
409 "HCameraServiceStub HandleSetTorchCallback callback is null");
410
411 return SetTorchCallback(callback);
412 }
413
HandleSetFoldStatusCallback(MessageParcel & data,MessageParcel & reply)414 int HCameraServiceStub::HandleSetFoldStatusCallback(MessageParcel& data, MessageParcel& reply)
415 {
416 auto remoteObject = data.ReadRemoteObject();
417 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
418 "HCameraServiceStub HandleSetFoldStatusCallback FoldServiceCallback is null");
419
420 auto callback = iface_cast<IFoldServiceCallback>(remoteObject);
421 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
422 "HCameraServiceStub HandleSetFoldStatusCallback callback is null");
423 bool isInnerCallback = data.ReadBool();
424 return SetFoldStatusCallback(callback, isInnerCallback);
425 }
426
HandleCreateCaptureSession(MessageParcel & data,MessageParcel & reply)427 int HCameraServiceStub::HandleCreateCaptureSession(MessageParcel& data, MessageParcel& reply)
428 {
429 sptr<ICaptureSession> session = nullptr;
430
431 int32_t operationMode = data.ReadInt32();
432 int ret = CreateCaptureSession(session, operationMode);
433 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
434 "HandleCreateCaptureSession CreateCaptureSession failed : %{public}d", ret);
435
436 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(session->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
437 "HCameraServiceStub HandleCreateCaptureSession Write CaptureSession obj failed");
438
439 return ret;
440 }
441
HandleCreateDeferredPhotoProcessingSession(MessageParcel & data,MessageParcel & reply)442 int HCameraServiceStub::HandleCreateDeferredPhotoProcessingSession(MessageParcel &data, MessageParcel &reply)
443 {
444 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
445 sptr<DeferredProcessing::IDeferredPhotoProcessingSession> session = nullptr;
446
447 int32_t userId = data.ReadInt32();
448 auto remoteObject = data.ReadRemoteObject();
449 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
450 "HandleCreateDeferredPhotoProcessingSession DeferredPhotoProcessingSessionCallback is null");
451
452 auto callback = iface_cast<DeferredProcessing::IDeferredPhotoProcessingSessionCallback>(remoteObject);
453 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
454 "HCameraServiceStub HandleCreateDeferredPhotoProcessingSession callback is null");
455
456 int ret = CreateDeferredPhotoProcessingSession(userId, callback, session);
457 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
458 "HandleCreateDeferredPhotoProcessingSession create failed : %{public}d", ret);
459 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(session->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
460 "HandleCreateDeferredPhotoProcessingSession Write HandleCreateDeferredPhotoProcessingSession obj failed");
461
462 return ret;
463 }
464
HandleCreateDeferredVideoProcessingSession(MessageParcel & data,MessageParcel & reply)465 int HCameraServiceStub::HandleCreateDeferredVideoProcessingSession(MessageParcel &data, MessageParcel &reply)
466 {
467 sptr<DeferredProcessing::IDeferredVideoProcessingSession> session = nullptr;
468
469 int32_t userId = data.ReadInt32();
470 auto remoteObject = data.ReadRemoteObject();
471 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
472 "HandleCreateDeferredVideoProcessingSession DeferredVideoProcessingSessionCallback is null");
473
474 auto callback = iface_cast<DeferredProcessing::IDeferredVideoProcessingSessionCallback>(remoteObject);
475 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
476 "HCameraServiceStub HandleCreateDeferredVideoProcessingSession callback is null");
477 int ret = CreateDeferredVideoProcessingSession(userId, callback, session);
478 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
479 "HandleCreateDeferredVideoProcessingSession create failed : %{public}d", ret);
480 CHECK_ERROR_RETURN_RET_LOG(!(reply.WriteRemoteObject(session->AsObject())), IPC_STUB_WRITE_PARCEL_ERR,
481 "HandleCreateDeferredVideoProcessingSession Write HandleCreateDeferredVideoProcessingSession obj failed");
482
483 return ret;
484 }
485
HandleCreatePhotoOutput(MessageParcel & data,MessageParcel & reply)486 int HCameraServiceStub::HandleCreatePhotoOutput(MessageParcel& data, MessageParcel& reply)
487 {
488 sptr<IStreamCapture> photoOutput = nullptr;
489 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
490 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
491 "HCameraServiceStub HandleCreatePhotoOutput BufferProducer is null");
492
493 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
494 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
495 "HCameraServiceStub HandleCreatePhotoOutput producer is null");
496
497 int32_t format = data.ReadInt32();
498 int32_t width = data.ReadInt32();
499 int32_t height = data.ReadInt32();
500 MEDIA_INFO_LOG(
501 "HCameraServiceStub::HandleCreatePhotoOutput, format: %{public}d, width: %{public}d, height: %{public}d",
502 format, width, height);
503 int ret = CreatePhotoOutput(producer, format, width, height, photoOutput);
504 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
505 "HCameraServiceStub::HandleCreatePhotoOutput Create photo output failed : %{public}d", ret);
506 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(photoOutput->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
507 "HCameraServiceStub HandleCreateCameraDevice Write photoOutput obj failed");
508
509 return ret;
510 }
511
HandleCreatePreviewOutput(MessageParcel & data,MessageParcel & reply)512 int HCameraServiceStub::HandleCreatePreviewOutput(MessageParcel& data, MessageParcel& reply)
513 {
514 sptr<IStreamRepeat> previewOutput = nullptr;
515 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
516 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
517 "HCameraServiceStub HandleCreatePreviewOutput BufferProducer is null");
518
519 int32_t format = data.ReadInt32();
520 int32_t width = data.ReadInt32();
521 int32_t height = data.ReadInt32();
522 MEDIA_INFO_LOG(
523 "CreatePreviewOutput, format: %{public}d, width: %{public}d, height: %{public}d", format, width, height);
524 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
525 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
526 "HCameraServiceStub HandleCreatePreviewOutput producer is null");
527
528 int ret = CreatePreviewOutput(producer, format, width, height, previewOutput);
529 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
530 "HandleCreatePreviewOutput CreatePreviewOutput failed : %{public}d", ret);
531 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(previewOutput->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
532 "HCameraServiceStub HandleCreatePreviewOutput Write previewOutput obj failed");
533
534 return ret;
535 }
536
HandleCreateDeferredPreviewOutput(MessageParcel & data,MessageParcel & reply)537 int HCameraServiceStub::HandleCreateDeferredPreviewOutput(MessageParcel& data, MessageParcel& reply)
538 {
539 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
540
541 sptr<IStreamRepeat> previewOutput = nullptr;
542 int32_t format = data.ReadInt32();
543 int32_t width = data.ReadInt32();
544 int32_t height = data.ReadInt32();
545 MEDIA_INFO_LOG(
546 "CreatePreviewOutput, format: %{public}d, width: %{public}d, height: %{public}d", format, width, height);
547 int ret = CreateDeferredPreviewOutput(format, width, height, previewOutput);
548 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
549 "HandleCreateDeferredPreviewOutput CreatePreviewOutput failed : %{public}d", ret);
550 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(previewOutput->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
551 "HCameraServiceStub HandleCreateDeferredPreviewOutput Write previewOutput obj failed");
552
553 return ret;
554 }
555
HandleCreateDepthDataOutput(MessageParcel & data,MessageParcel & reply)556 int HCameraServiceStub::HandleCreateDepthDataOutput(MessageParcel& data, MessageParcel& reply)
557 {
558 sptr<IStreamDepthData> depthDataOutput = nullptr;
559
560 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
561 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
562 "HCameraServiceStub HandleCreateDepthDataOutput BufferProducer is null");
563 int32_t format = data.ReadInt32();
564 int32_t width = data.ReadInt32();
565 int32_t height = data.ReadInt32();
566 MEDIA_INFO_LOG(
567 "CreateDepthDataOutput, format: %{public}d, width: %{public}d, height: %{public}d", format, width, height);
568 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
569 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
570 "HCameraServiceStub HandleCreateDepthDataOutput producer is null");
571 int errCode = CreateDepthDataOutput(producer, format, width, height, depthDataOutput);
572 CHECK_ERROR_RETURN_RET_LOG(errCode != ERR_NONE, errCode,
573 "HandleCreateDepthDataOutput CreateDepthDataOutput failed : %{public}d", errCode);
574 CHECK_ERROR_RETURN_RET_LOG(!(reply.WriteRemoteObject(depthDataOutput->AsObject())), IPC_STUB_WRITE_PARCEL_ERR,
575 "HCameraServiceStub HandleCreateDepthDataOutput Write previewOutput obj failed");
576 return errCode;
577 }
578
HandleCreateMetadataOutput(MessageParcel & data,MessageParcel & reply)579 int HCameraServiceStub::HandleCreateMetadataOutput(MessageParcel& data, MessageParcel& reply)
580 {
581 sptr<IStreamMetadata> metadataOutput = nullptr;
582 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
583 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
584 "HCameraServiceStub HandleCreateMetadataOutput BufferProducer is null");
585
586 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
587 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
588 "HCameraServiceStub HandleCreateMetadataOutput producer is null");
589
590 int32_t format = data.ReadInt32();
591 std::vector<int32_t> metadataTypes;
592 CHECK_ERROR_PRINT_LOG(!data.ReadInt32Vector(&metadataTypes),
593 "HStreamMetadataStub Start metadataTypes is null");
594 int ret = CreateMetadataOutput(producer, format, metadataTypes, metadataOutput);
595 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
596 "HCameraServiceStub HandleCreateMetadataOutput CreateMetadataOutput failed : %{public}d", ret);
597 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(metadataOutput->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
598 "HCameraServiceStub HandleCreateMetadataOutput Write metadataOutput obj failed");
599 return ret;
600 }
601
HandleCreateVideoOutput(MessageParcel & data,MessageParcel & reply)602 int HCameraServiceStub::HandleCreateVideoOutput(MessageParcel& data, MessageParcel& reply)
603 {
604 sptr<IStreamRepeat> videoOutput = nullptr;
605 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
606 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
607 "HCameraServiceStub HandleCreateVideoOutput BufferProducer is null");
608
609 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
610 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
611 "HCameraServiceStub HandleCreateVideoOutput producer is null");
612
613 int32_t format = data.ReadInt32();
614 int32_t width = data.ReadInt32();
615 int32_t height = data.ReadInt32();
616 int ret = CreateVideoOutput(producer, format, width, height, videoOutput);
617 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
618 "HCameraServiceStub HandleCreateVideoOutput CreateVideoOutput failed : %{public}d", ret);
619 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(videoOutput->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
620 "HCameraServiceStub HandleCreateVideoOutput Write videoOutput obj failed");
621
622 return ret;
623 }
624
HandleSetTorchLevel(MessageParcel & data,MessageParcel & reply)625 int HCameraServiceStub::HandleSetTorchLevel(MessageParcel &data, MessageParcel &reply)
626 {
627 MEDIA_DEBUG_LOG("HCameraServiceStub HandleSetTorchLevel enter");
628 float level = data.ReadFloat();
629 int ret = SetTorchLevel(level);
630 MEDIA_INFO_LOG("HCameraServiceStub HandleSetTorchLevel result: %{public}d", ret);
631
632 return ret;
633 }
634
UnSetAllCallback(pid_t pid)635 int32_t HCameraServiceStub::UnSetAllCallback(pid_t pid)
636 {
637 return CAMERA_OK;
638 }
639
CloseCameraForDestory(pid_t pid)640 int32_t HCameraServiceStub::CloseCameraForDestory(pid_t pid)
641 {
642 return CAMERA_OK;
643 }
644
DestroyStubForPid(pid_t pid)645 int HCameraServiceStub::DestroyStubForPid(pid_t pid)
646 {
647 UnSetAllCallback(pid);
648 ClearCameraListenerByPid(pid);
649 HCaptureSession::DestroyStubObjectForPid(pid);
650 CloseCameraForDestory(pid);
651
652 return CAMERA_OK;
653 }
654
ClientDied(pid_t pid)655 void HCameraServiceStub::ClientDied(pid_t pid)
656 {
657 DisableJeMalloc();
658 MEDIA_ERR_LOG("client pid is dead, pid:%{public}d", pid);
659 (void)DestroyStubForPid(pid);
660 }
661
ClearCameraListenerByPid(pid_t pid)662 void HCameraServiceStub::ClearCameraListenerByPid(pid_t pid)
663 {
664 sptr<IStandardCameraListener> cameraListenerTmp = nullptr;
665 if (cameraListenerMap_.Find(pid, cameraListenerTmp)) {
666 CHECK_EXECUTE(cameraListenerTmp != nullptr && cameraListenerTmp->AsObject() != nullptr,
667 cameraListenerTmp->RemoveCameraDeathRecipient());
668 cameraListenerMap_.Erase(pid);
669 }
670 }
671
SetListenerObject(const sptr<IRemoteObject> & object)672 int HCameraServiceStub::SetListenerObject(const sptr<IRemoteObject>& object)
673 {
674 pid_t pid = IPCSkeleton::GetCallingPid();
675 ClearCameraListenerByPid(pid); // Ensure cleanup before starting the listener if this is the second call
676 CHECK_ERROR_RETURN_RET_LOG(object == nullptr, CAMERA_ALLOC_ERROR, "set listener object is nullptr");
677
678 sptr<IStandardCameraListener> cameraListener = iface_cast<IStandardCameraListener>(object);
679 CHECK_ERROR_RETURN_RET_LOG(cameraListener == nullptr, CAMERA_ALLOC_ERROR,
680 "failed to cast IStandardCameraListener");
681
682 sptr<CameraDeathRecipient> deathRecipient = new (std::nothrow) CameraDeathRecipient(pid);
683 CHECK_ERROR_RETURN_RET_LOG(deathRecipient == nullptr, CAMERA_ALLOC_ERROR, "failed to new CameraDeathRecipient");
684
685 auto thisPtr = wptr<HCameraServiceStub>(this);
686 deathRecipient->SetNotifyCb([thisPtr](pid_t pid) {
687 auto serviceStubPtr = thisPtr.promote();
688 CHECK_EXECUTE(serviceStubPtr != nullptr, serviceStubPtr->ClientDied(pid));
689 });
690 cameraListener->AddCameraDeathRecipient(deathRecipient);
691 cameraListenerMap_.EnsureInsert(pid, cameraListener);
692
693 return CAMERA_OK;
694 }
695
SetListenerObject(MessageParcel & data,MessageParcel & reply)696 int HCameraServiceStub::SetListenerObject(MessageParcel& data, MessageParcel& reply)
697 {
698 sptr<IRemoteObject> object = data.ReadRemoteObject();
699 CHECK_ERROR_RETURN_RET(object == nullptr, ERR_NULL_OBJECT);
700 (void)reply.WriteInt32(SetListenerObject(object));
701
702 return ERR_NONE;
703 }
704
HandleAllowOpenByOHSide(MessageParcel & data,MessageParcel & reply)705 int HCameraServiceStub::HandleAllowOpenByOHSide(MessageParcel& data, MessageParcel& reply)
706 {
707 std::string cameraId = data.ReadString();
708 int32_t state = data.ReadInt32();
709 bool canOpenCamera = false;
710
711 int ret = AllowOpenByOHSide(cameraId, state, canOpenCamera);
712 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteBool(canOpenCamera), IPC_STUB_WRITE_PARCEL_ERR,
713 "HCameraServiceStub HandleAllowOpenByOHSide get camera failed");
714
715 return ret;
716 }
717
DestroyStubObj()718 int HCameraServiceStub::DestroyStubObj()
719 {
720 pid_t pid = IPCSkeleton::GetCallingPid();
721 MEDIA_DEBUG_LOG("DestroyStubObj client pid:%{public}d", pid);
722 (void)DestroyStubForPid(pid);
723
724 return CAMERA_OK;
725 }
726
HandleNotifyCameraState(MessageParcel & data)727 int HCameraServiceStub::HandleNotifyCameraState(MessageParcel& data)
728 {
729 std::string cameraId = data.ReadString();
730 int32_t state = data.ReadInt32();
731
732 int ret = NotifyCameraState(cameraId, state);
733 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HCameraServiceStub HandleNotifyCameraState failed : %{public}d", ret);
734
735 return ret;
736 }
737
HandleSetPeerCallback(MessageParcel & data)738 int HCameraServiceStub::HandleSetPeerCallback(MessageParcel& data)
739 {
740 auto remoteObject = data.ReadRemoteObject();
741 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
742 "HCameraServiceStub HandleSetPeerCallback Callback is null");
743
744 MEDIA_INFO_LOG("HandleSetPeerCallback get callback");
745 CHECK_ERROR_PRINT_LOG(remoteObject == nullptr, "HandleSetPeerCallback get null remoteObject");
746 auto callback = iface_cast<ICameraBroker>(remoteObject);
747 CHECK_ERROR_PRINT_LOG(callback == nullptr, "HandleSetPeerCallback get null callback");
748
749 return SetPeerCallback(callback);
750 }
751
HandleUnsetPeerCallback(MessageParcel & data)752 int HCameraServiceStub::HandleUnsetPeerCallback(MessageParcel& data)
753 {
754 MEDIA_INFO_LOG("HandleUnsetPeerCallback called");
755 return UnsetPeerCallback();
756 }
757
HandleProxyForFreeze(MessageParcel & data,MessageParcel & reply)758 int HCameraServiceStub::HandleProxyForFreeze(MessageParcel& data, MessageParcel& reply)
759 {
760 std::set<int32_t> pidList;
761 int32_t size = data.ReadInt32();
762 int32_t maxSize = 100;
763 CHECK_ERROR_RETURN_RET((size >= maxSize || size < 0), CAMERA_UNKNOWN_ERROR);
764
765 for (int32_t i = 0; i < size; i++) {
766 pidList.insert(data.ReadInt32());
767 }
768 bool isProxy = data.ReadBool();
769 MEDIA_DEBUG_LOG("isProxy value: %{public}d", isProxy);
770 int ret = ProxyForFreeze(pidList, isProxy);
771 reply.WriteInt32(static_cast<int32_t>(ret));
772
773 return ret;
774 }
775
HandleResetAllFreezeStatus(MessageParcel & data,MessageParcel & reply)776 int HCameraServiceStub::HandleResetAllFreezeStatus(MessageParcel& data, MessageParcel& reply)
777 {
778 return ResetAllFreezeStatus();
779 }
780
HandleGetDmDeviceInfo(MessageParcel & data,MessageParcel & reply)781 int HCameraServiceStub::HandleGetDmDeviceInfo(MessageParcel& data, MessageParcel& reply)
782 {
783 std::vector<std::string> deviceInfos;
784 int ret = GetDmDeviceInfo(deviceInfos);
785 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteStringVector(deviceInfos), IPC_STUB_WRITE_PARCEL_ERR,
786 "HCameraServiceStub HandleGetDmDeviceInfo WriteStringVector failed");
787 return ret;
788 }
789
HandleGetCameraOutputStatus(MessageParcel & data,MessageParcel & reply)790 int HCameraServiceStub::HandleGetCameraOutputStatus(MessageParcel& data, MessageParcel& reply)
791 {
792 int32_t pid = data.ReadInt32();
793 int32_t status = 0;
794 int ret = GetCameraOutputStatus(pid, status);
795 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteInt32(status), IPC_STUB_WRITE_PARCEL_ERR,
796 "GetCameraOutputStatus failed");
797 return ret;
798 }
799
HandleRequireMemorySize(MessageParcel & data,MessageParcel & reply)800 int HCameraServiceStub::HandleRequireMemorySize(MessageParcel& data, MessageParcel& reply)
801 {
802 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
803 int32_t memSize = data.ReadInt32();
804 int ret = RequireMemorySize(memSize);
805 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret, "RequireMemorySize failed : %{public}d", ret);
806 return ret;
807 }
808
HandleGetIdforCameraConcurrentType(MessageParcel & data,MessageParcel & reply)809 int HCameraServiceStub::HandleGetIdforCameraConcurrentType(MessageParcel& data, MessageParcel& reply)
810 {
811 int32_t position = data.ReadInt32();
812 std::string cameraid;
813 GetIdforCameraConcurrentType(position, cameraid);
814 reply.WriteString(cameraid);
815 return CAMERA_OK;
816 }
817
HandleGetConcurrentCameraAbility(MessageParcel & data,MessageParcel & reply)818 int HCameraServiceStub::HandleGetConcurrentCameraAbility(MessageParcel& data, MessageParcel& reply)
819 {
820 std::string cameraId = data.ReadString();
821 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
822 int ret = GetConcurrentCameraAbility(cameraId, cameraAbility);
823 bool result = OHOS::Camera::MetadataUtils::EncodeCameraMetadata(cameraAbility, reply);
824 CHECK_ERROR_RETURN_RET_LOG(!result, IPC_STUB_WRITE_PARCEL_ERR,
825 "HCameraServiceStub HandleGetConcurrentCameraAbility write ability failed");
826
827 return ret;
828 }
829
HandleCheckWhiteList(MessageParcel & data,MessageParcel & reply)830 int HCameraServiceStub::HandleCheckWhiteList(MessageParcel& data, MessageParcel& reply)
831 {
832 bool isInWhiteList = false;
833 int32_t ret = CheckWhiteList(isInWhiteList);
834 MEDIA_INFO_LOG("HCameraServiceStub HandleCheckWhiteList result: %{public}d, isMuted: %{public}d",
835 ret, isInWhiteList);
836 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteBool(isInWhiteList), IPC_STUB_WRITE_PARCEL_ERR,
837 "HCameraServiceStub HandleCheckWhiteList Write isInWhiteList failed");
838 return ret;
839 }
840 } // namespace CameraStandard
841 } // namespace OHOS
842