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
Open()47 void CameraManager::Open()
48 {
49 if (cameraDevice == nullptr) {
50 service->GetCameraIds(cameraIds);
51 if (cameraIds.size() == 0) {
52 CAMERA_LOGE("camera device list empty");
53 }
54 GetCameraMetadata();
55 deviceCallback = new OHOS::Camera::CameraManager::DemoCameraDeviceCallback();
56
57 rc = serviceV1_1->OpenCamera_V1_1(cameraIds.front(), deviceCallback, cameraDeviceV1_1);
58 if (rc != HDI::Camera::V1_0::NO_ERROR || cameraDeviceV1_1 == nullptr) {
59 CAMERA_LOGE("openCamera V1_1 failed, rc = %{public}d", rc);
60 return;
61 }
62
63 cameraDevice = static_cast<OHOS::HDI::Camera::V1_0::ICameraDevice *>(cameraDeviceV1_1.GetRefPtr());
64 CAMERA_LOGI("OpenCamera V1_1 success");
65 }
66 }
67
GetCameraMetadata()68 void CameraManager::GetCameraMetadata()
69 {
70 rc = service->GetCameraAbility(cameraIds.front(), abilityVec);
71 if (rc != HDI::Camera::V1_0::NO_ERROR) {
72 CAMERA_LOGE("GetCameraAbility failed, rc = %{public}d", rc);
73 }
74 MetadataUtils::ConvertVecToMetadata(abilityVec, ability);
75
76 common_metadata_header_t* data = ability->get();
77 camera_metadata_item_t entry;
78 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_AE_AVAILABLE_MODES, &entry);
79 if (ret == 0) {
80 CAMERA_LOGI("get OHOS_CONTROL_AE_AVAILABLE_MODES success");
81 }
82 }
83
Close()84 void CameraManager::Close()
85 {
86 if (cameraDevice != nullptr) {
87 cameraDevice->Close();
88 cameraDevice = nullptr;
89 }
90 }
91
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)92 int32_t CameraManager::TestStreamOperatorCallback::OnCaptureStarted(int32_t captureId,
93 const std::vector<int32_t> &streamId)
94 {
95 for (auto it : streamId) {
96 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
97 }
98 return HDI::Camera::V1_0::NO_ERROR;
99 }
100
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)101 int32_t CameraManager::TestStreamOperatorCallback::OnCaptureEnded(int32_t captureId,
102 const std::vector<CaptureEndedInfo> &infos)
103 {
104 for (auto it : infos) {
105 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
106 it.frameCount_);
107 }
108 return HDI::Camera::V1_0::NO_ERROR;
109 }
110
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)111 int32_t CameraManager::TestStreamOperatorCallback::OnCaptureError(int32_t captureId,
112 const std::vector<CaptureErrorInfo> &infos)
113 {
114 for (auto it : infos) {
115 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
116 it.error_);
117 }
118 return HDI::Camera::V1_0::NO_ERROR;
119 }
120
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)121 int32_t CameraManager::TestStreamOperatorCallback::OnFrameShutter(int32_t captureId,
122 const std::vector<int32_t> &streamIds, uint64_t timestamp)
123 {
124 (void)timestamp;
125 for (auto it : streamIds) {
126 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
127 }
128 return HDI::Camera::V1_0::NO_ERROR;
129 }
130
OnError(ErrorType type,int32_t errorMsg)131 int32_t CameraManager::DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorMsg)
132 {
133 CAMERA_LOGE("type: %{public}d, errorMsg: %{public}d", type, errorMsg);
134 return HDI::Camera::V1_0::NO_ERROR;
135 }
136
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)137 int32_t CameraManager::DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t> &result)
138 {
139 if (CameraManager::resultCallback_) {
140 std::shared_ptr<CameraMetadata> resultMeta;
141 MetadataUtils::ConvertVecToMetadata(result, resultMeta);
142 CameraManager::resultCallback_(timestamp, resultMeta);
143 }
144 return HDI::Camera::V1_0::NO_ERROR;
145 }
146
OnCameraStatus(const std::string & cameraId,CameraStatus status)147 int32_t CameraManager::TestCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
148 {
149 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
150 return HDI::Camera::V1_0::NO_ERROR;
151 }
152
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)153 int32_t CameraManager::TestCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
154 {
155 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
156 return HDI::Camera::V1_0::NO_ERROR;
157 }
158
OnCameraEvent(const std::string & cameraId,CameraEvent event)159 int32_t CameraManager::TestCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
160 {
161 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), event);
162 return HDI::Camera::V1_0::NO_ERROR;
163 }
164 }
165