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 "ani_common_event_utils.h"
16
17 #include "ani_common_want.h"
18 #include "event_log_wrapper.h"
19
20 namespace OHOS {
21 namespace EventManagerFwkAni {
22
23 using namespace OHOS::EventFwk;
24 using namespace OHOS::AppExecFwk;
25 #define SETTER_METHOD_NAME(property) "<set>" #property
26
GetStdString(ani_env * env,ani_string str,std::string & result)27 void AniCommonEventUtils::GetStdString(ani_env* env, ani_string str, std::string& result)
28 {
29 auto ret = ANI_ERROR;
30 ani_size sz {};
31 ret = env->String_GetUTF8Size(str, &sz);
32 if (ret != ANI_OK) {
33 EVENT_LOGE("GetStdString String_GetUTF8Size error. result: %{public}d.", ret);
34 return;
35 }
36 result.resize(sz + 1);
37 ret = env->String_GetUTF8SubString(str, 0, sz, result.data(), result.size(), &sz);
38 if (ret != ANI_OK) {
39 EVENT_LOGE("GetStdString String_GetUTF8Size error. result: %{public}d.", ret);
40 return;
41 }
42 result.resize(sz);
43 }
44
GetAniString(ani_env * env,const std::string str,ani_string & aniStr)45 ani_status AniCommonEventUtils::GetAniString(ani_env* env, const std::string str, ani_string& aniStr)
46 {
47 if (env == nullptr) {
48 EVENT_LOGE("GetAniStringByString fail, env is nullptr");
49 return ANI_INVALID_ARGS;
50 }
51 ani_status status = env->String_NewUTF8(str.c_str(), str.size(), &aniStr);
52 if (status != ANI_OK) {
53 EVENT_LOGE("String_NewUTF8 failed %{public}d", status);
54 return status;
55 }
56 return status;
57 }
58
GetStdStringArrayClass(ani_env * env,ani_object arrayObj,std::vector<std::string> & strings)59 void AniCommonEventUtils::GetStdStringArrayClass(ani_env* env, ani_object arrayObj, std::vector<std::string>& strings)
60 {
61 ani_double length;
62 auto ret = ANI_ERROR;
63 ret = env->Object_GetPropertyByName_Double(arrayObj, "length", &length);
64 if (ret != ANI_OK) {
65 EVENT_LOGE("GetStdStringArrayClass Object_GetPropertyByName_Double error. result: %{public}d.", ret);
66 return;
67 }
68
69 for (ani_int i = 0; i < static_cast<ani_int>(length); i++) {
70 ani_ref stringEntryRef;
71 ret = env->Object_CallMethodByName_Ref(arrayObj, "$_get", "I:Lstd/core/Object;", &stringEntryRef, i);
72 if (ret != ANI_OK) {
73 EVENT_LOGE("GetStdStringArrayClass Object_CallMethodByName_Ref error. result: %{public}d.", ret);
74 return;
75 }
76
77 std::string itemStr;
78 GetStdString(env, static_cast<ani_string>(stringEntryRef), itemStr);
79 strings.emplace_back(itemStr);
80 }
81
82 for (const auto& s : strings) {
83 EVENT_LOGI("GetStdStringArrayClass Array String Content: %{public}s.", s.c_str());
84 }
85 }
86
GetStringOrUndefined(ani_env * env,ani_object param,const char * name,std::string & res)87 bool AniCommonEventUtils::GetStringOrUndefined(ani_env* env, ani_object param, const char* name, std::string& res)
88 {
89 ani_ref obj = nullptr;
90 ani_boolean isUndefined = true;
91 ani_status status = ANI_ERROR;
92
93 if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) {
94 EVENT_LOGE("status : %{public}d", status);
95 return false;
96 }
97 if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) {
98 EVENT_LOGE("status : %{public}d", status);
99 return false;
100 }
101 if (isUndefined) {
102 EVENT_LOGW("%{public}s : undefined", name);
103 return false;
104 }
105
106 ani_ref str = nullptr;
107 if ((status = env->Object_CallMethodByName_Ref(reinterpret_cast<ani_object>(obj), "toString", nullptr, &str)) !=
108 ANI_OK) {
109 EVENT_LOGE("status : %{public}d", status);
110 return false;
111 }
112
113 GetStdString(env, reinterpret_cast<ani_string>(str), res);
114 return true;
115 }
116
GetDoubleOrUndefined(ani_env * env,ani_object param,const char * name,int32_t & res)117 bool AniCommonEventUtils::GetDoubleOrUndefined(ani_env* env, ani_object param, const char* name, int32_t& res)
118 {
119 ani_ref obj = nullptr;
120 ani_boolean isUndefined = true;
121 ani_status status = ANI_ERROR;
122
123 if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) {
124 EVENT_LOGE("status : %{public}d", status);
125 return false;
126 }
127 if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) {
128 EVENT_LOGE("status : %{public}d", status);
129 return false;
130 }
131 if (isUndefined) {
132 EVENT_LOGW("%{public}s : undefined", name);
133 return false;
134 }
135
136 ani_double result = 0;
137 if ((status = env->Object_CallMethodByName_Double(reinterpret_cast<ani_object>(obj), "unboxed", nullptr, &result))
138 != ANI_OK) {
139 EVENT_LOGE("status : %{public}d", status);
140 return false;
141 }
142
143 res = static_cast<int32_t>(result);
144 return true;
145 }
146
GetIntOrUndefined(ani_env * env,ani_object param,const char * name,int32_t & res)147 bool AniCommonEventUtils::GetIntOrUndefined(ani_env* env, ani_object param, const char* name, int32_t& res)
148 {
149 ani_ref obj = nullptr;
150 ani_boolean isUndefined = true;
151 ani_status status = ANI_ERROR;
152
153 if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) {
154 EVENT_LOGE("status : %{public}d", status);
155 return false;
156 }
157 if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) {
158 EVENT_LOGE("status : %{public}d", status);
159 return false;
160 }
161 if (isUndefined) {
162 EVENT_LOGW("%{public}s : undefined", name);
163 return false;
164 }
165
166 ani_int result = 0;
167 if ((status = env->Object_CallMethodByName_Int(reinterpret_cast<ani_object>(obj), "unboxed", nullptr, &result)) !=
168 ANI_OK) {
169 EVENT_LOGE("status : %{public}d", status);
170 return false;
171 }
172
173 res = static_cast<int32_t>(result);
174 return true;
175 }
176
GetBooleanOrUndefined(ani_env * env,ani_object param,const char * name,bool & res)177 bool AniCommonEventUtils::GetBooleanOrUndefined(ani_env* env, ani_object param, const char* name, bool& res)
178 {
179 ani_ref obj = nullptr;
180 ani_boolean isUndefined = true;
181 ani_status status = ANI_ERROR;
182
183 if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) {
184 EVENT_LOGE("status : %{public}d", status);
185 return false;
186 }
187 if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) {
188 EVENT_LOGE("status : %{public}d", status);
189 return false;
190 }
191 if (isUndefined) {
192 EVENT_LOGW("%{public}s : undefined", name);
193 return false;
194 }
195
196 ani_boolean result = 0;
197 if ((status = env->Object_CallMethodByName_Boolean(
198 reinterpret_cast<ani_object>(obj), "unboxed", nullptr, &result)) != ANI_OK) {
199 EVENT_LOGE("status : %{public}d", status);
200 return false;
201 }
202
203 res = static_cast<bool>(result);
204 return true;
205 }
206
GetStringArrayOrUndefined(ani_env * env,ani_object param,const char * name,std::vector<std::string> & res)207 bool AniCommonEventUtils::GetStringArrayOrUndefined(
208 ani_env* env, ani_object param, const char* name, std::vector<std::string>& res)
209 {
210 ani_ref obj = nullptr;
211 ani_boolean isUndefined = true;
212 ani_status status = ANI_ERROR;
213
214 if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) {
215 EVENT_LOGE("status : %{public}d", status);
216 return false;
217 }
218 if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) {
219 EVENT_LOGE("status : %{public}d", status);
220 return false;
221 }
222 if (isUndefined) {
223 EVENT_LOGW("%{public}s : undefined", name);
224 return false;
225 }
226
227 GetStdStringArrayClass(env, static_cast<ani_object>(obj), res);
228 return true;
229 }
230
GetWantParamsOrUndefined(ani_env * env,ani_object param,const char * name,AAFwk::WantParams & wantParams)231 bool AniCommonEventUtils::GetWantParamsOrUndefined(
232 ani_env* env, ani_object param, const char* name, AAFwk::WantParams& wantParams)
233 {
234 ani_ref obj = nullptr;
235 ani_boolean isUndefined = true;
236 ani_status status = ANI_ERROR;
237 if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) {
238 EVENT_LOGE("status : %{public}d", status);
239 return false;
240 }
241 if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) {
242 EVENT_LOGE("status : %{public}d", status);
243 return false;
244 }
245 if (isUndefined) {
246 EVENT_LOGW("%{public}s : undefined", name);
247 return false;
248 }
249
250 if (!UnwrapWantParams(env, obj, wantParams)) {
251 EVENT_LOGE("GetWantParamsOrUndefined UnwrapWantParams error.");
252 return false;
253 }
254
255 return true;
256 }
257
ConvertCommonEventPublishData(ani_env * env,ani_object optionsObject,Want & want,CommonEventData & commonEventData,CommonEventPublishInfo & commonEventPublishInfo)258 void AniCommonEventUtils::ConvertCommonEventPublishData(ani_env* env, ani_object optionsObject, Want& want,
259 CommonEventData &commonEventData, CommonEventPublishInfo &commonEventPublishInfo)
260 {
261 // Get the code.
262 int32_t code;
263 if (GetDoubleOrUndefined(env, optionsObject, "code", code)) {
264 EVENT_LOGI("ConvertCommonEventPublishData code: %{public}d.", code);
265 commonEventData.SetCode(code);
266 } else {
267 EVENT_LOGI("ConvertCommonEventPublishData code not exit");
268 }
269
270 // Get the data.
271 std::string dataStr;
272 if (GetStringOrUndefined(env, optionsObject, "data", dataStr)) {
273 EVENT_LOGI("ConvertCommonEventPublishData data: %{public}s.", dataStr.c_str());
274 commonEventData.SetData(dataStr);
275 } else {
276 EVENT_LOGI("ConvertCommonEventPublishData data not exit");
277 }
278
279 // Get the isOrdered.
280 bool isOrdered;
281 if (GetBooleanOrUndefined(env, optionsObject, "isOrdered", isOrdered)) {
282 EVENT_LOGI("ConvertCommonEventPublishData isOrdered: %{public}d.", isOrdered);
283 commonEventPublishInfo.SetOrdered(isOrdered);
284 } else {
285 EVENT_LOGI("ConvertCommonEventPublishData isOrdered not exit");
286 }
287
288 // Get the isSticky.
289 bool isSticky;
290 if (GetBooleanOrUndefined(env, optionsObject, "isSticky", isSticky)) {
291 EVENT_LOGI("ConvertCommonEventPublishData isSticky: %{public}d.", isSticky);
292 commonEventPublishInfo.SetSticky(isSticky);
293 } else {
294 EVENT_LOGI("ConvertCommonEventPublishData isSticky not exit");
295 }
296
297 // Get the bundleName.
298 std::string bundleNameStr;
299 if (GetStringOrUndefined(env, optionsObject, "bundleName", bundleNameStr)) {
300 EVENT_LOGI("ConvertCommonEventPublishData bundleName: %{public}s.", bundleNameStr.c_str());
301 commonEventPublishInfo.SetBundleName(bundleNameStr);
302 } else {
303 EVENT_LOGI("ConvertCommonEventPublishData bundleName not exit");
304 }
305
306 // Get the subscriberPermissions.
307 std::vector<std::string> subscriberPermissionsStr;
308 if (GetStringArrayOrUndefined(env, optionsObject, "subscriberPermissions", subscriberPermissionsStr)) {
309 EVENT_LOGI("ConvertCommonEventPublishData subscriberPermissionsStr success.");
310 commonEventPublishInfo.SetSubscriberPermissions(subscriberPermissionsStr);
311 } else {
312 EVENT_LOGI("ConvertCommonEventPublishData bundleName not exit");
313 }
314
315 // Get the parameters [Record]
316 AAFwk::WantParams wantParams;
317 if (GetWantParamsOrUndefined(env, optionsObject, "parameters", wantParams)) {
318 EVENT_LOGI("ConvertCommonEventPublishData parameters success.");
319 want.SetParams(wantParams);
320 } else {
321 EVENT_LOGI("ConvertCommonEventPublishData parameters not exit");
322 }
323 }
324
ConvertCommonEventSubscribeInfo(ani_env * env,ani_object infoObject,CommonEventSubscribeInfo & subscribeInfo)325 void AniCommonEventUtils::ConvertCommonEventSubscribeInfo(
326 ani_env* env, ani_object infoObject, CommonEventSubscribeInfo& subscribeInfo)
327 {
328 // Get the events.
329 std::vector<std::string> eventsStr;
330 if (GetStringArrayOrUndefined(env, infoObject, "events", eventsStr)) {
331 EVENT_LOGI("ConvertCommonEventPublishData events success.");
332 } else {
333 EVENT_LOGI("ConvertCommonEventPublishData events not exit");
334 }
335
336 MatchingSkills matchingSkills;
337 for (const auto &event : eventsStr) {
338 matchingSkills.AddEvent(event);
339 }
340 CommonEventSubscribeInfo commonEventSubscribeInfo(matchingSkills);
341
342 // Get the publisherPermission.
343 std::string publisherPermissionStr;
344 if (GetStringOrUndefined(env, infoObject, "publisherPermission", publisherPermissionStr)) {
345 EVENT_LOGI("ConvertCommonEventSubscribeInfo publisherPermission: %{public}s.", publisherPermissionStr.c_str());
346 commonEventSubscribeInfo.SetPermission(publisherPermissionStr);
347 } else {
348 EVENT_LOGI("ConvertCommonEventSubscribeInfo publisherPermission not exit");
349 }
350
351 // Get the publisherDeviceId.
352 std::string publisherDeviceIdStr;
353 if (GetStringOrUndefined(env, infoObject, "publisherDeviceId", publisherDeviceIdStr)) {
354 EVENT_LOGI("ConvertCommonEventSubscribeInfo publisherDeviceId: %{public}s.", publisherDeviceIdStr.c_str());
355 commonEventSubscribeInfo.SetDeviceId(publisherDeviceIdStr);
356 } else {
357 EVENT_LOGI("ConvertCommonEventSubscribeInfo publisherDeviceId not exit");
358 }
359
360 // Get the publisherBundleName.
361 std::string publisherBundleNameStr;
362 if (GetStringOrUndefined(env, infoObject, "publisherBundleName", publisherBundleNameStr)) {
363 EVENT_LOGI("ConvertCommonEventSubscribeInfo publisherBundleName: %{public}s.", publisherBundleNameStr.c_str());
364 commonEventSubscribeInfo.SetPublisherBundleName(publisherBundleNameStr);
365 } else {
366 EVENT_LOGI("ConvertCommonEventSubscribeInfo publisherBundleName not exit");
367 }
368
369 // Get the userId.
370 int32_t userId;
371 if (GetDoubleOrUndefined(env, infoObject, "userId", userId)) {
372 EVENT_LOGI("ConvertCommonEventPublishData userId: %{public}d.", userId);
373 commonEventSubscribeInfo.SetUserId(userId);
374 } else {
375 EVENT_LOGI("ConvertCommonEventPublishData userId not exit");
376 }
377
378 // Get the priority.
379 int32_t priority;
380 if (GetDoubleOrUndefined(env, infoObject, "priority", priority)) {
381 EVENT_LOGI("ConvertCommonEventPublishData priority: %{public}d.", priority);
382 commonEventSubscribeInfo.SetPriority(priority);
383 } else {
384 EVENT_LOGI("ConvertCommonEventPublishData priority not exit");
385 }
386
387 subscribeInfo = commonEventSubscribeInfo;
388 }
389
GetCommonEventSubscribeInfoToEts(ani_env * env,std::shared_ptr<SubscriberInstance> subscriber,ani_object & infoObject)390 void AniCommonEventUtils::GetCommonEventSubscribeInfoToEts(
391 ani_env* env, std::shared_ptr<SubscriberInstance> subscriber, ani_object &infoObject)
392 {
393 ani_class cls = nullptr;
394 ani_status status = ANI_ERROR;
395 CreateNewObjectByClass(env, "LcommonEvent/commonEventSubscribeInfo/CommonEventSubscribeInfoImpl;", cls, infoObject);
396 if ((infoObject == nullptr) || (cls == nullptr)) {
397 EVENT_LOGE("CommonEventSubscribeInfoToAni infoObject or cls is null.");
398 return;
399 }
400 if (subscriber == nullptr) {
401 EVENT_LOGE("subscriber is null.");
402 return;
403 }
404
405 // set events [Array<string>]
406 ani_object eventsParamRef = GetAniStringArray(env, subscriber->GetSubscribeInfo().GetMatchingSkills().GetEvents());
407 CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(events), eventsParamRef);
408
409 ani_string string = nullptr;
410 // set publisherPermission [string]
411 status = env->String_NewUTF8(
412 subscriber->GetSubscribeInfo().GetPermission().c_str(),
413 subscriber->GetSubscribeInfo().GetPermission().size(), &string);
414 CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(publisherPermission), string);
415
416 // set publisherDeviceId [string]
417 status = env->String_NewUTF8(
418 subscriber->GetSubscribeInfo().GetDeviceId().c_str(),
419 subscriber->GetSubscribeInfo().GetDeviceId().size(), &string);
420 CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(publisherDeviceId), string);
421
422 // set publisherBundleName [string]
423 status = env->String_NewUTF8(
424 subscriber->GetSubscribeInfo().GetPublisherBundleName().c_str(),
425 subscriber->GetSubscribeInfo().GetPublisherBundleName().size(), &string);
426 CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(publisherBundleName), string);
427
428 // set userId [number]
429 ani_object userIdObject;
430 CreateAniDoubleObject(env, userIdObject, static_cast<ani_double>(subscriber->GetSubscribeInfo().GetUserId()));
431 CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(userId), userIdObject);
432
433 // set priority [number]
434 ani_object priorityObject;
435 CreateAniDoubleObject(env, priorityObject, static_cast<ani_double>(subscriber->GetSubscribeInfo().GetPriority()));
436 CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(priority), priorityObject);
437 }
438
GetAniStringArray(ani_env * env,std::vector<std::string> strs)439 ani_object AniCommonEventUtils::GetAniStringArray(ani_env *env, std::vector<std::string> strs)
440 {
441 if (env == nullptr) {
442 EVENT_LOGE("GetAniStringArray fail, env is nullptr or strs is empty");
443 return nullptr;
444 }
445 int length = strs.size();
446 ani_object arrayObj = newArrayClass(env, length);
447 if (arrayObj == nullptr) {
448 return nullptr;
449 }
450 ani_size i = 0;
451 for (auto &str : strs) {
452 EVENT_LOGI("GetAniStringArray: %{public}s", str.c_str());
453 ani_string aniStr;
454 if ((env->String_NewUTF8(str.c_str(), str.size(), &aniStr) != ANI_OK) || aniStr == nullptr) {
455 EVENT_LOGE("String_NewUTF8 faild");
456 return nullptr;
457 }
458 ani_status status = env->Object_CallMethodByName_Void(arrayObj, "$_set", "ILstd/core/Object;:V", i, aniStr);
459 if (status != ANI_OK) {
460 EVENT_LOGE("Object_CallMethodByName_Void failed %{public}d", status);
461 return nullptr;
462 }
463 i++;
464 }
465 return arrayObj;
466 }
467
newArrayClass(ani_env * env,int length)468 ani_object AniCommonEventUtils::newArrayClass(ani_env *env, int length)
469 {
470 EVENT_LOGD("newArrayClass call");
471 if (env == nullptr || length < 0) {
472 EVENT_LOGE("CreateDouble fail, env is nullptr or length is less than zero");
473 return nullptr;
474 }
475 ani_class arrayCls = nullptr;
476 if (ANI_OK != env->FindClass("Lescompat/Array;", &arrayCls)) {
477 EVENT_LOGE("FindClass Lescompat/Array; Failed");
478 return nullptr;
479 }
480 ani_method arrayCtor;
481 if (ANI_OK != env->Class_FindMethod(arrayCls, "<ctor>", "I:V", &arrayCtor)) {
482 EVENT_LOGE("Class_FindMethod <ctor> Failed");
483 return nullptr;
484 }
485 ani_object arrayObj = nullptr;
486 if (ANI_OK != env->Object_New(arrayCls, arrayCtor, &arrayObj, length)) {
487 EVENT_LOGE("Object_New Array Faild");
488 return nullptr;
489 }
490 EVENT_LOGD("newArrayClass end");
491 return arrayObj;
492 }
493
CreateNewObjectByClass(ani_env * env,const char * className,ani_class & cls,ani_object & ani_data)494 void AniCommonEventUtils::CreateNewObjectByClass(
495 ani_env* env, const char* className, ani_class& cls, ani_object& ani_data)
496 {
497 auto aniResult = ANI_ERROR;
498 ani_method ctor = nullptr;
499 aniResult = env->FindClass(className, &cls);
500 if (aniResult != ANI_OK) {
501 EVENT_LOGE("CreateNewObjectByClass findClass error. result: %{public}d.", aniResult);
502 return;
503 }
504 if (cls == nullptr) {
505 EVENT_LOGE("CreateNewObjectByClass cls is null.");
506 return;
507 }
508 aniResult = env->Class_FindMethod(cls, "<ctor>", ":V", &ctor);
509 if (aniResult != ANI_OK) {
510 EVENT_LOGE("CreateNewObjectByClass Class_FindMethod error. result: %{public}d.", aniResult);
511 return;
512 }
513 aniResult = env->Object_New(cls, ctor, &ani_data);
514 if (aniResult != ANI_OK) {
515 EVENT_LOGE("CreateNewObjectByClass Object_New error. result: %{public}d.", aniResult);
516 }
517 return;
518 }
519
CreateBusinessErrorObject(ani_env * env,ani_object & object,int32_t code,const std::string & message)520 void AniCommonEventUtils::CreateBusinessErrorObject(
521 ani_env* env, ani_object& object, int32_t code, const std::string& message)
522 {
523 EVENT_LOGI("CreateBusinessErrorObject called.");
524 ani_status aniResult = ANI_ERROR;
525 ani_class cls;
526 ani_method ctor = nullptr;
527 if (env == nullptr) {
528 EVENT_LOGE("CreateBusinessErrorObject env is null.");
529 return;
530 }
531
532 aniResult = env->FindClass("L@ohos/base/BusinessError;", &cls);
533 if (aniResult != ANI_OK) {
534 EVENT_LOGE("CreateBusinessErrorObject findClass error. result: %{public}d.", aniResult);
535 return;
536 }
537 if (cls == nullptr) {
538 EVENT_LOGE("CreateBusinessErrorObject cls is null.");
539 return;
540 }
541 aniResult = env->Class_FindMethod(cls, "<ctor>", ":V", &ctor);
542 if (aniResult != ANI_OK) {
543 EVENT_LOGE("CreateBusinessErrorObject Class_FindMethod error. result: %{public}d.", aniResult);
544 return;
545 }
546 aniResult = env->Object_New(cls, ctor, &object);
547 if (aniResult != ANI_OK) {
548 EVENT_LOGE("CreateBusinessErrorObject Object_New error. result: %{public}d.", aniResult);
549 }
550
551 ani_string string = nullptr;
552 env->String_NewUTF8(message.c_str(), message.size(), &string);
553 aniResult = env->Object_SetFieldByName_Double(object, "code", ani_double(code));
554 aniResult = env->Object_SetFieldByName_Ref(object, "data", string);
555 }
556
557 template<typename valueType>
CallSetter(ani_env * env,ani_class cls,ani_object object,const char * setterName,valueType value)558 void AniCommonEventUtils::CallSetter(
559 ani_env* env, ani_class cls, ani_object object, const char* setterName, valueType value)
560 {
561 ani_status aniResult = ANI_ERROR;
562 ani_method setter;
563 aniResult = env->Class_FindMethod(cls, setterName, nullptr, &setter);
564 if (aniResult != ANI_OK) {
565 EVENT_LOGE("CallSetter Class_FindMethod error. result: %{public}d.", aniResult);
566 return;
567 }
568 aniResult = env->Object_CallMethod_Void(object, setter, value);
569 if (aniResult != ANI_OK) {
570 EVENT_LOGE("CallSetter Object_CallMethod_Void error. result: %{public}d.", aniResult);
571 }
572 return;
573 }
574
CreateAniDoubleObject(ani_env * env,ani_object & object,ani_double value)575 void AniCommonEventUtils::CreateAniDoubleObject(ani_env* env, ani_object &object, ani_double value)
576 {
577 ani_status aniResult = ANI_ERROR;
578 ani_class clsDouble = nullptr;
579 ani_method ctor;
580 aniResult = env->FindClass("Lstd/core/Double;", &clsDouble);
581 if (aniResult != ANI_OK) {
582 EVENT_LOGE("CreateAniDoubleObject FindClass error. result: %{public}d.", aniResult);
583 return;
584 }
585 aniResult = env->Class_FindMethod(clsDouble, "<ctor>", "D:V", &ctor);
586 if (aniResult != ANI_OK) {
587 EVENT_LOGE("CreateAniDoubleObject Class_FindMethod error. result: %{public}d.", aniResult);
588 return;
589 }
590 aniResult = env->Object_New(clsDouble, ctor, &object, value);
591 if (aniResult != ANI_OK) {
592 EVENT_LOGE("CreateAniDoubleObject Object_New error. result: %{public}d.", aniResult);
593 return;
594 }
595 }
596
ConvertCommonEventDataToEts(ani_env * env,ani_object & ani_data,const CommonEventData & commonEventData)597 void AniCommonEventUtils::ConvertCommonEventDataToEts(
598 ani_env* env, ani_object& ani_data, const CommonEventData& commonEventData)
599 {
600 EVENT_LOGI("ConvertCommonEventDataToEts called");
601
602 ani_class cls = nullptr;
603 CreateNewObjectByClass(env, "LcommonEvent/commonEventData/CommonEventDataImpl;", cls, ani_data);
604 if ((ani_data == nullptr) || (cls == nullptr)) {
605 EVENT_LOGE("ConvertCommonEventDataToEts ani_data or cls is null.");
606 return;
607 }
608
609 ani_string string = nullptr;
610 // set event [string]
611 env->String_NewUTF8(
612 commonEventData.GetWant().GetAction().c_str(), commonEventData.GetWant().GetAction().size(), &string);
613 CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(event), string);
614
615 // set bundleName [string]
616 env->String_NewUTF8(
617 commonEventData.GetWant().GetBundle().c_str(), commonEventData.GetWant().GetBundle().size(), &string);
618 CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(bundleName), string);
619
620 // set data [string]
621 env->String_NewUTF8(commonEventData.GetData().c_str(), commonEventData.GetData().size(), &string);
622 CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(data), string);
623
624 // set code [number]
625 ani_object codeObject;
626 CreateAniDoubleObject(env, codeObject, static_cast<ani_double>(commonEventData.GetCode()));
627 CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(code), codeObject);
628
629 // set parameters [Record]
630 ani_ref wantParamRef = WrapWantParams(env, commonEventData.GetWant().GetParams());
631 CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(parameters), wantParamRef);
632 }
633
634 } // namespace EventManagerFwkAni
635 } // namespace OHOS