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