1 /*
2  * Copyright (c) 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 "resource_manager_napi_sync_impl.h"
17 
18 #include <unordered_map>
19 #include "drawable_descriptor/drawable_descriptor.h"
20 #include "drawable_descriptor/js_drawable_descriptor.h"
21 #include "resource_manager_napi_utils.h"
22 #include "resource_manager_addon.h"
23 namespace OHOS {
24 namespace Global {
25 namespace Resource {
26 using namespace std::placeholders;
27 constexpr int ARRAY_SUBCRIPTOR_ZERO = 0;
28 constexpr int ARRAY_SUBCRIPTOR_ONE = 1;
29 constexpr int ARRAY_SUBCRIPTOR_TWO = 2;
30 constexpr int PARAMS_NUM_TWO = 2;
31 constexpr int PARAMS_NUM_THREE = 3;
ResourceManagerNapiSyncImpl()32 ResourceManagerNapiSyncImpl::ResourceManagerNapiSyncImpl()
33 {}
34 
~ResourceManagerNapiSyncImpl()35 ResourceManagerNapiSyncImpl::~ResourceManagerNapiSyncImpl()
36 {}
37 
38 std::unordered_map<std::string, std::function<napi_value(napi_env&, napi_callback_info&)>>
39     ResourceManagerNapiSyncImpl::syncFuncMatch {
__anon20ee2a990102(napi_env& env, napi_callback_info& info) 40     {"GetStringSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
41         return ResourceManagerNapiSyncImpl::GetStringSync(env, info);}},
__anon20ee2a990202(napi_env& env, napi_callback_info& info) 42     {"GetStringByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
43         return ResourceManagerNapiSyncImpl::GetStringByNameSync(env, info);}},
__anon20ee2a990302(napi_env& env, napi_callback_info& info) 44     {"GetBoolean", [](napi_env& env, napi_callback_info& info) -> napi_value {
45         return ResourceManagerNapiSyncImpl::GetBoolean(env, info);}},
__anon20ee2a990402(napi_env& env, napi_callback_info& info) 46     {"GetBooleanByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
47         return ResourceManagerNapiSyncImpl::GetBooleanByName(env, info);}},
__anon20ee2a990502(napi_env& env, napi_callback_info& info) 48     {"GetNumber", [](napi_env& env, napi_callback_info& info) -> napi_value {
49         return ResourceManagerNapiSyncImpl::GetNumber(env, info);}},
__anon20ee2a990602(napi_env& env, napi_callback_info& info) 50     {"GetNumberByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
51         return ResourceManagerNapiSyncImpl::GetNumberByName(env, info);}},
__anon20ee2a990702(napi_env& env, napi_callback_info& info) 52     {"GetDrawableDescriptor", [](napi_env& env, napi_callback_info& info) -> napi_value {
53         return ResourceManagerNapiSyncImpl::GetDrawableDescriptor(env, info);}},
__anon20ee2a990802(napi_env& env, napi_callback_info& info) 54     {"GetDrawableDescriptorByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
55         return ResourceManagerNapiSyncImpl::GetDrawableDescriptorByName(env, info);}},
__anon20ee2a990902(napi_env& env, napi_callback_info& info) 56     {"GetColorSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
57         return ResourceManagerNapiSyncImpl::GetColorSync(env, info);}},
__anon20ee2a990a02(napi_env& env, napi_callback_info& info) 58     {"GetColorByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
59         return ResourceManagerNapiSyncImpl::GetColorByNameSync(env, info);}},
__anon20ee2a990b02(napi_env& env, napi_callback_info& info) 60     {"AddResource", [](napi_env& env, napi_callback_info& info) -> napi_value {
61         return ResourceManagerNapiSyncImpl::AddResource(env, info);}},
__anon20ee2a990c02(napi_env& env, napi_callback_info& info) 62     {"RemoveResource", [](napi_env& env, napi_callback_info& info) -> napi_value {
63         return ResourceManagerNapiSyncImpl::RemoveResource(env, info);}},
__anon20ee2a990d02(napi_env& env, napi_callback_info& info) 64     {"GetMediaContentBase64Sync", [](napi_env& env, napi_callback_info& info) -> napi_value {
65         return ResourceManagerNapiSyncImpl::GetMediaContentBase64Sync(env, info);}},
__anon20ee2a990e02(napi_env& env, napi_callback_info& info) 66     {"GetMediaContentSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
67         return ResourceManagerNapiSyncImpl::GetMediaContentSync(env, info);}},
__anon20ee2a990f02(napi_env& env, napi_callback_info& info) 68     {"GetPluralStringValueSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
69         return ResourceManagerNapiSyncImpl::GetPluralStringValueSync(env, info);}},
__anon20ee2a991002(napi_env& env, napi_callback_info& info) 70     {"GetStringArrayValueSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
71         return ResourceManagerNapiSyncImpl::GetStringArrayValueSync(env, info);}},
__anon20ee2a991102(napi_env& env, napi_callback_info& info) 72     {"GetRawFileContentSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
73         return ResourceManagerNapiSyncImpl::GetRawFileContentSync(env, info);}},
__anon20ee2a991202(napi_env& env, napi_callback_info& info) 74     {"GetRawFdSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
75         return ResourceManagerNapiSyncImpl::GetRawFdSync(env, info);}},
__anon20ee2a991302(napi_env& env, napi_callback_info& info) 76     {"CloseRawFdSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
77         return ResourceManagerNapiSyncImpl::CloseRawFdSync(env, info);}},
__anon20ee2a991402(napi_env& env, napi_callback_info& info) 78     {"GetRawFileListSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
79         return ResourceManagerNapiSyncImpl::GetRawFileListSync(env, info);}},
__anon20ee2a991502(napi_env& env, napi_callback_info& info) 80     {"GetPluralStringByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
81         return ResourceManagerNapiSyncImpl::GetPluralStringByNameSync(env, info);}},
__anon20ee2a991602(napi_env& env, napi_callback_info& info) 82     {"GetMediaBase64ByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
83         return ResourceManagerNapiSyncImpl::GetMediaBase64ByNameSync(env, info);}},
__anon20ee2a991702(napi_env& env, napi_callback_info& info) 84     {"GetMediaByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
85         return ResourceManagerNapiSyncImpl::GetMediaByNameSync(env, info);}},
__anon20ee2a991802(napi_env& env, napi_callback_info& info) 86     {"GetStringArrayByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
87         return ResourceManagerNapiSyncImpl::GetStringArrayByNameSync(env, info);}},
__anon20ee2a991902(napi_env& env, napi_callback_info& info) 88     {"GetConfigurationSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
89         return ResourceManagerNapiSyncImpl::GetConfigurationSync(env, info);}},
__anon20ee2a991a02(napi_env& env, napi_callback_info& info) 90     {"GetDeviceCapabilitySync", [](napi_env& env, napi_callback_info& info) -> napi_value {
91         return ResourceManagerNapiSyncImpl::GetDeviceCapabilitySync(env, info);}},
__anon20ee2a991b02(napi_env& env, napi_callback_info& info) 92     {"GetLocales", [](napi_env& env, napi_callback_info& info) -> napi_value {
93         return ResourceManagerNapiSyncImpl::GetLocales(env, info);}},
__anon20ee2a991c02(napi_env& env, napi_callback_info& info) 94     {"GetSymbol", [](napi_env& env, napi_callback_info& info) -> napi_value {
95         return ResourceManagerNapiSyncImpl::GetSymbol(env, info);}},
__anon20ee2a991d02(napi_env& env, napi_callback_info& info) 96     {"GetSymbolByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
97         return ResourceManagerNapiSyncImpl::GetSymbolByName(env, info);}},
__anon20ee2a991e02(napi_env& env, napi_callback_info& info) 98     {"IsRawDir", [](napi_env& env, napi_callback_info& info) -> napi_value {
99         return ResourceManagerNapiSyncImpl::IsRawDir(env, info);}},
__anon20ee2a991f02(napi_env& env, napi_callback_info& info) 100     {"GetOverrideResourceManager", [](napi_env& env, napi_callback_info& info) -> napi_value {
101         return ResourceManagerNapiSyncImpl::GetOverrideResourceManager(env, info);}},
__anon20ee2a992002(napi_env& env, napi_callback_info& info) 102     {"GetOverrideConfiguration", [](napi_env& env, napi_callback_info& info) -> napi_value {
103         return ResourceManagerNapiSyncImpl::GetOverrideConfiguration(env, info);}},
__anon20ee2a992102(napi_env& env, napi_callback_info& info) 104     {"UpdateOverrideConfiguration", [](napi_env& env, napi_callback_info& info) -> napi_value {
105         return ResourceManagerNapiSyncImpl::UpdateOverrideConfiguration(env, info);}}
106 };
107 
GetResource(napi_env env,napi_callback_info info,const std::string & functionName)108 napi_value ResourceManagerNapiSyncImpl::GetResource(napi_env env, napi_callback_info info,
109     const std::string &functionName)
110 {
111     auto functionIndex = syncFuncMatch.find(functionName);
112     if (functionIndex == syncFuncMatch.end()) {
113         RESMGR_HILOGI(RESMGR_JS_TAG, "Invalid functionName, %{public}s", functionName.c_str());
114         return nullptr;
115     }
116     return functionIndex->second(env, info);
117 }
118 
InitPathAddon(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)119 int32_t ResourceManagerNapiSyncImpl::InitPathAddon(napi_env env, napi_callback_info info,
120     std::unique_ptr<ResMgrDataContext> &dataContext)
121 {
122     GET_PARAMS(env, info, PARAMS_NUM_TWO);
123     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
124     if (dataContext->addon_ == nullptr) {
125         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get addon in InitPathAddon");
126         return NOT_FOUND;
127     }
128     if (ResourceManagerNapiUtils::IsNapiString(env, info)) {
129         dataContext->path_ = ResourceManagerNapiUtils::GetResNameOrPath(env, argc, argv);
130     } else {
131         return ERROR_CODE_INVALID_INPUT_PARAMETER;
132     }
133     return SUCCESS;
134 }
135 
GetRawFileListSync(napi_env env,napi_callback_info info)136 napi_value ResourceManagerNapiSyncImpl::GetRawFileListSync(napi_env env, napi_callback_info info)
137 {
138     GET_PARAMS(env, info, PARAMS_NUM_TWO);
139 
140     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
141 
142     int32_t ret = InitPathAddon(env, info, dataContext);
143     if (ret != RState::SUCCESS) {
144         RESMGR_HILOGE(RESMGR_JS_TAG,
145             "Failed to init para in GetRawFileListSync by %{public}s", dataContext->path_.c_str());
146         ResourceManagerNapiUtils::NapiThrow(env, ret);
147         return nullptr;
148     }
149 
150     RState state = dataContext->addon_->GetResMgr()->GetRawFileList(dataContext->path_.c_str(),
151         dataContext->arrayValue_);
152     if (state != RState::SUCCESS || dataContext->arrayValue_.empty()) {
153         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get rawfile list by %{public}s", dataContext->path_.c_str());
154         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_RES_PATH_INVALID);
155         return nullptr;
156     }
157 
158     return ResourceManagerNapiUtils::CreateJsArray(env, *dataContext);
159 }
160 
GetRawFileContentSync(napi_env env,napi_callback_info info)161 napi_value ResourceManagerNapiSyncImpl::GetRawFileContentSync(napi_env env, napi_callback_info info)
162 {
163     GET_PARAMS(env, info, PARAMS_NUM_TWO);
164 
165     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
166 
167     int32_t ret = InitPathAddon(env, info, dataContext);
168     if (ret != RState::SUCCESS) {
169         RESMGR_HILOGE(RESMGR_JS_TAG,
170             "Failed to init para in GetRawFileContentSync by %{public}s", dataContext->path_.c_str());
171         ResourceManagerNapiUtils::NapiThrow(env, ret);
172         return nullptr;
173     }
174 
175     RState state = dataContext->addon_->GetResMgr()->GetRawFileFromHap(dataContext->path_,
176         dataContext->len_, dataContext->mediaData);
177     if (state != SUCCESS) {
178         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get rawfile by %{public}s", dataContext->path_.c_str());
179         ResourceManagerNapiUtils::NapiThrow(env, state);
180         return nullptr;
181     }
182 
183     return ResourceManagerNapiUtils::CreateJsUint8Array(env, *dataContext);
184 }
185 
GetRawFdSync(napi_env env,napi_callback_info info)186 napi_value ResourceManagerNapiSyncImpl::GetRawFdSync(napi_env env, napi_callback_info info)
187 {
188     GET_PARAMS(env, info, PARAMS_NUM_TWO);
189 
190     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
191 
192     int32_t ret = InitPathAddon(env, info, dataContext);
193     if (ret != RState::SUCCESS) {
194         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to init para in GetRawFdSync by %{public}s", dataContext->path_.c_str());
195         ResourceManagerNapiUtils::NapiThrow(env, ret);
196         return nullptr;
197     }
198 
199     RState state = dataContext->addon_->GetResMgr()->GetRawFileDescriptorFromHap(dataContext->path_,
200         dataContext->descriptor_);
201     if (state != RState::SUCCESS) {
202         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get rawfd by %{public}s", dataContext->path_.c_str());
203         ResourceManagerNapiUtils::NapiThrow(env, state);
204         return nullptr;
205     }
206     return ResourceManagerNapiUtils::CreateJsRawFd(env, *dataContext);
207 }
208 
CloseRawFdSync(napi_env env,napi_callback_info info)209 napi_value ResourceManagerNapiSyncImpl::CloseRawFdSync(napi_env env, napi_callback_info info)
210 {
211     GET_PARAMS(env, info, PARAMS_NUM_TWO);
212 
213     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
214 
215     int32_t ret = InitPathAddon(env, info, dataContext);
216     if (ret != RState::SUCCESS) {
217         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to init para in CloseRawFdSync by %{public}s", dataContext->path_.c_str());
218         ResourceManagerNapiUtils::NapiThrow(env, ret);
219         return nullptr;
220     }
221 
222     RState state = dataContext->addon_->GetResMgr()->CloseRawFileDescriptor(dataContext->path_);
223     if (state != RState::SUCCESS) {
224         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to close rawfd by %{public}s", dataContext->path_.c_str());
225         ResourceManagerNapiUtils::NapiThrow(env, state);
226         return nullptr;
227     }
228 
229     napi_value undefined;
230     if (napi_get_undefined(env, &undefined) != napi_ok) {
231         return nullptr;
232     }
233     return undefined;
234 }
235 
InitParamsFromParamArray(napi_env env,napi_value value,std::vector<std::tuple<ResourceManager::NapiValueType,std::string>> & jsParams)236 bool ResourceManagerNapiSyncImpl::InitParamsFromParamArray(napi_env env, napi_value value,
237     std::vector<std::tuple<ResourceManager::NapiValueType, std::string>> &jsParams)
238 {
239     napi_valuetype valuetype = ResourceManagerNapiUtils::GetType(env, value);
240     if (valuetype == napi_number) {
241         double param;
242         if (napi_get_value_double(env, value, &param) != napi_ok) {
243             RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get parameter value in InitParamsFromParamArray");
244             return false;
245         }
246         jsParams.push_back(std::make_tuple(ResourceManager::NapiValueType::NAPI_NUMBER, std::to_string(param)));
247         return true;
248     }
249     if (valuetype == napi_string) {
250         size_t len = 0;
251         if (napi_get_value_string_utf8(env, value, nullptr, 0, &len) != napi_ok) {
252             RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get parameter length in InitParamsFromParamArray");
253             return false;
254         }
255         std::vector<char> buf(len + 1);
256         if (napi_get_value_string_utf8(env, value, buf.data(), len + 1, &len) != napi_ok) {
257             RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get parameter value in InitParamsFromParamArray");
258             return false;
259         }
260         jsParams.push_back(std::make_tuple(ResourceManager::NapiValueType::NAPI_STRING, buf.data()));
261         return true;
262     }
263     return false;
264 }
265 
InitNapiParameters(napi_env env,napi_callback_info info,std::vector<std::tuple<ResourceManager::NapiValueType,std::string>> & jsParams)266 bool ResourceManagerNapiSyncImpl::InitNapiParameters(napi_env env, napi_callback_info info,
267     std::vector<std::tuple<ResourceManager::NapiValueType, std::string>> &jsParams)
268 {
269     size_t size = 1;
270     napi_get_cb_info(env, info, &size, nullptr, nullptr, nullptr);
271     // one parameter: resId or resource or Name
272     if (size == 1) {
273         return true;
274     }
275     napi_value paramArray[size];
276     napi_get_cb_info(env, info, &size, paramArray, nullptr, nullptr);
277 
278     for (size_t i = 1; i < size; ++i) {
279         if (!InitParamsFromParamArray(env, paramArray[i], jsParams)) {
280             return false;
281         }
282     }
283     return true;
284 }
285 
InitIdResourceAddon(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)286 int32_t ResourceManagerNapiSyncImpl::InitIdResourceAddon(napi_env env, napi_callback_info info,
287     std::unique_ptr<ResMgrDataContext> &dataContext)
288 {
289     GET_PARAMS(env, info, PARAMS_NUM_TWO);
290     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
291     if (dataContext->addon_ == nullptr) {
292         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get addon in InitIdResourceAddon");
293         return NOT_FOUND;
294     }
295     if (ResourceManagerNapiUtils::IsNapiNumber(env, info)) {
296         dataContext->resId_ = ResourceManagerNapiUtils::GetResId(env, argc, argv);
297     } else if (ResourceManagerNapiUtils::IsNapiObject(env, info)) {
298         auto resourcePtr = std::make_shared<ResourceManager::Resource>();
299         int32_t retCode = ResourceManagerNapiUtils::GetResourceObject(env, resourcePtr, argv[ARRAY_SUBCRIPTOR_ZERO]);
300         dataContext->resource_ = resourcePtr;
301         return retCode;
302     } else {
303         return ERROR_CODE_INVALID_INPUT_PARAMETER;
304     }
305     return SUCCESS;
306 }
307 
ProcessStrResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)308 int32_t ResourceManagerNapiSyncImpl::ProcessStrResource(napi_env env, napi_callback_info info,
309     std::unique_ptr<ResMgrDataContext> &dataContext)
310 {
311     std::shared_ptr<ResourceManager> resMgr = nullptr;
312     int32_t resId = 0;
313     bool ret = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
314     if (!ret) {
315         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetStringSync");
316         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
317     }
318 
319     if (!InitNapiParameters(env, info, dataContext->jsParams_)) {
320         RESMGR_HILOGE(RESMGR_JS_TAG, "GetStringSync formatting error");
321         return ERROR_CODE_RES_ID_FORMAT_ERROR;
322     }
323 
324     RState state = resMgr->GetStringFormatById(resId, dataContext->value_, dataContext->jsParams_);
325     if (state != RState::SUCCESS) {
326         dataContext->SetErrorMsg("GetStringSync failed state", true);
327         ResourceManagerNapiUtils::NapiThrow(env, state);
328         return state;
329     }
330     return SUCCESS;
331 }
332 
GetStringSync(napi_env env,napi_callback_info info)333 napi_value ResourceManagerNapiSyncImpl::GetStringSync(napi_env env, napi_callback_info info)
334 {
335     GET_PARAMS(env, info, PARAMS_NUM_TWO);
336 
337     auto dataContext = std::make_unique<ResMgrDataContext>();
338 
339     int32_t state = InitIdResourceAddon(env, info, dataContext);
340     if (state != RState::SUCCESS) {
341         dataContext->SetErrorMsg("Failed to init para in GetStringSync", true);
342         ResourceManagerNapiUtils::NapiThrow(env, state);
343         return nullptr;
344     }
345 
346     state = ProcessStrResource(env, info, dataContext);
347     if (state != RState::SUCCESS) {
348         dataContext->SetErrorMsg("Failed to process string in GetStringSync", true);
349         ResourceManagerNapiUtils::NapiThrow(env, state);
350         return nullptr;
351     }
352 
353     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
354 }
355 
ProcessSymbolResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)356 int32_t ResourceManagerNapiSyncImpl::ProcessSymbolResource(napi_env env, napi_callback_info info,
357     std::unique_ptr<ResMgrDataContext> &dataContext)
358 {
359     std::shared_ptr<ResourceManager> resMgr = nullptr;
360     int32_t resId = 0;
361     bool ret = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
362     if (!ret) {
363         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetSymbol");
364         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
365     }
366 
367     RState state = resMgr->GetSymbolById(resId, dataContext->symbolValue_);
368     if (state != RState::SUCCESS) {
369         dataContext->SetErrorMsg("GetSymbol failed state", true);
370         ResourceManagerNapiUtils::NapiThrow(env, state);
371     }
372     return state;
373 }
374 
GetSymbol(napi_env env,napi_callback_info info)375 napi_value ResourceManagerNapiSyncImpl::GetSymbol(napi_env env, napi_callback_info info)
376 {
377     GET_PARAMS(env, info, PARAMS_NUM_TWO);
378 
379     auto dataContext = std::make_unique<ResMgrDataContext>();
380 
381     int32_t state = InitIdResourceAddon(env, info, dataContext);
382     if (state != RState::SUCCESS) {
383         dataContext->SetErrorMsg("Failed to init para in GetSymbol", true);
384         ResourceManagerNapiUtils::NapiThrow(env, state);
385         return nullptr;
386     }
387 
388     state = ProcessSymbolResource(env, info, dataContext);
389     if (state != RState::SUCCESS) {
390         dataContext->SetErrorMsg("Failed to process symbol in GetSymbol", true);
391         ResourceManagerNapiUtils::NapiThrow(env, state);
392         return nullptr;
393     }
394 
395     return ResourceManagerNapiUtils::CreateJsSymbol(env, *dataContext);
396 }
397 
ProcessColorResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)398 int32_t ResourceManagerNapiSyncImpl::ProcessColorResource(napi_env env, napi_callback_info info,
399     std::unique_ptr<ResMgrDataContext> &dataContext)
400 {
401     std::shared_ptr<ResourceManager> resMgr = nullptr;
402     int32_t resId = 0;
403     bool ret = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
404     if (!ret) {
405         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in ProcessColorResource");
406         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
407     }
408 
409     RState state = resMgr->GetColorById(resId, dataContext->colorValue_);
410     if (state != RState::SUCCESS) {
411         dataContext->SetErrorMsg("GetColor failed state", true);
412         ResourceManagerNapiUtils::NapiThrow(env, state);
413         return state;
414     }
415     return SUCCESS;
416 }
417 
GetColorSync(napi_env env,napi_callback_info info)418 napi_value ResourceManagerNapiSyncImpl::GetColorSync(napi_env env, napi_callback_info info)
419 {
420     GET_PARAMS(env, info, PARAMS_NUM_TWO);
421 
422     auto dataContext = std::make_unique<ResMgrDataContext>();
423 
424     int32_t state = InitIdResourceAddon(env, info, dataContext);
425     if (state != RState::SUCCESS) {
426         dataContext->SetErrorMsg("Failed to init para in GetColorSync", true);
427         ResourceManagerNapiUtils::NapiThrow(env, state);
428         return nullptr;
429     }
430 
431     state = ProcessColorResource(env, info, dataContext);
432     if (state != RState::SUCCESS) {
433         dataContext->SetErrorMsg("Failed to process string in GetColorSync", true);
434         ResourceManagerNapiUtils::NapiThrow(env, state);
435         return nullptr;
436     }
437 
438     return ResourceManagerNapiUtils::CreateJsColor(env, *dataContext);
439 }
440 
ProcessNumResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)441 int32_t ResourceManagerNapiSyncImpl::ProcessNumResource(napi_env env, napi_callback_info info,
442     std::unique_ptr<ResMgrDataContext> &dataContext)
443 {
444     std::shared_ptr<ResourceManager> resMgr = nullptr;
445     int32_t resId = 0;
446     bool ret = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
447     if (!ret) {
448         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to ResourceManagerNapiUtils::GetHapResourceManager in GetNumber");
449         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
450     }
451 
452     RState state = resMgr->GetIntegerById(resId, dataContext->iValue_);
453     if (state != RState::SUCCESS) {
454         state = resMgr->GetFloatById(resId, dataContext->fValue_);
455         return state;
456     }
457     return SUCCESS;
458 }
459 
GetNumber(napi_env env,napi_callback_info info)460 napi_value ResourceManagerNapiSyncImpl::GetNumber(napi_env env, napi_callback_info info)
461 {
462     GET_PARAMS(env, info, PARAMS_NUM_TWO);
463 
464     auto dataContext = std::make_unique<ResMgrDataContext>();
465 
466     int32_t state = InitIdResourceAddon(env, info, dataContext);
467     if (state != RState::SUCCESS) {
468         dataContext->SetErrorMsg("Failed to init para in GetNumber", true);
469         ResourceManagerNapiUtils::NapiThrow(env, state);
470         return nullptr;
471     }
472 
473     state = ProcessNumResource(env, info, dataContext);
474     if (state != RState::SUCCESS) {
475         dataContext->SetErrorMsg("Failed to process string in GetNumber", true);
476         ResourceManagerNapiUtils::NapiThrow(env, state);
477         return nullptr;
478     }
479 
480     return ResourceManagerNapiUtils::CreateJsNumber(env, *dataContext);
481 }
482 
ProcessBoolResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)483 int32_t ResourceManagerNapiSyncImpl::ProcessBoolResource(napi_env env, napi_callback_info info,
484     std::unique_ptr<ResMgrDataContext> &dataContext)
485 {
486     std::shared_ptr<ResourceManager> resMgr = nullptr;
487     int32_t resId = 0;
488     bool ret2 = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
489     if (!ret2) {
490         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetBoolean");
491         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
492     }
493     RState state = resMgr->GetBooleanById(resId, dataContext->bValue_);
494     if (state != RState::SUCCESS) {
495         dataContext->SetErrorMsg("Failed to GetBoolean state", true);
496         return state;
497     }
498     return SUCCESS;
499 }
500 
GetBoolean(napi_env env,napi_callback_info info)501 napi_value ResourceManagerNapiSyncImpl::GetBoolean(napi_env env, napi_callback_info info)
502 {
503     GET_PARAMS(env, info, PARAMS_NUM_TWO);
504 
505     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
506 
507     int32_t state = ResourceManagerNapiSyncImpl::InitIdResourceAddon(env, info, dataContext);
508     if (state != RState::SUCCESS) {
509         dataContext->SetErrorMsg("Failed to init para in GetBoolean", true);
510         ResourceManagerNapiUtils::NapiThrow(env, state);
511         return nullptr;
512     }
513 
514     state = ProcessBoolResource(env, info, dataContext);
515     if (state != RState::SUCCESS) {
516         dataContext->SetErrorMsg("Failed to process bool resource in GetBoolean", true);
517         ResourceManagerNapiUtils::NapiThrow(env, state);
518         return nullptr;
519     }
520 
521     return ResourceManagerNapiUtils::CreateJsBool(env, *dataContext);
522 }
523 
ProcesstMediaContentBase64Resource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)524 int32_t ResourceManagerNapiSyncImpl::ProcesstMediaContentBase64Resource(napi_env env, napi_callback_info info,
525     std::unique_ptr<ResMgrDataContext> &dataContext)
526 {
527     std::shared_ptr<ResourceManager> resMgr = nullptr;
528     int32_t resId = 0;
529     bool ret2 = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
530     if (!ret2) {
531         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetMediaContentBase64Sync");
532         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
533     }
534     RState state = resMgr->GetMediaBase64DataById(resId, dataContext->value_, dataContext->density_);
535     if (state != RState::SUCCESS) {
536         dataContext->SetErrorMsg("Failed to GetMediaContentBase64Sync state", true);
537         return state;
538     }
539     return SUCCESS;
540 }
541 
GetMediaContentBase64Sync(napi_env env,napi_callback_info info)542 napi_value ResourceManagerNapiSyncImpl::GetMediaContentBase64Sync(napi_env env, napi_callback_info info)
543 {
544     GET_PARAMS(env, info, PARAMS_NUM_TWO);
545 
546     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
547 
548     int32_t state = ResourceManagerNapiSyncImpl::InitIdResourceAddon(env, info, dataContext);
549     if (state != RState::SUCCESS) {
550         dataContext->SetErrorMsg("Failed to init para in GetMediaContentBase64Sync", true);
551         ResourceManagerNapiUtils::NapiThrow(env, state);
552         return nullptr;
553     }
554     // density optional parameters
555     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
556         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
557         return nullptr;
558     }
559     state = ProcesstMediaContentBase64Resource(env, info, dataContext);
560     if (state != RState::SUCCESS) {
561         dataContext->SetErrorMsg("Failed to process media base64 resource in GetMediaContentBase64Sync", true);
562         ResourceManagerNapiUtils::NapiThrow(env, state);
563         return nullptr;
564     }
565 
566     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
567 }
568 
ProcessMediaContentResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)569 int32_t ResourceManagerNapiSyncImpl::ProcessMediaContentResource(napi_env env, napi_callback_info info,
570     std::unique_ptr<ResMgrDataContext> &dataContext)
571 {
572     std::shared_ptr<ResourceManager> resMgr = nullptr;
573     int32_t resId = 0;
574     bool ret2 = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
575     if (!ret2) {
576         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetMediaContentSync");
577         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
578     }
579     RState state = resMgr->GetMediaDataById(resId, dataContext->len_, dataContext->mediaData,
580         dataContext->density_);
581     if (state != RState::SUCCESS) {
582         dataContext->SetErrorMsg("Failed to GetMediaContentSync state", true);
583         return state;
584     }
585     return SUCCESS;
586 }
587 
GetMediaContentSync(napi_env env,napi_callback_info info)588 napi_value ResourceManagerNapiSyncImpl::GetMediaContentSync(napi_env env, napi_callback_info info)
589 {
590     GET_PARAMS(env, info, PARAMS_NUM_TWO);
591 
592     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
593 
594     int32_t state = ResourceManagerNapiSyncImpl::InitIdResourceAddon(env, info, dataContext);
595     if (state != RState::SUCCESS) {
596         dataContext->SetErrorMsg("Failed to init para in GetMediaContentSync", true);
597         ResourceManagerNapiUtils::NapiThrow(env, state);
598         return nullptr;
599     }
600     // density optional parameters
601     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
602         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
603         return nullptr;
604     }
605     state = ProcessMediaContentResource(env, info, dataContext);
606     if (state != RState::SUCCESS) {
607         dataContext->SetErrorMsg("Failed to process media resource in GetMediaContentSync", true);
608         ResourceManagerNapiUtils::NapiThrow(env, state);
609         return nullptr;
610     }
611 
612     return ResourceManagerNapiUtils::CreateJsUint8Array(env, *dataContext);
613 }
614 
ProcessPluralStringValueResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)615 int32_t ResourceManagerNapiSyncImpl::ProcessPluralStringValueResource(napi_env env, napi_callback_info info,
616     std::unique_ptr<ResMgrDataContext> &dataContext)
617 {
618     std::shared_ptr<ResourceManager> resMgr = nullptr;
619     int32_t resId = 0;
620     bool ret2 = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
621     if (!ret2) {
622         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetPluralStringValueSync");
623         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
624     }
625     if (!InitNapiParameters(env, info, dataContext->jsParams_)) {
626         RESMGR_HILOGE(RESMGR_JS_TAG, "GetPluralStringValueSync formatting error");
627         return ERROR_CODE_RES_ID_FORMAT_ERROR;
628     }
629     RState state = resMgr->GetFormatPluralStringById(dataContext->value_, resId, dataContext->param_,
630         dataContext->jsParams_);
631     if (state != RState::SUCCESS) {
632         dataContext->SetErrorMsg("Failed to GetPluralStringValueSync state", true, state);
633         return state;
634     }
635     return SUCCESS;
636 }
637 
GetPluralStringValueSync(napi_env env,napi_callback_info info)638 napi_value ResourceManagerNapiSyncImpl::GetPluralStringValueSync(napi_env env, napi_callback_info info)
639 {
640     GET_PARAMS(env, info, PARAMS_NUM_TWO);
641 
642     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
643 
644     int32_t state = ResourceManagerNapiSyncImpl::InitIdResourceAddon(env, info, dataContext);
645     if (state != RState::SUCCESS) {
646         dataContext->SetErrorMsg("Failed to init para in GetPluralStringValueSync", true);
647         ResourceManagerNapiUtils::NapiThrow(env, state);
648         return nullptr;
649     }
650 
651     if (ResourceManagerNapiUtils::GetType(env, argv[ARRAY_SUBCRIPTOR_ONE]) != napi_number) {
652         RESMGR_HILOGE(RESMGR_JS_TAG, "Parameter type is not napi_number in GetPluralStringValueSync");
653         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
654         return nullptr;
655     }
656     napi_get_value_int32(env, argv[ARRAY_SUBCRIPTOR_ONE], &dataContext->param_);
657 
658     state = ProcessPluralStringValueResource(env, info, dataContext);
659     if (state != RState::SUCCESS) {
660         dataContext->SetErrorMsg("Failed to process plural string resource in GetPluralStringValueSync", true);
661         ResourceManagerNapiUtils::NapiThrow(env, state);
662         return nullptr;
663     }
664 
665     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
666 }
667 
ProcessStringArrayValueResource(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)668 int32_t ResourceManagerNapiSyncImpl::ProcessStringArrayValueResource(napi_env env, napi_callback_info info,
669     std::unique_ptr<ResMgrDataContext> &dataContext)
670 {
671     std::shared_ptr<ResourceManager> resMgr = nullptr;
672     int32_t resId = 0;
673     bool ret2 = ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId);
674     if (!ret2) {
675         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get resMgr in GetStringArrayValueSync");
676         return ERROR_CODE_RES_NOT_FOUND_BY_ID;
677     }
678     RState state = resMgr->GetStringArrayById(resId, dataContext->arrayValue_);
679     if (state != RState::SUCCESS) {
680         dataContext->SetErrorMsg("Failed to GetStringArrayValueSync state", true);
681         return state;
682     }
683     return SUCCESS;
684 }
685 
GetStringArrayValueSync(napi_env env,napi_callback_info info)686 napi_value ResourceManagerNapiSyncImpl::GetStringArrayValueSync(napi_env env, napi_callback_info info)
687 {
688     GET_PARAMS(env, info, PARAMS_NUM_TWO);
689 
690     std::unique_ptr<ResMgrDataContext> dataContext = std::make_unique<ResMgrDataContext>();
691 
692     int32_t state = ResourceManagerNapiSyncImpl::InitIdResourceAddon(env, info, dataContext);
693     if (state != RState::SUCCESS) {
694         dataContext->SetErrorMsg("Failed to init para in GetStringArrayValueSync", true);
695         ResourceManagerNapiUtils::NapiThrow(env, state);
696         return nullptr;
697     }
698 
699     state = ProcessStringArrayValueResource(env, info, dataContext);
700     if (state != RState::SUCCESS) {
701         dataContext->SetErrorMsg("Failed to process string array resource in GetStringArrayValueSync", true);
702         ResourceManagerNapiUtils::NapiThrow(env, state);
703         return nullptr;
704     }
705 
706     return ResourceManagerNapiUtils::CreateJsArray(env, *dataContext);
707 }
708 
GetDrawableDescriptor(napi_env env,napi_callback_info info)709 napi_value ResourceManagerNapiSyncImpl::GetDrawableDescriptor(napi_env env, napi_callback_info info)
710 {
711     GET_PARAMS(env, info, PARAMS_NUM_THREE);
712     auto dataContext = std::make_unique<ResMgrDataContext>();
713     int32_t ret = ResourceManagerNapiSyncImpl::InitIdResourceAddon(env, info, dataContext);
714     if (ret != RState::SUCCESS) {
715         dataContext->SetErrorMsg("Failed to init para in GetDrawableDescriptor", true);
716         ResourceManagerNapiUtils::NapiThrow(env, ret);
717         return nullptr;
718     }
719     // density optional parameters
720     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
721         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
722         return nullptr;
723     }
724 
725     // data type optional parameters
726     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_TWO], dataContext->iconType_) != SUCCESS) {
727         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
728         return nullptr;
729     }
730 
731     std::shared_ptr<ResourceManager> resMgr = nullptr;
732     int32_t resId = 0;
733     if (!ResourceManagerNapiUtils::GetHapResourceManager(dataContext.get(), resMgr, resId)) {
734         dataContext->SetErrorMsg("Failed to get GetHapResourceManager in GetDrawableDescriptor", true);
735         return nullptr;
736     }
737     RState state = SUCCESS;
738     Ace::Napi::DrawableDescriptor::DrawableType drawableType;
739     if (dataContext->iconType_ == 1) {
740         std::string themeMask = resMgr->GetThemeMask();
741         std::pair<std::unique_ptr<uint8_t[]>, size_t> foregroundInfo;
742         std::pair<std::unique_ptr<uint8_t[]>, size_t> backgroundInfo;
743         state = resMgr->GetThemeIcons(resId, foregroundInfo, backgroundInfo, dataContext->density_);
744         if (state == SUCCESS) {
745             auto drawableDescriptor = Ace::Napi::DrawableDescriptorFactory::Create(foregroundInfo, backgroundInfo,
746                 themeMask, drawableType, resMgr);
747             return Ace::Napi::JsDrawableDescriptor::ToNapi(env, drawableDescriptor.release(), drawableType);
748         }
749     }
750     auto drawableDescriptor = Ace::Napi::DrawableDescriptorFactory::Create(resId, resMgr,
751         state, drawableType, dataContext->density_);
752     if (state != SUCCESS) {
753         dataContext->SetErrorMsg("Failed to Create drawableDescriptor", true);
754         ResourceManagerNapiUtils::NapiThrow(env, state);
755         return nullptr;
756     }
757     return Ace::Napi::JsDrawableDescriptor::ToNapi(env, drawableDescriptor.release(), drawableType);
758 }
759 
InitNameAddon(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)760 int32_t ResourceManagerNapiSyncImpl::InitNameAddon(napi_env env, napi_callback_info info,
761     std::unique_ptr<ResMgrDataContext> &dataContext)
762 {
763     GET_PARAMS(env, info, PARAMS_NUM_TWO);
764     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
765     if (dataContext->addon_ == nullptr) {
766         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get addon in InitNameAddon");
767         return NOT_FOUND;
768     }
769     if (ResourceManagerNapiUtils::IsNapiString(env, info)) {
770         dataContext->resName_ = ResourceManagerNapiUtils::GetResNameOrPath(env, argc, argv);
771     } else {
772         return ERROR_CODE_INVALID_INPUT_PARAMETER;
773     }
774     return SUCCESS;
775 }
776 
ProcessStrResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)777 int32_t ResourceManagerNapiSyncImpl::ProcessStrResourceByName(napi_env env, napi_callback_info info,
778     std::unique_ptr<ResMgrDataContext> &dataContext)
779 {
780     if (!InitNapiParameters(env, info, dataContext->jsParams_)) {
781         RESMGR_HILOGE(RESMGR_JS_TAG, "GetStringByNameSync formatting error");
782         return ERROR_CODE_RES_NAME_FORMAT_ERROR;
783     }
784 
785     RState state = dataContext->addon_->GetResMgr()->GetStringFormatByName(dataContext->resName_.c_str(),
786         dataContext->value_, dataContext->jsParams_);
787     if (state != RState::SUCCESS) {
788         dataContext->SetErrorMsg("GetStringByNameSync failed state", false);
789         return state;
790     }
791     return SUCCESS;
792 }
793 
GetStringByNameSync(napi_env env,napi_callback_info info)794 napi_value ResourceManagerNapiSyncImpl::GetStringByNameSync(napi_env env, napi_callback_info info)
795 {
796     GET_PARAMS(env, info, PARAMS_NUM_TWO);
797 
798     auto dataContext = std::make_unique<ResMgrDataContext>();
799 
800     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
801     if (state != RState::SUCCESS) {
802         dataContext->SetErrorMsg("Failed to init para in GetStringByNameSync", false);
803         ResourceManagerNapiUtils::NapiThrow(env, state);
804         return nullptr;
805     }
806 
807     state = ProcessStrResourceByName(env, info, dataContext);
808     if (state != RState::SUCCESS) {
809         dataContext->SetErrorMsg("Failed to process string in GetStringByNameSync", false);
810         ResourceManagerNapiUtils::NapiThrow(env, state);
811         return nullptr;
812     }
813 
814     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
815 }
816 
ProcessSymbolResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)817 int32_t ResourceManagerNapiSyncImpl::ProcessSymbolResourceByName(napi_env env, napi_callback_info info,
818     std::unique_ptr<ResMgrDataContext> &dataContext)
819 {
820     RState state = dataContext->addon_->GetResMgr()->GetSymbolByName(dataContext->resName_.c_str(),
821         dataContext->symbolValue_);
822     if (state != RState::SUCCESS) {
823         dataContext->SetErrorMsg("GetSymbolByName failed state", false);
824     }
825     return state;
826 }
827 
GetSymbolByName(napi_env env,napi_callback_info info)828 napi_value ResourceManagerNapiSyncImpl::GetSymbolByName(napi_env env, napi_callback_info info)
829 {
830     GET_PARAMS(env, info, PARAMS_NUM_TWO);
831 
832     auto dataContext = std::make_unique<ResMgrDataContext>();
833 
834     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
835     if (state != RState::SUCCESS) {
836         dataContext->SetErrorMsg("Failed to init para in GetSymbolByName", false);
837         ResourceManagerNapiUtils::NapiThrow(env, state);
838         return nullptr;
839     }
840 
841     state = ProcessSymbolResourceByName(env, info, dataContext);
842     if (state != RState::SUCCESS) {
843         dataContext->SetErrorMsg("Failed to process symbol in GetSymbolByName", false);
844         ResourceManagerNapiUtils::NapiThrow(env, state);
845         return nullptr;
846     }
847 
848     return ResourceManagerNapiUtils::CreateJsSymbol(env, *dataContext);
849 }
850 
851 
ProcessColorResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)852 int32_t ResourceManagerNapiSyncImpl::ProcessColorResourceByName(napi_env env, napi_callback_info info,
853     std::unique_ptr<ResMgrDataContext> &dataContext)
854 {
855     RState state = dataContext->addon_->GetResMgr()->GetColorByName(dataContext->resName_.c_str(),
856         dataContext->colorValue_);
857     if (state != RState::SUCCESS) {
858         dataContext->SetErrorMsg("GetColorByNameSync failed state", false);
859         return state;
860     }
861     return SUCCESS;
862 }
863 
GetColorByNameSync(napi_env env,napi_callback_info info)864 napi_value ResourceManagerNapiSyncImpl::GetColorByNameSync(napi_env env, napi_callback_info info)
865 {
866     GET_PARAMS(env, info, PARAMS_NUM_TWO);
867 
868     auto dataContext = std::make_unique<ResMgrDataContext>();
869 
870     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
871     if (state != RState::SUCCESS) {
872         dataContext->SetErrorMsg("Failed to init para in GetColorByNameSync", false);
873         ResourceManagerNapiUtils::NapiThrow(env, state);
874         return nullptr;
875     }
876 
877     state = ProcessColorResourceByName(env, info, dataContext);
878     if (state != RState::SUCCESS) {
879         dataContext->SetErrorMsg("Failed to process color in GetColorByNameSync", false);
880         ResourceManagerNapiUtils::NapiThrow(env, state);
881         return nullptr;
882     }
883 
884     return ResourceManagerNapiUtils::CreateJsColor(env, *dataContext);
885 }
886 
ProcessNumResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)887 int32_t ResourceManagerNapiSyncImpl::ProcessNumResourceByName(napi_env env, napi_callback_info info,
888     std::unique_ptr<ResMgrDataContext> &dataContext)
889 {
890     auto resMgr = dataContext->addon_->GetResMgr();
891     RState state = resMgr->GetIntegerByName(dataContext->resName_.c_str(),
892         dataContext->iValue_);
893     if (state != RState::SUCCESS) {
894         state = resMgr->GetFloatByName(dataContext->resName_.c_str(), dataContext->fValue_);
895         return state;
896     }
897     return SUCCESS;
898 }
899 
GetNumberByName(napi_env env,napi_callback_info info)900 napi_value ResourceManagerNapiSyncImpl::GetNumberByName(napi_env env, napi_callback_info info)
901 {
902     GET_PARAMS(env, info, PARAMS_NUM_TWO);
903 
904     auto dataContext = std::make_unique<ResMgrDataContext>();
905 
906     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
907     if (state != RState::SUCCESS) {
908         dataContext->SetErrorMsg("Failed to init para in GetNumberByName", false);
909         ResourceManagerNapiUtils::NapiThrow(env, state);
910         return nullptr;
911     }
912 
913     state = ProcessNumResourceByName(env, info, dataContext);
914     if (state != RState::SUCCESS) {
915         dataContext->SetErrorMsg("Failed to process number in GetNumberByName", false);
916         ResourceManagerNapiUtils::NapiThrow(env, state);
917         return nullptr;
918     }
919 
920     return ResourceManagerNapiUtils::CreateJsNumber(env, *dataContext);
921 }
922 
GetBooleanByName(napi_env env,napi_callback_info info)923 napi_value ResourceManagerNapiSyncImpl::GetBooleanByName(napi_env env, napi_callback_info info)
924 {
925     GET_PARAMS(env, info, PARAMS_NUM_TWO);
926 
927     auto dataContext = std::make_unique<ResMgrDataContext>();
928 
929     int32_t ret = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
930     if (ret != RState::SUCCESS) {
931         dataContext->SetErrorMsg("Failed to init para in GetBooleanByName", false);
932         ResourceManagerNapiUtils::NapiThrow(env, ret);
933         return nullptr;
934     }
935 
936     RState state = dataContext->addon_->GetResMgr()->GetBooleanByName(dataContext->resName_.c_str(),
937         dataContext->bValue_);
938     if (state != RState::SUCCESS) {
939         dataContext->SetErrorMsg("GetBooleanByName failed state", false);
940         ResourceManagerNapiUtils::NapiThrow(env, state);
941         return nullptr;
942     }
943 
944     return ResourceManagerNapiUtils::CreateJsBool(env, *dataContext);
945 }
946 
GetDrawableDescriptorByName(napi_env env,napi_callback_info info)947 napi_value ResourceManagerNapiSyncImpl::GetDrawableDescriptorByName(napi_env env, napi_callback_info info)
948 {
949     GET_PARAMS(env, info, PARAMS_NUM_THREE);
950     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
951         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
952         return nullptr;
953     }
954     auto dataContext = std::make_unique<ResMgrDataContext>();
955     // density optional parameters
956     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
957         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
958         return nullptr;
959     }
960     // icon type optional parameters
961     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_TWO], dataContext->iconType_) != SUCCESS) {
962         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
963         return nullptr;
964     }
965     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
966     if (dataContext->addon_ == nullptr) {
967         return nullptr;
968     }
969     dataContext->resName_ = ResourceManagerNapiUtils::GetResNameOrPath(env, argc, argv);
970     auto resMgr = dataContext->addon_->GetResMgr();
971     RState state = SUCCESS;
972     Ace::Napi::DrawableDescriptor::DrawableType drawableType = Ace::Napi::DrawableDescriptor::DrawableType::BASE;
973     if (dataContext->iconType_ == 1) {
974         std::string themeMask = resMgr->GetThemeMask();
975         std::pair<std::unique_ptr<uint8_t[]>, size_t> foregroundInfo;
976         std::pair<std::unique_ptr<uint8_t[]>, size_t> backgroundInfo;
977         if (resMgr->GetThemeIcons(0, foregroundInfo, backgroundInfo, dataContext->density_) == SUCCESS) {
978             auto drawableDescriptor = Ace::Napi::DrawableDescriptorFactory::Create(foregroundInfo, backgroundInfo,
979                 themeMask, drawableType, resMgr);
980             return Ace::Napi::JsDrawableDescriptor::ToNapi(env, drawableDescriptor.release(), drawableType);
981         }
982     }
983 
984     if (dataContext->iconType_ == 2) { // 2 means get the dynamic icon from theme
985         std::pair<std::unique_ptr<uint8_t[]>, size_t> iconInfo;
986         if (resMgr->GetDynamicIcon(dataContext->resName_, iconInfo, dataContext->density_) == SUCCESS) {
987             auto drawableDescriptor = std::make_unique<Ace::Napi::DrawableDescriptor>(std::move(iconInfo.first),
988                 iconInfo.second);
989             return Ace::Napi::JsDrawableDescriptor::ToNapi(env, drawableDescriptor.release(), drawableType);
990         }
991     }
992 
993     auto drawableDescriptor = Ace::Napi::DrawableDescriptorFactory::Create(dataContext->resName_.c_str(),
994         resMgr, state, drawableType, dataContext->density_);
995     if (state != SUCCESS) {
996         dataContext->SetErrorMsg("Failed to Create drawableDescriptor ", false);
997         ResourceManagerNapiUtils::NapiThrow(env, state);
998         return nullptr;
999     }
1000     return Ace::Napi::JsDrawableDescriptor::ToNapi(env, drawableDescriptor.release(), drawableType);
1001 }
1002 
GetNativeResoruceManager(napi_env env,napi_callback_info info)1003 std::shared_ptr<ResourceManager> GetNativeResoruceManager(napi_env env, napi_callback_info info)
1004 {
1005     auto addon = ResMgrDataContext::GetResourceManagerAddon(env, info);
1006     if (addon == nullptr) {
1007         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to get addon_ in GetNativeResoruceManager");
1008         return nullptr;
1009     }
1010     return addon->GetResMgr();
1011 }
1012 
AddResource(napi_env env,napi_callback_info info)1013 napi_value ResourceManagerNapiSyncImpl::AddResource(napi_env env, napi_callback_info info)
1014 {
1015     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1016     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1017         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1018         return nullptr;
1019     }
1020     auto dataContext = std::make_unique<ResMgrDataContext>();
1021     dataContext->path_ = ResourceManagerNapiUtils::GetResNameOrPath(env, argc, argv);
1022     auto resMgr = GetNativeResoruceManager(env, info);
1023     if (resMgr == nullptr) {
1024         RESMGR_HILOGE(RESMGR_JS_TAG, "resMgr is null, add overlay path = %{public}s", dataContext->path_.c_str());
1025         return nullptr;
1026     }
1027     if (!resMgr->AddAppOverlay(dataContext->path_)) {
1028         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str());
1029         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID);
1030         return nullptr;
1031     }
1032     return nullptr;
1033 }
1034 
RemoveResource(napi_env env,napi_callback_info info)1035 napi_value ResourceManagerNapiSyncImpl::RemoveResource(napi_env env, napi_callback_info info)
1036 {
1037     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1038     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1039         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1040         return nullptr;
1041     }
1042     auto dataContext = std::make_unique<ResMgrDataContext>();
1043     dataContext->path_ = ResourceManagerNapiUtils::GetResNameOrPath(env, argc, argv);
1044     auto resMgr = GetNativeResoruceManager(env, info);
1045     if (resMgr == nullptr) {
1046         RESMGR_HILOGE(RESMGR_JS_TAG, "resMgr is null, overlay path = %{public}s", dataContext->path_.c_str());
1047         return nullptr;
1048     }
1049     if (!resMgr->RemoveAppOverlay(dataContext->path_)) {
1050         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to remove overlay path = %{public}s", dataContext->path_.c_str());
1051         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID);
1052         return nullptr;
1053     }
1054     return nullptr;
1055 }
1056 
ProcessPluralStrResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1057 int32_t ResourceManagerNapiSyncImpl::ProcessPluralStrResourceByName(napi_env env, napi_callback_info info,
1058     std::unique_ptr<ResMgrDataContext> &dataContext)
1059 {
1060     if (!InitNapiParameters(env, info, dataContext->jsParams_)) {
1061         RESMGR_HILOGE(RESMGR_JS_TAG, "GetPluralStringByNameSync formatting error");
1062         return ERROR_CODE_RES_ID_FORMAT_ERROR;
1063     }
1064     RState state = dataContext->addon_->GetResMgr()->GetFormatPluralStringByName(dataContext->value_,
1065         dataContext->resName_.c_str(), dataContext->param_, dataContext->jsParams_);
1066     if (state != RState::SUCCESS) {
1067         dataContext->SetErrorMsg("GetPluralStringByNameSync failed state", false);
1068         return state;
1069     }
1070     return SUCCESS;
1071 }
1072 
GetPluralStringByNameSync(napi_env env,napi_callback_info info)1073 napi_value ResourceManagerNapiSyncImpl::GetPluralStringByNameSync(napi_env env, napi_callback_info info)
1074 {
1075     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1076     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1077         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1078         return nullptr;
1079     }
1080     auto dataContext = std::make_unique<ResMgrDataContext>();
1081     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1082     if (state != RState::SUCCESS) {
1083         dataContext->SetErrorMsg("Failed to init para in GetPluralStringByNameSync", false);
1084         ResourceManagerNapiUtils::NapiThrow(env, state);
1085         return nullptr;
1086     }
1087 
1088     if (ResourceManagerNapiUtils::GetType(env, argv[ARRAY_SUBCRIPTOR_ONE]) != napi_number) {
1089         RESMGR_HILOGE(RESMGR_JS_TAG, "Parameter type is not napi_number in GetPluralStringByNameSync");
1090         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1091         return nullptr;
1092     }
1093     napi_get_value_int32(env, argv[ARRAY_SUBCRIPTOR_ONE], &dataContext->param_);
1094 
1095     state = ProcessPluralStrResourceByName(env, info, dataContext);
1096     if (state != RState::SUCCESS) {
1097         dataContext->SetErrorMsg("Failed to process plural string in GetPluralStringByNameSync", false);
1098         ResourceManagerNapiUtils::NapiThrow(env, state);
1099         return nullptr;
1100     }
1101 
1102     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
1103 }
1104 
ProcessMediaBase64ResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1105 int32_t ResourceManagerNapiSyncImpl::ProcessMediaBase64ResourceByName(napi_env env, napi_callback_info info,
1106     std::unique_ptr<ResMgrDataContext> &dataContext)
1107 {
1108     RState state = dataContext->addon_->GetResMgr()->GetMediaBase64DataByName(dataContext->resName_.c_str(),
1109         dataContext->value_, dataContext->density_);
1110     if (state != RState::SUCCESS) {
1111         dataContext->SetErrorMsg("Failed to get media data in GetMediaBase64ByNameSync", false);
1112         return state;
1113     }
1114     return SUCCESS;
1115 }
1116 
GetMediaBase64ByNameSync(napi_env env,napi_callback_info info)1117 napi_value ResourceManagerNapiSyncImpl::GetMediaBase64ByNameSync(napi_env env, napi_callback_info info)
1118 {
1119     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1120     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1121         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1122         return nullptr;
1123     }
1124     auto dataContext = std::make_unique<ResMgrDataContext>();
1125     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1126     if (state != RState::SUCCESS) {
1127         dataContext->SetErrorMsg("Failed to init para in GetMediaBase64ByNameSync", false);
1128         ResourceManagerNapiUtils::NapiThrow(env, state);
1129         return nullptr;
1130     }
1131 
1132     // density optional parameters
1133     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
1134         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1135         return nullptr;
1136     }
1137 
1138     state = ProcessMediaBase64ResourceByName(env, info, dataContext);
1139     if (state != RState::SUCCESS) {
1140         dataContext->SetErrorMsg("Failed to process media base64 resource in GetMediaBase64ByNameSync", false);
1141         ResourceManagerNapiUtils::NapiThrow(env, state);
1142         return nullptr;
1143     }
1144 
1145     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
1146 }
1147 
ProcessMediaResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1148 int32_t ResourceManagerNapiSyncImpl::ProcessMediaResourceByName(napi_env env, napi_callback_info info,
1149     std::unique_ptr<ResMgrDataContext> &dataContext)
1150 {
1151     RState state = dataContext->addon_->GetResMgr()->GetMediaDataByName(dataContext->resName_.c_str(),
1152         dataContext->len_, dataContext->mediaData, dataContext->density_);
1153     if (state != RState::SUCCESS) {
1154         dataContext->SetErrorMsg("GetMediaByNameSync failed state", false);
1155         return state;
1156     }
1157     return SUCCESS;
1158 }
1159 
GetMediaByNameSync(napi_env env,napi_callback_info info)1160 napi_value ResourceManagerNapiSyncImpl::GetMediaByNameSync(napi_env env, napi_callback_info info)
1161 {
1162     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1163     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1164         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1165         return nullptr;
1166     }
1167     auto dataContext = std::make_unique<ResMgrDataContext>();
1168     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1169     if (state != RState::SUCCESS) {
1170         dataContext->SetErrorMsg("Failed to init para in GetMediaByNameSync", false);
1171         ResourceManagerNapiUtils::NapiThrow(env, state);
1172         return nullptr;
1173     }
1174 
1175     // density optional parameters
1176     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
1177         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1178         return nullptr;
1179     }
1180 
1181     state = ProcessMediaResourceByName(env, info, dataContext);
1182     if (state != RState::SUCCESS) {
1183         dataContext->SetErrorMsg("Failed to process media resource in GetMediaByNameSync", false);
1184         ResourceManagerNapiUtils::NapiThrow(env, state);
1185         return nullptr;
1186     }
1187 
1188     return ResourceManagerNapiUtils::CreateJsUint8Array(env, *dataContext);
1189 }
1190 
ProcessStringArrayResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1191 int32_t ResourceManagerNapiSyncImpl::ProcessStringArrayResourceByName(napi_env env, napi_callback_info info,
1192     std::unique_ptr<ResMgrDataContext> &dataContext)
1193 {
1194     RState state = dataContext->addon_->GetResMgr()->GetStringArrayByName(dataContext->resName_.c_str(),
1195         dataContext->arrayValue_);
1196     if (state != RState::SUCCESS) {
1197         dataContext->SetErrorMsg("GetStringArrayByNameSync failed state", false);
1198         return state;
1199     }
1200     return SUCCESS;
1201 }
1202 
GetStringArrayByNameSync(napi_env env,napi_callback_info info)1203 napi_value ResourceManagerNapiSyncImpl::GetStringArrayByNameSync(napi_env env, napi_callback_info info)
1204 {
1205     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1206     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1207         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1208         return nullptr;
1209     }
1210     auto dataContext = std::make_unique<ResMgrDataContext>();
1211     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1212     if (state != RState::SUCCESS) {
1213         dataContext->SetErrorMsg("Failed to init para in GetStringArrayByNameSync", false);
1214         ResourceManagerNapiUtils::NapiThrow(env, state);
1215         return nullptr;
1216     }
1217 
1218     state = ProcessStringArrayResourceByName(env, info, dataContext);
1219     if (state != RState::SUCCESS) {
1220         dataContext->SetErrorMsg("Failed to process string array resource in GetStringArrayByNameSync", false);
1221         ResourceManagerNapiUtils::NapiThrow(env, state);
1222         return nullptr;
1223     }
1224     return ResourceManagerNapiUtils::CreateJsArray(env, *dataContext);
1225 }
1226 
GetConfigurationSync(napi_env env,napi_callback_info info)1227 napi_value ResourceManagerNapiSyncImpl::GetConfigurationSync(napi_env env, napi_callback_info info)
1228 {
1229     auto dataContext = std::make_unique<ResMgrDataContext>();
1230     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1231     return ResourceManagerNapiUtils::CreateJsConfig(env, *dataContext);
1232 }
1233 
GetDeviceCapabilitySync(napi_env env,napi_callback_info info)1234 napi_value ResourceManagerNapiSyncImpl::GetDeviceCapabilitySync(napi_env env, napi_callback_info info)
1235 {
1236     auto dataContext = std::make_unique<ResMgrDataContext>();
1237     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1238     return ResourceManagerNapiUtils::CreateJsDeviceCap(env, *dataContext);
1239 }
1240 
GetLocales(napi_env env,napi_callback_info info)1241 napi_value ResourceManagerNapiSyncImpl::GetLocales(napi_env env, napi_callback_info info)
1242 {
1243     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1244     auto dataContext = std::make_unique<ResMgrDataContext>();
1245     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1246 
1247     // includeSystem optional parameters
1248     if (ResourceManagerNapiUtils::GetIncludeSystem(env, argv[ARRAY_SUBCRIPTOR_ZERO],
1249         dataContext->bValue_) != SUCCESS) {
1250         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1251         return nullptr;
1252     }
1253     dataContext->addon_->GetResMgr()->GetLocales(dataContext->arrayValue_, dataContext->bValue_);
1254     return ResourceManagerNapiUtils::CreateJsArray(env, *dataContext);
1255 }
1256 
IsRawDir(napi_env env,napi_callback_info info)1257 napi_value ResourceManagerNapiSyncImpl::IsRawDir(napi_env env, napi_callback_info info)
1258 {
1259     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1260     auto dataContext = std::make_unique<ResMgrDataContext>();
1261 
1262     int32_t ret = InitPathAddon(env, info, dataContext);
1263     if (ret != RState::SUCCESS) {
1264         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to init para in IsRawDir by %{public}s", dataContext->path_.c_str());
1265         ResourceManagerNapiUtils::NapiThrow(env, ret);
1266         return nullptr;
1267     }
1268 
1269     RState state = dataContext->addon_->GetResMgr()->IsRawDirFromHap(dataContext->path_,
1270         dataContext->bValue_);
1271     if (state != RState::SUCCESS) {
1272         RESMGR_HILOGE(RESMGR_JS_TAG,
1273             "Failed to determine the raw file is directory by %{public}s", dataContext->path_.c_str());
1274         ResourceManagerNapiUtils::NapiThrow(env, state);
1275         return nullptr;
1276     }
1277     return ResourceManagerNapiUtils::CreateJsBool(env, *dataContext);
1278 }
1279 
GetOverrideResourceManager(napi_env env,napi_callback_info info)1280 napi_value ResourceManagerNapiSyncImpl::GetOverrideResourceManager(napi_env env, napi_callback_info info)
1281 {
1282     auto dataContext = std::make_unique<ResMgrDataContext>();
1283     int32_t state = getAddonAndConfig(env, info, dataContext);
1284     if (state != RState::SUCCESS) {
1285         dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false);
1286         ResourceManagerNapiUtils::NapiThrow(env, state);
1287         return nullptr;
1288     }
1289 
1290     std::shared_ptr<ResourceManager> resMgr = dataContext->addon_->GetResMgr();
1291     std::shared_ptr<ResourceManager> overrideResMgr = resMgr->GetOverrideResourceManager(
1292         dataContext->overrideResConfig_);
1293     if (overrideResMgr == nullptr) {
1294         dataContext->SetErrorMsg("GetOverrideResourceManager, overrideResMgr is null", false);
1295         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1296         return nullptr;
1297     }
1298 
1299     return dataContext->addon_->CreateOverrideAddon(env, overrideResMgr);
1300 }
1301 
getAddonAndConfig(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1302 RState ResourceManagerNapiSyncImpl::getAddonAndConfig(napi_env env, napi_callback_info info,
1303     std::unique_ptr<ResMgrDataContext> &dataContext)
1304 {
1305     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1306     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1307     if (dataContext->addon_ == nullptr) {
1308         RESMGR_HILOGE(RESMGR_JS_TAG, "getAddonAndConfig failed to get addon");
1309         return ERROR_CODE_INVALID_INPUT_PARAMETER;
1310     }
1311     if (ResourceManagerNapiUtils::GetConfigObject(env, argv[ARRAY_SUBCRIPTOR_ZERO], dataContext) != SUCCESS) {
1312         RESMGR_HILOGE(RESMGR_JS_TAG, "getAddonAndConfig failed to get resConfig");
1313         return ERROR_CODE_INVALID_INPUT_PARAMETER;
1314     }
1315     return SUCCESS;
1316 }
1317 
GetOverrideConfiguration(napi_env env,napi_callback_info info)1318 napi_value ResourceManagerNapiSyncImpl::GetOverrideConfiguration(napi_env env, napi_callback_info info)
1319 {
1320     auto dataContext = std::make_unique<ResMgrDataContext>();
1321     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1322     if (dataContext->addon_ == nullptr) {
1323         RESMGR_HILOGE(RESMGR_JS_TAG, "GetOverrideConfiguration failed to get addon");
1324         return nullptr;
1325     }
1326     return ResourceManagerNapiUtils::CreateOverrideJsConfig(env, *dataContext);
1327 }
1328 
UpdateOverrideConfiguration(napi_env env,napi_callback_info info)1329 napi_value ResourceManagerNapiSyncImpl::UpdateOverrideConfiguration(napi_env env, napi_callback_info info)
1330 {
1331     auto dataContext = std::make_unique<ResMgrDataContext>();
1332     int32_t state = getAddonAndConfig(env, info, dataContext);
1333     if (state != RState::SUCCESS) {
1334         dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false);
1335         ResourceManagerNapiUtils::NapiThrow(env, state);
1336         return nullptr;
1337     }
1338 
1339     std::shared_ptr<ResourceManager> resMgr = dataContext->addon_->GetResMgr();
1340     state = resMgr->UpdateOverrideResConfig(*dataContext->overrideResConfig_);
1341     if (state != RState::SUCCESS) {
1342         dataContext->SetErrorMsg("UpdateOverrideConfiguration failed due to invalid config", false);
1343         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1344     }
1345     return nullptr;
1346 }
1347 } // namespace Resource
1348 } // namespace Global
1349 } // namespace OHOS