1 /*
2  * Copyright (c) 2021-2024 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/ohos/osal/resource_adapter_impl.h"
17 
18 #include <dirent.h>
19 
20 #include "drawable_descriptor.h"
21 
22 #include "adapter/ohos/entrance/ace_container.h"
23 #include "adapter/ohos/osal/resource_convertor.h"
24 #include "adapter/ohos/osal/resource_theme_style.h"
25 namespace OHOS::Ace {
26 namespace {
27 
28 constexpr uint32_t OHOS_THEME_ID = 125829872; // ohos_theme
29 
CheckThemeId(int32_t& themeId)30 void CheckThemeId(int32_t& themeId)
31 {
32     if (themeId >= 0) {
33         return;
34     }
35     themeId = OHOS_THEME_ID;
36 }
37 
38 const char* PATTERN_MAP[] = {
39     THEME_PATTERN_BUTTON,
40     THEME_PATTERN_CHECKBOX,
41     THEME_PATTERN_DATA_PANEL,
42     THEME_PATTERN_RADIO,
43     THEME_PATTERN_SWIPER,
44     THEME_PATTERN_SWITCH,
45     THEME_PATTERN_TOOLBAR,
46     THEME_PATTERN_TOGGLE,
47     THEME_PATTERN_TOAST,
48     THEME_PATTERN_DIALOG,
49     THEME_PATTERN_DRAG_BAR,
50     THEME_PATTERN_CLOSE_ICON,
51     THEME_PATTERN_SEMI_MODAL,
52     THEME_PATTERN_BADGE,
53     THEME_PATTERN_CALENDAR,
54     THEME_PATTERN_CAMERA,
55     THEME_PATTERN_CARD,
56     THEME_PATTERN_CLOCK,
57     THEME_PATTERN_COUNTER,
58     THEME_PATTERN_DIVIDER,
59     THEME_PATTERN_FOCUS_ANIMATION,
60     THEME_PATTERN_GRID,
61     THEME_PATTERN_HYPERLINK,
62     THEME_PATTERN_IMAGE,
63     THEME_PATTERN_LIST,
64     THEME_PATTERN_LIST_ITEM,
65     THEME_PATTERN_MARQUEE,
66     THEME_PATTERN_NAVIGATION_BAR,
67     THEME_PATTERN_PICKER,
68     THEME_PATTERN_PIECE,
69     THEME_PATTERN_POPUP,
70     THEME_PATTERN_PROGRESS,
71     THEME_PATTERN_QRCODE,
72     THEME_PATTERN_RATING,
73     THEME_PATTERN_REFRESH,
74     THEME_PATTERN_SCROLL_BAR,
75     THEME_PATTERN_SEARCH,
76     THEME_PATTERN_SELECT,
77     THEME_PATTERN_SLIDER,
78     THEME_PATTERN_STEPPER,
79     THEME_PATTERN_TAB,
80     THEME_PATTERN_TEXT,
81     THEME_PATTERN_TEXTFIELD,
82     THEME_PATTERN_TEXT_OVERLAY,
83     THEME_PATTERN_VIDEO,
84     THEME_PATTERN_ICON,
85     THEME_PATTERN_INDEXER,
86     THEME_PATTERN_APP_BAR,
87     THEME_PATTERN_ADVANCED_PATTERN,
88     THEME_PATTERN_SECURITY_COMPONENT,
89     THEME_PATTERN_FORM,
90     THEME_PATTERN_SIDE_BAR,
91     THEME_PATTERN_RICH_EDITOR,
92     THEME_PATTERN_PATTERN_LOCK,
93     THEME_PATTERN_GAUGE,
94     THEME_PATTERN_SHEET,
95     THEME_BLUR_STYLE_COMMON,
96     THEME_PATTERN_SHADOW,
97     THEME_PATTERN_CONTAINER_MODAL,
98     THEME_PATTERN_SCROLLABLE,
99     THEME_PATTERN_LINEAR_INDICATOR
100 };
101 
IsDirExist(const std::string& path)102 bool IsDirExist(const std::string& path)
103 {
104     char realPath[PATH_MAX] = { 0x00 };
105     CHECK_NULL_RETURN(realpath(path.c_str(), realPath), false);
106     DIR* dir = opendir(realPath);
107     CHECK_NULL_RETURN(dir, false);
108     closedir(dir);
109     return true;
110 }
111 
ParseDimensionUnit(const std::string& unit)112 DimensionUnit ParseDimensionUnit(const std::string& unit)
113 {
114     if (unit == "px") {
115         return DimensionUnit::PX;
116     } else if (unit == "fp") {
117         return DimensionUnit::FP;
118     } else if (unit == "lpx") {
119         return DimensionUnit::LPX;
120     } else if (unit == "%") {
121         return DimensionUnit::PERCENT;
122     } else {
123         return DimensionUnit::VP;
124     }
125 };
126 
127 } // namespace
128 
Create()129 RefPtr<ResourceAdapter> ResourceAdapter::Create()
130 {
131     return AceType::MakeRefPtr<ResourceAdapterImpl>();
132 }
133 
Init(const ResourceInfo& resourceInfo)134 void ResourceAdapterImpl::Init(const ResourceInfo& resourceInfo)
135 {
136     std::string resPath = resourceInfo.GetPackagePath();
137     std::string hapPath = resourceInfo.GetHapPath();
138     auto resConfig = ConvertConfigToGlobal(resourceInfo.GetResourceConfiguration());
139     std::shared_ptr<Global::Resource::ResourceManager> newResMgr(Global::Resource::CreateResourceManager());
140     std::string resIndexPath = hapPath.empty() ? (resPath + "resources.index") : hapPath;
141     auto resRet = newResMgr->AddResource(resIndexPath.c_str());
142 
143     if (resConfig != nullptr) {
144         auto configRet = newResMgr->UpdateResConfig(*resConfig);
145         LOGI("AddRes result=%{public}d, UpdateResConfig result=%{public}d, ori=%{public}d, dpi=%{public}f, "
146              "device=%{public}d, colorMode=%{public}d, inputDevice=%{public}d",
147             resRet, configRet, resConfig->GetDirection(), resConfig->GetScreenDensity(), resConfig->GetDeviceType(),
148             resConfig->GetColorMode(), resConfig->GetInputDevice());
149     }
150     sysResourceManager_ = newResMgr;
151     {
152         std::unique_lock<std::shared_mutex> lock(resourceMutex_);
153         resourceManager_ = sysResourceManager_;
154     }
155     packagePathStr_ = (hapPath.empty() || IsDirExist(resPath)) ? resPath : std::string();
156     resConfig_ = resConfig;
157 }
158 
UpdateConfig(const ResourceConfiguration& config, bool themeFlag)159 void ResourceAdapterImpl::UpdateConfig(const ResourceConfiguration& config, bool themeFlag)
160 {
161     auto resConfig = ConvertConfigToGlobal(config);
162     LOGI("UpdateConfig ori=%{public}d, dpi=%{public}f, device=%{public}d, "
163          "colorMode=%{public}d, inputDevice=%{public}d",
164         resConfig->GetDirection(), resConfig->GetScreenDensity(), resConfig->GetDeviceType(), resConfig->GetColorMode(),
165         resConfig->GetInputDevice());
166     if (sysResourceManager_ && resConfig != nullptr) {
167         sysResourceManager_->UpdateResConfig(*resConfig, themeFlag);
168     }
169     for (auto& resMgr : resourceManagers_) {
170         if (resConfig != nullptr) {
171             resMgr.second->UpdateResConfig(*resConfig, themeFlag);
172         }
173     }
174     resConfig_ = resConfig;
175 }
176 
GetTheme(int32_t themeId)177 RefPtr<ThemeStyle> ResourceAdapterImpl::GetTheme(int32_t themeId)
178 {
179     CheckThemeId(themeId);
180     auto theme = AceType::MakeRefPtr<ResourceThemeStyle>(AceType::Claim(this));
181     constexpr char flag[] = "ohos_"; // fit with resource/base/theme.json and pattern.json
182     {
183         auto manager = GetResourceManager();
184         if (manager) {
185             auto ret = manager->GetThemeById(themeId, theme->rawAttrs_);
186             for (size_t i = 0; i < sizeof(PATTERN_MAP) / sizeof(PATTERN_MAP[0]); i++) {
187                 ResourceThemeStyle::RawAttrMap attrMap;
188                 std::string patternTag = PATTERN_MAP[i];
189                 std::string patternName = std::string(flag) + PATTERN_MAP[i];
190                 ret = manager->GetPatternByName(patternName.c_str(), attrMap);
191                 if (attrMap.empty()) {
192                     continue;
193                 }
194                 theme->patternAttrs_[patternTag] = attrMap;
195             }
196             LOGI("themeId=%{public}d, ret=%{public}d, attr size=%{public}zu, pattern size=%{public}zu", themeId, ret,
197                 theme->rawAttrs_.size(), theme->patternAttrs_.size());
198         }
199     }
200 
201     if (theme->patternAttrs_.empty() && theme->rawAttrs_.empty()) {
202         LOGW("theme resource get failed, use default theme config.");
203         return nullptr;
204     }
205 
206     theme->ParseContent();
207     theme->patternAttrs_.clear();
208     return theme;
209 }
210 
GetColor(uint32_t resId)211 Color ResourceAdapterImpl::GetColor(uint32_t resId)
212 {
213     uint32_t result = 0;
214     auto manager = GetResourceManager();
215     CHECK_NULL_RETURN(manager, Color(result));
216     auto state = manager->GetColorById(resId, result);
217     if (state != Global::Resource::SUCCESS) {
218         LOGE("GetColor error, id=%{public}u", resId);
219     }
220     return Color(result);
221 }
222 
GetColorByName(const std::string& resName)223 Color ResourceAdapterImpl::GetColorByName(const std::string& resName)
224 {
225     uint32_t result = 0;
226     auto actualResName = GetActualResourceName(resName);
227     auto manager = GetResourceManager();
228     CHECK_NULL_RETURN(manager, Color(result));
229     auto state = manager->GetColorByName(actualResName.c_str(), result);
230     if (state != Global::Resource::SUCCESS) {
231         LOGE("GetColor error, resName=%{public}s", resName.c_str());
232     }
233     return Color(result);
234 }
235 
GetDimension(uint32_t resId)236 Dimension ResourceAdapterImpl::GetDimension(uint32_t resId)
237 {
238     float dimensionFloat = 0.0f;
239 #ifdef NG_BUILD
240     std::string unit;
241     auto manager = GetResourceManager();
242     if (manager) {
243         auto state = manager->GetFloatById(resId, dimensionFloat, unit);
244         if (state != Global::Resource::SUCCESS) {
245             LOGE("NG: GetDimension error, id=%{public}u", resId);
246         }
247     }
248     return Dimension(static_cast<double>(dimensionFloat), ParseDimensionUnit(unit));
249 #else
250     if (Container::IsCurrentUseNewPipeline()) {
251         std::string unit;
252         auto manager = GetResourceManager();
253         if (manager) {
254             auto state = manager->GetFloatById(resId, dimensionFloat, unit);
255             if (state != Global::Resource::SUCCESS) {
256                 LOGE("NG: GetDimension error, id=%{public}u", resId);
257             }
258         }
259         return Dimension(static_cast<double>(dimensionFloat), ParseDimensionUnit(unit));
260     }
261 
262     auto manager = GetResourceManager();
263     CHECK_NULL_RETURN(manager, Dimension(static_cast<double>(dimensionFloat)));
264     auto state = manager->GetFloatById(resId, dimensionFloat);
265     if (state != Global::Resource::SUCCESS) {
266         LOGE("GetDimension error, id=%{public}u", resId);
267     }
268     return Dimension(static_cast<double>(dimensionFloat));
269 #endif
270 }
271 
GetDimensionByName(const std::string& resName)272 Dimension ResourceAdapterImpl::GetDimensionByName(const std::string& resName)
273 {
274     float dimensionFloat = 0.0f;
275     auto actualResName = GetActualResourceName(resName);
276     auto manager = GetResourceManager();
277     CHECK_NULL_RETURN(manager, Dimension());
278     std::string unit;
279     auto state = manager->GetFloatByName(actualResName.c_str(), dimensionFloat, unit);
280     if (state != Global::Resource::SUCCESS) {
281         LOGE("GetDimension error, resName=%{public}s", resName.c_str());
282     }
283     return Dimension(static_cast<double>(dimensionFloat), ParseDimensionUnit(unit));
284 }
285 
GetString(uint32_t resId)286 std::string ResourceAdapterImpl::GetString(uint32_t resId)
287 {
288     std::string strResult = "";
289     auto manager = GetResourceManager();
290     CHECK_NULL_RETURN(manager, strResult);
291     manager->GetStringById(resId, strResult);
292     return strResult;
293 }
294 
GetStringByName(const std::string& resName)295 std::string ResourceAdapterImpl::GetStringByName(const std::string& resName)
296 {
297     std::string strResult = "";
298     auto actualResName = GetActualResourceName(resName);
299     auto manager = GetResourceManager();
300     CHECK_NULL_RETURN(manager, strResult);
301     manager->GetStringByName(actualResName.c_str(), strResult);
302     return strResult;
303 }
304 
GetPluralString(uint32_t resId, int quantity)305 std::string ResourceAdapterImpl::GetPluralString(uint32_t resId, int quantity)
306 {
307     std::string strResult = "";
308     auto manager = GetResourceManager();
309     CHECK_NULL_RETURN(manager, strResult);
310     auto state = manager->GetPluralStringById(resId, quantity, strResult);
311     if (state != Global::Resource::SUCCESS) {
312         LOGE("GetPluralString error, id=%{public}u", resId);
313     }
314     return strResult;
315 }
316 
GetPluralStringByName(const std::string& resName, int quantity)317 std::string ResourceAdapterImpl::GetPluralStringByName(const std::string& resName, int quantity)
318 {
319     std::string strResult = "";
320     auto actualResName = GetActualResourceName(resName);
321     auto manager = GetResourceManager();
322     CHECK_NULL_RETURN(manager, strResult);
323     auto state = manager->GetPluralStringByName(actualResName.c_str(), quantity, strResult);
324     if (state != Global::Resource::SUCCESS) {
325         LOGE("GetPluralString error, resName=%{public}s", resName.c_str());
326     }
327     return strResult;
328 }
329 
GetStringArray(uint32_t resId) const330 std::vector<std::string> ResourceAdapterImpl::GetStringArray(uint32_t resId) const
331 {
332     std::vector<std::string> strResults;
333     auto manager = GetResourceManager();
334     CHECK_NULL_RETURN(manager, strResults);
335     manager->GetStringArrayById(resId, strResults);
336     return strResults;
337 }
338 
GetStringArrayByName(const std::string& resName) const339 std::vector<std::string> ResourceAdapterImpl::GetStringArrayByName(const std::string& resName) const
340 {
341     std::vector<std::string> strResults;
342     auto actualResName = GetActualResourceName(resName);
343     auto manager = GetResourceManager();
344     CHECK_NULL_RETURN(manager, strResults);
345     auto state = manager->GetStringArrayByName(actualResName.c_str(), strResults);
346     if (state != Global::Resource::SUCCESS) {
347         LOGE("GetStringArray error, resName=%{public}s", resName.c_str());
348     }
349     return strResults;
350 }
351 
GetDouble(uint32_t resId)352 double ResourceAdapterImpl::GetDouble(uint32_t resId)
353 {
354     float result = 0.0f;
355     auto manager = GetResourceManager();
356     CHECK_NULL_RETURN(manager, static_cast<double>(result));
357     auto state = manager->GetFloatById(resId, result);
358     if (state != Global::Resource::SUCCESS) {
359         LOGE("GetDouble error, id=%{public}u", resId);
360     }
361     return static_cast<double>(result);
362 }
363 
GetDoubleByName(const std::string& resName)364 double ResourceAdapterImpl::GetDoubleByName(const std::string& resName)
365 {
366     float result = 0.0f;
367     auto actualResName = GetActualResourceName(resName);
368     auto manager = GetResourceManager();
369     CHECK_NULL_RETURN(manager, static_cast<double>(result));
370     auto state = manager->GetFloatByName(actualResName.c_str(), result);
371     if (state != Global::Resource::SUCCESS) {
372         LOGE("GetDouble error, resName=%{public}s", resName.c_str());
373     }
374     return static_cast<double>(result);
375 }
376 
GetInt(uint32_t resId)377 int32_t ResourceAdapterImpl::GetInt(uint32_t resId)
378 {
379     int32_t result = 0;
380     auto manager = GetResourceManager();
381     CHECK_NULL_RETURN(manager, result);
382     auto state = manager->GetIntegerById(resId, result);
383     if (state != Global::Resource::SUCCESS) {
384         LOGE("GetInt error, id=%{public}u", resId);
385     }
386     return result;
387 }
388 
GetIntByName(const std::string& resName)389 int32_t ResourceAdapterImpl::GetIntByName(const std::string& resName)
390 {
391     int32_t result = 0;
392     auto actualResName = GetActualResourceName(resName);
393     auto manager = GetResourceManager();
394     CHECK_NULL_RETURN(manager, result);
395     auto state = manager->GetIntegerByName(actualResName.c_str(), result);
396     if (state != Global::Resource::SUCCESS) {
397         LOGE("GetInt error, resName=%{public}s", resName.c_str());
398     }
399     return result;
400 }
401 
GetIntArray(uint32_t resId) const402 std::vector<uint32_t> ResourceAdapterImpl::GetIntArray(uint32_t resId) const
403 {
404     std::vector<int> intVectorResult;
405     {
406         auto manager = GetResourceManager();
407         if (manager) {
408             auto state = manager->GetIntArrayById(resId, intVectorResult);
409             if (state != Global::Resource::SUCCESS) {
410                 LOGE("GetIntArray error, id=%{public}u", resId);
411             }
412         }
413     }
414 
415     std::vector<uint32_t> result;
416     std::transform(
417         intVectorResult.begin(), intVectorResult.end(), result.begin(), [](int x) { return static_cast<uint32_t>(x); });
418     return result;
419 }
420 
GetIntArrayByName(const std::string& resName) const421 std::vector<uint32_t> ResourceAdapterImpl::GetIntArrayByName(const std::string& resName) const
422 {
423     std::vector<int> intVectorResult;
424     auto actualResName = GetActualResourceName(resName);
425     auto manager = GetResourceManager();
426     CHECK_NULL_RETURN(manager, {});
427     auto state = manager->GetIntArrayByName(actualResName.c_str(), intVectorResult);
428     if (state != Global::Resource::SUCCESS) {
429         LOGE("GetIntArray error, resName=%{public}s", resName.c_str());
430     }
431 
432     std::vector<uint32_t> result;
433     std::transform(
434         intVectorResult.begin(), intVectorResult.end(), result.begin(), [](int x) { return static_cast<uint32_t>(x); });
435     return result;
436 }
437 
GetBoolean(uint32_t resId) const438 bool ResourceAdapterImpl::GetBoolean(uint32_t resId) const
439 {
440     bool result = false;
441     auto manager = GetResourceManager();
442     CHECK_NULL_RETURN(manager, result);
443     auto state = manager->GetBooleanById(resId, result);
444     if (state != Global::Resource::SUCCESS) {
445         LOGE("GetBoolean error, id=%{public}u", resId);
446     }
447     return result;
448 }
449 
GetBooleanByName(const std::string& resName) const450 bool ResourceAdapterImpl::GetBooleanByName(const std::string& resName) const
451 {
452     bool result = false;
453     auto actualResName = GetActualResourceName(resName);
454     auto manager = GetResourceManager();
455     CHECK_NULL_RETURN(manager, result);
456     auto state = manager->GetBooleanByName(actualResName.c_str(), result);
457     if (state != Global::Resource::SUCCESS) {
458         LOGE("GetBoolean error, resName=%{public}s", resName.c_str());
459     }
460     return result;
461 }
462 
GetPixelMap(uint32_t resId)463 std::shared_ptr<Media::PixelMap> ResourceAdapterImpl::GetPixelMap(uint32_t resId)
464 {
465     auto manager = GetResourceManager();
466 
467     CHECK_NULL_RETURN(manager, nullptr);
468     Napi::DrawableDescriptor::DrawableType drawableType;
469     Global::Resource::RState state;
470     auto drawableDescriptor = Napi::DrawableDescriptorFactory::Create(resId, resourceManager_, state, drawableType, 0);
471     if (state != Global::Resource::SUCCESS) {
472         LOGE("Failed to Create drawableDescriptor by %{public}d", resId);
473         return nullptr;
474     }
475     CHECK_NULL_RETURN(drawableDescriptor, nullptr);
476     return drawableDescriptor->GetPixelMap();
477 }
478 
GetMediaPath(uint32_t resId)479 std::string ResourceAdapterImpl::GetMediaPath(uint32_t resId)
480 {
481     std::string mediaPath = "";
482     auto manager = GetResourceManager();
483     CHECK_NULL_RETURN(manager, "");
484     auto state = manager->GetMediaById(resId, mediaPath);
485     if (state != Global::Resource::SUCCESS) {
486         LOGE("GetMediaById error, id=%{public}u, errorCode=%{public}u", resId, state);
487         return "";
488     }
489     if (SystemProperties::GetUnZipHap()) {
490         return "file:///" + mediaPath;
491     }
492     auto pos = mediaPath.find_last_of('.');
493     if (pos == std::string::npos) {
494         LOGE("GetMediaById error, return mediaPath[%{private}s] format error", mediaPath.c_str());
495         return "";
496     }
497     return "resource:///" + std::to_string(resId) + mediaPath.substr(pos);
498 }
499 
GetMediaPathByName(const std::string& resName)500 std::string ResourceAdapterImpl::GetMediaPathByName(const std::string& resName)
501 {
502     std::string mediaPath = "";
503     auto actualResName = GetActualResourceName(resName);
504     {
505         auto manager = GetResourceManager();
506         CHECK_NULL_RETURN(manager, "");
507         auto state = manager->GetMediaByName(actualResName.c_str(), mediaPath);
508         if (state != Global::Resource::SUCCESS) {
509             LOGE("GetMediaPathByName error, resName=%{public}s, errorCode=%{public}u", resName.c_str(), state);
510             return "";
511         }
512     }
513     if (SystemProperties::GetUnZipHap()) {
514         return "file:///" + mediaPath;
515     }
516     auto pos = mediaPath.find_last_of('.');
517     if (pos == std::string::npos) {
518         LOGE("GetMediaById error, return mediaPath[%{private}s] format error", mediaPath.c_str());
519         return "";
520     }
521     return "resource:///" + actualResName + mediaPath.substr(pos);
522 }
523 
GetRawfile(const std::string& fileName)524 std::string ResourceAdapterImpl::GetRawfile(const std::string& fileName)
525 {
526     // as web component not support resource format: resource://RAWFILE/{fileName}, use old format
527     if (!packagePathStr_.empty()) {
528         std::string outPath;
529         auto manager = GetResourceManager();
530         CHECK_NULL_RETURN(manager, "");
531         // Adapt to the input like: "file:///index.html?a=1", before the new solution comes.
532         auto it = std::find_if(fileName.begin(), fileName.end(), [](char c) { return (c == '#') || (c == '?'); });
533         std::string params;
534         std::string newFileName = fileName;
535         if (it != fileName.end()) {
536             newFileName = std::string(fileName.begin(), it);
537             params = std::string(it, fileName.end());
538         }
539         auto state = manager->GetRawFilePathByName(newFileName, outPath);
540         if (state != Global::Resource::SUCCESS) {
541             LOGE("GetRawfile error, filename:%{public}s, error:%{public}u", fileName.c_str(), state);
542             return "";
543         }
544         return "file:///" + outPath + params;
545     }
546     return "resource://RAWFILE/" + fileName;
547 }
548 
GetRawFileData(const std::string& rawFile, size_t& len, std::unique_ptr<uint8_t[]>& dest)549 bool ResourceAdapterImpl::GetRawFileData(const std::string& rawFile, size_t& len, std::unique_ptr<uint8_t[]>& dest)
550 {
551     auto manager = GetResourceManager();
552     CHECK_NULL_RETURN(manager, false);
553     auto state = manager->GetRawFileFromHap(rawFile, len, dest);
554     if (state != Global::Resource::SUCCESS || !dest) {
555         LOGW("GetRawFileFromHap error, raw filename:%{public}s, error:%{public}u", rawFile.c_str(), state);
556         return false;
557     }
558     return true;
559 }
560 
GetRawFileData(const std::string& rawFile, size_t& len, std::unique_ptr<uint8_t[]>& dest, const std::string& bundleName, const std::string& moduleName)561 bool ResourceAdapterImpl::GetRawFileData(const std::string& rawFile, size_t& len, std::unique_ptr<uint8_t[]>& dest,
562     const std::string& bundleName, const std::string& moduleName)
563 {
564     UpdateResourceManager(bundleName, moduleName);
565     auto manager = GetResourceManager();
566     CHECK_NULL_RETURN(manager, false);
567     auto state = manager->GetRawFileFromHap(rawFile, len, dest);
568     if (state != Global::Resource::SUCCESS || !dest) {
569         LOGW("GetRawFileFromHap error, raw filename:%{public}s, bundleName:%{public}s, moduleName:%{public}s, "
570              "error:%{public}u",
571             rawFile.c_str(), bundleName.c_str(), moduleName.c_str(), state);
572         return false;
573     }
574     return true;
575 }
576 
GetMediaData(uint32_t resId, size_t& len, std::unique_ptr<uint8_t[]>& dest)577 bool ResourceAdapterImpl::GetMediaData(uint32_t resId, size_t& len, std::unique_ptr<uint8_t[]>& dest)
578 {
579     auto manager = GetResourceManager();
580     CHECK_NULL_RETURN(manager, false);
581     auto state = manager->GetMediaDataById(resId, len, dest);
582     if (state != Global::Resource::SUCCESS) {
583         LOGW("GetMediaDataById error, id=%{public}u, error:%{public}u", resId, state);
584         return false;
585     }
586     return true;
587 }
588 
GetMediaData(uint32_t resId, size_t& len, std::unique_ptr<uint8_t[]>& dest, const std::string& bundleName, const std::string& moduleName)589 bool ResourceAdapterImpl::GetMediaData(uint32_t resId, size_t& len, std::unique_ptr<uint8_t[]>& dest,
590     const std::string& bundleName, const std::string& moduleName)
591 {
592     UpdateResourceManager(bundleName, moduleName);
593     auto manager = GetResourceManager();
594     CHECK_NULL_RETURN(manager, false);
595     auto state = manager->GetMediaDataById(resId, len, dest);
596     if (state != Global::Resource::SUCCESS) {
597         LOGW("GetMediaDataById error, id=%{public}u, bundleName:%{public}s, moduleName:%{public}s, error:%{public}u",
598             resId, bundleName.c_str(), moduleName.c_str(), state);
599         return false;
600     }
601     return true;
602 }
603 
GetMediaData(const std::string& resName, size_t& len, std::unique_ptr<uint8_t[]>& dest)604 bool ResourceAdapterImpl::GetMediaData(const std::string& resName, size_t& len, std::unique_ptr<uint8_t[]>& dest)
605 {
606     auto manager = GetResourceManager();
607     CHECK_NULL_RETURN(manager, false);
608     auto state = manager->GetMediaDataByName(resName.c_str(), len, dest);
609     if (state != Global::Resource::SUCCESS) {
610         LOGW("GetMediaDataByName error, res=%{public}s, error:%{public}u", resName.c_str(), state);
611         return false;
612     }
613     return true;
614 }
615 
GetMediaData(const std::string& resName, size_t& len, std::unique_ptr<uint8_t[]>& dest, const std::string& bundleName, const std::string& moduleName)616 bool ResourceAdapterImpl::GetMediaData(const std::string& resName, size_t& len, std::unique_ptr<uint8_t[]>& dest,
617     const std::string& bundleName, const std::string& moduleName)
618 {
619     UpdateResourceManager(bundleName, moduleName);
620     auto manager = GetResourceManager();
621     CHECK_NULL_RETURN(manager, false);
622     auto state = manager->GetMediaDataByName(resName.c_str(), len, dest);
623     if (state != Global::Resource::SUCCESS) {
624         LOGW("GetMediaDataByName error, res=%{public}s, bundleName:%{public}s, moduleName:%{public}s, error:%{public}u",
625             resName.c_str(), bundleName.c_str(), moduleName.c_str(), state);
626         return false;
627     }
628     return true;
629 }
630 
UpdateResourceManager(const std::string& bundleName, const std::string& moduleName)631 void ResourceAdapterImpl::UpdateResourceManager(const std::string& bundleName, const std::string& moduleName)
632 {
633     std::unique_lock<std::shared_mutex> lcok(resourceMutex_);
634     if (bundleName.empty() || moduleName.empty()) {
635         resourceManager_ = sysResourceManager_;
636         return;
637     }
638 
639     auto resourceMgrIter = resourceManagers_.find({ bundleName, moduleName });
640     if (resourceMgrIter != resourceManagers_.end()) {
641         resourceManager_ = resourceMgrIter->second;
642         return;
643     } else {
644         auto container = Container::Current();
645         CHECK_NULL_VOID(container);
646         auto aceContainer = AceType::DynamicCast<Platform::AceContainer>(container);
647         CHECK_NULL_VOID(aceContainer);
648         auto context = aceContainer->GetAbilityContextByModule(bundleName, moduleName);
649         CHECK_NULL_VOID(context);
650         resourceManagers_[{ bundleName, moduleName }] = context->GetResourceManager();
651         resourceManager_ = context->GetResourceManager();
652         if (resourceManager_ && resConfig_ != nullptr) {
653             resourceManager_->UpdateResConfig(*resConfig_);
654         }
655     }
656 }
657 
GetRawFileDescription( const std::string& rawfileName, RawfileDescription& rawfileDescription) const658 bool ResourceAdapterImpl::GetRawFileDescription(
659     const std::string& rawfileName, RawfileDescription& rawfileDescription) const
660 {
661     OHOS::Global::Resource::ResourceManager::RawFileDescriptor descriptor;
662     auto manager = GetResourceManager();
663     CHECK_NULL_RETURN(manager, false);
664     auto state = manager->GetRawFileDescriptorFromHap(rawfileName, descriptor);
665     if (state != Global::Resource::SUCCESS) {
666         LOGE("GetRawfileDescription error, rawfileName=%{public}s, error:%{public}u", rawfileName.c_str(), state);
667         return false;
668     }
669     rawfileDescription.fd = descriptor.fd;
670     rawfileDescription.offset = descriptor.offset;
671     rawfileDescription.length = descriptor.length;
672     return true;
673 }
674 
GetMediaById(const int32_t& resId, std::string& mediaPath) const675 bool ResourceAdapterImpl::GetMediaById(const int32_t& resId, std::string& mediaPath) const
676 {
677     auto manager = GetResourceManager();
678     CHECK_NULL_RETURN(manager, false);
679     auto state = manager->GetMediaById(resId, mediaPath);
680     if (state != Global::Resource::SUCCESS) {
681         LOGE("GetMediaById error, resId=%{public}d, error:%{public}u", resId, state);
682         return false;
683     }
684     return true;
685 }
686 
GetActualResourceName(const std::string& resName) const687 std::string ResourceAdapterImpl::GetActualResourceName(const std::string& resName) const
688 {
689     auto index = resName.find_last_of('.');
690     if (index == std::string::npos) {
691         LOGE("GetActualResourceName error, incorrect resName format.");
692         return {};
693     }
694     return resName.substr(index + 1, resName.length() - index - 1);
695 }
696 
GetResourceLimitKeys() const697 uint32_t ResourceAdapterImpl::GetResourceLimitKeys() const
698 {
699     auto manager = GetResourceManager();
700     CHECK_NULL_RETURN(manager, 0);
701     return manager->GetResourceLimitKeys();
702 }
703 
GetSymbolById(uint32_t resId) const704 uint32_t ResourceAdapterImpl::GetSymbolById(uint32_t resId) const
705 {
706     uint32_t result = 0;
707     auto manager = GetResourceManager();
708     CHECK_NULL_RETURN(manager, -1);
709     manager->GetSymbolById(resId, result);
710     return result;
711 }
712 
713 } // namespace OHOS::Ace
714