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