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 "adapter/preview/osal/resource_adapter_impl_standard.h"
17
18 #include "adapter/ohos/osal/resource_theme_style.h"
19 #include "adapter/preview/entrance/ace_application_info.h"
20 #include "adapter/preview/osal/resource_convertor.h"
21 #include "core/components/theme/theme_attributes.h"
22
23 namespace OHOS::Ace {
24
25 namespace {
26 #ifdef WINDOWS_PLATFORM
27 constexpr char DELIMITER[] = "\\";
28 #else
29 constexpr char DELIMITER[] = "/";
30 #endif
31
32 constexpr uint32_t OHOS_THEME_ID = 125829872; // ohos_theme
33
CheckThemeId(int32_t & themeId)34 void CheckThemeId(int32_t& themeId)
35 {
36 if (themeId >= 0) {
37 return;
38 }
39 themeId = OHOS_THEME_ID;
40 }
41
42 const char* PATTERN_MAP[] = {
43 THEME_PATTERN_BUTTON,
44 THEME_PATTERN_CHECKBOX,
45 THEME_PATTERN_DATA_PANEL,
46 THEME_PATTERN_RADIO,
47 THEME_PATTERN_SWIPER,
48 THEME_PATTERN_SWITCH,
49 THEME_PATTERN_TOOLBAR,
50 THEME_PATTERN_TOGGLE,
51 THEME_PATTERN_TOAST,
52 THEME_PATTERN_DIALOG,
53 THEME_PATTERN_DRAG_BAR,
54 THEME_PATTERN_CLOSE_ICON,
55 THEME_PATTERN_SEMI_MODAL,
56 // append
57 THEME_PATTERN_BADGE,
58 THEME_PATTERN_CALENDAR,
59 THEME_PATTERN_CAMERA,
60 THEME_PATTERN_CLOCK,
61 THEME_PATTERN_COUNTER,
62 THEME_PATTERN_DIVIDER,
63 THEME_PATTERN_FOCUS_ANIMATION,
64 THEME_PATTERN_GRID,
65 THEME_PATTERN_IMAGE,
66 THEME_PATTERN_LIST,
67 THEME_PATTERN_LIST_ITEM,
68 THEME_PATTERN_MARQUEE,
69 THEME_PATTERN_NAVIGATION_BAR,
70 THEME_PATTERN_PICKER,
71 THEME_PATTERN_PIECE,
72 THEME_PATTERN_POPUP,
73 THEME_PATTERN_PROGRESS,
74 THEME_PATTERN_QRCODE,
75 THEME_PATTERN_RATING,
76 THEME_PATTERN_REFRESH,
77 THEME_PATTERN_SCROLL_BAR,
78 THEME_PATTERN_SEARCH,
79 THEME_PATTERN_SELECT,
80 THEME_PATTERN_SLIDER,
81 THEME_PATTERN_STEPPER,
82 THEME_PATTERN_TAB,
83 THEME_PATTERN_TEXT,
84 THEME_PATTERN_TEXTFIELD,
85 THEME_PATTERN_TEXT_OVERLAY,
86 THEME_PATTERN_VIDEO,
87 THEME_PATTERN_ICON,
88 THEME_PATTERN_INDEXER,
89 THEME_PATTERN_APP_BAR,
90 THEME_PATTERN_SECURITY_COMPONENT,
91 THEME_PATTERN_SIDE_BAR,
92 THEME_PATTERN_PATTERN_LOCK
93 };
94 } // namespace
95
Create()96 RefPtr<ResourceAdapter> ResourceAdapter::Create()
97 {
98 return AceType::MakeRefPtr<ResourceAdapterImpl>();
99 }
100
ParseDimensionUnit(const std::string & unit)101 DimensionUnit ParseDimensionUnit(const std::string& unit)
102 {
103 if (unit == "px") {
104 return DimensionUnit::PX;
105 } else if (unit == "fp") {
106 return DimensionUnit::FP;
107 } else if (unit == "lpx") {
108 return DimensionUnit::LPX;
109 } else if (unit == "%") {
110 return DimensionUnit::PERCENT;
111 } else {
112 return DimensionUnit::VP;
113 }
114 }
115
Init(const ResourceInfo & resourceInfo)116 void ResourceAdapterImpl::Init(const ResourceInfo& resourceInfo)
117 {
118 std::string appResPath = resourceInfo.GetPackagePath();
119 std::string sysResPath = resourceInfo.GetSystemPackagePath();
120 auto resConfig = ConvertConfigToGlobal(resourceInfo.GetResourceConfiguration());
121 std::shared_ptr<Global::Resource::ResourceManager> newResMgr(Global::Resource::CreateResourceManager());
122
123 std::string appResIndexPath = appResPath + DELIMITER + "resources.index";
124 auto appResRet = newResMgr->AddResource(appResIndexPath.c_str());
125 std::string sysResIndexPath = sysResPath + DELIMITER + "resources.index";
126 auto sysResRet = newResMgr->AddResource(sysResIndexPath.c_str());
127
128 auto configRet = newResMgr->UpdateResConfig(*resConfig);
129 LOGI("AddAppRes result=%{public}d, AddSysRes result=%{public}d, UpdateResConfig result=%{public}d, "
130 "ori=%{public}d, dpi=%{public}f, device=%{public}d",
131 appResRet, sysResRet, configRet, resConfig->GetDirection(), resConfig->GetScreenDensity(),
132 resConfig->GetDeviceType());
133 Platform::AceApplicationInfoImpl::GetInstance().SetResourceManager(newResMgr);
134 resourceManager_ = newResMgr;
135 packagePathStr_ = appResPath;
136 }
137
UpdateConfig(const ResourceConfiguration & config)138 void ResourceAdapterImpl::UpdateConfig(const ResourceConfiguration& config)
139 {
140 auto resConfig = ConvertConfigToGlobal(config);
141 LOGI("UpdateConfig ori=%{public}d, dpi=%{public}f, device=%{public}d", resConfig->GetDirection(),
142 resConfig->GetScreenDensity(), resConfig->GetDeviceType());
143 resourceManager_->UpdateResConfig(*resConfig);
144 }
145
GetTheme(int32_t themeId)146 RefPtr<ThemeStyle> ResourceAdapterImpl::GetTheme(int32_t themeId)
147 {
148 CheckThemeId(themeId);
149 auto theme = AceType::MakeRefPtr<ResourceThemeStyle>(AceType::Claim(this));
150 constexpr char OHFlag[] = "ohos_"; // fit with resource/base/theme.json and pattern.json
151 if (resourceManager_) {
152 auto ret = resourceManager_->GetThemeById(themeId, theme->rawAttrs_);
153 for (size_t i = 0; i < sizeof(PATTERN_MAP) / sizeof(PATTERN_MAP[0]); i++) {
154 ResourceThemeStyle::RawAttrMap attrMap;
155 std::string patternTag = PATTERN_MAP[i];
156 std::string patternName = std::string(OHFlag) + PATTERN_MAP[i];
157 ret = resourceManager_->GetPatternByName(patternName.c_str(), attrMap);
158 LOGD("theme pattern[%{public}s, %{public}s], attr size=%{public}zu", patternTag.c_str(),
159 patternName.c_str(), attrMap.size());
160 if (attrMap.empty()) {
161 continue;
162 }
163 theme->patternAttrs_[patternTag] = attrMap;
164 }
165 LOGI("themeId=%{public}d, ret=%{public}d, attr size=%{public}zu, pattern size=%{public}zu", themeId, ret,
166 theme->rawAttrs_.size(), theme->patternAttrs_.size());
167 }
168
169 if (theme->patternAttrs_.empty() && theme->rawAttrs_.empty()) {
170 LOGW("theme resource get failed, use default theme config.");
171 return nullptr;
172 }
173
174 theme->ParseContent();
175 theme->patternAttrs_.clear();
176 return theme;
177 };
178
GetColor(uint32_t resId)179 Color ResourceAdapterImpl::GetColor(uint32_t resId)
180 {
181 uint32_t result = 0;
182 if (resourceManager_) {
183 auto state = resourceManager_->GetColorById(resId, result);
184 if (state != Global::Resource::SUCCESS) {
185 LOGE("GetColor error, id=%{public}u", resId);
186 }
187 }
188 return Color(result);
189 }
190
GetDimension(uint32_t resId)191 Dimension ResourceAdapterImpl::GetDimension(uint32_t resId)
192 {
193 float dimensionFloat = 0.0f;
194 std::string unit = "";
195 if (resourceManager_) {
196 auto state = resourceManager_->GetFloatById(resId, dimensionFloat, unit);
197 if (state != Global::Resource::SUCCESS) {
198 LOGE("GetDimension error, id=%{public}u", resId);
199 }
200 }
201 return Dimension(static_cast<double>(dimensionFloat), ParseDimensionUnit(unit));
202 }
203
GetString(uint32_t resId)204 std::string ResourceAdapterImpl::GetString(uint32_t resId)
205 {
206 std::string strResult = "";
207 if (resourceManager_) {
208 auto state = resourceManager_->GetStringById(resId, strResult);
209 if (state != Global::Resource::SUCCESS) {
210 LOGE("GetString error, id=%{public}u", resId);
211 }
212 }
213 return strResult;
214 }
215
GetPluralString(uint32_t resId,int quantity)216 std::string ResourceAdapterImpl::GetPluralString(uint32_t resId, int quantity)
217 {
218 std::string strResult = "";
219 if (resourceManager_) {
220 auto state = resourceManager_->GetPluralStringById(resId, quantity, strResult);
221 if (state != Global::Resource::SUCCESS) {
222 LOGE("GetPluralString error, id=%{public}u", resId);
223 }
224 }
225 return strResult;
226 }
227
GetStringArray(uint32_t resId) const228 std::vector<std::string> ResourceAdapterImpl::GetStringArray(uint32_t resId) const
229 {
230 std::vector<std::string> strResults;
231 if (resourceManager_) {
232 auto state = resourceManager_->GetStringArrayById(resId, strResults);
233 if (state != Global::Resource::SUCCESS) {
234 LOGE("GetStringArray error, id=%{public}u", resId);
235 }
236 }
237 return strResults;
238 }
239
GetDouble(uint32_t resId)240 double ResourceAdapterImpl::GetDouble(uint32_t resId)
241 {
242 float result = 0.0f;
243 if (resourceManager_) {
244 auto state = resourceManager_->GetFloatById(resId, result);
245 if (state != Global::Resource::SUCCESS) {
246 LOGE("GetDouble error, id=%{public}u", resId);
247 }
248 }
249 return static_cast<double>(result);
250 }
251
GetInt(uint32_t resId)252 int32_t ResourceAdapterImpl::GetInt(uint32_t resId)
253 {
254 int32_t result = 0;
255 if (resourceManager_) {
256 auto state = resourceManager_->GetIntegerById(resId, result);
257 if (state != Global::Resource::SUCCESS) {
258 LOGE("GetInt error, id=%{public}u", resId);
259 }
260 }
261 return result;
262 }
263
GetIntArray(uint32_t resId) const264 std::vector<uint32_t> ResourceAdapterImpl::GetIntArray(uint32_t resId) const
265 {
266 std::vector<int> intVectorResult;
267 if (resourceManager_) {
268 auto state = resourceManager_->GetIntArrayById(resId, intVectorResult);
269 if (state != Global::Resource::SUCCESS) {
270 LOGE("GetIntArray error, id=%{public}u", resId);
271 }
272 }
273 std::vector<uint32_t> result;
274 std::transform(
275 intVectorResult.begin(), intVectorResult.end(), result.begin(), [](int x) { return static_cast<uint32_t>(x); });
276 return result;
277 }
278
GetBoolean(uint32_t resId) const279 bool ResourceAdapterImpl::GetBoolean(uint32_t resId) const
280 {
281 bool result = false;
282 if (resourceManager_) {
283 auto state = resourceManager_->GetBooleanById(resId, result);
284 if (state != Global::Resource::SUCCESS) {
285 LOGE("GetBoolean error, id=%{public}u", resId);
286 }
287 }
288 return result;
289 }
290
GetMediaPath(uint32_t resId)291 std::string ResourceAdapterImpl::GetMediaPath(uint32_t resId)
292 {
293 std::string mediaPath = "";
294 if (resourceManager_) {
295 auto state = resourceManager_->GetMediaById(resId, mediaPath);
296 if (state != Global::Resource::SUCCESS) {
297 LOGE("GetMediaPath error, id=%{public}u", resId);
298 return "";
299 }
300 // The Media file directory starts with file// on the PC Preview
301 return "file://" + mediaPath;
302 }
303 return "";
304 }
305
GetRawfile(const std::string & fileName)306 std::string ResourceAdapterImpl::GetRawfile(const std::string& fileName)
307 {
308 // The rawfile file directory starts with file// on the PC Preview
309 return "file://" + packagePathStr_ + "/resources/rawfile/" + fileName;
310 }
311
GetRawFileData(const std::string & rawFile,size_t & len,std::unique_ptr<uint8_t[]> & dest)312 bool ResourceAdapterImpl::GetRawFileData(const std::string& rawFile, size_t& len, std::unique_ptr<uint8_t[]>& dest)
313 {
314 return false;
315 }
316
GetMediaData(uint32_t resId,size_t & len,std::unique_ptr<uint8_t[]> & dest)317 bool ResourceAdapterImpl::GetMediaData(uint32_t resId, size_t& len, std::unique_ptr<uint8_t[]>& dest)
318 {
319 return false;
320 }
321
GetMediaData(const std::string & resName,size_t & len,std::unique_ptr<uint8_t[]> & dest)322 bool ResourceAdapterImpl::GetMediaData(const std::string& resName, size_t& len, std::unique_ptr<uint8_t[]>& dest)
323 {
324 return false;
325 }
326
UpdateResourceManager(const std::string & bundleName,const std::string & moduleName)327 void ResourceAdapterImpl::UpdateResourceManager(const std::string& bundleName, const std::string& moduleName)
328 {
329 return;
330 }
331 } // namespace OHOS::Ace
332