1 /*
2 * Copyright (c) 2021-2023 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 "common.h"
17
18 namespace OHOS::Camera {
19 CameraManager::ResultCallback CameraManager::resultCallback_ = 0;
Init()20 void CameraManager::Init()
21 {
22 uint32_t mainVer;
23 uint32_t minVer;
24 int32_t ret;
25 if (serviceV1_1 == nullptr) {
26 serviceV1_1 = OHOS::HDI::Camera::V1_1::ICameraHost::Get("camera_service", false);
27 if (serviceV1_1 == nullptr) {
28 CAMERA_LOGE("V1_1::IcameraHost get failed");
29 return;
30 } else {
31 CAMERA_LOGI("ICameraHost get success");
32 ret = serviceV1_1->GetVersion(mainVer, minVer);
33 if (ret != 0) {
34 CAMERA_LOGE("V1_1::ICameraHost get version failed, ret = %{public}d", ret);
35 } else {
36 CAMERA_LOGE("V1_1::ICameraHost get version success, %{public}d, %{public}d", mainVer, minVer);
37 }
38 }
39
40 service = static_cast<OHOS::HDI::Camera::V1_0::ICameraHost *>(serviceV1_1.GetRefPtr());
41 }
42
43 hostCallback = new TestCameraHostCallback();
44 service->SetCallback(hostCallback);
45 }
46
InitV1_2()47 void CameraManager::InitV1_2()
48 {
49 uint32_t mainVer;
50 uint32_t minVer;
51 int32_t ret;
52 if (serviceV1_2 == nullptr) {
53 serviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraHost::Get("camera_service", false);
54 if (serviceV1_2 == nullptr) {
55 CAMERA_LOGE("V1_2::IcameraHost get failed");
56 return;
57 } else {
58 CAMERA_LOGI("ICameraHost get success");
59 ret = serviceV1_2->GetVersion(mainVer, minVer);
60 if (ret != 0) {
61 CAMERA_LOGE("V1_2::ICameraHost get version failed, ret = %{public}d", ret);
62 } else {
63 CAMERA_LOGE("V1_2::ICameraHost get version success, %{public}d, %{public}d", mainVer, minVer);
64 }
65 }
66
67 service = static_cast<OHOS::HDI::Camera::V1_0::ICameraHost *>(serviceV1_2.GetRefPtr());
68 }
69
70 hostCallback = new TestCameraHostCallback();
71 service->SetCallback(hostCallback);
72 }
73
OpenV1_2()74 void CameraManager::OpenV1_2()
75 {
76 if (cameraDevice == nullptr) {
77 service->GetCameraIds(cameraIds);
78 if (cameraIds.size() == 0) {
79 CAMERA_LOGE("camera device list empty");
80 }
81 GetCameraMetadata();
82 deviceCallback = new OHOS::Camera::CameraManager::DemoCameraDeviceCallback();
83
84 rc = serviceV1_2->OpenCamera_V1_1(cameraIds.front(), deviceCallback, cameraDeviceV1_1);
85 if (rc != HDI::Camera::V1_0::NO_ERROR || cameraDeviceV1_1 == nullptr) {
86 CAMERA_LOGE("openCamera V1_1 failed, rc = %{public}d", rc);
87 return;
88 }
89
90 cameraDevice = static_cast<OHOS::HDI::Camera::V1_0::ICameraDevice *>(cameraDeviceV1_1.GetRefPtr());
91 CAMERA_LOGI("OpenCamera V1_2 success");
92 }
93 }
94
OpenCameraV1_2()95 void CameraManager::OpenCameraV1_2()
96 {
97 if (cameraDevice == nullptr) {
98 service->GetCameraIds(cameraIds);
99 if (cameraIds.size() == 0) {
100 CAMERA_LOGE("camera device list empty");
101 }
102 GetCameraMetadata();
103 deviceCallback = new OHOS::Camera::CameraManager::DemoCameraDeviceCallback();
104
105 rc = serviceV1_2->OpenCamera_V1_2(cameraIds.front(), deviceCallback, cameraDeviceV1_2);
106 if (rc != HDI::Camera::V1_0::NO_ERROR || cameraDeviceV1_2 == nullptr) {
107 CAMERA_LOGE("openCamera V1_1 failed, rc = %{public}d", rc);
108 return;
109 }
110
111 cameraDevice = static_cast<OHOS::HDI::Camera::V1_0::ICameraDevice *>(cameraDeviceV1_2.GetRefPtr());
112 CAMERA_LOGI("OpenCamera V1_2 success");
113 }
114 }
115
Open()116 void CameraManager::Open()
117 {
118 if (cameraDevice == nullptr) {
119 service->GetCameraIds(cameraIds);
120 if (cameraIds.size() == 0) {
121 CAMERA_LOGE("camera device list empty");
122 }
123 GetCameraMetadata();
124 deviceCallback = new OHOS::Camera::CameraManager::DemoCameraDeviceCallback();
125
126 rc = serviceV1_1->OpenCamera_V1_1(cameraIds.front(), deviceCallback, cameraDeviceV1_1);
127 if (rc != HDI::Camera::V1_0::NO_ERROR || cameraDeviceV1_1 == nullptr) {
128 CAMERA_LOGE("openCamera V1_1 failed, rc = %{public}d", rc);
129 return;
130 }
131
132 cameraDevice = static_cast<OHOS::HDI::Camera::V1_0::ICameraDevice *>(cameraDeviceV1_1.GetRefPtr());
133 CAMERA_LOGI("OpenCamera V1_1 success");
134 }
135 }
136
GetCameraMetadata()137 void CameraManager::GetCameraMetadata()
138 {
139 rc = service->GetCameraAbility(cameraIds.front(), abilityVec);
140 if (rc != HDI::Camera::V1_0::NO_ERROR) {
141 CAMERA_LOGE("GetCameraAbility failed, rc = %{public}d", rc);
142 }
143 MetadataUtils::ConvertVecToMetadata(abilityVec, ability);
144
145 common_metadata_header_t* data = ability->get();
146 camera_metadata_item_t entry;
147 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_AE_AVAILABLE_MODES, &entry);
148 if (ret == 0) {
149 CAMERA_LOGI("get OHOS_CONTROL_AE_AVAILABLE_MODES success");
150 }
151 }
152
Close()153 void CameraManager::Close()
154 {
155 if (cameraDevice != nullptr) {
156 cameraDevice->Close();
157 cameraDevice = nullptr;
158 }
159 }
160
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)161 int32_t CameraManager::TestStreamOperatorCallback::OnCaptureStarted(int32_t captureId,
162 const std::vector<int32_t> &streamId)
163 {
164 for (auto it : streamId) {
165 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
166 }
167 return HDI::Camera::V1_0::NO_ERROR;
168 }
169
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)170 int32_t CameraManager::TestStreamOperatorCallback::OnCaptureEnded(int32_t captureId,
171 const std::vector<CaptureEndedInfo> &infos)
172 {
173 for (auto it : infos) {
174 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
175 it.frameCount_);
176 }
177 return HDI::Camera::V1_0::NO_ERROR;
178 }
179
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)180 int32_t CameraManager::TestStreamOperatorCallback::OnCaptureError(int32_t captureId,
181 const std::vector<CaptureErrorInfo> &infos)
182 {
183 for (auto it : infos) {
184 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
185 it.error_);
186 }
187 return HDI::Camera::V1_0::NO_ERROR;
188 }
189
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)190 int32_t CameraManager::TestStreamOperatorCallback::OnFrameShutter(int32_t captureId,
191 const std::vector<int32_t> &streamIds, uint64_t timestamp)
192 {
193 (void)timestamp;
194 for (auto it : streamIds) {
195 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
196 }
197 return HDI::Camera::V1_0::NO_ERROR;
198 }
199
OnError(ErrorType type,int32_t errorMsg)200 int32_t CameraManager::DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorMsg)
201 {
202 CAMERA_LOGE("type: %{public}d, errorMsg: %{public}d", type, errorMsg);
203 return HDI::Camera::V1_0::NO_ERROR;
204 }
205
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)206 int32_t CameraManager::DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t> &result)
207 {
208 if (CameraManager::resultCallback_) {
209 std::shared_ptr<CameraMetadata> resultMeta;
210 MetadataUtils::ConvertVecToMetadata(result, resultMeta);
211 CameraManager::resultCallback_(timestamp, resultMeta);
212 }
213 return HDI::Camera::V1_0::NO_ERROR;
214 }
215
OnCameraStatus(const std::string & cameraId,CameraStatus status)216 int32_t CameraManager::TestCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
217 {
218 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
219 return HDI::Camera::V1_0::NO_ERROR;
220 }
221
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)222 int32_t CameraManager::TestCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
223 {
224 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
225 return HDI::Camera::V1_0::NO_ERROR;
226 }
227
OnCameraEvent(const std::string & cameraId,CameraEvent event)228 int32_t CameraManager::TestCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
229 {
230 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), event);
231 return HDI::Camera::V1_0::NO_ERROR;
232 }
233
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)234 int32_t CameraManager::TestStreamOperatorCallbackV1_2::OnCaptureStarted(
235 int32_t captureId, const std::vector<int32_t> &streamId)
236 {
237 for (auto it : streamId) {
238 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
239 }
240 return HDI::Camera::V1_0::NO_ERROR;
241 }
242
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)243 int32_t CameraManager::TestStreamOperatorCallbackV1_2::OnCaptureEnded(int32_t captureId,
244 const std::vector<CaptureEndedInfo> &infos)
245 {
246 for (auto it : infos) {
247 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
248 it.frameCount_);
249 }
250 return HDI::Camera::V1_0::NO_ERROR;
251 }
252
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)253 int32_t CameraManager::TestStreamOperatorCallbackV1_2::OnCaptureError(int32_t captureId,
254 const std::vector<CaptureErrorInfo> &infos)
255 {
256 for (auto it : infos) {
257 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
258 it.error_);
259 }
260 return HDI::Camera::V1_0::NO_ERROR;
261 }
262
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)263 int32_t CameraManager::TestStreamOperatorCallbackV1_2::OnFrameShutter(int32_t captureId,
264 const std::vector<int32_t> &streamIds, uint64_t timestamp)
265 {
266 (void)timestamp;
267 for (auto it : streamIds) {
268 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
269 }
270 return HDI::Camera::V1_0::NO_ERROR;
271 }
272
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> & infos)273 int32_t CameraManager::TestStreamOperatorCallbackV1_2::OnCaptureStarted_V1_2(int32_t captureId,
274 const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> &infos)
275 {
276 for (auto it : infos) {
277 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it.streamId_);
278 }
279 return HDI::Camera::V1_0::NO_ERROR;
280 }
281
282 }
283