diff --git a/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets b/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets index a6d2cf1d5031dd6fa9f9c429d74cb757dd33028e..d0f184777de34b2bd165b4789b19ce1f060a770a 100644 --- a/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets +++ b/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets @@ -23,63 +23,83 @@ import{ CommonEventSubscriber } from 'commonEvent.commonEventSubscriber'; const TAG: string = 'commonEventManager'; namespace commonEventManager { loadLibrary("ani_commoneventmanager.z"); - export native function publishExecute(event: string):int; - export native function publishWithOptionsExecute(event: string, options: CommonEventPublishData):int; - export native function createSubscriberExecute(subscribeInfo: CommonEventSubscribeInfo):CommonEventSubscriber; + export native function publishExecute(event: string):ResultDate; + export native function publishWithOptionsExecute(event: string, options: CommonEventPublishData):ResultDate; + export native function createSubscriberExecute(subscribeInfo: CommonEventSubscribeInfo):ResultDate; export native function subscribeExecute(subscriber: CommonEventSubscriber, - callback: AsyncCallback):int; - export native function unsubscribeExecute(subscriber: CommonEventSubscriber):int; + callback: AsyncCallback):ResultDate; + export native function unsubscribeExecute(subscriber: CommonEventSubscriber):ResultDate; - export function publish(event: string, callback: AsyncCallback): void { + export function publish(event: string, callback: AsyncCallback): void { hilog.info(0x0000, TAG, 'publish called event: %{public}s', event); - let task = taskpool.execute(commonEventManager.publishExecute, event); - task.then((e: NullishType)=>{ - let resultCode: Int = e as Int; - hilog.info(0x0000, TAG, 'publish call result:%{public}d.', resultCode.intValue()); - let r: BusinessError = { code: resultCode.intValue(), data: undefined }; - callback(r, undefined); - }, (err:Object): void => { - hilog.error(0x0000, TAG, 'publish error.'); - }); + + + try { + let task = taskpool.execute(commonEventManager.publishExecute, event); + task.then((result: NullishType)=>{ + let resultDate: ResultDate = result as ResultDate; + hilog.info(0x0000, TAG, 'publish call result:%{public}s.', JSON.stringify(resultDate)); + let errorCode: Int = resultDate.code as Int; + let r: BusinessError = { code: errorCode.intValue(), message: resultDate.message }; + callback(r, undefined); + }); + // throw new Error("testError"); + + + } catch (error: BusinessError) { + // let err: BusinessError = error as BusinessError; + // hilog.info(0x0000, TAG, 'publish catch. err.code: %{public}d', error.code); + + hilog.info(0x0000, TAG, 'publish catch.'); + hilog.info(0x0000, TAG, 'publish catch. err.message: ' + error.message); + throw error; + } + } - export function publish(event: string, options: CommonEventPublishData, callback: AsyncCallback): void { + export function publish(event: string, options: CommonEventPublishData, callback: AsyncCallback): void { hilog.info(0x0000, TAG, 'publish with option call.'); let task = taskpool.execute(commonEventManager.publishWithOptionsExecute, event, options); - task.then((e: NullishType)=>{ - let resultCode: Int = e as Int; - hilog.info(0x0000, TAG, 'publish with option result:%{public}d.', resultCode.intValue()); - let r: BusinessError = { code: resultCode.intValue(), data: undefined }; + task.then((result: NullishType)=>{ + let resultDate: ResultDate = result as ResultDate; + hilog.info(0x0000, TAG, 'publish with option result:%{public}s.', JSON.stringify(resultDate)); + let errorCode: Int = resultDate.code as Int; + let r: BusinessError = { code: errorCode.intValue(), message: resultDate.message }; callback(r, undefined); - }, (err:Object): void => { - hilog.error(0x0000, TAG, 'publish with option error.'); }); } export function createSubscriber(subscribeInfo: CommonEventSubscribeInfo, - callback: AsyncCallback): void { + callback: AsyncCallback): void { hilog.info(0x0000, TAG, 'createSubscriber callback call.'); let task = taskpool.execute(commonEventManager.createSubscriberExecute, subscribeInfo); - task.then((e: NullishType)=>{ - let result: CommonEventSubscriber = e as CommonEventSubscriber; - hilog.info(0x0000, TAG, 'createSubscriber result.'); - let r: BusinessError = { code: 0, data: undefined }; - callback(r, result); - }, (err:Object): void => { - hilog.error(0x0000, TAG, 'createSubscriber error.'); + task.then((result: NullishType)=>{ + let resultDate: ResultDate = result as ResultDate; + hilog.info(0x0000, TAG, 'createSubscriber result:%{public}s.', JSON.stringify(resultDate)); + let subscriber: CommonEventSubscriber = resultDate.data as CommonEventSubscriber; + let errorCode: Int = resultDate.code as Int; + let r: BusinessError = { code: errorCode.intValue(), message: resultDate.message }; + callback(r, subscriber); }); } export function createSubscriber(subscribeInfo: CommonEventSubscribeInfo):Promise { hilog.info(0x0000, TAG, 'createSubscriber Promise call'); - let p = new Promise((resolve: (v: CommonEventSubscriber) => void) => { + let p = new Promise((resolve: (v: CommonEventSubscriber) => void, + reject: (error: Object) => void) => { let p1 = taskpool.execute(commonEventManager.createSubscriberExecute, subscribeInfo); - p1.then((e :NullishType)=>{ + p1.then((result :NullishType)=>{ hilog.info(0x0000, TAG, 'createSubscriber Promise result.'); - let result: CommonEventSubscriber = e as CommonEventSubscriber; - resolve(result); - }, (err: Error): void => { - hilog.error(0x0000, TAG, 'createSubscriber Promise error'); + let resultDate: ResultDate = result as ResultDate; + hilog.info(0x0000, TAG, 'createSubscriber result:%{public}s.', JSON.stringify(resultDate)); + let errorCode: Int = resultDate.code as Int; + if (errorCode != 0) { + let r: BusinessError = { code: errorCode.intValue(), message: resultDate.message }; + reject(r); + } else { + let subscriber: CommonEventSubscriber = resultDate.data as CommonEventSubscriber; + resolve(subscriber); + } }); }); return p; @@ -87,37 +107,36 @@ namespace commonEventManager { export function createSubscriberSync(subscribeInfo: CommonEventSubscribeInfo): CommonEventSubscriber{ hilog.info(0x0000, TAG, 'createSubscriberSync call'); - return commonEventManager.createSubscriberExecute(subscribeInfo); + let resultDate: ResultDate = commonEventManager.createSubscriberExecute(subscribeInfo); + return resultDate.data as CommonEventSubscriber; } - export function subscribe(subscriber: CommonEventSubscriber, callback: AsyncCallback): void { + export function subscribe(subscriber: CommonEventSubscriber, callback: AsyncCallback): void { hilog.info(0x0000, TAG, 'subscribe call.'); let task = taskpool.execute(commonEventManager.subscribeExecute, subscriber, callback); - task.then((e: NullishType)=>{ - let resultCode: Int = e as Int; - hilog.info(0x0000, TAG, 'subscribe result:%{public}d.', resultCode.intValue()); - if (resultCode != 0) { - let a: CommonEventData; - let r: BusinessError = { code: resultCode.intValue(), data: undefined }; - callback(r, a); + task.then((result: NullishType)=>{ + let resultDate: ResultDate = result as ResultDate; + hilog.info(0x0000, TAG, 'subscribe result:%{public}s.', JSON.stringify(resultDate)); + let errorCode: Int = resultDate.code as Int; + if (errorCode != 0) { + let r: BusinessError = { code: errorCode.intValue(), message: resultDate.message }; + let data: CommonEventData; + callback(r, data); } - }, (err:Object): void => { - hilog.error(0x0000, TAG, 'subscribe error'); }); } - export function unsubscribe(subscriber: CommonEventSubscriber, callback?: AsyncCallback): void { + export function unsubscribe(subscriber: CommonEventSubscriber, callback?: AsyncCallback): void { hilog.info(0x0000, TAG, 'unsubscribe call.'); let task = taskpool.execute(commonEventManager.unsubscribeExecute, subscriber); - task.then((e: NullishType)=>{ - let resultCode: Int = e as Int; - hilog.info(0x0000, TAG, 'unsubscribe result:%{public}d.', resultCode.intValue()); - let r: BusinessError = { code: resultCode.intValue(), data: undefined }; + task.then((result: NullishType)=>{ + let resultDate: ResultDate = result as ResultDate; + hilog.info(0x0000, TAG, 'unsubscribe result:%{public}s.', JSON.stringify(resultDate)); if (callback != undefined) { + let errorCode: Int = resultDate.code as Int; + let r: BusinessError = { code: errorCode.intValue(), message: resultDate.message }; callback(r, undefined); } - }, (err:Object): void => { - hilog.error(0x0000, TAG, 'unsubscribe error'); }); } @@ -134,6 +153,20 @@ namespace commonEventManager { COMMON_EVENT_TIMEZONE_CHANGED = 'usual.event.TIMEZONE_CHANGED' } + class ResultDate { + constructor( + code: number, + message: string + ) { + this.code = code; + this.message = message; + this.data = undefined; + } + public code: number; + public message: string; + public data?: Object | undefined; + } + } export default commonEventManager; diff --git a/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets b/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets index fa4607b20371babb9a4c23656735067dbf2e17f9..0e0ec4aa3798e43ee3599a0f3f39f07a13fe4190 100644 --- a/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets +++ b/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets @@ -13,14 +13,44 @@ * limitations under the License. */ +class Cleaner { + private ptr: long = 0 + + constructor(ptr:long) { + this.ptr = ptr + } + native clean(): void +} + +function callback(cleaner: Cleaner): void { + cleaner.clean() +} +let destroyRegister = new FinalizationRegistry(callback) +let unregisterToken = new object() + export interface CommonEventSubscriber { - subscriberInstanceWrapper : long; getCodeSync(): number; } class CommonEventSubscriberInner implements CommonEventSubscriber { - public native subscriberInstanceWrapper : long = 0; + static {loadLibrary("ani_commoneventmanager.z")} + private subscriberInstanceWrapper: long = 0; + public getCodeSync(): number { return 2; } + + private cleaner: Cleaner | null = null; + + constructor(wrapper:long) { + if(this.subscriberInstanceWrapper == 0){ + this.subscriberInstanceWrapper = wrapper; + } + this.registerCleaner(this.subscriberInstanceWrapper) + } + + registerCleaner(ptr: long): void { + this.cleaner = new Cleaner(ptr) + destroyRegister.register(this, this.cleaner!, unregisterToken); + } } \ No newline at end of file diff --git a/interfaces/kits/ani/common_event/include/ani_common_event_utils.h b/interfaces/kits/ani/common_event/include/ani_common_event_utils.h index 0a4002e11f86368d567d21ff3ff34c939c6d60bf..1ba51b36a52b4a1d09bd7f9edd3bc1feb5e7b3a1 100644 --- a/interfaces/kits/ani/common_event/include/ani_common_event_utils.h +++ b/interfaces/kits/ani/common_event/include/ani_common_event_utils.h @@ -47,6 +47,8 @@ public: static void CallSetter(ani_env* env, ani_class cls, ani_object object, const char* setterName, valueType value); static void CreateAniDoubleObject(ani_env* env, ani_object &object, ani_double value); static void CreateBusinessErrorObject(ani_env* env, ani_object &object, int32_t code, const std::string &message); + static void CreateResultDateObject(ani_env* env, ani_object& object, int32_t code, ani_ref data = nullptr); + static void AniThrowError(ani_env* env, int32_t errCode, const std::string &msg = std::string()); }; } // namespace EventManagerFwkAni } // namespace OHOS diff --git a/interfaces/kits/ani/common_event/src/ani_common_event.cpp b/interfaces/kits/ani/common_event/src/ani_common_event.cpp index c4c038f1bd7ff2f1c8ede97d3fef1c7e4fc9cf0b..6225af1450e86445eca29c60fc7a65f42dff3a10 100644 --- a/interfaces/kits/ani/common_event/src/ani_common_event.cpp +++ b/interfaces/kits/ani/common_event/src/ani_common_event.cpp @@ -17,16 +17,22 @@ #include "ani_common_event_utils.h" #include "event_log_wrapper.h" + +#include "ces_inner_error_code.h" + namespace OHOS { namespace EventManagerFwkAni { using namespace OHOS::EventFwk; +using namespace OHOS::Notification; std::atomic_ullong SubscriberInstance::subscriberID_ = 0; static std::map, std::shared_ptr> subscriberInstances; static std::mutex subscriberInsMutex; +static const int8_t NO_ERROR = 0; +static const int8_t ERR_CES_FAILED = 1; -static uint32_t publishExecute(ani_env* env, ani_string eventId) +static ani_object publishExecute(ani_env* env, ani_string eventId) { EVENT_LOGI("publishExecute call."); std::string eventIdStr; @@ -37,12 +43,16 @@ static uint32_t publishExecute(ani_env* env, ani_string eventId) Want want; want.SetAction(eventIdStr); commonEventData.SetWant(want); + auto errorCode = CommonEventManager::NewPublishCommonEvent(commonEventData, commonEventPublishInfo); + EVENT_LOGI("publishExecute result: %{public}d.", errorCode); - return errorCode; + ani_object resultObj = nullptr; + AniCommonEventUtils::CreateResultDateObject(env, resultObj, errorCode); + return resultObj; } -static uint32_t publishWithOptionsExecute(ani_env* env, ani_string eventId, ani_object optionsObject) +static ani_object publishWithOptionsExecute(ani_env* env, ani_string eventId, ani_object optionsObject) { EVENT_LOGI("publishWithOptionsExecute call."); std::string eventIdStr; @@ -59,10 +69,12 @@ static uint32_t publishWithOptionsExecute(ani_env* env, ani_string eventId, ani_ env, optionsObject, want, commonEventData, commonEventPublishInfo); auto errorCode = CommonEventManager::NewPublishCommonEvent(commonEventData, commonEventPublishInfo); EVENT_LOGI("publishWithOptionsExecute result: %{public}d.", errorCode); - return errorCode; + ani_object resultObj = nullptr; + AniCommonEventUtils::CreateResultDateObject(env, resultObj, errorCode); + return resultObj; } -static ani_ref createSubscriberExecute(ani_env* env, ani_object infoObject) +static ani_object createSubscriberExecute(ani_env* env, ani_object infoObject) { EVENT_LOGI("createSubscriberExecute call."); CommonEventSubscribeInfo subscribeInfo; @@ -70,7 +82,7 @@ static ani_ref createSubscriberExecute(ani_env* env, ani_object infoObject) auto ret = ANI_OK; auto wrapper = new (std::nothrow) SubscriberInstanceWrapper(subscribeInfo); if (wrapper == nullptr) { - return nullptr; + // return nullptr; } ani_class cls; ret = env->FindClass("LcommonEvent/commonEventSubscriber/CommonEventSubscriberInner;", &cls); @@ -78,55 +90,37 @@ static ani_ref createSubscriberExecute(ani_env* env, ani_object infoObject) EVENT_LOGE("createSubscriberExecute FindClass error. result: %{public}d.", ret); delete wrapper; wrapper = nullptr; - return nullptr; + // return nullptr; } ani_method ctor; - ret = env->Class_FindMethod(cls, "", ":V", &ctor); + ret = env->Class_FindMethod(cls, "", "J:V", &ctor); if (ret != ANI_OK) { EVENT_LOGE("createSubscriberExecute Class_FindMethod error. result: %{public}d.", ret); delete wrapper; wrapper = nullptr; - return nullptr; + // return nullptr; } ani_object subscriberObj; - ret = env->Object_New(cls, ctor, &subscriberObj); + ret = env->Object_New(cls, ctor, &subscriberObj, reinterpret_cast(wrapper)); if (ret != ANI_OK) { EVENT_LOGE("createSubscriberExecute Object_New error. result: %{public}d.", ret); delete wrapper; wrapper = nullptr; - return nullptr; + // return nullptr; } - - ani_method wrapperField; - ret = env->Class_FindMethod(cls, "subscriberInstanceWrapper", nullptr, &wrapperField); - if (ret != ANI_OK) { - EVENT_LOGE("createSubscriberExecute Class_FindField error. result: %{public}d.", ret); - delete wrapper; - wrapper = nullptr; - return nullptr; + auto errorCode = NO_ERROR; + if (subscriberObj == nullptr) { + EVENT_LOGE("createSubscriberExecute subscriberObj is null."); + errorCode = ERR_CES_FAILED; } - ret = env->Object_CallMethod_Void(subscriberObj, wrapperField, reinterpret_cast(wrapper)); - if (ret != ANI_OK) { - EVENT_LOGE("createSubscriberExecute Object_SetField_Long error. result: %{public}d.", ret); - delete wrapper; - wrapper = nullptr; - return nullptr; - } - - ani_ref resultRef = nullptr; - ret = env->GlobalReference_Create(subscriberObj, &resultRef); - if (ret != ANI_OK) { - EVENT_LOGE("createSubscriberExecute GlobalReference_Create error. result: %{public}d.", ret); - delete wrapper; - wrapper = nullptr; - return nullptr; - } EVENT_LOGI("createSubscriberExecute end."); - return resultRef; + ani_object resultObj = nullptr; + AniCommonEventUtils::CreateResultDateObject(env, resultObj, errorCode, subscriberObj); + return resultObj; } -static uint32_t subscribeExecute(ani_env* env, ani_ref subscribeRef, ani_object callback) +static ani_object subscribeExecute(ani_env* env, ani_ref subscribeRef, ani_object callback) { EVENT_LOGI("subscribeExecute call."); auto ret = ANI_OK; @@ -136,26 +130,26 @@ static uint32_t subscribeExecute(ani_env* env, ani_ref subscribeRef, ani_object static_cast(subscribeRef), "subscriberInstanceWrapper", &wrapper_long); if (ret != ANI_OK) { EVENT_LOGE("subscribeExecute Object_GetPropertyByName_Long error. result: %{public}d.", ret); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } SubscriberInstanceWrapper* wrapper = nullptr; wrapper = reinterpret_cast(wrapper_long); if (wrapper == nullptr) { EVENT_LOGE("subscribeExecute wrapper is null."); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } auto subscriberInstance = GetSubscriberByWrapper(wrapper); if (subscriberInstance == nullptr) { EVENT_LOGE("subscriberInstance is null."); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } ani_ref resultRef = nullptr; ret = env->GlobalReference_Create(callback, &resultRef); if (ret != ANI_OK) { EVENT_LOGE("createSubscriberExecute GlobalReference_Create error. result: %{public}d.", ret); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } if (resultRef == nullptr) { EVENT_LOGE("subscribeExecute resultRef is null."); @@ -167,16 +161,18 @@ static uint32_t subscribeExecute(ani_env* env, ani_ref subscribeRef, ani_object ret = env->GetVM(&etsVm); if (ret != ANI_OK) { EVENT_LOGE("OnReceiveEvent GetVM error. result: %{public}d.", ret); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } subscriberInstance->SetVm(etsVm); auto result = CommonEventManager::NewSubscribeCommonEvent(subscriberInstance); - + result = ERR_NOTIFICATION_CES_NO_SUBSCRIBER; EVENT_LOGI("subscribeExecute result: %{public}d.", result); - return result; + ani_object resultObj = nullptr; + AniCommonEventUtils::CreateResultDateObject(env, resultObj, result); + return resultObj; } -static uint32_t unsubscribeExecute(ani_env* env, ani_ref subscribeRef) +static ani_object unsubscribeExecute(ani_env* env, ani_ref subscribeRef) { EVENT_LOGI("unsubscribeExecute call."); auto ret = ANI_OK; @@ -186,24 +182,26 @@ static uint32_t unsubscribeExecute(ani_env* env, ani_ref subscribeRef) static_cast(subscribeRef), "subscriberInstanceWrapper", &wrapper_long); if (ret != ANI_OK) { EVENT_LOGE("subscribeExecute Object_GetPropertyByName_Long error. result: %{public}d.", ret); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } SubscriberInstanceWrapper* wrapper = nullptr; wrapper = reinterpret_cast(wrapper_long); if (wrapper == nullptr) { EVENT_LOGE("unsubscribeExecute wrapper is null."); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } auto subscriberInstance = GetSubscriberByWrapper(wrapper); if (subscriberInstance == nullptr) { EVENT_LOGE("subscriberInstance is null."); - return ANI_INVALID_ARGS; + // return ANI_INVALID_ARGS; } auto result = CommonEventManager::NewUnSubscribeCommonEvent(subscriberInstance); EVENT_LOGI("unsubscribeExecute result: %{public}d.", result); - return result; + ani_object resultObj = nullptr; + AniCommonEventUtils::CreateResultDateObject(env, resultObj, result); + return resultObj; } std::shared_ptr GetSubscriberByWrapper(SubscriberInstanceWrapper* wrapper) @@ -230,6 +228,9 @@ SubscriberInstance::SubscriberInstance(const CommonEventSubscribeInfo& sp) : Com SubscriberInstance::~SubscriberInstance() { EVENT_LOGI("destroy SubscriberInstance"); + if (env_ != nullptr && callback_ != nullptr) { + env_->GlobalReference_Delete(callback_); + } } void SubscriberInstance::OnReceiveEvent(const CommonEventData& data) @@ -335,6 +336,15 @@ std::shared_ptr SubscriberInstanceWrapper::GetSubscriber() return subscriber; } +static void clean([[maybe_unused]] ani_env *env, [[maybe_unused]] ani_object object) +{ + ani_long ptr; + if (ANI_OK != env->Object_GetFieldByName_Long(object, "ptr", &ptr)) { + return; + } + delete reinterpret_cast(ptr); +} + extern "C" { ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) { @@ -354,18 +364,22 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) } std::array methods = { - ani_native_function { "publishExecute", "Lstd/core/String;:I", + ani_native_function { "publishExecute", + "Lstd/core/String;:L@ohos/commonEventManager/commonEventManager/ResultDate;", reinterpret_cast(OHOS::EventManagerFwkAni::publishExecute) }, ani_native_function { "publishWithOptionsExecute", - "Lstd/core/String;LcommonEvent/commonEventPublishData/CommonEventPublishData;:I", + "Lstd/core/String;LcommonEvent/commonEventPublishData/CommonEventPublishData;:L@ohos/commonEventManager/" + "commonEventManager/ResultDate;", reinterpret_cast(OHOS::EventManagerFwkAni::publishWithOptionsExecute) }, ani_native_function { "createSubscriberExecute", - "LcommonEvent/commonEventSubscribeInfo/CommonEventSubscribeInfo;:LcommonEvent/commonEventSubscriber/" - "CommonEventSubscriber;", + "LcommonEvent/commonEventSubscribeInfo/CommonEventSubscribeInfo;:L@ohos/commonEventManager/" + "commonEventManager/ResultDate;", reinterpret_cast(OHOS::EventManagerFwkAni::createSubscriberExecute) }, ani_native_function { "subscribeExecute", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::subscribeExecute) }, - ani_native_function { "unsubscribeExecute", "LcommonEvent/commonEventSubscriber/CommonEventSubscriber;:I", + ani_native_function { "unsubscribeExecute", + "LcommonEvent/commonEventSubscriber/CommonEventSubscriber;:L@ohos/commonEventManager/commonEventManager/" + "ResultDate;", reinterpret_cast(OHOS::EventManagerFwkAni::unsubscribeExecute) }, }; @@ -375,6 +389,20 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) return ANI_INVALID_TYPE; } + ani_class cls; + status = env->FindClass("LcommonEvent/commonEventSubscriber/Cleaner;", &cls); + if (status != ANI_OK) { + EVENT_LOGE("Not found LcommonEvent/commonEventSubscriber/Cleaner"); + return ANI_INVALID_ARGS; + } + std::array cleanMethod = { + ani_native_function{"clean", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::clean)}}; + status = env->Class_BindNativeMethods(cls, cleanMethod.data(), cleanMethod.size()); + if (status != ANI_OK) { + EVENT_LOGE("Cannot bind native methods to LcommonEvent/commonEventSubscriber/Cleaner"); + return ANI_INVALID_TYPE; + } + *result = ANI_VERSION_1; return ANI_OK; } diff --git a/interfaces/kits/ani/common_event/src/ani_common_event_utils.cpp b/interfaces/kits/ani/common_event/src/ani_common_event_utils.cpp index 496552f9a7fcc62e3d5f085069ccd2cb7d458a45..09aa9b3ab250f2c50336a301b1e8a044d9de67c5 100644 --- a/interfaces/kits/ani/common_event/src/ani_common_event_utils.cpp +++ b/interfaces/kits/ani/common_event/src/ani_common_event_utils.cpp @@ -14,6 +14,7 @@ */ #include "ani_common_event_utils.h" +#include "ces_inner_error_code.h" #include "event_log_wrapper.h" namespace OHOS { @@ -21,8 +22,26 @@ namespace EventManagerFwkAni { using namespace OHOS::EventFwk; using namespace OHOS::AppExecFwk; +using namespace OHOS::Notification; #define SETTER_METHOD_NAME(property) "" #property +static const std::unordered_map ErrorCodeToMsg { + {ERR_NOTIFICATION_CES_COMMON_PERMISSION_DENIED, + "Permission verification failed, usually the result returned by VerifyAccessToken."}, + {ERR_NOTIFICATION_CES_COMMON_NOT_SYSTEM_APP, "The application isn't system application."}, + {ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID, "Parameter error."}, + {ERR_NOTIFICATION_CES_COMMON_SYSTEMCAP_NOT_SUPPORT, "Capability not supported."}, + {ERR_NOTIFICATION_CES_WANT_ACTION_IS_NULL, "The action field in the want parameter is null."}, + {ERR_NOTIFICATION_CES_SANDBOX_NOT_SUPPORT, "A sandbox application cannot send common events."}, + {ERR_NOTIFICATION_CES_EVENT_FREQ_TOO_HIGH, "Too many common events are sent in a short period of time."}, + {ERR_NOTIFICATION_CES_NOT_SA_SYSTEM_APP, "A third-party application cannot send system common events."}, + {ERR_NOTIFICATION_CES_NO_SUBSCRIBER, "The subscriber is not found."}, + {ERR_NOTIFICATION_CES_USERID_INVALID, "Invalid userId."}, + {ERR_NOTIFICATION_SEND_ERROR, "Failed to send the message."}, + {ERR_NOTIFICATION_CESM_ERROR, "Failed to read the data."}, + {ERR_NOTIFICATION_SYS_ERROR, "System error."} +}; + void AniCommonEventUtils::GetStdString(ani_env* env, ani_string str, std::string& result) { auto ret = ANI_ERROR; @@ -368,7 +387,13 @@ void AniCommonEventUtils::CreateBusinessErrorObject( ani_string string = nullptr; env->String_NewUTF8(message.c_str(), message.size(), &string); aniResult = env->Object_SetFieldByName_Double(object, "code", ani_double(code)); - aniResult = env->Object_SetFieldByName_Ref(object, "data", string); + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateBusinessErrorObject Object_SetFieldByName_Double error. result: %{public}d.", aniResult); + } + aniResult = env->Object_SetPropertyByName_Ref(object, "message", string); + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateBusinessErrorObject Object_SetFieldByName_Ref error. result: %{public}d.", aniResult); + } } template @@ -446,5 +471,75 @@ void AniCommonEventUtils::ConvertCommonEventDataToEts( // set parameters [Record] } +void AniCommonEventUtils::CreateResultDateObject(ani_env* env, ani_object& object, int32_t code, ani_ref data) +{ + EVENT_LOGI("CreateResultDateObject called, code: %{public}d", code); + + ani_status aniResult = ANI_ERROR; + ani_class cls; + ani_method ctor = nullptr; + if (env == nullptr) { + EVENT_LOGE("CreateResultDateObject env is null."); + return; + } + + aniResult = env->FindClass("L@ohos/commonEventManager/commonEventManager/ResultDate;", &cls); + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateResultDateObject findClass error. result: %{public}d.", aniResult); + return; + } + if (cls == nullptr) { + EVENT_LOGE("CreateResultDateObject cls is null."); + return; + } + aniResult = env->Class_FindMethod(cls, "", "DLstd/core/String;:V", &ctor); + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateResultDateObject Class_FindMethod error. result: %{public}d.", aniResult); + return; + } + + auto iter = ErrorCodeToMsg.find(code); + std::string message = iter != ErrorCodeToMsg.end() ? iter->second : ""; + EVENT_LOGE("CreateResultDateObject Class_FindMethod error. message: %{public}s.", message.c_str()); + ani_string aniMessage = nullptr; + env->String_NewUTF8(message.c_str(), message.size(), &aniMessage); + aniResult = env->Object_New(cls, ctor, &object, ani_double(code), aniMessage); + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateResultDateObject Object_New error. result: %{public}d.", aniResult); + } + + if (data != nullptr) { + aniResult = env->Object_SetFieldByName_Ref(object, "data", data); + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateResultDateObject Object_SetFieldByName_Ref error. result: %{public}d.", aniResult); + } + } +} + +void AniCommonEventUtils::AniThrowError(ani_env* env, int32_t errCode, const std::string &msg) +{ + EVENT_LOGI("AniThrowError called, code: %{public}d", errCode); + if (env == nullptr) { + EVENT_LOGE("AniThrowError env is null."); + return; + } + auto iter = ErrorCodeToMsg.find(errCode); + std::string errMsg = iter != ErrorCodeToMsg.end() ? iter->second : ""; + + if (!msg.empty()) { + errMsg.append(" ").append(msg); + } + + ani_object errObj; + CreateBusinessErrorObject(env, errObj, errCode, errMsg); + + ani_status aniResult = ANI_ERROR; + aniResult = env->ThrowError(static_cast(errObj)); + + if (aniResult != ANI_OK) { + EVENT_LOGE("CreateResultDateObject ThrowError error. result: %{public}d.", aniResult); + } +} + } // namespace EventManagerFwkAni } // namespace OHOS \ No newline at end of file