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_config.h"
17 #include "hcs_deal.h"
18
19 namespace {
20 const std::string CONFIG_PATH_NAME = "/system/etc/hdfconfig/camera_host_config.hcb";
21 }
22
23 namespace OHOS::Camera {
24 std::map<std::string, CameraId> CameraHostConfig::enumCameraIdMap_ = {
25 { "CAMERA_FIRST", CAMERA_FIRST },
26 { "CAMERA_SECOND", CAMERA_SECOND },
27 { "CAMERA_THIRD", CAMERA_THIRD },
28 { "CAMERA_FOURTH", CAMERA_FOURTH },
29 { "CAMERA_FIFTH", CAMERA_FIFTH },
30 { "CAMERA_SIXTH", CAMERA_SIXTH },
31 };
32 CameraHostConfig *CameraHostConfig::instance_ = nullptr;
33 CameraHostConfig::AutoRelease CameraHostConfig::autoRelease_;
34
GetInstance()35 CameraHostConfig *CameraHostConfig::GetInstance()
36 {
37 if (instance_ == nullptr) {
38 instance_ = new (std::nothrow) CameraHostConfig();
39 if (instance_ != nullptr) {
40 instance_->ReadConfigFile();
41 }
42 }
43 return instance_;
44 }
45
CameraHostConfig()46 CameraHostConfig::CameraHostConfig()
47 {
48 }
49
~CameraHostConfig()50 CameraHostConfig::~CameraHostConfig()
51 {
52 }
53
ReadConfigFile()54 RetCode CameraHostConfig::ReadConfigFile()
55 {
56 std::unique_ptr<HcsDeal> hcsDeal = std::make_unique<HcsDeal>(CONFIG_PATH_NAME);
57 if (hcsDeal == nullptr) {
58 CAMERA_LOGE("make HcsDeal failed. [pathname = %{public}s]", CONFIG_PATH_NAME.c_str());
59 return RC_ERROR;
60 }
61
62 RetCode rc = hcsDeal->Init();
63 if (rc != RC_OK) {
64 CAMERA_LOGE("hcs deal init failed. [pathname = %{public}s]", CONFIG_PATH_NAME.c_str());
65 return rc;
66 }
67
68 rc = hcsDeal->GetCameraId(cameraIdMap_);
69 if (rc != RC_OK || cameraIdMap_.empty()) {
70 CAMERA_LOGE("config camera id not found. [pathname = %{public}s]", CONFIG_PATH_NAME.c_str());
71 return rc;
72 }
73
74 rc = hcsDeal->GetMetadata(cameraAbilityMap_);
75 if (rc != RC_OK || cameraAbilityMap_.empty()) {
76 CAMERA_LOGE("config camera ability not found. [pathname = %{public}s]", CONFIG_PATH_NAME.c_str());
77 return rc;
78 }
79
80 return RC_OK;
81 }
82
GetCameraIds(std::vector<std::string> & cameraIds)83 RetCode CameraHostConfig::GetCameraIds(std::vector<std::string> &cameraIds)
84 {
85 auto itr = cameraAbilityMap_.begin();
86 for (; itr != cameraAbilityMap_.end(); itr++) {
87 cameraIds.push_back(itr->first);
88 }
89
90 return RC_OK;
91 }
92
GetPhysicCameraIds(const std::string & lCameraId,std::vector<std::string> & pCameraIds)93 RetCode CameraHostConfig::GetPhysicCameraIds(const std::string &lCameraId, std::vector<std::string> &pCameraIds)
94 {
95 auto itr = cameraIdMap_.find(lCameraId);
96 if (itr != cameraIdMap_.end()) {
97 pCameraIds = itr->second;
98 return RC_OK;
99 }
100 return RC_ERROR;
101 }
102
GetCameraAbility(const std::string & cameraId,std::shared_ptr<CameraAbility> & ability)103 RetCode CameraHostConfig::GetCameraAbility(
104 const std::string &cameraId, std::shared_ptr<CameraAbility> &ability)
105 {
106 auto itr = cameraAbilityMap_.find(cameraId);
107 if (itr != cameraAbilityMap_.end()) {
108 ability = itr->second;
109 return RC_OK;
110 }
111
112 return RC_ERROR;
113 }
114
AddCameraId(const std::string & logicalCameraId,const std::vector<std::string> & physicalCameraIds,const std::shared_ptr<CameraAbility> ability)115 RetCode CameraHostConfig::AddCameraId(const std::string &logicalCameraId,
116 const std::vector<std::string> &physicalCameraIds, const std::shared_ptr<CameraAbility> ability)
117 {
118 auto itrCameraId = cameraIdMap_.find(logicalCameraId);
119 auto itrCameraAbility = cameraAbilityMap_.find(logicalCameraId);
120 if (itrCameraId != cameraIdMap_.end() || itrCameraAbility != cameraAbilityMap_.end()) {
121 CAMERA_LOGE("logicalCameraId %{public}s Add Error", logicalCameraId.c_str());
122 return RC_ERROR;
123 } else {
124 cameraIdMap_.insert(std::make_pair(logicalCameraId, physicalCameraIds));
125 cameraAbilityMap_.insert(std::make_pair(logicalCameraId, ability));
126 return RC_OK;
127 }
128 }
129
SubtractCameraId(const std::vector<std::string> & physicalCameraIds)130 std::string CameraHostConfig::SubtractCameraId(const std::vector<std::string> &physicalCameraIds)
131 {
132 if (physicalCameraIds.size() > 1) {
133 CAMERA_LOGE("physicalCameraIds %{public}d >1 Error", physicalCameraIds.size());
134 }
135 std::string logicalCameraId = ReturnLogicalCameraIdToString(physicalCameraIds[0]);
136 if (logicalCameraId.size() == 0) {
137 return std::string("");
138 }
139 auto itrCameraId = cameraIdMap_.find(logicalCameraId);
140 auto itrCameraAbility = cameraAbilityMap_.find(logicalCameraId);
141 if (itrCameraId == cameraIdMap_.end() || itrCameraAbility == cameraAbilityMap_.end()) {
142 CAMERA_LOGE("physicalCameraIds %{public}s Subtract Error", physicalCameraIds[0].c_str());
143 return std::string("");
144 } else {
145 cameraIdMap_.erase(itrCameraId);
146 cameraAbilityMap_.erase(itrCameraAbility);
147 return logicalCameraId;
148 }
149 }
150
ReturnEnableLogicalCameraId()151 std::string CameraHostConfig::ReturnEnableLogicalCameraId()
152 {
153 std::string logicalCameraId;
154 bool logicalCameraIdStatus = false;
155 for (int32_t id = 1; id < CAMERA_MAX+1; id++) {
156 logicalCameraId = "lcam00";
157 logicalCameraId = logicalCameraId + std::to_string(id);
158 auto itr = cameraIdMap_.find(logicalCameraId);
159 if (itr == cameraIdMap_.end()) {
160 logicalCameraIdStatus = true;
161 break;
162 }
163 }
164 if (logicalCameraIdStatus) {
165 return logicalCameraId;
166 } else {
167 return std::string("");
168 }
169 }
170
ReturnPhysicalCameraIdToString(const CameraId & physicalCameraId)171 std::string CameraHostConfig::ReturnPhysicalCameraIdToString(const CameraId &physicalCameraId)
172 {
173 for (auto iter = enumCameraIdMap_.begin(); iter != enumCameraIdMap_.end(); iter++) {
174 if (iter->second == physicalCameraId) {
175 return iter->first;
176 }
177 }
178 return std::string("");
179 }
180
ReturnLogicalCameraIdToString(const std::string & physicalCameraId)181 std::string CameraHostConfig::ReturnLogicalCameraIdToString(const std::string &physicalCameraId)
182 {
183 for (auto iter = cameraIdMap_.begin(); iter != cameraIdMap_.end(); iter++) {
184 if (iter->second[0] == physicalCameraId) {
185 return iter->first;
186 }
187 }
188 return std::string("");
189 }
190 } // end namespace OHOS::Camera
191