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