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, ¶m) != 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