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_repeat_stub.h"
17
18 #include "camera_log.h"
19 #include "camera_service_ipc_interface_code.h"
20 #include "camera_util.h"
21
22 namespace OHOS {
23 namespace CameraStandard {
24 static constexpr float SKETCH_RATIO_MAX_VALUE = 100.0f;
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)25 int HStreamRepeatStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
26 {
27 DisableJeMalloc();
28 int errCode = -1;
29
30 CHECK_ERROR_RETURN_RET(data.ReadInterfaceToken() != GetDescriptor(), errCode);
31 errCode = OperatePermissionCheck(code);
32 CHECK_ERROR_RETURN_RET(errCode != CAMERA_OK, errCode);
33 switch (code) {
34 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_START_VIDEO_RECORDING):
35 errCode = Start();
36 break;
37 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_STOP_VIDEO_RECORDING):
38 errCode = Stop();
39 break;
40 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_STREAM_REPEAT_SET_CALLBACK):
41 errCode = HStreamRepeatStub::HandleSetCallback(data);
42 break;
43 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_STREAM_REPEAT_UNSET_CALLBACK):
44 errCode = UnSetCallback();
45 break;
46 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_STREAM_REPEAT_RELEASE):
47 errCode = Release();
48 break;
49 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_ADD_DEFERRED_SURFACE):
50 errCode = HStreamRepeatStub::HandleAddDeferredSurface(data);
51 break;
52 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_FORK_SKETCH_STREAM_REPEAT):
53 errCode = HStreamRepeatStub::HandleForkSketchStreamRepeat(data, reply);
54 break;
55 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_REMOVE_SKETCH_STREAM_REPEAT):
56 errCode = RemoveSketchStreamRepeat();
57 break;
58 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_UPDATE_SKETCH_RATIO):
59 errCode = HandleUpdateSketchRatio(data);
60 break;
61 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_STREAM_FRAME_RANGE_SET):
62 errCode = HandleSetFrameRate(data);
63 break;
64 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_ENABLE_SECURE_STREAM):
65 errCode = EnableSecure(data.ReadBool());
66 break;
67 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_ENABLE_STREAM_MIRROR):
68 errCode = HandleSetMirror(data);
69 break;
70 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_GET_STREAM_MIRROR):
71 errCode = HandleGetMirror(data, reply);
72 break;
73 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_ATTACH_META_SURFACE):
74 errCode = HandleAttachMetaSurface(data);
75 break;
76 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_PRIVIEW_ROTATION):
77 errCode = HandleSetCameraRotation(data);
78 break;
79 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_ENABLE_AUTO_FRAME_RATE):
80 errCode = HandleToggleAutoVideoFrameRate(data);
81 break;
82 case static_cast<uint32_t>(StreamRepeatInterfaceCode::CAMERA_API_VERSION):
83 errCode = HandleSetCameraApi(data);
84 break;
85 default:
86 MEDIA_ERR_LOG("HStreamRepeatStub request code %{public}u not handled", code);
87 errCode = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
88 break;
89 }
90
91 return errCode;
92 }
93
HandleSetCallback(MessageParcel & data)94 int32_t HStreamRepeatStub::HandleSetCallback(MessageParcel& data)
95 {
96 auto remoteObject = data.ReadRemoteObject();
97 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
98 "HStreamRepeatStub HandleSetCallback StreamRepeatCallback is null");
99
100 auto callback = iface_cast<IStreamRepeatCallback>(remoteObject);
101 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
102 "HStreamRepeatStub HandleSetCallback callback is null");
103
104 return SetCallback(callback);
105 }
106
HandleAddDeferredSurface(MessageParcel & data)107 int32_t HStreamRepeatStub::HandleAddDeferredSurface(MessageParcel& data)
108 {
109 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
110
111 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
112 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
113 "HStreamRepeatStub HandleAddDeferredSurface BufferProducer is null");
114
115 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
116 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
117 "HStreamRepeatStub HandleAddDeferredSurface producer is null");
118
119 int ret = AddDeferredSurface(producer);
120 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
121 "HStreamRepeatStub::HandleAddDeferredSurface add deferred surface failed : %{public}d", ret);
122
123 return ret;
124 }
125
HandleForkSketchStreamRepeat(MessageParcel & data,MessageParcel & reply)126 int32_t HStreamRepeatStub::HandleForkSketchStreamRepeat(MessageParcel& data, MessageParcel& reply)
127 {
128 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
129
130 sptr<IStreamRepeat> sketchStream = nullptr;
131 int32_t width = data.ReadInt32();
132 int32_t height = data.ReadInt32();
133 float sketchRatio = data.ReadFloat();
134 int ret = ForkSketchStreamRepeat(width, height, sketchStream, sketchRatio);
135 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
136 "HStreamRepeatStub::HandleForkSketchStreamRepeat failed : %{public}d", ret);
137 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteRemoteObject(sketchStream->AsObject()), IPC_STUB_WRITE_PARCEL_ERR,
138 "HStreamRepeatStub HandleForkSketchStreamRepeat Write sketchStream obj failed");
139
140 return ret;
141 }
142
HandleUpdateSketchRatio(MessageParcel & data)143 int32_t HStreamRepeatStub::HandleUpdateSketchRatio(MessageParcel& data)
144 {
145 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
146 float sketchRatio = data.ReadFloat();
147 // SketchRatio value could be negative value
148 CHECK_ERROR_RETURN_RET_LOG(sketchRatio > SKETCH_RATIO_MAX_VALUE, IPC_STUB_INVALID_DATA_ERR,
149 "HStreamRepeatStub HandleUpdateSketchRatio sketchRatio value is illegal %{public}f", sketchRatio);
150 return UpdateSketchRatio(sketchRatio);
151 }
152
HandleSetFrameRate(MessageParcel & data)153 int32_t HStreamRepeatStub::HandleSetFrameRate(MessageParcel& data)
154 {
155 int32_t minFrameRate = data.ReadInt32();
156 int32_t maxFrameRate = data.ReadInt32();
157
158 int ret = SetFrameRate(minFrameRate, maxFrameRate);
159 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HStreamRepeatStub::HandleSetFrameRate failed : %{public}d", ret);
160 return ret;
161 }
162
HandleSetMirror(MessageParcel & data)163 int32_t HStreamRepeatStub::HandleSetMirror(MessageParcel& data)
164 {
165 bool isEnable = data.ReadBool();
166
167 int ret = SetMirror(isEnable);
168 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HStreamRepeatStub::HandleSetMirror failed : %{public}d", ret);
169 return ret;
170 }
171
HandleGetMirror(MessageParcel & data,MessageParcel & reply)172 int32_t HStreamRepeatStub::HandleGetMirror(MessageParcel& data, MessageParcel& reply)
173 {
174 bool isEnable = false;
175 int ret = GetMirror(isEnable);
176 MEDIA_INFO_LOG("HCameraServiceStub HandleGetMirror result: %{public}d, isMuted: %{public}d", ret, isEnable);
177 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteBool(isEnable), IPC_STUB_WRITE_PARCEL_ERR,
178 "HCameraServiceStub HandleGetMirror Write isEnable failed");
179 return ret;
180 }
181
HandleAttachMetaSurface(MessageParcel & data)182 int32_t HStreamRepeatStub::HandleAttachMetaSurface(MessageParcel& data)
183 {
184 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
185 int32_t videoMetaType = data.ReadInt32();
186
187 CHECK_ERROR_RETURN_RET_LOG(remoteObj == nullptr, IPC_STUB_INVALID_DATA_ERR,
188 "HStreamRepeatStub HandleAttachMetaSurface BufferProducer is null");
189
190 sptr<OHOS::IBufferProducer> producer = iface_cast<OHOS::IBufferProducer>(remoteObj);
191 CHECK_ERROR_RETURN_RET_LOG(producer == nullptr, IPC_STUB_INVALID_DATA_ERR,
192 "HStreamRepeatStub HandleAttachMetaSurface producer is null");
193 int errCode = AttachMetaSurface(producer, videoMetaType);
194 CHECK_ERROR_RETURN_RET_LOG(errCode != ERR_NONE, errCode,
195 "HStreamRepeatStub::HandleAttachMetaSurface add deferred surface failed : %{public}d", errCode);
196
197 return errCode;
198 }
199
HandleSetCameraRotation(MessageParcel & data)200 int32_t HStreamRepeatStub::HandleSetCameraRotation(MessageParcel& data)
201 {
202 bool isEnable = data.ReadBool();
203 int32_t rotation = data.ReadInt32();
204
205 int ret = SetCameraRotation(isEnable, rotation);
206 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HStreamRepeatStub::SetCameraRotation failed : %{public}d", ret);
207 return ret;
208 }
209
HandleSetCameraApi(MessageParcel & data)210 int32_t HStreamRepeatStub::HandleSetCameraApi(MessageParcel& data)
211 {
212 uint32_t apiCompatibleVersion = data.ReadUint32();
213
214 int ret = SetCameraApi(apiCompatibleVersion);
215 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE, "HStreamRepeatStub::SetCameraApi failed : %{public}d", ret);
216 return ret;
217 }
218
HandleToggleAutoVideoFrameRate(MessageParcel & data)219 int32_t HStreamRepeatStub::HandleToggleAutoVideoFrameRate(MessageParcel& data)
220 {
221 CHECK_ERROR_RETURN_RET(!CheckSystemApp(), CAMERA_NO_PERMISSION);
222 bool isEnable = data.ReadBool();
223
224 int ret = ToggleAutoVideoFrameRate(isEnable);
225 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
226 "HStreamRepeatStub::HandleToggleAutoVideoFrameRate failed : %{public}d", ret);
227 return ret;
228 }
229 } // namespace CameraStandard
230 } // namespace OHOS
231