• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 {
__anon7ffeae610102(napi_env& env, napi_callback_info& info) 40     {"GetStringSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
41         return ResourceManagerNapiSyncImpl::GetStringSync(env, info);}},
__anon7ffeae610202(napi_env& env, napi_callback_info& info) 42     {"GetStringByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
43         return ResourceManagerNapiSyncImpl::GetStringByNameSync(env, info);}},
__anon7ffeae610302(napi_env& env, napi_callback_info& info) 44     {"GetBoolean", [](napi_env& env, napi_callback_info& info) -> napi_value {
45         return ResourceManagerNapiSyncImpl::GetBoolean(env, info);}},
__anon7ffeae610402(napi_env& env, napi_callback_info& info) 46     {"GetBooleanByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
47         return ResourceManagerNapiSyncImpl::GetBooleanByName(env, info);}},
__anon7ffeae610502(napi_env& env, napi_callback_info& info) 48     {"GetNumber", [](napi_env& env, napi_callback_info& info) -> napi_value {
49         return ResourceManagerNapiSyncImpl::GetNumber(env, info);}},
__anon7ffeae610602(napi_env& env, napi_callback_info& info) 50     {"GetNumberByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
51         return ResourceManagerNapiSyncImpl::GetNumberByName(env, info);}},
__anon7ffeae610702(napi_env& env, napi_callback_info& info) 52     {"GetDrawableDescriptor", [](napi_env& env, napi_callback_info& info) -> napi_value {
53         return ResourceManagerNapiSyncImpl::GetDrawableDescriptor(env, info);}},
__anon7ffeae610802(napi_env& env, napi_callback_info& info) 54     {"GetDrawableDescriptorByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
55         return ResourceManagerNapiSyncImpl::GetDrawableDescriptorByName(env, info);}},
__anon7ffeae610902(napi_env& env, napi_callback_info& info) 56     {"GetColorSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
57         return ResourceManagerNapiSyncImpl::GetColorSync(env, info);}},
__anon7ffeae610a02(napi_env& env, napi_callback_info& info) 58     {"GetColorByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
59         return ResourceManagerNapiSyncImpl::GetColorByNameSync(env, info);}},
__anon7ffeae610b02(napi_env& env, napi_callback_info& info) 60     {"AddResource", [](napi_env& env, napi_callback_info& info) -> napi_value {
61         return ResourceManagerNapiSyncImpl::AddResource(env, info);}},
__anon7ffeae610c02(napi_env& env, napi_callback_info& info) 62     {"RemoveResource", [](napi_env& env, napi_callback_info& info) -> napi_value {
63         return ResourceManagerNapiSyncImpl::RemoveResource(env, info);}},
__anon7ffeae610d02(napi_env& env, napi_callback_info& info) 64     {"GetMediaContentBase64Sync", [](napi_env& env, napi_callback_info& info) -> napi_value {
65         return ResourceManagerNapiSyncImpl::GetMediaContentBase64Sync(env, info);}},
__anon7ffeae610e02(napi_env& env, napi_callback_info& info) 66     {"GetMediaContentSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
67         return ResourceManagerNapiSyncImpl::GetMediaContentSync(env, info);}},
__anon7ffeae610f02(napi_env& env, napi_callback_info& info) 68     {"GetPluralStringValueSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
69         return ResourceManagerNapiSyncImpl::GetPluralStringValueSync(env, info);}},
__anon7ffeae611002(napi_env& env, napi_callback_info& info) 70     {"GetStringArrayValueSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
71         return ResourceManagerNapiSyncImpl::GetStringArrayValueSync(env, info);}},
__anon7ffeae611102(napi_env& env, napi_callback_info& info) 72     {"GetRawFileContentSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
73         return ResourceManagerNapiSyncImpl::GetRawFileContentSync(env, info);}},
__anon7ffeae611202(napi_env& env, napi_callback_info& info) 74     {"GetRawFdSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
75         return ResourceManagerNapiSyncImpl::GetRawFdSync(env, info);}},
__anon7ffeae611302(napi_env& env, napi_callback_info& info) 76     {"CloseRawFdSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
77         return ResourceManagerNapiSyncImpl::CloseRawFdSync(env, info);}},
__anon7ffeae611402(napi_env& env, napi_callback_info& info) 78     {"GetRawFileListSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
79         return ResourceManagerNapiSyncImpl::GetRawFileListSync(env, info);}},
__anon7ffeae611502(napi_env& env, napi_callback_info& info) 80     {"GetPluralStringByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
81         return ResourceManagerNapiSyncImpl::GetPluralStringByNameSync(env, info);}},
__anon7ffeae611602(napi_env& env, napi_callback_info& info) 82     {"GetMediaBase64ByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
83         return ResourceManagerNapiSyncImpl::GetMediaBase64ByNameSync(env, info);}},
__anon7ffeae611702(napi_env& env, napi_callback_info& info) 84     {"GetMediaByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
85         return ResourceManagerNapiSyncImpl::GetMediaByNameSync(env, info);}},
__anon7ffeae611802(napi_env& env, napi_callback_info& info) 86     {"GetStringArrayByNameSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
87         return ResourceManagerNapiSyncImpl::GetStringArrayByNameSync(env, info);}},
__anon7ffeae611902(napi_env& env, napi_callback_info& info) 88     {"GetConfigurationSync", [](napi_env& env, napi_callback_info& info) -> napi_value {
89         return ResourceManagerNapiSyncImpl::GetConfigurationSync(env, info);}},
__anon7ffeae611a02(napi_env& env, napi_callback_info& info) 90     {"GetDeviceCapabilitySync", [](napi_env& env, napi_callback_info& info) -> napi_value {
91         return ResourceManagerNapiSyncImpl::GetDeviceCapabilitySync(env, info);}},
__anon7ffeae611b02(napi_env& env, napi_callback_info& info) 92     {"GetLocales", [](napi_env& env, napi_callback_info& info) -> napi_value {
93         return ResourceManagerNapiSyncImpl::GetLocales(env, info);}},
__anon7ffeae611c02(napi_env& env, napi_callback_info& info) 94     {"GetSymbol", [](napi_env& env, napi_callback_info& info) -> napi_value {
95         return ResourceManagerNapiSyncImpl::GetSymbol(env, info);}},
__anon7ffeae611d02(napi_env& env, napi_callback_info& info) 96     {"GetSymbolByName", [](napi_env& env, napi_callback_info& info) -> napi_value {
97         return ResourceManagerNapiSyncImpl::GetSymbolByName(env, info);}},
__anon7ffeae611e02(napi_env& env, napi_callback_info& info) 98     {"IsRawDir", [](napi_env& env, napi_callback_info& info) -> napi_value {
99         return ResourceManagerNapiSyncImpl::IsRawDir(env, info);}},
__anon7ffeae611f02(napi_env& env, napi_callback_info& info) 100     {"GetOverrideResourceManager", [](napi_env& env, napi_callback_info& info) -> napi_value {
101         return ResourceManagerNapiSyncImpl::GetOverrideResourceManager(env, info);}},
__anon7ffeae612002(napi_env& env, napi_callback_info& info) 102     {"GetOverrideConfiguration", [](napi_env& env, napi_callback_info& info) -> napi_value {
103         return ResourceManagerNapiSyncImpl::GetOverrideConfiguration(env, info);}},
__anon7ffeae612102(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->AddAppOverlay(dataContext->path_)) {
1024         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str());
1025         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID);
1026         return nullptr;
1027     }
1028     return nullptr;
1029 }
1030 
RemoveResource(napi_env env,napi_callback_info info)1031 napi_value ResourceManagerNapiSyncImpl::RemoveResource(napi_env env, napi_callback_info info)
1032 {
1033     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1034     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1035         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1036         return nullptr;
1037     }
1038     auto dataContext = std::make_unique<ResMgrDataContext>();
1039     dataContext->path_ = ResourceManagerNapiUtils::GetResNameOrPath(env, argc, argv);
1040     auto resMgr = GetNativeResoruceManager(env, info);
1041     if (!resMgr->RemoveAppOverlay(dataContext->path_)) {
1042         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str());
1043         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID);
1044         return nullptr;
1045     }
1046     return nullptr;
1047 }
1048 
ProcessPluralStrResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1049 int32_t ResourceManagerNapiSyncImpl::ProcessPluralStrResourceByName(napi_env env, napi_callback_info info,
1050     std::unique_ptr<ResMgrDataContext> &dataContext)
1051 {
1052     if (!InitNapiParameters(env, info, dataContext->jsParams_)) {
1053         RESMGR_HILOGE(RESMGR_JS_TAG, "GetPluralStringByNameSync formatting error");
1054         return ERROR_CODE_RES_ID_FORMAT_ERROR;
1055     }
1056     RState state = dataContext->addon_->GetResMgr()->GetFormatPluralStringByName(dataContext->value_,
1057         dataContext->resName_.c_str(), dataContext->param_, dataContext->jsParams_);
1058     if (state != RState::SUCCESS) {
1059         dataContext->SetErrorMsg("GetPluralStringByNameSync failed state", false);
1060         return state;
1061     }
1062     return SUCCESS;
1063 }
1064 
GetPluralStringByNameSync(napi_env env,napi_callback_info info)1065 napi_value ResourceManagerNapiSyncImpl::GetPluralStringByNameSync(napi_env env, napi_callback_info info)
1066 {
1067     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1068     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1069         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1070         return nullptr;
1071     }
1072     auto dataContext = std::make_unique<ResMgrDataContext>();
1073     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1074     if (state != RState::SUCCESS) {
1075         dataContext->SetErrorMsg("Failed to init para in GetPluralStringByNameSync", false);
1076         ResourceManagerNapiUtils::NapiThrow(env, state);
1077         return nullptr;
1078     }
1079 
1080     if (ResourceManagerNapiUtils::GetType(env, argv[ARRAY_SUBCRIPTOR_ONE]) != napi_number) {
1081         RESMGR_HILOGE(RESMGR_JS_TAG, "Parameter type is not napi_number in GetPluralStringByNameSync");
1082         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1083         return nullptr;
1084     }
1085     napi_get_value_int32(env, argv[ARRAY_SUBCRIPTOR_ONE], &dataContext->param_);
1086 
1087     state = ProcessPluralStrResourceByName(env, info, dataContext);
1088     if (state != RState::SUCCESS) {
1089         dataContext->SetErrorMsg("Failed to process plural string in GetPluralStringByNameSync", false);
1090         ResourceManagerNapiUtils::NapiThrow(env, state);
1091         return nullptr;
1092     }
1093 
1094     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
1095 }
1096 
ProcessMediaBase64ResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1097 int32_t ResourceManagerNapiSyncImpl::ProcessMediaBase64ResourceByName(napi_env env, napi_callback_info info,
1098     std::unique_ptr<ResMgrDataContext> &dataContext)
1099 {
1100     RState state = dataContext->addon_->GetResMgr()->GetMediaBase64DataByName(dataContext->resName_.c_str(),
1101         dataContext->value_, dataContext->density_);
1102     if (state != RState::SUCCESS) {
1103         dataContext->SetErrorMsg("Failed to get media data in GetMediaBase64ByNameSync", false);
1104         return state;
1105     }
1106     return SUCCESS;
1107 }
1108 
GetMediaBase64ByNameSync(napi_env env,napi_callback_info info)1109 napi_value ResourceManagerNapiSyncImpl::GetMediaBase64ByNameSync(napi_env env, napi_callback_info info)
1110 {
1111     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1112     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1113         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1114         return nullptr;
1115     }
1116     auto dataContext = std::make_unique<ResMgrDataContext>();
1117     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1118     if (state != RState::SUCCESS) {
1119         dataContext->SetErrorMsg("Failed to init para in GetMediaBase64ByNameSync", false);
1120         ResourceManagerNapiUtils::NapiThrow(env, state);
1121         return nullptr;
1122     }
1123 
1124     // density optional parameters
1125     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
1126         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1127         return nullptr;
1128     }
1129 
1130     state = ProcessMediaBase64ResourceByName(env, info, dataContext);
1131     if (state != RState::SUCCESS) {
1132         dataContext->SetErrorMsg("Failed to process media base64 resource in GetMediaBase64ByNameSync", false);
1133         ResourceManagerNapiUtils::NapiThrow(env, state);
1134         return nullptr;
1135     }
1136 
1137     return ResourceManagerNapiUtils::CreateJsString(env, *dataContext);
1138 }
1139 
ProcessMediaResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1140 int32_t ResourceManagerNapiSyncImpl::ProcessMediaResourceByName(napi_env env, napi_callback_info info,
1141     std::unique_ptr<ResMgrDataContext> &dataContext)
1142 {
1143     RState state = dataContext->addon_->GetResMgr()->GetMediaDataByName(dataContext->resName_.c_str(),
1144         dataContext->len_, dataContext->mediaData, dataContext->density_);
1145     if (state != RState::SUCCESS) {
1146         dataContext->SetErrorMsg("GetMediaByNameSync failed state", false);
1147         return state;
1148     }
1149     return SUCCESS;
1150 }
1151 
GetMediaByNameSync(napi_env env,napi_callback_info info)1152 napi_value ResourceManagerNapiSyncImpl::GetMediaByNameSync(napi_env env, napi_callback_info info)
1153 {
1154     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1155     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1156         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1157         return nullptr;
1158     }
1159     auto dataContext = std::make_unique<ResMgrDataContext>();
1160     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1161     if (state != RState::SUCCESS) {
1162         dataContext->SetErrorMsg("Failed to init para in GetMediaByNameSync", false);
1163         ResourceManagerNapiUtils::NapiThrow(env, state);
1164         return nullptr;
1165     }
1166 
1167     // density optional parameters
1168     if (ResourceManagerNapiUtils::GetDataType(env, argv[ARRAY_SUBCRIPTOR_ONE], dataContext->density_) != SUCCESS) {
1169         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1170         return nullptr;
1171     }
1172 
1173     state = ProcessMediaResourceByName(env, info, dataContext);
1174     if (state != RState::SUCCESS) {
1175         dataContext->SetErrorMsg("Failed to process media resource in GetMediaByNameSync", false);
1176         ResourceManagerNapiUtils::NapiThrow(env, state);
1177         return nullptr;
1178     }
1179 
1180     return ResourceManagerNapiUtils::CreateJsUint8Array(env, *dataContext);
1181 }
1182 
ProcessStringArrayResourceByName(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1183 int32_t ResourceManagerNapiSyncImpl::ProcessStringArrayResourceByName(napi_env env, napi_callback_info info,
1184     std::unique_ptr<ResMgrDataContext> &dataContext)
1185 {
1186     RState state = dataContext->addon_->GetResMgr()->GetStringArrayByName(dataContext->resName_.c_str(),
1187         dataContext->arrayValue_);
1188     if (state != RState::SUCCESS) {
1189         dataContext->SetErrorMsg("GetStringArrayByNameSync failed state", false);
1190         return state;
1191     }
1192     return SUCCESS;
1193 }
1194 
GetStringArrayByNameSync(napi_env env,napi_callback_info info)1195 napi_value ResourceManagerNapiSyncImpl::GetStringArrayByNameSync(napi_env env, napi_callback_info info)
1196 {
1197     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1198     if (!ResourceManagerNapiUtils::IsNapiString(env, info)) {
1199         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1200         return nullptr;
1201     }
1202     auto dataContext = std::make_unique<ResMgrDataContext>();
1203     int32_t state = ResourceManagerNapiSyncImpl::InitNameAddon(env, info, dataContext);
1204     if (state != RState::SUCCESS) {
1205         dataContext->SetErrorMsg("Failed to init para in GetStringArrayByNameSync", false);
1206         ResourceManagerNapiUtils::NapiThrow(env, state);
1207         return nullptr;
1208     }
1209 
1210     state = ProcessStringArrayResourceByName(env, info, dataContext);
1211     if (state != RState::SUCCESS) {
1212         dataContext->SetErrorMsg("Failed to process string array resource in GetStringArrayByNameSync", false);
1213         ResourceManagerNapiUtils::NapiThrow(env, state);
1214         return nullptr;
1215     }
1216     return ResourceManagerNapiUtils::CreateJsArray(env, *dataContext);
1217 }
1218 
GetConfigurationSync(napi_env env,napi_callback_info info)1219 napi_value ResourceManagerNapiSyncImpl::GetConfigurationSync(napi_env env, napi_callback_info info)
1220 {
1221     auto dataContext = std::make_unique<ResMgrDataContext>();
1222     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1223     return ResourceManagerNapiUtils::CreateJsConfig(env, *dataContext);
1224 }
1225 
GetDeviceCapabilitySync(napi_env env,napi_callback_info info)1226 napi_value ResourceManagerNapiSyncImpl::GetDeviceCapabilitySync(napi_env env, napi_callback_info info)
1227 {
1228     auto dataContext = std::make_unique<ResMgrDataContext>();
1229     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1230     return ResourceManagerNapiUtils::CreateJsDeviceCap(env, *dataContext);
1231 }
1232 
GetLocales(napi_env env,napi_callback_info info)1233 napi_value ResourceManagerNapiSyncImpl::GetLocales(napi_env env, napi_callback_info info)
1234 {
1235     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1236     auto dataContext = std::make_unique<ResMgrDataContext>();
1237     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1238 
1239     // includeSystem optional parameters
1240     if (ResourceManagerNapiUtils::GetIncludeSystem(env, argv[ARRAY_SUBCRIPTOR_ZERO],
1241         dataContext->bValue_) != SUCCESS) {
1242         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1243         return nullptr;
1244     }
1245     dataContext->addon_->GetResMgr()->GetLocales(dataContext->arrayValue_, dataContext->bValue_);
1246     return ResourceManagerNapiUtils::CreateJsArray(env, *dataContext);
1247 }
1248 
IsRawDir(napi_env env,napi_callback_info info)1249 napi_value ResourceManagerNapiSyncImpl::IsRawDir(napi_env env, napi_callback_info info)
1250 {
1251     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1252     auto dataContext = std::make_unique<ResMgrDataContext>();
1253 
1254     int32_t ret = InitPathAddon(env, info, dataContext);
1255     if (ret != RState::SUCCESS) {
1256         RESMGR_HILOGE(RESMGR_JS_TAG, "Failed to init para in IsRawDir by %{public}s", dataContext->path_.c_str());
1257         ResourceManagerNapiUtils::NapiThrow(env, ret);
1258         return nullptr;
1259     }
1260 
1261     RState state = dataContext->addon_->GetResMgr()->IsRawDirFromHap(dataContext->path_,
1262         dataContext->bValue_);
1263     if (state != RState::SUCCESS) {
1264         RESMGR_HILOGE(RESMGR_JS_TAG,
1265             "Failed to determine the raw file is directory by %{public}s", dataContext->path_.c_str());
1266         ResourceManagerNapiUtils::NapiThrow(env, state);
1267         return nullptr;
1268     }
1269     return ResourceManagerNapiUtils::CreateJsBool(env, *dataContext);
1270 }
1271 
GetOverrideResourceManager(napi_env env,napi_callback_info info)1272 napi_value ResourceManagerNapiSyncImpl::GetOverrideResourceManager(napi_env env, napi_callback_info info)
1273 {
1274     auto dataContext = std::make_unique<ResMgrDataContext>();
1275     int32_t state = getAddonAndConfig(env, info, dataContext);
1276     if (state != RState::SUCCESS) {
1277         dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false);
1278         ResourceManagerNapiUtils::NapiThrow(env, state);
1279         return nullptr;
1280     }
1281 
1282     std::shared_ptr<ResourceManager> resMgr = dataContext->addon_->GetResMgr();
1283     std::shared_ptr<ResourceManager> overrideResMgr = resMgr->GetOverrideResourceManager(
1284         dataContext->overrideResConfig_);
1285     if (overrideResMgr == nullptr) {
1286         dataContext->SetErrorMsg("GetOverrideResourceManager, overrideResMgr is null", false);
1287         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1288         return nullptr;
1289     }
1290 
1291     return dataContext->addon_->CreateOverrideAddon(env, overrideResMgr);
1292 }
1293 
getAddonAndConfig(napi_env env,napi_callback_info info,std::unique_ptr<ResMgrDataContext> & dataContext)1294 RState ResourceManagerNapiSyncImpl::getAddonAndConfig(napi_env env, napi_callback_info info,
1295     std::unique_ptr<ResMgrDataContext> &dataContext)
1296 {
1297     GET_PARAMS(env, info, PARAMS_NUM_TWO);
1298     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1299     if (dataContext->addon_ == nullptr) {
1300         RESMGR_HILOGE(RESMGR_JS_TAG, "getAddonAndConfig failed to get addon");
1301         return ERROR_CODE_INVALID_INPUT_PARAMETER;
1302     }
1303     if (ResourceManagerNapiUtils::GetConfigObject(env, argv[ARRAY_SUBCRIPTOR_ZERO], dataContext) != SUCCESS) {
1304         RESMGR_HILOGE(RESMGR_JS_TAG, "getAddonAndConfig failed to get resConfig");
1305         return ERROR_CODE_INVALID_INPUT_PARAMETER;
1306     }
1307     return SUCCESS;
1308 }
1309 
GetOverrideConfiguration(napi_env env,napi_callback_info info)1310 napi_value ResourceManagerNapiSyncImpl::GetOverrideConfiguration(napi_env env, napi_callback_info info)
1311 {
1312     auto dataContext = std::make_unique<ResMgrDataContext>();
1313     dataContext->addon_ = ResMgrDataContext::GetResourceManagerAddon(env, info);
1314     if (dataContext->addon_ == nullptr) {
1315         RESMGR_HILOGE(RESMGR_JS_TAG, "GetOverrideConfiguration failed to get addon");
1316         return nullptr;
1317     }
1318     return ResourceManagerNapiUtils::CreateOverrideJsConfig(env, *dataContext);
1319 }
1320 
UpdateOverrideConfiguration(napi_env env,napi_callback_info info)1321 napi_value ResourceManagerNapiSyncImpl::UpdateOverrideConfiguration(napi_env env, napi_callback_info info)
1322 {
1323     auto dataContext = std::make_unique<ResMgrDataContext>();
1324     int32_t state = getAddonAndConfig(env, info, dataContext);
1325     if (state != RState::SUCCESS) {
1326         dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false);
1327         ResourceManagerNapiUtils::NapiThrow(env, state);
1328         return nullptr;
1329     }
1330 
1331     std::shared_ptr<ResourceManager> resMgr = dataContext->addon_->GetResMgr();
1332     state = resMgr->UpdateOverrideResConfig(*dataContext->overrideResConfig_);
1333     if (state != RState::SUCCESS) {
1334         dataContext->SetErrorMsg("UpdateOverrideConfiguration failed due to invalid config", false);
1335         ResourceManagerNapiUtils::NapiThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER);
1336     }
1337     return nullptr;
1338 }
1339 } // namespace Resource
1340 } // namespace Global
1341 } // namespace OHOS