1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "resource_manager_ffi.h"
17 #include <vector>
18 #include "utils.h"
19
20 using namespace OHOS::FFI;
21 using namespace OHOS::Global::Resource;
22
23 namespace OHOS {
24 namespace Resource {
25 extern "C" {
ClearCharPointer(char ** ptr,int count)26 void ClearCharPointer(char** ptr, int count)
27 {
28 for (int i = 0; i < count; i++) {
29 free(ptr[i]);
30 }
31 }
32
VectorToCArrString(std::vector<std::string> & vec,int32_t & code)33 CArrString VectorToCArrString(std::vector<std::string>& vec, int32_t &code)
34 {
35 CArrString ret = { .head = nullptr, .size = 0};
36 if (vec.size() == 0) {
37 return ret;
38 }
39 char** result = reinterpret_cast<char**>(malloc(sizeof(char*) * vec.size()));
40 if (result == nullptr) {
41 code = RState::NOT_ENOUGH_MEM;
42 return ret;
43 }
44 for (size_t i = 0; i < vec.size(); i++) {
45 result[i] = ::Utils::MallocCString(vec[i]);
46 if (result[i] == nullptr) {
47 ClearCharPointer(result, i);
48 free(result);
49 code = RState::NOT_ENOUGH_MEM;
50 return ret;
51 }
52 }
53 ret.head = result;
54 ret.size = static_cast<int64_t>(vec.size());
55 return ret;
56 }
57
CJ_GetResourceManagerStageMode(OHOS::AbilityRuntime::Context * context)58 int64_t CJ_GetResourceManagerStageMode(OHOS::AbilityRuntime::Context* context)
59 {
60 if (context == nullptr) {
61 return ERR_INVALID_INSTANCE_CODE;
62 }
63 auto nativeResMgrLibrary = FFIData::Create<ResourceManagerImpl>(context);
64 if (!nativeResMgrLibrary) {
65 return ERR_INVALID_INSTANCE_CODE;
66 }
67 return nativeResMgrLibrary->GetID();
68 }
69
CJ_GetSystemResMgr()70 RetDataI64 CJ_GetSystemResMgr()
71 {
72 RetDataI64 ret = { .code = SUCCESS_CODE, .data = -1 };
73 auto resMgr = FFIData::Create<ResourceManagerImpl>();
74 if (resMgr->IsEmpty()) {
75 ret.code = ERROR_CODE_SYSTEM_RES_MANAGER_GET_FAILED;
76 return ret;
77 }
78 ret.data = resMgr->GetID();
79 return ret;
80 }
81
82
FfiGetOverrideResMgr(int64_t id,OHOS::Resource::ConfigurationEx cfg)83 RetDataI64 FfiGetOverrideResMgr(int64_t id, OHOS::Resource::ConfigurationEx cfg)
84 {
85 RetDataI64 ret = { .code = SUCCESS_CODE, .data = -1 };
86 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
87 if (!instance) {
88 ret.code = ERR_INVALID_INSTANCE_CODE;
89 return ret;
90 }
91 std::shared_ptr<ResourceManager> overrideResMgr = instance->GetOverrideResMgr(cfg, ret.code);
92 if (ret.code != SUCCESS_CODE) {
93 return ret;
94 }
95 auto nativeResMgrLibrary = FFIData::Create<ResourceManagerImpl>(instance->GetBundleName(), overrideResMgr,
96 instance->GetContext());
97 if (!nativeResMgrLibrary) {
98 ret.code = ERR_INVALID_INSTANCE_CODE;
99 return ret;
100 }
101 ret.data = nativeResMgrLibrary->GetID();
102 return ret;
103 }
104
CJ_CloseRawFd(int64_t id,const char * path)105 int32_t CJ_CloseRawFd(int64_t id, const char* path)
106 {
107 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
108 if (!instance) {
109 return ERR_INVALID_INSTANCE_CODE;
110 }
111 return instance->CloseRawFd(path);
112 }
113
CJ_GetRawFd(int64_t id,const char * rawFileName,ResourceManager::RawFileDescriptor & descriptor)114 int32_t CJ_GetRawFd(int64_t id, const char* rawFileName, ResourceManager::RawFileDescriptor &descriptor)
115 {
116 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
117 if (!instance) {
118 return ERR_INVALID_INSTANCE_CODE;
119 }
120 return instance->GetRawFd(rawFileName, descriptor);
121 }
122
CopyUI8Arr(RetDataCArrUI8 & ret,std::unique_ptr<uint8_t[]> & data,size_t len)123 void CopyUI8Arr(RetDataCArrUI8 &ret, std::unique_ptr<uint8_t[]> &data, size_t len)
124 {
125 if (len <= 0) {
126 LOGE("Wrong data size!")
127 return;
128 }
129 uint8_t* outValue = static_cast<uint8_t*>(malloc(sizeof(uint8_t) * len));
130 if (outValue == nullptr) {
131 ret.code = RState::ERROR;
132 return;
133 }
134 for (size_t i = 0; i < len; ++i) {
135 outValue[i] = data[i];
136 }
137 ret.data.size = static_cast<int64_t>(len);
138 ret.data.head = outValue;
139 }
140
CJ_GetRawFileContent(int64_t id,const char * path)141 RetDataCArrUI8 CJ_GetRawFileContent(int64_t id, const char* path)
142 {
143 LOGI("CJ_GetRawFileContent start");
144 RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
145 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
146 if (!instance) {
147 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
148 return ret;
149 }
150 size_t len = 0;
151 std::unique_ptr<uint8_t[]> data;
152 int32_t state = instance->GetRawFileContent(path, len, data);
153 ret.code = state;
154 if (state == SUCCESS_CODE) {
155 CopyUI8Arr(ret, data, len);
156 }
157 return ret;
158 }
159
CJ_GetRawFileList(int64_t id,const char * path)160 RetDataCArrString CJ_GetRawFileList(int64_t id, const char* path)
161 {
162 RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
163 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
164 if (!instance) {
165 return ret;
166 }
167 std::vector<std::string> value;
168 ret.code = instance->GetRawFileList(path, value);
169 if (ret.code != RState::SUCCESS) {
170 return ret;
171 }
172 ret.data = VectorToCArrString(value, ret.code);
173 return ret;
174 }
175
CJ_AddResource(int64_t id,const char * path)176 int32_t CJ_AddResource(int64_t id, const char *path)
177 {
178 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
179 if (!instance) {
180 return ERR_INVALID_INSTANCE_CODE;
181 }
182 return instance->AddResource(path);
183 }
184
CJ_RemoveResource(int64_t id,const char * path)185 int32_t CJ_RemoveResource(int64_t id, const char *path)
186 {
187 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
188 if (!instance) {
189 return ERR_INVALID_INSTANCE_CODE;
190 }
191 return instance->RemoveResource(path);
192 }
193
CJ_GetPluralStringValue(int64_t id,uint32_t resId,int64_t num)194 RetDataCString CJ_GetPluralStringValue(int64_t id, uint32_t resId, int64_t num)
195 {
196 LOGI("CJ_GetPluralStringValue start");
197 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
198 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
199 if (!instance) {
200 return ret;
201 }
202 std::string value;
203 ret.code = instance->GetPluralStringValue(resId, num, value);
204 if (ret.code != RState::SUCCESS) {
205 return ret;
206 }
207 ret.data = ::Utils::MallocCString(value);
208 return ret;
209 }
210
CJ_GetPluralStringValueByResource(int64_t id,CResource resource,int64_t num)211 RetDataCString CJ_GetPluralStringValueByResource(int64_t id, CResource resource, int64_t num)
212 {
213 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
214 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
215 if (!instance) {
216 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
217 return ret;
218 }
219 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
220 .moduleName = std::string(resource.moduleName), .id = resource.id };
221 std::shared_ptr<ResourceManager> resMgr = nullptr;
222 uint32_t resId = 0;
223 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
224 LOGE("ResourceManager CJ_GetPluralStringValueByResource failed at GetHapResourceManager");
225 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
226 return ret;
227 }
228 std::string value;
229 ret.code = resMgr->GetPluralStringByIdFormat(value, resId, num, num);
230 if (ret.code != RState::SUCCESS) {
231 LOGE("ResourceManagerImpl::GetPluralStringByIdFormat failed %{public}" PRIu32, ret.code);
232 return ret;
233 }
234 LOGI("ResourceManagerImpl::GetPluralStringByIdFormat success");
235 ret.data = ::Utils::MallocCString(value);
236 return ret;
237 }
238
CJ_GetPluralStringByName(int64_t id,const char * name,int64_t quantity)239 RetDataCString CJ_GetPluralStringByName(int64_t id, const char *name, int64_t quantity)
240 {
241 LOGI("CJ_GetPluralStringValue start");
242 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
243 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
244 if (!instance) {
245 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
246 return ret;
247 }
248 std::string value;
249 ret.code = instance->GetPluralStringValue(name, quantity, value);
250 if (ret.code != RState::SUCCESS) {
251 return ret;
252 }
253 ret.data = ::Utils::MallocCString(value);
254 return ret;
255 }
256
CJ_GetStringArrayValue(int64_t id,uint32_t resId)257 RetDataCArrString CJ_GetStringArrayValue(int64_t id, uint32_t resId)
258 {
259 RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
260 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
261 if (!instance) {
262 return ret;
263 }
264 std::vector<std::string> value;
265 ret.code = instance->GetStringArrayValue(resId, value);
266 if (ret.code != RState::SUCCESS) {
267 return ret;
268 }
269 ret.data = VectorToCArrString(value, ret.code);
270 return ret;
271 }
272
CJ_GetStringArrayValueByResource(int64_t id,CResource resource)273 RetDataCArrString CJ_GetStringArrayValueByResource(int64_t id, CResource resource)
274 {
275 RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
276 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
277 if (!instance) {
278 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
279 return ret;
280 }
281 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
282 .moduleName = std::string(resource.moduleName), .id = resource.id };
283 std::shared_ptr<ResourceManager> resMgr = nullptr;
284 uint32_t resId = 0;
285 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
286 LOGE("ResourceManager CJ_GetStringArrayValueByResource failed at GetHapResourceManager");
287 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
288 return ret;
289 }
290 std::vector<std::string> value;
291 ret.code = resMgr->GetStringArrayById(resId, value);
292 if (ret.code != RState::SUCCESS) {
293 LOGE("ResourceManagerImpl::GetStringArrayById failed %{public}" PRIu32, ret.code);
294 return ret;
295 }
296 ret.data = VectorToCArrString(value, ret.code);
297 return ret;
298 }
299
CJ_GetStringArrayByName(int64_t id,const char * name)300 RetDataCArrString CJ_GetStringArrayByName(int64_t id, const char *name)
301 {
302 LOGI("CJ_GetStringArrayByName start");
303 RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
304 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
305 if (!instance) {
306 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
307 return ret;
308 }
309 std::vector<std::string> value;
310 ret.code = instance->GetStringArrayByName(name, value);
311 if (ret.code != RState::SUCCESS) {
312 return ret;
313 }
314 ret.data = VectorToCArrString(value, ret.code);
315 return ret;
316 }
317
CJ_GetString(int64_t id,uint32_t resId)318 RetDataCString CJ_GetString(int64_t id, uint32_t resId)
319 {
320 LOGI("CJ_GetString start");
321 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
322 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
323 if (!instance) {
324 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
325 return ret;
326 }
327 std::string value;
328 ret.code = instance->GetString(resId, value);
329 if (ret.code != RState::SUCCESS) {
330 return ret;
331 }
332 ret.data = ::Utils::MallocCString(value);
333 return ret;
334 }
335
CJ_GetStringByResource(int64_t id,CResource resource)336 RetDataCString CJ_GetStringByResource(int64_t id, CResource resource)
337 {
338 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
339 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
340 if (!instance) {
341 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
342 return ret;
343 }
344 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
345 .moduleName = std::string(resource.moduleName), .id = resource.id };
346 std::shared_ptr<ResourceManager> resMgr = nullptr;
347 uint32_t resId = 0;
348 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
349 LOGE("ResourceManager CJ_GetStringByResource failed at GetHapResourceManager");
350 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
351 return ret;
352 }
353 std::string value;
354 ret.code = resMgr->GetStringById(resId, value);
355 if (ret.code != RState::SUCCESS) {
356 LOGE("ResourceManagerImpl::GetStringById failed %{public}" PRIu32, ret.code);
357 return ret;
358 }
359 LOGI("ResourceManagerImpl::GetStringById success");
360 ret.data = ::Utils::MallocCString(value);
361 return ret;
362 }
363
CJ_GetStringByName(int64_t id,const char * name)364 RetDataCString CJ_GetStringByName(int64_t id, const char* name)
365 {
366 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
367 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
368 if (!instance) {
369 ret.code = ERR_INVALID_INSTANCE_CODE;
370 return ret;
371 }
372 std::string value;
373 ret.code = instance->GetStringByName(name, value);
374 if (ret.code != RState::SUCCESS) {
375 return ret;
376 }
377 ret.data = ::Utils::MallocCString(value);
378 return ret;
379 }
380
CJ_GetColorByName(int64_t id,const char * name,uint32_t & data)381 int32_t CJ_GetColorByName(int64_t id, const char* name, uint32_t &data)
382 {
383 LOGI("CJ_GetColorByName start");
384 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
385 if (!instance) {
386 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
387 return ERR_INVALID_INSTANCE_CODE;
388 }
389 return instance->GetColorByName(name, data);
390 }
391
CJ_GetColor(int64_t id,uint32_t resId,uint32_t & data)392 int32_t CJ_GetColor(int64_t id, uint32_t resId, uint32_t &data)
393 {
394 LOGI("CJ_GetColor start");
395 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
396 if (!instance) {
397 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
398 return ERR_INVALID_INSTANCE_CODE;
399 }
400 return instance->GetColorById(resId, data);
401 }
402
CJ_GetColorByResource(int64_t id,CResource resource,uint32_t & data)403 int32_t CJ_GetColorByResource(int64_t id, CResource resource, uint32_t &data)
404 {
405 LOGI("CJ_GetColorByResource start");
406 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
407 if (!instance) {
408 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
409 return ERR_INVALID_INSTANCE_CODE;
410 }
411 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
412 .moduleName = std::string(resource.moduleName), .id = resource.id };
413 std::shared_ptr<ResourceManager> resMgr = nullptr;
414 uint32_t resId = 0;
415 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
416 LOGE("ResourceManager CJ_GetColorByResource failed at GetHapResourceManager");
417 return RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
418 }
419 return resMgr->GetColorById(resId, data);
420 }
421
CJ_GetBoolean(int64_t id,uint32_t resId,bool & data)422 int32_t CJ_GetBoolean(int64_t id, uint32_t resId, bool &data)
423 {
424 LOGI("CJ_GetBoolean start");
425 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
426 if (!instance) {
427 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
428 return ERR_INVALID_INSTANCE_CODE;
429 }
430 return instance->GetBooleanById(resId, data);
431 }
432
CJ_GetBooleanByResource(int64_t id,CResource resource,bool & data)433 int32_t CJ_GetBooleanByResource(int64_t id, CResource resource, bool &data)
434 {
435 LOGI("CJ_GetBoolean start");
436 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
437 if (!instance) {
438 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
439 return ERR_INVALID_INSTANCE_CODE;
440 }
441 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
442 .moduleName = std::string(resource.moduleName), .id = resource.id };
443 std::shared_ptr<ResourceManager> resMgr = nullptr;
444 uint32_t resId = 0;
445 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
446 LOGE("ResourceManager CJ_GetBooleanByResource failed at GetHapResourceManager");
447 return RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
448 }
449 return resMgr->GetBooleanById(resId, data);
450 }
451
CJ_GetBooleanByName(int64_t id,const char * name,bool & data)452 int32_t CJ_GetBooleanByName(int64_t id, const char* name, bool &data)
453 {
454 LOGI("CJ_GetBooleanByName start");
455 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
456 if (!instance) {
457 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
458 return ERR_INVALID_INSTANCE_CODE;
459 }
460 return instance->GetBooleanByName(name, data);
461 }
462
CJ_GetNumber(int64_t id,uint32_t resId,RetGetNumber & data)463 int32_t CJ_GetNumber(int64_t id, uint32_t resId, RetGetNumber &data)
464 {
465 LOGI("CJ_GetNumber start");
466 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
467 if (!instance) {
468 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
469 return ERR_INVALID_INSTANCE_CODE;
470 }
471 data.isInt = true;
472 auto state = instance->GetIntegerById(resId, data.intValue);
473 if (state != SUCCESS_CODE) {
474 state = instance->GetFloatById(resId, data.floatValue);
475 data.isInt = false;
476 }
477 return state;
478 }
479
CJ_GetNumberByResource(int64_t id,CResource resource,RetGetNumber & data)480 int32_t CJ_GetNumberByResource(int64_t id, CResource resource, RetGetNumber &data)
481 {
482 LOGI("CJ_GetNumber start");
483 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
484 if (!instance) {
485 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
486 return ERR_INVALID_INSTANCE_CODE;
487 }
488 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
489 .moduleName = std::string(resource.moduleName), .id = resource.id };
490 std::shared_ptr<ResourceManager> resMgr = nullptr;
491 uint32_t resId = 0;
492 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
493 LOGE("ResourceManager CJ_GetNumberByResource failed at GetHapResourceManager");
494 return RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
495 }
496 data.isInt = true;
497 auto state = instance->GetIntegerById(resId, data.intValue);
498 if (state != SUCCESS_CODE) {
499 state = instance->GetFloatById(resId, data.floatValue);
500 data.isInt = false;
501 }
502 return state;
503 }
504
CJ_GetNumberByName(int64_t id,const char * name,RetGetNumber & data)505 int32_t CJ_GetNumberByName(int64_t id, const char* name, RetGetNumber &data)
506 {
507 LOGI("CJ_GetNumberByName start");
508 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
509 if (!instance) {
510 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
511 return ERR_INVALID_INSTANCE_CODE;
512 }
513 data.isInt = true;
514 auto state = instance->GetIntegerByName(name, data.intValue);
515 if (state != SUCCESS_CODE) {
516 state = instance->GetFloatByName(name, data.floatValue);
517 data.isInt = false;
518 }
519 return state;
520 }
521
CJ_GetConfiguration(int64_t id,OHOS::Resource::Configuration & cfg)522 int32_t CJ_GetConfiguration(int64_t id, OHOS::Resource::Configuration &cfg)
523 {
524 LOGI("CJ_GetConfiguration start");
525 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
526 if (!instance) {
527 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
528 return ERR_INVALID_INSTANCE_CODE;
529 }
530 instance->GetConfiguration(cfg);
531 return SUCCESS_CODE;
532 }
533
FfiResMgrGetConfiguration(int64_t id,OHOS::Resource::ConfigurationEx * cfg)534 int32_t FfiResMgrGetConfiguration(int64_t id, OHOS::Resource::ConfigurationEx* cfg)
535 {
536 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
537 if (!instance) {
538 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
539 return ERR_INVALID_INSTANCE_CODE;
540 }
541 instance->GetConfiguration(cfg);
542 return SUCCESS_CODE;
543 }
544
FfiResMgrGetOverrideConfiguration(int64_t id,OHOS::Resource::ConfigurationEx * cfg)545 int32_t FfiResMgrGetOverrideConfiguration(int64_t id, OHOS::Resource::ConfigurationEx* cfg)
546 {
547 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
548 if (!instance) {
549 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
550 return ERR_INVALID_INSTANCE_CODE;
551 }
552 instance->GetOverrideConfiguration(cfg);
553 return SUCCESS_CODE;
554 }
555
FfiResMgrFreeConfiguration(OHOS::Resource::ConfigurationEx * cfg)556 void FfiResMgrFreeConfiguration(OHOS::Resource::ConfigurationEx* cfg)
557 {
558 free(cfg->locale);
559 cfg->locale = nullptr;
560 }
561
CJ_GetDeviceCapability(int64_t id,OHOS::Resource::DeviceCapability & deviceCapability)562 int32_t CJ_GetDeviceCapability(int64_t id, OHOS::Resource::DeviceCapability &deviceCapability)
563 {
564 LOGI("CJ_GetDeviceCapability start");
565 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
566 if (!instance) {
567 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
568 return ERR_INVALID_INSTANCE_CODE;
569 }
570 instance->GetDeviceCapability(deviceCapability);
571 return SUCCESS_CODE;
572 }
573
CJ_GetMediaByName(int64_t id,const char * resName,uint32_t density)574 RetDataCArrUI8 CJ_GetMediaByName(int64_t id, const char* resName, uint32_t density)
575 {
576 LOGI("CJ_GetMediaByName start");
577 RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
578 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
579 if (!instance) {
580 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
581 return ret;
582 }
583 size_t len = 0;
584 std::unique_ptr<uint8_t[]> data;
585 int32_t state = instance->GetMediaDataByName(resName, len, data, density);
586 ret.code = state;
587 if (state == SUCCESS_CODE) {
588 CopyUI8Arr(ret, data, len);
589 }
590 return ret;
591 }
592
CJ_GetMediaContent(int64_t id,uint32_t resId,uint32_t density)593 RetDataCArrUI8 CJ_GetMediaContent(int64_t id, uint32_t resId, uint32_t density)
594 {
595 LOGI("CJ_GetMediaContent start");
596 RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
597 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
598 if (!instance) {
599 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
600 return ret;
601 }
602 size_t len = 0;
603 std::unique_ptr<uint8_t[]> data;
604 int32_t state = instance->GetMediaDataById(resId, len, data, density);
605 ret.code = state;
606 if (state == SUCCESS_CODE) {
607 CopyUI8Arr(ret, data, len);
608 }
609 return ret;
610 }
611
CJ_GetMediaContentByResource(int64_t id,CResource resource,uint32_t density)612 RetDataCArrUI8 CJ_GetMediaContentByResource(int64_t id, CResource resource, uint32_t density)
613 {
614 LOGI("CJ_GetMediaContent start");
615 RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
616 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
617 if (!instance) {
618 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
619 return ret;
620 }
621 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
622 .moduleName = std::string(resource.moduleName), .id = resource.id };
623 std::shared_ptr<ResourceManager> resMgr = nullptr;
624 uint32_t resId = 0;
625 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
626 LOGE("ResourceManager CJ_GetMediaContentByResource failed at GetHapResourceManager");
627 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
628 return ret;
629 }
630 size_t len = 0;
631 std::unique_ptr<uint8_t[]> data;
632 int32_t state = resMgr->GetMediaDataById(resId, len, data, density);
633 ret.code = state;
634 if (state == SUCCESS_CODE) {
635 CopyUI8Arr(ret, data, len);
636 }
637 return ret;
638 }
639
CJ_GetMediaContentBase64(int64_t id,uint32_t resId,uint32_t density)640 RetDataCString CJ_GetMediaContentBase64(int64_t id, uint32_t resId, uint32_t density)
641 {
642 LOGI("CJ_GetMediaContentBase64 start");
643 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
644 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
645 if (!instance) {
646 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
647 return ret;
648 }
649 std::string value;
650 ret.code = instance->GetMediaContentBase64ById(resId, value, density);
651 if (ret.code != RState::SUCCESS) {
652 return ret;
653 }
654 ret.data = ::Utils::MallocCString(value);
655 return ret;
656 }
657
CJ_GetMediaContentBase64ByResource(int64_t id,CResource resource,uint32_t density)658 RetDataCString CJ_GetMediaContentBase64ByResource(int64_t id, CResource resource, uint32_t density)
659 {
660 LOGI("CJ_GetMediaContentBase64ByResource start");
661 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
662 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
663 if (!instance) {
664 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
665 return ret;
666 }
667 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
668 .moduleName = std::string(resource.moduleName), .id = resource.id };
669 std::shared_ptr<ResourceManager> resMgr = nullptr;
670 uint32_t resId = 0;
671 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
672 LOGE("ResourceManager CJ_GetMediaContentBase64ByResource failed at GetHapResourceManager");
673 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
674 return ret;
675 }
676 std::string value;
677 ret.code = resMgr->GetMediaBase64DataById(resId, value, density);
678 if (ret.code != RState::SUCCESS) {
679 return ret;
680 }
681 ret.data = ::Utils::MallocCString(value);
682 return ret;
683 }
684
CJ_GetMediaContentBase64ByName(int64_t id,const char * resName,uint32_t density)685 RetDataCString CJ_GetMediaContentBase64ByName(int64_t id, const char* resName, uint32_t density)
686 {
687 LOGI("CJ_GetMediaContentBase64 start");
688 RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
689 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
690 if (!instance) {
691 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
692 return ret;
693 }
694 std::string value;
695 ret.code = instance->GetMediaContentBase64ByName(resName, value, density);
696 if (ret.code != RState::SUCCESS) {
697 return ret;
698 }
699 ret.data = ::Utils::MallocCString(value);
700 return ret;
701 }
702
CJ_GetDrawableDescriptor(int64_t id,uint32_t resId,uint32_t density)703 RetDataI64 CJ_GetDrawableDescriptor(int64_t id, uint32_t resId, uint32_t density)
704 {
705 LOGI("CJ_GetDrawableDescriptor start");
706 RetDataI64 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
707 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
708 if (!instance) {
709 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
710 return ret;
711 }
712 ret.code = instance->GetDrawableDescriptor(resId, ret.data, density);
713 if (ret.code != RState::SUCCESS) {
714 return ret;
715 }
716 return ret;
717 }
718
CJ_GetDrawableDescriptorByResource(int64_t id,CResource resource,uint32_t density)719 RetDataI64 CJ_GetDrawableDescriptorByResource(int64_t id, CResource resource, uint32_t density)
720 {
721 LOGI("CJ_GetDrawableDescriptor start");
722 RetDataI64 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
723 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
724 if (!instance) {
725 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
726 return ret;
727 }
728 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
729 .moduleName = std::string(resource.moduleName), .id = resource.id };
730 std::shared_ptr<ResourceManager> resMgr = nullptr;
731 uint32_t resId = 0;
732 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
733 LOGE("ResourceManager CJ_GetDrawableDescriptorByResource failed at GetHapResourceManager");
734 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
735 return ret;
736 }
737 RState state;
738 auto drawableDescriptor = OHOS::Resource::GetDrawableDescriptorPtr(resId, resMgr, density, state);
739 ret.code = state;
740 if (ret.code != SUCCESS) {
741 LOGE("Failed to Create drawableDescriptor by %{public}" PRIu32, resId);
742 return ret;
743 }
744 auto ptr = FFIData::Create<DrawableDescriptorImpl>(drawableDescriptor);
745 if (!ptr) {
746 ret.code = ERR_INVALID_INSTANCE_CODE;
747 return ret;
748 }
749 ret.data = ptr->GetID();
750 return ret;
751 }
752
CJ_GetDrawableDescriptorByName(int64_t id,const char * resName,uint32_t density)753 RetDataI64 CJ_GetDrawableDescriptorByName(int64_t id, const char* resName, uint32_t density)
754 {
755 LOGI("CJ_GetDrawableDescriptorByName start");
756 RetDataI64 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
757 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
758 if (!instance) {
759 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
760 return ret;
761 }
762 ret.code = instance->GetDrawableDescriptorByName(resName, ret.data, density);
763 if (ret.code != RState::SUCCESS) {
764 return ret;
765 }
766 return ret;
767 }
768
CJ_GetLocales(int64_t id,bool includeSystem)769 RetDataCArrString CJ_GetLocales(int64_t id, bool includeSystem)
770 {
771 LOGI("CJ_GetLocales start");
772 RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
773 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
774 if (!instance) {
775 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
776 return ret;
777 }
778 std::vector<std::string> value;
779 instance->GetLocales(includeSystem, value);
780 ret.code = RState::SUCCESS;
781 ret.data = VectorToCArrString(value, ret.code);
782 return ret;
783 }
784
CJ_GetSymbol(int64_t id,uint32_t resId)785 RetDataU32 CJ_GetSymbol(int64_t id, uint32_t resId)
786 {
787 LOGI("CJ_GetSymbol start");
788 RetDataU32 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
789 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
790 if (!instance) {
791 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
792 return ret;
793 }
794 ret.code = instance->GetSymbolById(resId, ret.data);
795 if (ret.code != RState::SUCCESS) {
796 return ret;
797 }
798 return ret;
799 }
800
CJ_GetSymbolByResource(int64_t id,CResource resource)801 RetDataU32 CJ_GetSymbolByResource(int64_t id, CResource resource)
802 {
803 LOGI("CJ_GetSymbol start");
804 RetDataU32 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
805 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
806 if (!instance) {
807 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
808 return ret;
809 }
810 OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
811 .moduleName = std::string(resource.moduleName), .id = resource.id };
812 std::shared_ptr<ResourceManager> resMgr = nullptr;
813 uint32_t resId = 0;
814 if (!instance->GetHapResourceManager(res, resMgr, resId)) {
815 LOGE("ResourceManager CJ_GetSymbolByResource failed at GetHapResourceManager");
816 ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
817 return ret;
818 }
819 ret.code = resMgr->GetSymbolById(resId, ret.data);
820 if (ret.code != RState::SUCCESS) {
821 LOGE("ResourceManagerImpl::GetSymbolByResource failed %{public}" PRIu32, ret.code);
822 return ret;
823 }
824 LOGI("ResourceManagerImpl::GetSymbolByResource success")
825 return ret;
826 }
827
CJ_GetSymbolByName(int64_t id,const char * name)828 RetDataU32 CJ_GetSymbolByName(int64_t id, const char* name)
829 {
830 LOGI("CJ_GetSymbolByName start");
831 RetDataU32 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
832 auto instance = FFIData::GetData<ResourceManagerImpl>(id);
833 if (!instance) {
834 LOGE("ResourceManager instance not exist %{public}" PRId64, id);
835 return ret;
836 }
837 ret.code = instance->GetSymbolByName(name, ret.data);
838 if (ret.code != RState::SUCCESS) {
839 return ret;
840 }
841 return ret;
842 }
843 }
844 }
845 }