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 #include <cinttypes>
18 #include "camera_log.h"
19 #include "metadata_utils.h"
20 #include "camera_service_ipc_interface_code.h"
21 #include "input/camera_death_recipient.h"
22 #include "hcamera_service.h"
23 #include "input/i_standard_camera_listener.h"
24 #include "ipc_skeleton.h"
25 #include "xcollie/xcollie.h"
26 #include "xcollie/xcollie_define.h"
27
28 namespace OHOS {
29 namespace CameraStandard {
HCameraServiceStub()30 HCameraServiceStub::HCameraServiceStub()
31 {
32 deathRecipientMap_.Clear();
33 cameraListenerMap_.Clear();
34 MEDIA_DEBUG_LOG("0x%{public}06" PRIXPTR " Instances create",
35 (POINTER_MASK & reinterpret_cast<uintptr_t>(this)));
36 }
37
~HCameraServiceStub()38 HCameraServiceStub::~HCameraServiceStub()
39 {
40 MEDIA_DEBUG_LOG("0x%{public}06" PRIXPTR " Instances destroy",
41 (POINTER_MASK & reinterpret_cast<uintptr_t>(this)));
42 }
43
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)44 int HCameraServiceStub::OnRemoteRequest(
45 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
46 {
47 DisableJeMalloc();
48 int errCode = -1;
49 if (data.ReadInterfaceToken() != GetDescriptor()) {
50 return -1;
51 }
52 const int TIME_OUT_SECONDS = 10;
53 int32_t id = HiviewDFX::XCollie::GetInstance().SetTimer(
54 "CameraServiceStub", TIME_OUT_SECONDS, nullptr, nullptr, HiviewDFX::XCOLLIE_FLAG_LOG);
55 switch (code) {
56 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEVICE): {
57 errCode = HCameraServiceStub::HandleCreateCameraDevice(data, reply);
58 break;
59 }
60 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_CALLBACK):
61 errCode = HCameraServiceStub::HandleSetCallback(data, reply);
62 break;
63 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_MUTE_CALLBACK): {
64 errCode = HCameraServiceStub::HandleSetMuteCallback(data, reply);
65 break;
66 }
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_CREATE_CAPTURE_SESSION): {
71 errCode = HCameraServiceStub::HandleCreateCaptureSession(data, reply);
72 break;
73 }
74 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_PHOTO_OUTPUT):
75 errCode = HCameraServiceStub::HandleCreatePhotoOutput(data, reply);
76 break;
77 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_PREVIEW_OUTPUT): {
78 errCode = HCameraServiceStub::HandleCreatePreviewOutput(data, reply);
79 break;
80 }
81 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_DEFERRED_PREVIEW_OUTPUT):
82 errCode = HCameraServiceStub::HandleCreateDeferredPreviewOutput(data, reply);
83 break;
84 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_VIDEO_OUTPUT): {
85 errCode = HCameraServiceStub::HandleCreateVideoOutput(data, reply);
86 break;
87 }
88 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_LISTENER_OBJ):
89 errCode = HCameraServiceStub::SetListenerObject(data, reply);
90 break;
91 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_CREATE_METADATA_OUTPUT):
92 errCode = HCameraServiceStub::HandleCreateMetadataOutput(data, reply);
93 break;
94 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_MUTE_CAMERA): {
95 errCode = HCameraServiceStub::HandleMuteCamera(data, reply);
96 break;
97 }
98 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_IS_CAMERA_MUTED):
99 errCode = HCameraServiceStub::HandleIsCameraMuted(data, reply);
100 break;
101 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_PRE_LAUNCH_CAMERA): {
102 errCode = HCameraServiceStub::HandlePrelaunchCamera(data, reply);
103 break;
104 }
105 case static_cast<uint32_t>(CameraServiceInterfaceCode::CAMERA_SERVICE_SET_PRE_LAUNCH_CAMERA):
106 errCode = HCameraServiceStub::HandleSetPrelaunchConfig(data, reply);
107 break;
108 default:
109 MEDIA_ERR_LOG("HCameraServiceStub request code %{public}d not handled", code);
110 errCode = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
111 break;
112 }
113 HiviewDFX::XCollie::GetInstance().CancelTimer(id);
114
115 return errCode;
116 }
117
HandleGetCameras(MessageParcel & data,MessageParcel & reply)118 int HCameraServiceStub::HandleGetCameras(MessageParcel &data, MessageParcel &reply)
119 {
120 std::vector<std::string> cameraIds;
121 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList;
122
123 int errCode = GetCameras(cameraIds, cameraAbilityList);
124 if (!reply.WriteStringVector(cameraIds)) {
125 MEDIA_ERR_LOG("HCameraServiceStub HandleGetCameras WriteStringVector failed");
126 return IPC_STUB_WRITE_PARCEL_ERR;
127 }
128
129 int count = static_cast<int>(cameraAbilityList.size());
130 if (!reply.WriteInt32(count)) {
131 MEDIA_ERR_LOG("HCameraServiceStub HandleGetCameras Write vector size failed");
132 return IPC_STUB_WRITE_PARCEL_ERR;
133 }
134
135 for (auto cameraAbility : cameraAbilityList) {
136 if (!(OHOS::Camera::MetadataUtils::EncodeCameraMetadata(cameraAbility, reply))) {
137 MEDIA_ERR_LOG("HCameraServiceStub HandleGetCameras write ability failed");
138 return IPC_STUB_WRITE_PARCEL_ERR;
139 }
140 }
141
142 return errCode;
143 }
144
HandleCreateCameraDevice(MessageParcel & data,MessageParcel & reply)145 int HCameraServiceStub::HandleCreateCameraDevice(MessageParcel &data, MessageParcel &reply)
146 {
147 std::string cameraId = data.ReadString();
148 sptr<ICameraDeviceService> device = nullptr;
149
150 int errCode = CreateCameraDevice(cameraId, device);
151 if (errCode != ERR_NONE) {
152 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateCameraDevice Create camera device failed : %{public}d", errCode);
153 return errCode;
154 }
155
156 if (!reply.WriteRemoteObject(device->AsObject())) {
157 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateCameraDevice Write CameraDevice obj failed");
158 return IPC_STUB_WRITE_PARCEL_ERR;
159 }
160
161 return errCode;
162 }
163
HandleMuteCamera(MessageParcel & data,MessageParcel & reply)164 int HCameraServiceStub::HandleMuteCamera(MessageParcel &data, MessageParcel &reply)
165 {
166 bool muteMode = data.ReadBool();
167 MEDIA_DEBUG_LOG("HCameraServiceStub HandleMuteCamera read muteMode : %{public}d", muteMode);
168
169 int32_t ret = MuteCamera(muteMode);
170 MEDIA_INFO_LOG("HCameraServiceStub HandleMuteCamera MuteCamera result: %{public}d", ret);
171 return ret;
172 }
173
HandlePrelaunchCamera(MessageParcel & data,MessageParcel & reply)174 int HCameraServiceStub::HandlePrelaunchCamera(MessageParcel &data, MessageParcel &reply)
175 {
176 MEDIA_DEBUG_LOG("HCameraServiceStub HandlePrelaunchCamera enter");
177 int32_t ret = PrelaunchCamera();
178 MEDIA_INFO_LOG("HCameraServiceStub HandlePrelaunchCamera result: %{public}d", ret);
179 return ret;
180 }
181
HandleSetPrelaunchConfig(MessageParcel & data,MessageParcel & reply)182 int HCameraServiceStub::HandleSetPrelaunchConfig(MessageParcel &data, MessageParcel &reply)
183 {
184 MEDIA_DEBUG_LOG("HCameraServiceStub HandleSetPrelaunchConfig enter");
185 std::string cameraId = data.ReadString();
186 int32_t ret = SetPrelaunchConfig(cameraId);
187 MEDIA_INFO_LOG("HCameraServiceStub HandleSetPrelaunchConfig result: %{public}d", ret);
188 return ret;
189 }
190
HandleIsCameraMuted(MessageParcel & data,MessageParcel & reply)191 int HCameraServiceStub::HandleIsCameraMuted(MessageParcel &data, MessageParcel &reply)
192 {
193 bool isMuted = false;
194 int32_t ret = IsCameraMuted(isMuted);
195 MEDIA_INFO_LOG("HCameraServiceStub HandleIsCameraMuted result: %{public}d, isMuted: %{public}d", ret, isMuted);
196 if (!reply.WriteBool(isMuted)) {
197 MEDIA_ERR_LOG("HCameraServiceStub HandleIsCameraMuted Write isMuted failed");
198 return IPC_STUB_WRITE_PARCEL_ERR;
199 }
200 return ret;
201 }
202
HandleSetCallback(MessageParcel & data,MessageParcel & reply)203 int HCameraServiceStub::HandleSetCallback(MessageParcel &data, MessageParcel &reply)
204 {
205 auto remoteObject = data.ReadRemoteObject();
206 if (remoteObject == nullptr) {
207 MEDIA_ERR_LOG("HCameraServiceStub HandleSetCallback CameraServiceCallback is null");
208 return IPC_STUB_INVALID_DATA_ERR;
209 }
210
211 auto callback = iface_cast<ICameraServiceCallback>(remoteObject);
212
213 return SetCallback(callback);
214 }
215
HandleSetMuteCallback(MessageParcel & data,MessageParcel & reply)216 int HCameraServiceStub::HandleSetMuteCallback(MessageParcel &data, MessageParcel &reply)
217 {
218 auto remoteObject = data.ReadRemoteObject();
219 if (remoteObject == nullptr) {
220 MEDIA_ERR_LOG("HCameraServiceStub HandleSetMuteCallback CameraMuteServiceCallback is null");
221 return IPC_STUB_INVALID_DATA_ERR;
222 }
223
224 auto callback = iface_cast<ICameraMuteServiceCallback>(remoteObject);
225
226 return SetMuteCallback(callback);
227 }
228
HandleCreateCaptureSession(MessageParcel & data,MessageParcel & reply)229 int HCameraServiceStub::HandleCreateCaptureSession(MessageParcel &data, MessageParcel &reply)
230 {
231 sptr<ICaptureSession> session = nullptr;
232
233 int errCode = CreateCaptureSession(session);
234 if (errCode != ERR_NONE) {
235 MEDIA_ERR_LOG("HandleCreateCaptureSession CreateCaptureSession failed : %{public}d", errCode);
236 return errCode;
237 }
238
239 if (!reply.WriteRemoteObject(session->AsObject())) {
240 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateCaptureSession Write CaptureSession obj failed");
241 return IPC_STUB_WRITE_PARCEL_ERR;
242 }
243
244 return errCode;
245 }
246
HandleCreatePhotoOutput(MessageParcel & data,MessageParcel & reply)247 int HCameraServiceStub::HandleCreatePhotoOutput(MessageParcel &data, MessageParcel &reply)
248 {
249 sptr<IStreamCapture> photoOutput = nullptr;
250 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
251
252 if (remoteObj == nullptr) {
253 MEDIA_ERR_LOG("HCameraServiceStub HandleCreatePhotoOutput BufferProducer is null");
254 return IPC_STUB_INVALID_DATA_ERR;
255 }
256
257 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
258 int32_t format = data.ReadInt32();
259 int32_t width = data.ReadInt32();
260 int32_t height = data.ReadInt32();
261 int errCode = CreatePhotoOutput(producer, format, width, height, photoOutput);
262 if (errCode != ERR_NONE) {
263 MEDIA_ERR_LOG("HCameraServiceStub::HandleCreatePhotoOutput Create photo output failed : %{public}d", errCode);
264 return errCode;
265 }
266
267 if (!reply.WriteRemoteObject(photoOutput->AsObject())) {
268 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateCameraDevice Write photoOutput obj failed");
269 return IPC_STUB_WRITE_PARCEL_ERR;
270 }
271
272 return errCode;
273 }
274
HandleCreatePreviewOutput(MessageParcel & data,MessageParcel & reply)275 int HCameraServiceStub::HandleCreatePreviewOutput(MessageParcel &data, MessageParcel &reply)
276 {
277 sptr<IStreamRepeat> previewOutput = nullptr;
278
279 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
280 if (remoteObj == nullptr) {
281 MEDIA_ERR_LOG("HCameraServiceStub HandleCreatePreviewOutput BufferProducer is null");
282 return IPC_STUB_INVALID_DATA_ERR;
283 }
284 int32_t format = data.ReadInt32();
285 int32_t width = data.ReadInt32();
286 int32_t height = data.ReadInt32();
287 MEDIA_INFO_LOG("CreatePreviewOutput, format: %{public}d, width: %{public}d, height: %{public}d",
288 format, width, height);
289 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
290 int errCode = CreatePreviewOutput(producer, format, width, height, previewOutput);
291 if (errCode != ERR_NONE) {
292 MEDIA_ERR_LOG("HandleCreatePreviewOutput CreatePreviewOutput failed : %{public}d", errCode);
293 return errCode;
294 }
295 if (!reply.WriteRemoteObject(previewOutput->AsObject())) {
296 MEDIA_ERR_LOG("HCameraServiceStub HandleCreatePreviewOutput Write previewOutput obj failed");
297 return IPC_STUB_WRITE_PARCEL_ERR;
298 }
299 return errCode;
300 }
301
HandleCreateDeferredPreviewOutput(MessageParcel & data,MessageParcel & reply)302 int HCameraServiceStub::HandleCreateDeferredPreviewOutput(MessageParcel &data, MessageParcel &reply)
303 {
304 sptr<IStreamRepeat> previewOutput = nullptr;
305
306 int32_t format = data.ReadInt32();
307 int32_t width = data.ReadInt32();
308 int32_t height = data.ReadInt32();
309 MEDIA_INFO_LOG("CreatePreviewOutput, format: %{public}d, width: %{public}d, height: %{public}d",
310 format, width, height);
311
312 int errCode = CreateDeferredPreviewOutput(format, width, height, previewOutput);
313 if (errCode != ERR_NONE) {
314 MEDIA_ERR_LOG("HandleCreatePreviewOutput CreatePreviewOutput failed : %{public}d", errCode);
315 return errCode;
316 }
317 if (!reply.WriteRemoteObject(previewOutput->AsObject())) {
318 MEDIA_ERR_LOG("HCameraServiceStub HandleCreatePreviewOutput Write previewOutput obj failed");
319 return IPC_STUB_WRITE_PARCEL_ERR;
320 }
321 return errCode;
322 }
323
HandleCreateMetadataOutput(MessageParcel & data,MessageParcel & reply)324 int HCameraServiceStub::HandleCreateMetadataOutput(MessageParcel &data, MessageParcel &reply)
325 {
326 sptr<IStreamMetadata> metadataOutput = nullptr;
327 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
328
329 if (remoteObj == nullptr) {
330 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateMetadataOutput BufferProducer is null");
331 return IPC_STUB_INVALID_DATA_ERR;
332 }
333 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
334 int32_t format = data.ReadInt32();
335 int errCode = CreateMetadataOutput(producer, format, metadataOutput);
336 if (errCode != ERR_NONE) {
337 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateMetadataOutput CreateMetadataOutput failed : %{public}d",
338 errCode);
339 return errCode;
340 }
341 if (!reply.WriteRemoteObject(metadataOutput->AsObject())) {
342 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateMetadataOutput Write metadataOutput obj failed");
343 return IPC_STUB_WRITE_PARCEL_ERR;
344 }
345 return errCode;
346 }
347
HandleCreateVideoOutput(MessageParcel & data,MessageParcel & reply)348 int HCameraServiceStub::HandleCreateVideoOutput(MessageParcel &data, MessageParcel &reply)
349 {
350 sptr<IStreamRepeat> videoOutput = nullptr;
351 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
352
353 if (remoteObj == nullptr) {
354 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateVideoOutput BufferProducer is null");
355 return IPC_STUB_INVALID_DATA_ERR;
356 }
357
358 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
359 int32_t format = data.ReadInt32();
360 int32_t width = data.ReadInt32();
361 int32_t height = data.ReadInt32();
362 int errCode = CreateVideoOutput(producer, format, width, height, videoOutput);
363 if (errCode != ERR_NONE) {
364 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateVideoOutput CreateVideoOutput failed : %{public}d", errCode);
365 return errCode;
366 }
367 if (!reply.WriteRemoteObject(videoOutput->AsObject())) {
368 MEDIA_ERR_LOG("HCameraServiceStub HandleCreateVideoOutput Write videoOutput obj failed");
369 return IPC_STUB_WRITE_PARCEL_ERR;
370 }
371
372 return errCode;
373 }
374
UnSetCallback(pid_t pid)375 int32_t HCameraServiceStub::UnSetCallback(pid_t pid)
376 {
377 return CAMERA_OK;
378 }
379
CloseCameraForDestory(pid_t pid)380 int32_t HCameraServiceStub::CloseCameraForDestory(pid_t pid)
381 {
382 return CAMERA_OK;
383 }
384
DestroyStubForPid(pid_t pid)385 int HCameraServiceStub::DestroyStubForPid(pid_t pid)
386 {
387 sptr<CameraDeathRecipient> deathRecipient = nullptr;
388 sptr<IStandardCameraListener> cameraListener = nullptr;
389 if (deathRecipientMap_.Find(pid, deathRecipient)) {
390 if (deathRecipient != nullptr) {
391 deathRecipient->SetNotifyCb(nullptr);
392 }
393 deathRecipientMap_.Erase(pid);
394 }
395 if (cameraListenerMap_.Find(pid, cameraListener)) {
396 if (cameraListener != nullptr && cameraListener->AsObject() != nullptr && deathRecipient != nullptr) {
397 (void)cameraListener->AsObject()->RemoveDeathRecipient(deathRecipient);
398 }
399 cameraListenerMap_.Erase(pid);
400 }
401 HCaptureSession::DestroyStubObjectForPid(pid);
402 CloseCameraForDestory(pid);
403 UnSetCallback(pid);
404 return CAMERA_OK;
405 }
406
ClientDied(pid_t pid)407 void HCameraServiceStub::ClientDied(pid_t pid)
408 {
409 DisableJeMalloc();
410 MEDIA_ERR_LOG("client pid is dead, pid:%{public}d", pid);
411 (void)DestroyStubForPid(pid);
412 }
413
SetListenerObject(const sptr<IRemoteObject> & object)414 int HCameraServiceStub::SetListenerObject(const sptr<IRemoteObject> &object)
415 {
416 int errCode = -1;
417 sptr<CameraDeathRecipient> deathRecipientTmp = nullptr;
418 sptr<IStandardCameraListener> cameraListenerTmp = nullptr;
419 pid_t pid = IPCSkeleton::GetCallingPid();
420 if (deathRecipientMap_.Find(pid, deathRecipientTmp)) {
421 deathRecipientMap_.Erase(pid);
422 }
423 if (cameraListenerMap_.Find(pid, cameraListenerTmp)) {
424 if (cameraListenerTmp != nullptr && cameraListenerTmp->AsObject() != nullptr && deathRecipientTmp != nullptr) {
425 (void)cameraListenerTmp->AsObject()->RemoveDeathRecipient(deathRecipientTmp);
426 }
427 cameraListenerMap_.Erase(pid);
428 }
429 CHECK_AND_RETURN_RET_LOG(object != nullptr, CAMERA_ALLOC_ERROR, "set listener object is nullptr");
430 sptr<IStandardCameraListener> cameraListener = iface_cast<IStandardCameraListener>(object);
431 CHECK_AND_RETURN_RET_LOG(cameraListener != nullptr, CAMERA_ALLOC_ERROR,
432 "failed to convert IStandardCameraListener");
433 sptr<CameraDeathRecipient> deathRecipient = new(std::nothrow) CameraDeathRecipient(pid);
434 CHECK_AND_RETURN_RET_LOG(deathRecipient != nullptr, CAMERA_ALLOC_ERROR, "failed to new CameraDeathRecipient");
435 deathRecipient->SetNotifyCb(std::bind(&HCameraServiceStub::ClientDied, this, std::placeholders::_1));
436 if (cameraListener->AsObject() != nullptr) {
437 (void)cameraListener->AsObject()->AddDeathRecipient(deathRecipient);
438 }
439 MEDIA_DEBUG_LOG("client pid pid:%{public}d", pid);
440 cameraListenerMap_.EnsureInsert(pid, cameraListener);
441 deathRecipientMap_.EnsureInsert(pid, deathRecipient);
442 return errCode;
443 }
444
SetListenerObject(MessageParcel & data,MessageParcel & reply)445 int HCameraServiceStub::SetListenerObject(MessageParcel &data, MessageParcel &reply)
446 {
447 int errCode = -1;
448 sptr<IRemoteObject> object = data.ReadRemoteObject();
449 (void)reply.WriteInt32(SetListenerObject(object));
450 return errCode;
451 }
452 } // namespace CameraStandard
453 } // namespace OHOS
454