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