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_device_stub.h"
17 #include "camera_log.h"
18 #include "camera_util.h"
19 #include "camera_xcollie.h"
20 #include "metadata_utils.h"
21 #include "camera_service_ipc_interface_code.h"
22
23 namespace OHOS {
24 namespace CameraStandard {
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)25 int HCameraDeviceStub::OnRemoteRequest(
26 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
27 {
28 DisableJeMalloc();
29 int errCode = -1;
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>(CameraDeviceInterfaceCode::CAMERA_DEVICE_OPEN): {
35 errCode =HCameraDeviceStub::HandleOpenSecureCameraResults(data, reply);
36 break;
37 }
38 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_CLOSE): {
39 CameraXCollie cameraXCollie("HCameraDeviceStub::Close");
40 errCode = Close();
41 }
42 break;
43 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_RELEASE): {
44 CameraXCollie cameraXCollie("HCameraDeviceStub::Release");
45 errCode = Release();
46 }
47 break;
48 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_SET_CALLBACK):
49 errCode = HCameraDeviceStub::HandleSetCallback(data);
50 break;
51 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_UNSET_CALLBACK):
52 errCode = UnSetCallback();
53 break;
54 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_UPDATE_SETTNGS):
55 errCode = HCameraDeviceStub::HandleUpdateSetting(data);
56 break;
57 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_SET_USED_POS):
58 errCode = HCameraDeviceStub::HandleUsedAsPos(data);
59 break;
60 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_GET_STATUS):
61 errCode = HCameraDeviceStub::HandleGetStatus(data, reply);
62 break;
63 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_ENABLED_RESULT):
64 errCode = HCameraDeviceStub::HandleEnableResult(data);
65 break;
66 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_GET_ENABLED_RESULT):
67 errCode = HCameraDeviceStub::HandleGetEnabledResults(reply);
68 break;
69 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_DISABLED_RESULT):
70 errCode = HCameraDeviceStub::HandleDisableResult(data);
71 break;
72 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_OPEN_CONCURRENT):
73 errCode = HCameraDeviceStub::HandleOpenConcurrent(data, reply);
74 break;
75 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_DELAYED_CLOSE): {
76 CameraXCollie cameraXCollie("HCameraDeviceStub::delayedClose");
77 errCode = closeDelayed();
78 }
79 break;
80 case static_cast<uint32_t>(CameraDeviceInterfaceCode::CAMERA_DEVICE_SET_DEVICE_RETRY_TIME):
81 errCode = HCameraDeviceStub::HandleSetDeviceRetryTime(data, reply);
82 break;
83 default:
84 MEDIA_ERR_LOG("HCameraDeviceStub request code %{public}d not handled", code);
85 errCode = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
86 break;
87 }
88
89 return errCode;
90 }
91
HandleSetCallback(MessageParcel & data)92 int32_t HCameraDeviceStub::HandleSetCallback(MessageParcel &data)
93 {
94 auto remoteObject = data.ReadRemoteObject();
95 CHECK_ERROR_RETURN_RET_LOG(remoteObject == nullptr, IPC_STUB_INVALID_DATA_ERR,
96 "HCameraDeviceStub HandleSetCallback CameraDeviceServiceCallback is null");
97
98 auto callback = iface_cast<ICameraDeviceServiceCallback>(remoteObject);
99 CHECK_ERROR_RETURN_RET_LOG(callback == nullptr, IPC_STUB_INVALID_DATA_ERR,
100 "HCameraDeviceStub HandleSetCallback callback is null");
101
102 return SetCallback(callback);
103 }
104
HandleUpdateSetting(MessageParcel & data)105 int32_t HCameraDeviceStub::HandleUpdateSetting(MessageParcel &data)
106 {
107 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = nullptr;
108 OHOS::Camera::MetadataUtils::DecodeCameraMetadata(data, metadata);
109
110 return UpdateSetting(metadata);
111 }
112
HandleUsedAsPos(MessageParcel & data)113 int32_t HCameraDeviceStub::HandleUsedAsPos(MessageParcel &data)
114 {
115 uint8_t value = 0;
116 value = data.ReadUint8();
117
118 return SetUsedAsPosition(value);
119 }
120
HandleGetStatus(MessageParcel & data,MessageParcel & reply)121 int32_t HCameraDeviceStub::HandleGetStatus(MessageParcel &data, MessageParcel &reply)
122 {
123 std::shared_ptr<OHOS::Camera::CameraMetadata> metadataIn = nullptr;
124 std::shared_ptr<OHOS::Camera::CameraMetadata> metadataOut = nullptr;
125
126 OHOS::Camera::MetadataUtils::DecodeCameraMetadata(data, metadataIn);
127
128 int errCode = GetStatus(metadataIn, metadataOut);
129
130 bool result = OHOS::Camera::MetadataUtils::EncodeCameraMetadata(metadataOut, reply);
131 CHECK_ERROR_RETURN_RET_LOG(!result, IPC_STUB_WRITE_PARCEL_ERR,
132 "HCameraServiceStub HandleGetStatus write metadata failed");
133
134 return errCode;
135 }
136
HandleGetEnabledResults(MessageParcel & reply)137 int32_t HCameraDeviceStub::HandleGetEnabledResults(MessageParcel &reply)
138 {
139 std::vector<int32_t> results;
140 int ret = GetEnabledResults(results);
141 CHECK_ERROR_RETURN_RET_LOG(ret != ERR_NONE, ret,
142 "CameraDeviceStub::HandleGetEnabledResults GetEnabledResults failed : %{public}d", ret);
143
144 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteInt32Vector(results), IPC_STUB_WRITE_PARCEL_ERR,
145 "HCameraDeviceStub::HandleGetEnabledResults write results failed");
146
147 return ret;
148 }
149
HandleEnableResult(MessageParcel & data)150 int32_t HCameraDeviceStub::HandleEnableResult(MessageParcel &data)
151 {
152 std::vector<int32_t> results;
153 CHECK_ERROR_RETURN_RET_LOG(!data.ReadInt32Vector(&results), IPC_STUB_INVALID_DATA_ERR,
154 "CameraDeviceStub::HandleEnableResult read results failed");
155
156 int ret = EnableResult(results);
157 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
158 "CameraDeviceStub::HandleEnableResult EnableResult failed : %{public}d", ret);
159
160 return ret;
161 }
162
HandleDisableResult(MessageParcel & data)163 int32_t HCameraDeviceStub::HandleDisableResult(MessageParcel &data)
164 {
165 std::vector<int32_t> results;
166 CHECK_ERROR_RETURN_RET_LOG(!data.ReadInt32Vector(&results), IPC_STUB_INVALID_DATA_ERR,
167 "CameraDeviceStub::HandleDisableResult read results failed");
168
169 int ret = DisableResult(results);
170 CHECK_ERROR_PRINT_LOG(ret != ERR_NONE,
171 "CameraDeviceStub::HandleDisableResult DisableResult failed : %{public}d", ret);
172
173 return ret;
174 }
175
HandleOpenSecureCameraResults(MessageParcel & data,MessageParcel & reply)176 int32_t HCameraDeviceStub::HandleOpenSecureCameraResults(MessageParcel &data, MessageParcel &reply)
177 {
178 CameraXCollie cameraXCollie("HandleOpenSecureCameraResults");
179 int32_t errorCode;
180 if (data.ReadBool()) {
181 uint64_t secureSeqId = 0L;
182 errorCode = OpenSecureCamera(&secureSeqId);
183 CHECK_ERROR_RETURN_RET_LOG(errorCode != ERR_NONE, errorCode,
184 "HCameraDeviceStub::openSecureCamera failed : %{public}d", errorCode);
185 CHECK_ERROR_RETURN_RET_LOG(!reply.WriteInt64(secureSeqId), IPC_STUB_WRITE_PARCEL_ERR,
186 "HCameraDeviceStub::openSecureCamera write results failed");
187 } else {
188 errorCode = Open();
189 }
190
191 return errorCode;
192 }
193
HandleOpenConcurrent(MessageParcel & data,MessageParcel & reply)194 int32_t HCameraDeviceStub::HandleOpenConcurrent(MessageParcel &data, MessageParcel &reply)
195 {
196 CameraXCollie cameraXCollie("HandleOpenConcurrent");
197 int32_t errorCode = ERR_NONE;
198 int32_t concurrentTypeofcamera = data.ReadInt32();
199 errorCode = Open(concurrentTypeofcamera);
200 CHECK_ERROR_RETURN_RET_LOG(errorCode != ERR_NONE, errorCode,
201 "HCameraDeviceStub::openSecureCamera failed : %{public}d", errorCode);
202 return errorCode;
203 }
204
HandleSetDeviceRetryTime(MessageParcel & data,MessageParcel & reply)205 int32_t HCameraDeviceStub::HandleSetDeviceRetryTime(MessageParcel& data, MessageParcel& reply)
206 {
207 return SetDeviceRetryTime();
208 }
209 } // namespace CameraStandard
210 } // namespace OHOS
211