1 /*
2 * Copyright (c) 2025 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 #include "print_base_ani_util.h"
16 #include "print_log.h"
17
18 namespace OHOS::Print {
19
CreateInt(ani_env * env,ani_int value)20 ani_object CreateInt(ani_env *env, ani_int value)
21 {
22 ani_class cls;
23 ani_status status = ANI_ERROR;
24 if ((status = env->FindClass("std.core.Int", &cls)) != ANI_OK) {
25 PRINT_HILOGE("FindClass status : %{public}d", status);
26 return nullptr;
27 }
28 ani_method ctor;
29 if ((status = env->Class_FindMethod(cls, "<ctor>", "i:", &ctor)) != ANI_OK) {
30 PRINT_HILOGE("Class_FindMethod status : %{public}d", status);
31 return nullptr;
32 }
33 ani_object object;
34 if ((status = env->Object_New(cls, ctor, &object, value)) != ANI_OK) {
35 PRINT_HILOGE("Object_New status : %{public}d", status);
36 return nullptr;
37 }
38 return object;
39 }
40
CreateBoolean(ani_env * env,ani_boolean value)41 ani_object CreateBoolean(ani_env *env, ani_boolean value)
42 {
43 if (env == nullptr) {
44 PRINT_HILOGE("null env");
45 return nullptr;
46 }
47 ani_status status = ANI_ERROR;
48 ani_class cls = nullptr;
49 if ((status = env->FindClass("std.core.Boolean", &cls)) != ANI_OK) {
50 PRINT_HILOGE("status: %{public}d", status);
51 return nullptr;
52 }
53 ani_method ctor = nullptr;
54 if ((status = env->Class_FindMethod(cls, "<ctor>", "z:", &ctor)) != ANI_OK) {
55 PRINT_HILOGE("status: %{public}d", status);
56 return nullptr;
57 }
58 ani_object obj = nullptr;
59 if ((status = env->Object_New(cls, ctor, &obj, value)) != ANI_OK) {
60 PRINT_HILOGE("status: %{public}d", status);
61 return nullptr;
62 }
63 return obj;
64 }
65
CreateAniString(ani_env * env,const std::string & str)66 ani_string CreateAniString(ani_env *env, const std::string &str)
67 {
68 if (env == nullptr) {
69 PRINT_HILOGE("env is nullptr");
70 return nullptr;
71 }
72 ani_string aniStr = nullptr;
73 ani_status status = env->String_NewUTF8(str.c_str(), str.size(), &aniStr);
74 if (status != ANI_OK) {
75 PRINT_HILOGE("status : %{public}d", status);
76 return nullptr;
77 }
78 return aniStr;
79 }
80
CreateAniStringArray(ani_env * env,const std::vector<std::string> & strs)81 ani_object CreateAniStringArray(ani_env *env, const std::vector<std::string>& strs)
82 {
83 if (env == nullptr) {
84 PRINT_HILOGE("env is nullptr");
85 return nullptr;
86 }
87 ani_object arrayObj = nullptr;
88 ani_class arrayCls = nullptr;
89 ani_method arrayCtor;
90 ani_string aniStr = nullptr;
91 ani_status status = ANI_ERROR;
92 constexpr const char *classArray = "escompat.Array";
93 status = env->FindClass(classArray, &arrayCls);
94 if (status != ANI_OK) {
95 PRINT_HILOGE("status : %{public}d", status);
96 return nullptr;
97 }
98 status = env->Class_FindMethod(arrayCls, "<ctor>", "i:", &arrayCtor);
99 if (status != ANI_OK) {
100 PRINT_HILOGE("status : %{public}d", status);
101 return nullptr;
102 }
103 status = env->Object_New(arrayCls, arrayCtor, &arrayObj, strs.size());
104 if (status != ANI_OK) {
105 PRINT_HILOGE("status : %{public}d", status);
106 return nullptr;
107 }
108 for (size_t i = 0; i < strs.size(); i++) {
109 aniStr = nullptr;
110 status = env->String_NewUTF8(strs[i].c_str(), strs[i].size(), &aniStr);
111 if (aniStr == nullptr) {
112 PRINT_HILOGE("null aniStr");
113 return nullptr;
114 }
115 if (status != ANI_OK) {
116 PRINT_HILOGE("status : %{public}d", status);
117 return nullptr;
118 }
119 constexpr const char *SET_OBJECT_VOID_SIGNATURE = "iC{std.core.Object}:";
120 status = env->Object_CallMethodByName_Void(arrayObj, "$_set", SET_OBJECT_VOID_SIGNATURE, i, aniStr);
121 if (status != ANI_OK) {
122 PRINT_HILOGE("status : %{public}d", status);
123 return nullptr;
124 }
125 }
126 return arrayObj;
127 }
128
129
CreateEnumByIndex(ani_env * env,const std::string & enumDescriptor,ani_size enumIndex)130 ani_enum_item CreateEnumByIndex(ani_env *env, const std::string &enumDescriptor, ani_size enumIndex)
131 {
132 if (env == nullptr) {
133 PRINT_HILOGE("env is nullptr");
134 return nullptr;
135 }
136 ani_enum enumType;
137 if (ANI_OK != env->FindEnum(enumDescriptor.c_str(), &enumType)) {
138 PRINT_HILOGE("Find Enum Faild");
139 return nullptr;
140 }
141
142 ani_enum_item enumItem;
143 if (ANI_OK != env->Enum_GetEnumItemByIndex(enumType, enumIndex, &enumItem)) {
144 PRINT_HILOGE("Enum_GetEnumItemByIndex FAILD");
145 return nullptr;
146 }
147 return enumItem;
148 }
149
CreateEnumArray(ani_env * env,const std::string & enumDescriptor,std::vector<uint32_t> enumIndexArray)150 ani_object CreateEnumArray(ani_env *env, const std::string &enumDescriptor, std::vector<uint32_t> enumIndexArray)
151 {
152 if (env == nullptr) {
153 PRINT_HILOGE("env is nullptr");
154 return nullptr;
155 }
156 ani_class arrayCls = nullptr;
157 ani_status status = env->FindClass("escompat.Array", &arrayCls);
158 if (status != ANI_OK) {
159 PRINT_HILOGE("[ANI] find class fail");
160 return nullptr;
161 }
162 ani_method arrayCtor = nullptr;
163 status = env->Class_FindMethod(arrayCls, "<ctor>", "i:", &arrayCtor);
164 if (status != ANI_OK) {
165 PRINT_HILOGE("[ANI] Class_FindMethod Failed");
166 return nullptr;
167 }
168 ani_size length = enumIndexArray.size();
169 ani_object arrayObj = nullptr;
170 status = env->Object_New(arrayCls, arrayCtor, &arrayObj, length);
171 if (status != ANI_OK) {
172 PRINT_HILOGE("Object_New failed %{public}d", status);
173 return nullptr;
174 }
175
176 for (size_t i = 0; i < enumIndexArray.size(); i++) {
177 ani_enum_item item = CreateEnumByIndex(env, enumDescriptor, enumIndexArray[i]);
178 if (ANI_OK != env->Object_CallMethodByName_Void(arrayObj, "$_set", "iC{std.core.Object}:", i, item)) {
179 PRINT_HILOGE("Set Array item Failed");
180 return nullptr;
181 }
182 }
183 return arrayObj;
184 }
185
CreateObject(ani_env * env,const char * signature,const char * className)186 ani_object CreateObject(ani_env *env, const char *signature, const char* className)
187 {
188 if (env == nullptr) {
189 PRINT_HILOGE("env is nullptr");
190 return nullptr;
191 }
192 ani_object obj = {};
193 ani_class cls {};
194 if (ANI_OK != env->FindClass(className, &cls)) {
195 PRINT_HILOGE("[ANI] find class fail");
196 return nullptr;
197 }
198
199 ani_method ctor;
200 if (ANI_OK != env->Class_FindMethod(cls, "<ctor>", signature, &ctor)) {
201 PRINT_HILOGE("[ANI] find method fail");
202 return nullptr;
203 }
204
205 if (ANI_OK != env->Object_New(cls, ctor, &obj)) {
206 PRINT_HILOGE("Create Object Failed");
207 return nullptr;
208 }
209 return obj;
210 }
211
GetStdString(ani_env * env,ani_string str,std::string & res)212 bool GetStdString(ani_env *env, ani_string str, std::string &res)
213 {
214 if (env == nullptr) {
215 PRINT_HILOGE("env is nullptr");
216 return false;
217 }
218 ani_size sz {};
219 ani_status status = ANI_ERROR;
220 if ((status = env->String_GetUTF8Size(str, &sz)) != ANI_OK) {
221 PRINT_HILOGE("status : %{public}d", status);
222 return false;
223 }
224 res.resize(sz + 1);
225 if ((status = env->String_GetUTF8SubString(str, 0, sz, res.data(), res.size(), &sz)) != ANI_OK) {
226 PRINT_HILOGE("status : %{public}d", status);
227 return false;
228 }
229 res.resize(sz);
230 return true;
231 }
232
GetStdStringArray(ani_env * env,ani_object param,std::vector<std::string> & res)233 bool GetStdStringArray(ani_env *env, ani_object param, std::vector<std::string> &res)
234 {
235 if (env == nullptr) {
236 PRINT_HILOGE("env is nullptr");
237 return false;
238 }
239 ani_double length = 0.0;
240 ani_status status = ANI_ERROR;
241 status = env->Object_GetPropertyByName_Double(param, "length", &length);
242 if (status != ANI_OK) {
243 PRINT_HILOGE("Object_GetPropertyByName_Double fail, status = %{public}u", status);
244 return false;
245 }
246 for (int32_t i = 0; i < static_cast<int32_t>(length); i++) {
247 ani_ref stringEntryRef = nullptr;
248 status = env->Object_CallMethodByName_Ref(param, "$_get",
249 "I:Lstd/core/Object;", &stringEntryRef, i);
250 if (status != ANI_OK) {
251 PRINT_HILOGE("Object_CallMethodByName_Ref fail, status = %{public}u", status);
252 return false;
253 }
254 std::string file;
255 if (!GetStdString(env, static_cast<ani_string>(stringEntryRef), file)) {
256 PRINT_HILOGE("GetStdString fail");
257 return false;
258 }
259 res.emplace_back(file);
260 }
261 return true;
262 }
263
GetEnumValueInt(ani_env * env,ani_enum_item enumObj,uint32_t & enumValue)264 bool GetEnumValueInt(ani_env *env, ani_enum_item enumObj, uint32_t& enumValue)
265 {
266 if (env == nullptr) {
267 PRINT_HILOGE("env is nullptr");
268 return false;
269 }
270 ani_int result = 0;
271 env->EnumItem_GetValue_Int(enumObj, &result);
272 enumValue = result;
273 return true;
274 }
275 } // namespace OHOS::Print