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