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_CloseRawFd(int64_t id,const char * path)70 int32_t CJ_CloseRawFd(int64_t id, const char* path)
71 {
72     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
73     if (!instance) {
74         return ERR_INVALID_INSTANCE_CODE;
75     }
76     return instance->CloseRawFd(path);
77 }
78 
CJ_GetRawFd(int64_t id,const char * rawFileName,ResourceManager::RawFileDescriptor & descriptor)79 int32_t CJ_GetRawFd(int64_t id, const char* rawFileName, ResourceManager::RawFileDescriptor &descriptor)
80 {
81     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
82     if (!instance) {
83         return ERR_INVALID_INSTANCE_CODE;
84     }
85     return instance->GetRawFd(rawFileName, descriptor);
86 }
87 
CopyUI8Arr(RetDataCArrUI8 & ret,std::unique_ptr<uint8_t[]> & data,size_t len)88 void CopyUI8Arr(RetDataCArrUI8 &ret, std::unique_ptr<uint8_t[]> &data, size_t len)
89 {
90     if (len <= 0) {
91         LOGE("Wrong data size!")
92         return;
93     }
94     uint8_t* outValue = static_cast<uint8_t*>(malloc(sizeof(uint8_t) * len));
95     if (outValue == nullptr) {
96         ret.code = RState::ERROR;
97         return;
98     }
99     for (size_t i = 0; i < len; ++i) {
100         outValue[i] = data[i];
101     }
102     ret.data.size = static_cast<int64_t>(len);
103     ret.data.head = outValue;
104 }
105 
CJ_GetRawFileContent(int64_t id,const char * path)106 RetDataCArrUI8 CJ_GetRawFileContent(int64_t id, const char* path)
107 {
108     LOGI("CJ_GetRawFileContent start");
109     RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
110     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
111     if (!instance) {
112         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
113         return ret;
114     }
115     size_t len = 0;
116     std::unique_ptr<uint8_t[]> data;
117     int32_t state = instance->GetRawFileContent(path, len, data);
118     ret.code = state;
119     if (state == SUCCESS_CODE) {
120         CopyUI8Arr(ret, data, len);
121     }
122     return ret;
123 }
124 
CJ_GetRawFileList(int64_t id,const char * path)125 RetDataCArrString CJ_GetRawFileList(int64_t id, const char* path)
126 {
127     RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
128     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
129     if (!instance) {
130         return ret;
131     }
132     std::vector<std::string> value;
133     ret.code = instance->GetRawFileList(path, value);
134     if (ret.code != RState::SUCCESS) {
135         return ret;
136     }
137     ret.data = VectorToCArrString(value, ret.code);
138     return ret;
139 }
140 
CJ_AddResource(int64_t id,const char * path)141 int32_t CJ_AddResource(int64_t id, const char *path)
142 {
143     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
144     if (!instance) {
145         return ERR_INVALID_INSTANCE_CODE;
146     }
147     return instance->AddResource(path);
148 }
149 
CJ_RemoveResource(int64_t id,const char * path)150 int32_t CJ_RemoveResource(int64_t id, const char *path)
151 {
152     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
153     if (!instance) {
154         return ERR_INVALID_INSTANCE_CODE;
155     }
156     return instance->RemoveResource(path);
157 }
158 
CJ_GetPluralStringValue(int64_t id,uint32_t resId,int64_t num)159 RetDataCString CJ_GetPluralStringValue(int64_t id, uint32_t resId, int64_t num)
160 {
161     LOGI("CJ_GetPluralStringValue start");
162     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
163     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
164     if (!instance) {
165         return ret;
166     }
167     std::string value;
168     ret.code = instance->GetPluralStringValue(resId, num, value);
169     if (ret.code != RState::SUCCESS) {
170         return ret;
171     }
172     ret.data = ::Utils::MallocCString(value);
173     return ret;
174 }
175 
CJ_GetPluralStringValueByResource(int64_t id,CResource resource,int64_t num)176 RetDataCString CJ_GetPluralStringValueByResource(int64_t id, CResource resource, int64_t num)
177 {
178     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
179     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
180     if (!instance) {
181         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
182         return ret;
183     }
184     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
185         .moduleName = std::string(resource.moduleName), .id = resource.id };
186     std::shared_ptr<ResourceManager> resMgr = nullptr;
187     int32_t resId = 0;
188     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
189         LOGE("ResourceManager CJ_GetPluralStringValueByResource failed at GetHapResourceManager");
190         ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
191         return ret;
192     }
193     std::string value;
194     ret.code = resMgr->GetPluralStringByIdFormat(value, resId, num, num);
195     if (ret.code != RState::SUCCESS) {
196         LOGE("ResourceManagerImpl::GetPluralStringByIdFormat failed %{public}" PRIu32, ret.code);
197         return ret;
198     }
199     LOGI("ResourceManagerImpl::GetPluralStringByIdFormat success");
200     ret.data = ::Utils::MallocCString(value);
201     return ret;
202 }
203 
CJ_GetPluralStringByName(int64_t id,const char * name,int64_t quantity)204 RetDataCString CJ_GetPluralStringByName(int64_t id, const char *name, int64_t quantity)
205 {
206     LOGI("CJ_GetPluralStringValue start");
207     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
208     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
209     if (!instance) {
210         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
211         return ret;
212     }
213     std::string value;
214     ret.code = instance->GetPluralStringValue(name, quantity, value);
215     if (ret.code != RState::SUCCESS) {
216         return ret;
217     }
218     ret.data = ::Utils::MallocCString(value);
219     return ret;
220 }
221 
CJ_GetStringArrayValue(int64_t id,uint32_t resId)222 RetDataCArrString CJ_GetStringArrayValue(int64_t id, uint32_t resId)
223 {
224     RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
225     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
226     if (!instance) {
227         return ret;
228     }
229     std::vector<std::string> value;
230     ret.code = instance->GetStringArrayValue(resId, value);
231     if (ret.code != RState::SUCCESS) {
232         return ret;
233     }
234     ret.data = VectorToCArrString(value, ret.code);
235     return ret;
236 }
237 
CJ_GetStringArrayValueByResource(int64_t id,CResource resource)238 RetDataCArrString CJ_GetStringArrayValueByResource(int64_t id, CResource resource)
239 {
240     RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
241     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
242     if (!instance) {
243         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
244         return ret;
245     }
246     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
247         .moduleName = std::string(resource.moduleName), .id = resource.id };
248     std::shared_ptr<ResourceManager> resMgr = nullptr;
249     int32_t resId = 0;
250     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
251         LOGE("ResourceManager CJ_GetStringArrayValueByResource failed at GetHapResourceManager");
252         ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
253         return ret;
254     }
255     std::vector<std::string> value;
256     ret.code = resMgr->GetStringArrayById(resId, value);
257     if (ret.code != RState::SUCCESS) {
258         LOGE("ResourceManagerImpl::GetStringArrayById failed %{public}" PRIu32, ret.code);
259         return ret;
260     }
261     ret.data = VectorToCArrString(value, ret.code);
262     return ret;
263 }
264 
CJ_GetStringArrayByName(int64_t id,const char * name)265 RetDataCArrString CJ_GetStringArrayByName(int64_t id, const char *name)
266 {
267     LOGI("CJ_GetStringArrayByName start");
268     RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
269     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
270     if (!instance) {
271         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
272         return ret;
273     }
274     std::vector<std::string> value;
275     ret.code = instance->GetStringArrayByName(name, value);
276     if (ret.code != RState::SUCCESS) {
277         return ret;
278     }
279     ret.data = VectorToCArrString(value, ret.code);
280     return ret;
281 }
282 
CJ_GetString(int64_t id,uint32_t resId)283 RetDataCString CJ_GetString(int64_t id, uint32_t resId)
284 {
285     LOGI("CJ_GetString start");
286     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
287     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
288     if (!instance) {
289         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
290         return ret;
291     }
292     std::string value;
293     ret.code = instance->GetString(resId, value);
294     if (ret.code != RState::SUCCESS) {
295         return ret;
296     }
297     ret.data = ::Utils::MallocCString(value);
298     return ret;
299 }
300 
CJ_GetStringByResource(int64_t id,CResource resource)301 RetDataCString CJ_GetStringByResource(int64_t id, CResource resource)
302 {
303     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
304     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
305     if (!instance) {
306         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
307         return ret;
308     }
309     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
310         .moduleName = std::string(resource.moduleName), .id = resource.id };
311     std::shared_ptr<ResourceManager> resMgr = nullptr;
312     int32_t resId = 0;
313     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
314         LOGE("ResourceManager CJ_GetStringByResource failed at GetHapResourceManager");
315         ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
316         return ret;
317     }
318     std::string value;
319     ret.code = resMgr->GetStringById(resId, value);
320     if (ret.code != RState::SUCCESS) {
321         LOGE("ResourceManagerImpl::GetStringById failed %{public}" PRIu32, ret.code);
322         return ret;
323     }
324     LOGI("ResourceManagerImpl::GetStringById success");
325     ret.data = ::Utils::MallocCString(value);
326     return ret;
327 }
328 
CJ_GetStringByName(int64_t id,const char * name)329 RetDataCString CJ_GetStringByName(int64_t id, const char* name)
330 {
331     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
332     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
333     if (!instance) {
334         ret.code = ERR_INVALID_INSTANCE_CODE;
335         return ret;
336     }
337     std::string value;
338     ret.code = instance->GetStringByName(name, value);
339     if (ret.code != RState::SUCCESS) {
340         return ret;
341     }
342     ret.data = ::Utils::MallocCString(value);
343     return ret;
344 }
345 
CJ_GetColorByName(int64_t id,const char * name,uint32_t & data)346 int32_t CJ_GetColorByName(int64_t id, const char* name, uint32_t &data)
347 {
348     LOGI("CJ_GetColorByName start");
349     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
350     if (!instance) {
351         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
352         return ERR_INVALID_INSTANCE_CODE;
353     }
354     return instance->GetColorByName(name, data);
355 }
356 
CJ_GetColor(int64_t id,uint32_t resId,uint32_t & data)357 int32_t CJ_GetColor(int64_t id, uint32_t resId, uint32_t &data)
358 {
359     LOGI("CJ_GetColor start");
360     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
361     if (!instance) {
362         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
363         return ERR_INVALID_INSTANCE_CODE;
364     }
365     return instance->GetColorById(resId, data);
366 }
367 
CJ_GetColorByResource(int64_t id,CResource resource,uint32_t & data)368 int32_t CJ_GetColorByResource(int64_t id, CResource resource, uint32_t &data)
369 {
370     LOGI("CJ_GetColorByResource start");
371     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
372     if (!instance) {
373         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
374         return ERR_INVALID_INSTANCE_CODE;
375     }
376     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
377         .moduleName = std::string(resource.moduleName), .id = resource.id };
378     std::shared_ptr<ResourceManager> resMgr = nullptr;
379     int32_t resId = 0;
380     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
381         LOGE("ResourceManager CJ_GetColorByResource failed at GetHapResourceManager");
382         return RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
383     }
384     return resMgr->GetColorById(resId, data);
385 }
386 
CJ_GetBoolean(int64_t id,uint32_t resId,bool & data)387 int32_t CJ_GetBoolean(int64_t id, uint32_t resId, bool &data)
388 {
389     LOGI("CJ_GetBoolean start");
390     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
391     if (!instance) {
392         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
393         return ERR_INVALID_INSTANCE_CODE;
394     }
395     return instance->GetBooleanById(resId, data);
396 }
397 
CJ_GetBooleanByResource(int64_t id,CResource resource,bool & data)398 int32_t CJ_GetBooleanByResource(int64_t id, CResource resource, bool &data)
399 {
400     LOGI("CJ_GetBoolean start");
401     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
402     if (!instance) {
403         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
404         return ERR_INVALID_INSTANCE_CODE;
405     }
406     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
407         .moduleName = std::string(resource.moduleName), .id = resource.id };
408     std::shared_ptr<ResourceManager> resMgr = nullptr;
409     int32_t resId = 0;
410     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
411         LOGE("ResourceManager CJ_GetBooleanByResource failed at GetHapResourceManager");
412         return RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
413     }
414     return resMgr->GetBooleanById(resId, data);
415 }
416 
CJ_GetBooleanByName(int64_t id,const char * name,bool & data)417 int32_t CJ_GetBooleanByName(int64_t id, const char* name, bool &data)
418 {
419     LOGI("CJ_GetBooleanByName start");
420     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
421     if (!instance) {
422         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
423         return ERR_INVALID_INSTANCE_CODE;
424     }
425     return instance->GetBooleanByName(name, data);
426 }
427 
CJ_GetNumber(int64_t id,uint32_t resId,RetGetNumber & data)428 int32_t CJ_GetNumber(int64_t id, uint32_t resId, RetGetNumber &data)
429 {
430     LOGI("CJ_GetNumber start");
431     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
432     if (!instance) {
433         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
434         return ERR_INVALID_INSTANCE_CODE;
435     }
436     data.isInt = true;
437     auto state = instance->GetIntegerById(resId, data.intValue);
438     if (state != SUCCESS_CODE) {
439         state = instance->GetFloatById(resId, data.floatValue);
440         data.isInt = false;
441     }
442     return state;
443 }
444 
CJ_GetNumberByResource(int64_t id,CResource resource,RetGetNumber & data)445 int32_t CJ_GetNumberByResource(int64_t id, CResource resource, RetGetNumber &data)
446 {
447     LOGI("CJ_GetNumber start");
448     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
449     if (!instance) {
450         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
451         return ERR_INVALID_INSTANCE_CODE;
452     }
453     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
454         .moduleName = std::string(resource.moduleName), .id = resource.id };
455     std::shared_ptr<ResourceManager> resMgr = nullptr;
456     int32_t resId = 0;
457     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
458         LOGE("ResourceManager CJ_GetNumberByResource failed at GetHapResourceManager");
459         return RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
460     }
461     data.isInt = true;
462     auto state = instance->GetIntegerById(resId, data.intValue);
463     if (state != SUCCESS_CODE) {
464         state = instance->GetFloatById(resId, data.floatValue);
465         data.isInt = false;
466     }
467     return state;
468 }
469 
CJ_GetNumberByName(int64_t id,const char * name,RetGetNumber & data)470 int32_t CJ_GetNumberByName(int64_t id, const char* name, RetGetNumber &data)
471 {
472     LOGI("CJ_GetNumberByName start");
473     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
474     if (!instance) {
475         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
476         return ERR_INVALID_INSTANCE_CODE;
477     }
478     data.isInt = true;
479     auto state = instance->GetIntegerByName(name, data.intValue);
480     if (state != SUCCESS_CODE) {
481         state = instance->GetFloatByName(name, data.floatValue);
482         data.isInt = false;
483     }
484     return state;
485 }
486 
CJ_GetConfiguration(int64_t id,OHOS::Resource::Configuration & cfg)487 int32_t CJ_GetConfiguration(int64_t id, OHOS::Resource::Configuration &cfg)
488 {
489     LOGI("CJ_GetConfiguration start");
490     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
491     if (!instance) {
492         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
493         return ERR_INVALID_INSTANCE_CODE;
494     }
495     instance->GetConfiguration(cfg);
496     return SUCCESS_CODE;
497 }
498 
CJ_GetDeviceCapability(int64_t id,OHOS::Resource::DeviceCapability & deviceCapability)499 int32_t CJ_GetDeviceCapability(int64_t id, OHOS::Resource::DeviceCapability &deviceCapability)
500 {
501     LOGI("CJ_GetDeviceCapability start");
502     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
503     if (!instance) {
504         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
505         return ERR_INVALID_INSTANCE_CODE;
506     }
507     instance->GetDeviceCapability(deviceCapability);
508     return SUCCESS_CODE;
509 }
510 
CJ_GetMediaByName(int64_t id,const char * resName,uint32_t density)511 RetDataCArrUI8 CJ_GetMediaByName(int64_t id, const char* resName, uint32_t density)
512 {
513     LOGI("CJ_GetMediaByName start");
514     RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
515     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
516     if (!instance) {
517         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
518         return ret;
519     }
520     size_t len = 0;
521     std::unique_ptr<uint8_t[]> data;
522     int32_t state = instance->GetMediaDataByName(resName, len, data, density);
523     ret.code = state;
524     if (state == SUCCESS_CODE) {
525         CopyUI8Arr(ret, data, len);
526     }
527     return ret;
528 }
529 
CJ_GetMediaContent(int64_t id,uint32_t resId,uint32_t density)530 RetDataCArrUI8 CJ_GetMediaContent(int64_t id, uint32_t resId, uint32_t density)
531 {
532     LOGI("CJ_GetMediaContent start");
533     RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
534     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
535     if (!instance) {
536         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
537         return ret;
538     }
539     size_t len = 0;
540     std::unique_ptr<uint8_t[]> data;
541     int32_t state = instance->GetMediaDataById(resId, len, data, density);
542     ret.code = state;
543     if (state == SUCCESS_CODE) {
544         CopyUI8Arr(ret, data, len);
545     }
546     return ret;
547 }
548 
CJ_GetMediaContentByResource(int64_t id,CResource resource,uint32_t density)549 RetDataCArrUI8 CJ_GetMediaContentByResource(int64_t id, CResource resource, uint32_t density)
550 {
551     LOGI("CJ_GetMediaContent start");
552     RetDataCArrUI8 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0} };
553     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
554     if (!instance) {
555         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
556         return ret;
557     }
558     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
559         .moduleName = std::string(resource.moduleName), .id = resource.id };
560     std::shared_ptr<ResourceManager> resMgr = nullptr;
561     int32_t resId = 0;
562     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
563         LOGE("ResourceManager CJ_GetMediaContentByResource failed at GetHapResourceManager");
564         ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
565         return ret;
566     }
567     size_t len = 0;
568     std::unique_ptr<uint8_t[]> data;
569     int32_t state = resMgr->GetMediaDataById(resId, len, data, density);
570     ret.code = state;
571     if (state == SUCCESS_CODE) {
572         CopyUI8Arr(ret, data, len);
573     }
574     return ret;
575 }
576 
CJ_GetMediaContentBase64(int64_t id,uint32_t resId,uint32_t density)577 RetDataCString CJ_GetMediaContentBase64(int64_t id, uint32_t resId, uint32_t density)
578 {
579     LOGI("CJ_GetMediaContentBase64 start");
580     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
581     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
582     if (!instance) {
583         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
584         return ret;
585     }
586     std::string value;
587     ret.code = instance->GetMediaContentBase64ById(resId, value, density);
588     if (ret.code != RState::SUCCESS) {
589         return ret;
590     }
591     ret.data = ::Utils::MallocCString(value);
592     return ret;
593 }
594 
CJ_GetMediaContentBase64ByResource(int64_t id,CResource resource,uint32_t density)595 RetDataCString CJ_GetMediaContentBase64ByResource(int64_t id, CResource resource, uint32_t density)
596 {
597     LOGI("CJ_GetMediaContentBase64ByResource start");
598     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
599     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
600     if (!instance) {
601         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
602         return ret;
603     }
604     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
605         .moduleName = std::string(resource.moduleName), .id = resource.id };
606     std::shared_ptr<ResourceManager> resMgr = nullptr;
607     int32_t resId = 0;
608     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
609         LOGE("ResourceManager CJ_GetMediaContentBase64ByResource failed at GetHapResourceManager");
610         ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
611         return ret;
612     }
613     std::string value;
614     ret.code = resMgr->GetMediaBase64DataById(resId, value, density);
615     if (ret.code != RState::SUCCESS) {
616         return ret;
617     }
618     ret.data = ::Utils::MallocCString(value);
619     return ret;
620 }
621 
CJ_GetMediaContentBase64ByName(int64_t id,const char * resName,uint32_t density)622 RetDataCString CJ_GetMediaContentBase64ByName(int64_t id, const char* resName, uint32_t density)
623 {
624     LOGI("CJ_GetMediaContentBase64 start");
625     RetDataCString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = nullptr };
626     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
627     if (!instance) {
628         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
629         return ret;
630     }
631     std::string value;
632     ret.code = instance->GetMediaContentBase64ByName(resName, value, density);
633     if (ret.code != RState::SUCCESS) {
634         return ret;
635     }
636     ret.data = ::Utils::MallocCString(value);
637     return ret;
638 }
639 
CJ_GetDrawableDescriptor(int64_t id,uint32_t resId,uint32_t density)640 RetDataI64 CJ_GetDrawableDescriptor(int64_t id, uint32_t resId, uint32_t density)
641 {
642     LOGI("CJ_GetDrawableDescriptor start");
643     RetDataI64 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
644     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
645     if (!instance) {
646         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
647         return ret;
648     }
649     ret.code = instance->GetDrawableDescriptor(resId, ret.data, density);
650     if (ret.code != RState::SUCCESS) {
651         return ret;
652     }
653     return ret;
654 }
655 
CJ_GetDrawableDescriptorByResource(int64_t id,CResource resource,uint32_t density)656 RetDataI64 CJ_GetDrawableDescriptorByResource(int64_t id, CResource resource, uint32_t density)
657 {
658     LOGI("CJ_GetDrawableDescriptor start");
659     RetDataI64 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
660     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
661     if (!instance) {
662         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
663         return ret;
664     }
665     OHOS::Global::Resource::ResourceManager::Resource res = { .bundleName = std::string(resource.bundleName),
666         .moduleName = std::string(resource.moduleName), .id = resource.id };
667     std::shared_ptr<ResourceManager> resMgr = nullptr;
668     int32_t resId = 0;
669     if (!instance->GetHapResourceManager(res, resMgr, resId)) {
670         LOGE("ResourceManager CJ_GetDrawableDescriptorByResource failed at GetHapResourceManager");
671         ret.code = RState::ERROR_CODE_RES_NOT_FOUND_BY_ID;
672         return ret;
673     }
674     RState state;
675     auto drawableDescriptor = OHOS::Resource::GetDrawableDescriptorPtr(resId, resMgr, density, state);
676     ret.code = state;
677     if (ret.code != SUCCESS) {
678         LOGE("Failed to Create drawableDescriptor by %{public}" PRIu32, resId);
679         return ret;
680     }
681     auto ptr = FFIData::Create<DrawableDescriptorImpl>(drawableDescriptor);
682     if (!ptr) {
683         ret.code = ERR_INVALID_INSTANCE_CODE;
684         return ret;
685     }
686     ret.data = ptr->GetID();
687     return ret;
688 }
689 
CJ_GetDrawableDescriptorByName(int64_t id,const char * resName,uint32_t density)690 RetDataI64 CJ_GetDrawableDescriptorByName(int64_t id, const char* resName, uint32_t density)
691 {
692     LOGI("CJ_GetDrawableDescriptorByName start");
693     RetDataI64 ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = -1 };
694     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
695     if (!instance) {
696         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
697         return ret;
698     }
699     ret.code = instance->GetDrawableDescriptorByName(resName, ret.data, density);
700     if (ret.code != RState::SUCCESS) {
701         return ret;
702     }
703     return ret;
704 }
705 
CJ_GetLocales(int64_t id,bool includeSystem)706 RetDataCArrString CJ_GetLocales(int64_t id, bool includeSystem)
707 {
708     LOGI("CJ_GetLocales start");
709     RetDataCArrString ret = { .code = ERR_INVALID_INSTANCE_CODE, .data = { .head = nullptr, .size = 0 } };
710     auto instance = FFIData::GetData<ResourceManagerImpl>(id);
711     if (!instance) {
712         LOGE("ResourceManager instance not exist %{public}" PRId64, id);
713         return ret;
714     }
715     std::vector<std::string> value;
716     instance->GetLocales(includeSystem, value);
717     ret.code = RState::SUCCESS;
718     ret.data = VectorToCArrString(value, ret.code);
719     return ret;
720 }
721 }
722 }
723 }