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 "hstream_capture_stub.h"
17 #include "camera_log.h"
18 #include "camera_util.h"
19 #include "metadata_utils.h"
20 #include "camera_service_ipc_interface_code.h"
21
22 namespace OHOS {
23 namespace CameraStandard {
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)24 int HStreamCaptureStub::OnRemoteRequest(
25 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
26 {
27 DisableJeMalloc();
28 int errCode = -1;
29
30 CHECK_AND_RETURN_RET(data.ReadInterfaceToken() == GetDescriptor(), errCode);
31 errCode = OperatePermissionCheck(code);
32 CHECK_AND_RETURN_RET(errCode == CAMERA_OK, errCode);
33 switch (code) {
34 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_START):
35 errCode = HStreamCaptureStub::HandleCapture(data);
36 break;
37 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_CANCEL):
38 errCode = CancelCapture();
39 break;
40 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_CONFIRM):
41 errCode = HStreamCaptureStub::HandleConfirmCapture(data);
42 break;
43 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_SET_CALLBACK):
44 errCode = HStreamCaptureStub::HandleSetCallback(data);
45 break;
46 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_CAPTURE_RELEASE):
47 errCode = Release();
48 break;
49 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_SERVICE_SET_THUMBNAIL):
50 errCode = HandleSetThumbnail(data);
51 break;
52 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_ENABLE_RAW_DELIVERY):
53 errCode = HandleEnableRawDelivery(data);
54 break;
55 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_SERVICE_ENABLE_DEFERREDTYPE):
56 errCode = HandleEnableDeferredType(data);
57 break;
58 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_GET_DEFERRED_PHOTO):
59 errCode = IsDeferredPhotoEnabled();
60 break;
61 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_GET_DEFERRED_VIDEO):
62 errCode = IsDeferredVideoEnabled();
63 break;
64 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_SET_VIDEO_CODEC_TYPE):
65 errCode = HandleSetMovingPhotoVideoCodecType(data);
66 break;
67 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_STREAM_SET_BUFFER_PRODUCER_INFO):
68 errCode = HandleSetBufferProducerInfo(data);
69 break;
70 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_PHOTO_ROTATION):
71 errCode = HandleSetCameraPhotoRotation(data);
72 break;
73 case static_cast<uint32_t>(StreamCaptureInterfaceCode::CAMERA_CAPTURE_DFX):
74 errCode = HandleAcquireBufferToPrepareProxy(data);
75 break;
76 default:
77 MEDIA_ERR_LOG("HStreamCaptureStub request code %{public}u not handled", code);
78 errCode = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
79 break;
80 }
81
82 return errCode;
83 }
84
HandleCapture(MessageParcel & data)85 int32_t HStreamCaptureStub::HandleCapture(MessageParcel &data)
86 {
87 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = nullptr;
88 OHOS::Camera::MetadataUtils::DecodeCameraMetadata(data, metadata);
89
90 return Capture(metadata);
91 }
92
HandleConfirmCapture(MessageParcel & data)93 int32_t HStreamCaptureStub::HandleConfirmCapture(MessageParcel &data)
94 {
95 CHECK_AND_RETURN_RET(CheckSystemApp(), CAMERA_NO_PERMISSION);
96 return ConfirmCapture();
97 }
98
HandleSetThumbnail(MessageParcel & data)99 int32_t HStreamCaptureStub::HandleSetThumbnail(MessageParcel &data)
100 {
101 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
102 CHECK_AND_RETURN_RET_LOG(remoteObj != nullptr, IPC_STUB_INVALID_DATA_ERR,
103 "HStreamCaptureStub HandleCreatePhotoOutput BufferProducer is null");
104 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
105 CHECK_AND_RETURN_RET_LOG(producer != nullptr, IPC_STUB_INVALID_DATA_ERR,
106 "HStreamCaptureStub HandleSetThumbnail producer is null");
107 bool isEnabled = data.ReadBool();
108 int32_t ret = SetThumbnail(isEnabled, producer);
109 MEDIA_DEBUG_LOG("HStreamCaptureStub HandleSetThumbnail result: %{public}d", ret);
110 return ret;
111 }
112
HandleEnableRawDelivery(MessageParcel & data)113 int32_t HStreamCaptureStub::HandleEnableRawDelivery(MessageParcel &data)
114 {
115 bool enabled = data.ReadBool();
116 int32_t ret = EnableRawDelivery(enabled);
117 MEDIA_DEBUG_LOG("HStreamCaptureStub HandleEnableRawDelivery result: %{public}d", ret);
118 return ret;
119 }
120
HandleSetBufferProducerInfo(MessageParcel & data)121 int32_t HStreamCaptureStub::HandleSetBufferProducerInfo(MessageParcel &data)
122 {
123 std::string bufferName = data.ReadString();
124 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
125 CHECK_AND_RETURN_RET_LOG(remoteObj != nullptr, IPC_STUB_INVALID_DATA_ERR,
126 "HStreamCaptureStub HandleSetBufferProducerInfo BufferProducer is null");
127 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
128 CHECK_AND_RETURN_RET_LOG(producer != nullptr, IPC_STUB_INVALID_DATA_ERR,
129 "HStreamCaptureStub HandleSetBufferProducerInfo producer is null");
130 int32_t ret = SetBufferProducerInfo(bufferName, producer);
131 MEDIA_DEBUG_LOG("HStreamCaptureStub HandleSetBufferProducerInfo result: %{public}d", ret);
132 return ret;
133 }
134
HandleEnableDeferredType(MessageParcel & data)135 int32_t HStreamCaptureStub::HandleEnableDeferredType(MessageParcel &data)
136 {
137 CHECK_AND_RETURN_RET(CheckSystemApp(), CAMERA_NO_PERMISSION);
138 int32_t type = data.ReadInt32();
139 int32_t ret = DeferImageDeliveryFor(type);
140 MEDIA_DEBUG_LOG("HStreamCaptureStub HandleEnableDeferredType result: %{public}d", ret);
141 return ret;
142 }
143
HandleSetMovingPhotoVideoCodecType(MessageParcel & data)144 int32_t HStreamCaptureStub::HandleSetMovingPhotoVideoCodecType(MessageParcel &data)
145 {
146 int32_t type = data.ReadInt32();
147 int32_t ret = SetMovingPhotoVideoCodecType(type);
148 MEDIA_DEBUG_LOG("HStreamCaptureStub HandleSetMovingPhotoVideoCodecType result: %{public}d", ret);
149 return ret;
150 }
151
HandleSetCallback(MessageParcel & data)152 int32_t HStreamCaptureStub::HandleSetCallback(MessageParcel &data)
153 {
154 auto remoteObject = data.ReadRemoteObject();
155 CHECK_AND_RETURN_RET_LOG(remoteObject != nullptr, IPC_STUB_INVALID_DATA_ERR,
156 "HStreamCaptureStub HandleSetCallback StreamCaptureCallback is null");
157
158 auto callback = iface_cast<IStreamCaptureCallback>(remoteObject);
159 CHECK_AND_RETURN_RET_LOG(callback != nullptr, IPC_STUB_INVALID_DATA_ERR,
160 "HStreamCaptureStub HandleSetCallback callback is null");
161 return SetCallback(callback);
162 }
163
HandleSetCameraPhotoRotation(MessageParcel & data)164 int32_t HStreamCaptureStub::HandleSetCameraPhotoRotation(MessageParcel& data)
165 {
166 bool isEnable = data.ReadBool();
167
168 int ret = SetCameraPhotoRotation(isEnable);
169 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HStreamCaptureStub::SetCameraPhotoRotation failed : %{public}d", ret);
170 return ret;
171 }
172
HandleAcquireBufferToPrepareProxy(MessageParcel & data)173 int32_t HStreamCaptureStub::HandleAcquireBufferToPrepareProxy(MessageParcel& data)
174 {
175 int32_t captureId = data.ReadInt32();
176 int32_t ret = AcquireBufferToPrepareProxy(captureId);
177 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
178 "HStreamCaptureStub::HandleAcquireBufferToPrepareProxy failed : %{public}d", ret);
179 return ret;
180 }
181 } // namespace CameraStandard
182 } // namespace OHOS
183