1 /*
2 * Copyright (c) 2021 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 "camera_host_stub.h"
17 #include <hdf_log.h>
18 #include <hdf_base.h>
19 #include <hdf_sbuf_ipc.h>
20 #include "metadata_utils.h"
21 #include "icamera_device.h"
22 #include "icamera_host_callback.h"
23 #include "cmd_common.h"
24
25 namespace OHOS::Camera {
CameraHostStub()26 CameraHostStub::CameraHostStub()
27 {
28 }
29
Init()30 RetCode CameraHostStub::Init()
31 {
32 cameraHost_ = CameraHost::CreateCameraHost();
33 if (cameraHost_ == nullptr) {
34 HDF_LOGE("%s: camera host service start failed", __func__);
35 return RC_ERROR;
36 }
37 return RC_OK;
38 }
39
CameraHostStubSetCallback(MessageParcel & data,MessageParcel & reply,MessageOption & option)40 int32_t CameraHostStub::CameraHostStubSetCallback(
41 MessageParcel &data, MessageParcel &reply, MessageOption &option)
42 {
43 if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) {
44 HDF_LOGE("%{public}s: invalid interface descriptor.", __func__);
45 return INVALID_ARGUMENT;
46 }
47
48 bool flag = data.ReadBool();
49 sptr<ICameraHostCallback> hostCallback = nullptr;
50 if (flag) {
51 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
52 hostCallback = OHOS::iface_cast<ICameraHostCallback>(remoteObj);
53 }
54 CamRetCode ret = cameraHost_->SetCallback(hostCallback);
55 if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
56 HDF_LOGE("%s: write retcode failed", __func__);
57 return HDF_FAILURE;
58 }
59
60 return HDF_SUCCESS;
61 }
62
CameraHostStubGetCameraIds(MessageParcel & data,MessageParcel & reply,MessageOption & option)63 int32_t CameraHostStub::CameraHostStubGetCameraIds(
64 MessageParcel &data, MessageParcel &reply, MessageOption &option)
65 {
66 if (cameraHost_ == nullptr) {
67 return HDF_FAILURE;
68 }
69
70 if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) {
71 HDF_LOGE("%{public}s: invalid interface descriptor.", __func__);
72 return INVALID_ARGUMENT;
73 }
74 std::vector<std::string> cameraIds;
75 CamRetCode ret = cameraHost_->GetCameraIds(cameraIds);
76 if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
77 HDF_LOGE("%s: write retcode failed", __func__);
78 return HDF_FAILURE;
79 }
80
81 if (!reply.WriteStringVector(cameraIds)) {
82 HDF_LOGE("%s: write cameraIds failed", __func__);
83 return HDF_FAILURE;
84 }
85
86 return HDF_SUCCESS;
87 }
88
CameraHostStubGetCameraAbility(MessageParcel & data,MessageParcel & reply,MessageOption & option)89 int32_t CameraHostStub::CameraHostStubGetCameraAbility(
90 MessageParcel &data, MessageParcel &reply, MessageOption &option)
91 {
92 if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) {
93 HDF_LOGE("%{public}s: invalid interface descriptor.", __func__);
94 return INVALID_ARGUMENT;
95 }
96
97 const std::string cameraId = data.ReadString();
98 if (cameraId.empty()) {
99 HDF_LOGE("%s: read input param is empty", __func__);
100 return HDF_ERR_INVALID_PARAM;
101 }
102
103 std::shared_ptr<CameraAbility> ability = nullptr;
104 CamRetCode ret = cameraHost_->GetCameraAbility(cameraId, ability);
105 if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
106 HDF_LOGE("%s: write retcode failed", __func__);
107 return HDF_FAILURE;
108 }
109
110 bool bRet = MetadataUtils::EncodeCameraMetadata(ability, reply);
111 if (!bRet) {
112 HDF_LOGE("%s: write ability failed", __func__);
113 return HDF_FAILURE;
114 }
115
116 return HDF_SUCCESS;
117 }
118
CameraHostStubOpenCamera(MessageParcel & data,MessageParcel & reply,MessageOption & option)119 int32_t CameraHostStub::CameraHostStubOpenCamera(
120 MessageParcel &data, MessageParcel &reply, MessageOption &option)
121 {
122 if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) {
123 HDF_LOGE("%{public}s: invalid interface descriptor.", __func__);
124 return INVALID_ARGUMENT;
125 }
126
127 const std::string cameraId = data.ReadString();
128 if (cameraId.empty()) {
129 HDF_LOGE("%s: read input param is empty", __func__);
130 return HDF_ERR_INVALID_PARAM;
131 }
132
133 bool flag = data.ReadBool();
134 OHOS::sptr<ICameraDeviceCallback> deviceCallback = nullptr;
135 if (flag) {
136 OHOS::sptr<IRemoteObject> remoteCallback = data.ReadRemoteObject();
137 deviceCallback = OHOS::iface_cast<ICameraDeviceCallback>(remoteCallback);
138 }
139
140 OHOS::sptr<ICameraDevice> cameraDevice = nullptr;
141 CamRetCode ret = cameraHost_->OpenCamera(cameraId, deviceCallback, cameraDevice);
142 if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
143 HDF_LOGE("%s: get stream operator failed", __func__);
144 return HDF_FAILURE;
145 }
146
147 bool deviceFlag = (cameraDevice != nullptr);
148 if (!reply.WriteBool(deviceFlag)) {
149 HDF_LOGE("%s: write camera device flag failed", __func__);
150 return HDF_FAILURE;
151 }
152
153 if (deviceFlag && !reply.WriteRemoteObject(cameraDevice->AsObject())) {
154 HDF_LOGE("%s: write camera device failed", __func__);
155 return HDF_FAILURE;
156 }
157
158 return HDF_SUCCESS;
159 }
160
CameraHostStubSetFlashlight(MessageParcel & data,MessageParcel & reply,MessageOption & option)161 int32_t CameraHostStub::CameraHostStubSetFlashlight(
162 MessageParcel &data, MessageParcel &reply, MessageOption &option)
163 {
164 if (data.ReadInterfaceToken() != CameraHostStub::GetDescriptor()) {
165 HDF_LOGE("%{public}s: invalid interface descriptor.", __func__);
166 return INVALID_ARGUMENT;
167 }
168
169 if (cameraHost_ == nullptr) {
170 HDF_LOGE("%s: camera host is null", __func__);
171 return HDF_FAILURE;
172 }
173
174 std::string cameraId = data.ReadString();
175 bool isEnable = data.ReadBool();
176 CamRetCode ret = cameraHost_->SetFlashlight(cameraId, isEnable);
177 if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
178 HDF_LOGE("%s: write retcode failed", __func__);
179 return HDF_FAILURE;
180 }
181
182 return HDF_SUCCESS;
183 }
184
CameraHostServiceStubOnRemoteRequest(int cmdId,MessageParcel & data,MessageParcel & reply,MessageOption & option)185 int32_t CameraHostStub::CameraHostServiceStubOnRemoteRequest(int cmdId, MessageParcel &data,
186 MessageParcel &reply, MessageOption &option)
187 {
188 switch (cmdId) {
189 case CMD_CAMERA_HOST_SET_CALLBACK: {
190 return CameraHostStubSetCallback(data, reply, option);
191 }
192 case CMD_CAMERA_HOST_GET_CAMERAID: {
193 return CameraHostStubGetCameraIds(data, reply, option);
194 }
195 case CMD_CAMERA_HOST_GET_CAMERA_ABILITY: {
196 return CameraHostStubGetCameraAbility(data, reply, option);
197 }
198 case CMD_CAMERA_HOST_OPEN_CAMERA: {
199 return CameraHostStubOpenCamera(data, reply, option);
200 }
201 case CMD_CAMERA_HOST_SET_FLASH_LIGHT: {
202 return CameraHostStubSetFlashlight(data, reply, option);
203 }
204 default: {
205 HDF_LOGE("%s: not support cmd %d", __func__, cmdId);
206 return HDF_ERR_INVALID_PARAM;
207 }
208 }
209 return HDF_SUCCESS;
210 }
211 }
212
CameraHostStubInstance()213 void *CameraHostStubInstance()
214 {
215 OHOS::Camera::CameraHostStub *stub =
216 new (std::nothrow) OHOS::Camera::CameraHostStub();
217 if (stub == nullptr) {
218 HDF_LOGE("%s: camera host stub create failed.", __func__);
219 return nullptr;
220 }
221
222 OHOS::Camera::RetCode ret = stub->Init();
223 if (ret != OHOS::Camera::RC_OK) {
224 delete stub;
225 stub = nullptr;
226 return nullptr;
227 }
228
229 return reinterpret_cast<void*>(stub);
230 }
231
DestroyCameraHostStub(void * stubObj)232 void DestroyCameraHostStub(void *stubObj)
233 {
234 delete reinterpret_cast<OHOS::Camera::CameraHostStub *>(stubObj);
235 }
236
CameraHostServiceOnRemoteRequest(void * stub,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)237 int32_t CameraHostServiceOnRemoteRequest(void *stub, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
238 {
239 if (stub == nullptr) {
240 HDF_LOGE("%s:stub is null", __func__);
241 return HDF_FAILURE;
242 }
243
244 OHOS::Camera::CameraHostStub *cameraHostStub =
245 reinterpret_cast<OHOS::Camera::CameraHostStub *>(stub);
246 OHOS::MessageParcel *dataParcel = nullptr;
247 OHOS::MessageParcel *replyParcel = nullptr;
248
249 if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) {
250 HDF_LOGE("%s:invalid reply sbuf object to dispatch", __func__);
251 return HDF_ERR_INVALID_PARAM;
252 }
253
254 if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) {
255 HDF_LOGE("%s:invalid data sbuf object to dispatch", __func__);
256 return HDF_ERR_INVALID_PARAM;
257 }
258
259 OHOS::MessageOption option;
260 return cameraHostStub->CameraHostServiceStubOnRemoteRequest(cmdId, *dataParcel, *replyParcel, option);
261 }
262