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