From 4393c42a3f151dbb1fd66f472ecb13e6a29c82e0 Mon Sep 17 00:00:00 2001 From: heguokai <275503077@qq.com> Date: Tue, 8 Jul 2025 16:42:37 +0800 Subject: [PATCH 1/2] =?UTF-8?q?Ani=20code=E7=A7=BB=E6=A4=8Dmaster?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: heguokai <275503077@qq.com> --- ...ation.StaticSubscriberExtensionAbility.ets | 26 + ...ation.StaticSubscriberExtensionContext.ets | 52 ++ .../ets/@ohos.commonEventManager.ets | 233 +++++++- .../commonEvent/commonEventSubscribeInfo.ets | 9 + .../ets/commonEvent/commonEventSubscriber.ets | 471 +++++++++++++++- .../common_event/include/ani_common_event.h | 3 + .../include/ani_common_event_throw_error.h | 56 ++ .../include/ani_common_event_utils.h | 9 + .../ani/common_event/src/ani_common_event.cpp | 524 ++++++++++++++++-- .../src/ani_common_event_utils.cpp | 193 ++++++- 10 files changed, 1507 insertions(+), 69 deletions(-) create mode 100644 interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionAbility.ets create mode 100644 interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionContext.ets create mode 100644 interfaces/kits/ani/common_event/include/ani_common_event_throw_error.h diff --git a/interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionAbility.ets b/interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionAbility.ets new file mode 100644 index 00000000..7ecf2941 --- /dev/null +++ b/interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionAbility.ets @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import{ CommonEventData } from 'commonEvent.commonEventData'; +import StaticSubscriberExtensionContext from '@ohos.application.StaticSubscriberExtensionContext'; + +export default class StaticSubscriberExtensionAbility { + + context: StaticSubscriberExtensionContext = {}; + + onReceiveEvent(event: CommonEventData): void { + console.log("StsonReceiveEvent, event:" + event.code); + } +} \ No newline at end of file diff --git a/interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionContext.ets b/interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionContext.ets new file mode 100644 index 00000000..6fec4793 --- /dev/null +++ b/interfaces/kits/ani/common_event/ets/@ohos.application.StaticSubscriberExtensionContext.ets @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { BusinessError, AsyncCallback } from '@ohos.base'; +import Want from '@ohos.app.ability.Want'; +import ExtensionContext from 'application.ExtensionContext'; +import hilog from '@ohos.hilog'; + +const TAG: string = 'commonEventManager'; + +type ResolveCallback = (data: T) => void; +type RejectCallback = (err: Error) => void; + +loadLibrary("ani_commoneventmanager.z"); +export class StaticSubscriberExtensionContext extends ExtensionContext { + nativeStaticSubscriberExtensionContext: long = 0; + native nativeStartAbilitySync(want: Want): void; + + startAbility(want: Want, callback: AsyncCallback): void { + let task = taskpool.execute(this.nativeStartAbilitySync, want); + task.then((e: NullishType)=>{ + callback(null, undefined); + }, (error: Object): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }); + } + + startAbility(want: Want): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let task = taskpool.execute(this.nativeStartAbilitySync, want); + task.then((e: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + hilog.error(0xD001202, TAG, 'nativeStartAbilitySync Promise error'); + reject(error); + }); + }); + return pPromise; + } +} \ No newline at end of file diff --git a/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets b/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets index 30688c11..9c43774b 100644 --- a/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets +++ b/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets @@ -23,12 +23,12 @@ 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): int; + export native function publishWithOptionsExecute(event: string, options: CommonEventPublishData): int; + export native function createSubscriberExecute(subscribeInfo: CommonEventSubscribeInfo): CommonEventSubscriber; export native function subscribeExecute(subscriber: CommonEventSubscriber, - callback: AsyncCallback):int; - export native function unsubscribeExecute(subscriber: CommonEventSubscriber):int; + callback: AsyncCallback): int; + export native function unsubscribeExecute(subscriber: CommonEventSubscriber): int; export function publish(event: string, callback: AsyncCallback): void { hilog.info(0x0000, TAG, 'publish called event: %{public}s', event); @@ -70,7 +70,7 @@ namespace commonEventManager { }); } - export function createSubscriber(subscribeInfo: CommonEventSubscribeInfo):Promise { + export function createSubscriber(subscribeInfo: CommonEventSubscribeInfo): Promise { hilog.info(0x0000, TAG, 'createSubscriber Promise call'); let p = new Promise((resolve: (v: CommonEventSubscriber) => void, reject: (error: Object) => void) => { @@ -86,7 +86,7 @@ namespace commonEventManager { return p; } - export function createSubscriberSync(subscribeInfo: CommonEventSubscribeInfo): CommonEventSubscriber{ + export function createSubscriberSync(subscribeInfo: CommonEventSubscribeInfo): CommonEventSubscriber { hilog.info(0x0000, TAG, 'createSubscriberSync call'); return commonEventManager.createSubscriberExecute(subscribeInfo); } @@ -123,16 +123,227 @@ namespace commonEventManager { } export enum Support { + COMMON_EVENT_BOOT_COMPLETED = 'usual.event.BOOT_COMPLETED', + COMMON_EVENT_LOCKED_BOOT_COMPLETED = 'usual.event.LOCKED_BOOT_COMPLETED', + COMMON_EVENT_SHUTDOWN = 'usual.event.SHUTDOWN', + COMMON_EVENT_BATTERY_CHANGED = 'usual.event.BATTERY_CHANGED', + COMMON_EVENT_BATTERY_LOW = 'usual.event.BATTERY_LOW', + COMMON_EVENT_BATTERY_OKAY = 'usual.event.BATTERY_OKAY', + COMMON_EVENT_POWER_CONNECTED = 'usual.event.POWER_CONNECTED', + COMMON_EVENT_POWER_DISCONNECTED = 'usual.event.POWER_DISCONNECTED', COMMON_EVENT_SCREEN_OFF = 'usual.event.SCREEN_OFF', COMMON_EVENT_SCREEN_ON = 'usual.event.SCREEN_ON', - COMMON_EVENT_USER_INFO_UPDATED = 'usual.event.USER_INFO_UPDATED', - COMMON_EVENT_DISTRIBUTED_ACCOUNT_LOGOUT = 'common.event.DISTRIBUTED_ACCOUNT_LOGOUT', + COMMON_EVENT_THERMAL_LEVEL_CHANGED = 'usual.event.THERMAL_LEVEL_CHANGED', + COMMON_EVENT_ENTER_FORCE_SLEEP = 'usual.event.ENTER_FORCE_SLEEP', + COMMON_EVENT_EXIT_FORCE_SLEEP = 'usual.event.EXIT_FORCE_SLEEP', + COMMON_EVENT_ENTER_HIBERNATE = 'usual.event.ENTER_HIBERNATE', + COMMON_EVENT_EXIT_HIBERNATE = 'usual.event.EXIT_HIBERNATE', + COMMON_EVENT_TIME_TICK = 'usual.event.TIME_TICK', + COMMON_EVENT_TIME_CHANGED = 'usual.event.TIME_CHANGED', + COMMON_EVENT_DATE_CHANGED = 'usual.event.DATE_CHANGED', + COMMON_EVENT_TIMEZONE_CHANGED = 'usual.event.TIMEZONE_CHANGED', + COMMON_EVENT_CLOSE_SYSTEM_DIALOGS = 'usual.event.CLOSE_SYSTEM_DIALOGS', + COMMON_EVENT_PACKAGE_ADDED = 'usual.event.PACKAGE_ADDED', + COMMON_EVENT_PACKAGE_REPLACED = 'usual.event.PACKAGE_REPLACED', + COMMON_EVENT_MY_PACKAGE_REPLACED = 'usual.event.MY_PACKAGE_REPLACED', + COMMON_EVENT_PACKAGE_REMOVED = 'usual.event.PACKAGE_REMOVED', + COMMON_EVENT_BUNDLE_REMOVED = 'usual.event.BUNDLE_REMOVED', + COMMON_EVENT_PACKAGE_FULLY_REMOVED = 'usual.event.PACKAGE_FULLY_REMOVED', + COMMON_EVENT_PACKAGE_CHANGED = 'usual.event.PACKAGE_CHANGED', + COMMON_EVENT_PACKAGE_RESTARTED = 'usual.event.PACKAGE_RESTARTED', + COMMON_EVENT_PACKAGE_DATA_CLEARED = 'usual.event.PACKAGE_DATA_CLEARED', + COMMON_EVENT_PACKAGE_CACHE_CLEARED = 'usual.event.PACKAGE_CACHE_CLEARED', + COMMON_EVENT_PACKAGES_SUSPENDED = 'usual.event.PACKAGES_SUSPENDED', + COMMON_EVENT_PACKAGES_UNSUSPENDED = 'usual.event.PACKAGES_UNSUSPENDED', + COMMON_EVENT_MY_PACKAGE_SUSPENDED = 'usual.event.MY_PACKAGE_SUSPENDED', + COMMON_EVENT_MY_PACKAGE_UNSUSPENDED = 'usual.event.MY_PACKAGE_UNSUSPENDED', + COMMON_EVENT_UID_REMOVED = 'usual.event.UID_REMOVED', + COMMON_EVENT_PACKAGE_FIRST_LAUNCH = 'usual.event.PACKAGE_FIRST_LAUNCH', + COMMON_EVENT_PACKAGE_NEEDS_VERIFICATION = 'usual.event.PACKAGE_NEEDS_VERIFICATION', + COMMON_EVENT_PACKAGE_VERIFIED = 'usual.event.PACKAGE_VERIFIED', + COMMON_EVENT_EXTERNAL_APPLICATIONS_AVAILABLE = 'usual.event.EXTERNAL_APPLICATIONS_AVAILABLE', + COMMON_EVENT_EXTERNAL_APPLICATIONS_UNAVAILABLE = 'usual.event.EXTERNAL_APPLICATIONS_UNAVAILABLE', + COMMON_EVENT_CONFIGURATION_CHANGED = 'usual.event.CONFIGURATION_CHANGED', + COMMON_EVENT_LOCALE_CHANGED = 'usual.event.LOCALE_CHANGED', + COMMON_EVENT_MANAGE_PACKAGE_STORAGE = 'usual.event.MANAGE_PACKAGE_STORAGE', + COMMON_EVENT_DRIVE_MODE = 'common.event.DRIVE_MODE', + COMMON_EVENT_HOME_MODE = 'common.event.HOME_MODE', + COMMON_EVENT_OFFICE_MODE = 'common.event.OFFICE_MODE', + COMMON_EVENT_USER_STARTED = 'usual.event.USER_STARTED', + COMMON_EVENT_USER_BACKGROUND = 'usual.event.USER_BACKGROUND', + COMMON_EVENT_USER_FOREGROUND = 'usual.event.USER_FOREGROUND', + COMMON_EVENT_USER_SWITCHED = 'usual.event.USER_SWITCHED', + COMMON_EVENT_USER_STARTING = 'usual.event.USER_STARTING', + COMMON_EVENT_USER_UNLOCKED = 'usual.event.USER_UNLOCKED', + COMMON_EVENT_USER_STOPPING = 'usual.event.USER_STOPPING', + COMMON_EVENT_USER_STOPPED = 'usual.event.USER_STOPPED', COMMON_EVENT_DISTRIBUTED_ACCOUNT_LOGIN = 'common.event.DISTRIBUTED_ACCOUNT_LOGIN', + COMMON_EVENT_DISTRIBUTED_ACCOUNT_LOGOUT = 'common.event.DISTRIBUTED_ACCOUNT_LOGOUT', + COMMON_EVENT_DISTRIBUTED_ACCOUNT_TOKEN_INVALID = 'common.event.DISTRIBUTED_ACCOUNT_TOKEN_INVALID', + COMMON_EVENT_DISTRIBUTED_ACCOUNT_LOGOFF = 'common.event.DISTRIBUTED_ACCOUNT_LOGOFF', + COMMON_EVENT_WIFI_POWER_STATE = 'usual.event.wifi.POWER_STATE', + COMMON_EVENT_WIFI_SCAN_FINISHED = 'usual.event.wifi.SCAN_FINISHED', + COMMON_EVENT_WIFI_RSSI_VALUE = 'usual.event.wifi.RSSI_VALUE', + COMMON_EVENT_WIFI_CONN_STATE = 'usual.event.wifi.CONN_STATE', + COMMON_EVENT_WIFI_HOTSPOT_STATE = 'usual.event.wifi.HOTSPOT_STATE', + COMMON_EVENT_WIFI_AP_STA_JOIN = 'usual.event.wifi.WIFI_HS_STA_JOIN', + COMMON_EVENT_WIFI_AP_STA_LEAVE = 'usual.event.wifi.WIFI_HS_STA_LEAVE', + COMMON_EVENT_WIFI_MPLINK_STATE_CHANGE = 'usual.event.wifi.mplink.STATE_CHANGE', + COMMON_EVENT_WIFI_P2P_CONN_STATE = 'usual.event.wifi.p2p.CONN_STATE_CHANGE', + COMMON_EVENT_WIFI_P2P_STATE_CHANGED = 'usual.event.wifi.p2p.STATE_CHANGE', + COMMON_EVENT_WIFI_P2P_PEERS_STATE_CHANGED = 'usual.event.wifi.p2p.DEVICES_CHANGE', + COMMON_EVENT_WIFI_P2P_PEERS_DISCOVERY_STATE_CHANGED = 'usual.event.wifi.p2p.PEER_DISCOVERY_STATE_CHANGE', + COMMON_EVENT_WIFI_P2P_CURRENT_DEVICE_STATE_CHANGED = 'usual.event.wifi.p2p.CURRENT_DEVICE_CHANGE', + COMMON_EVENT_WIFI_P2P_GROUP_STATE_CHANGED = 'usual.event.wifi.p2p.GROUP_STATE_CHANGED', + COMMON_EVENT_BLUETOOTH_HANDSFREE_AG_CONNECT_STATE_UPDATE = + 'usual.event.bluetooth.handsfree.ag.CONNECT_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_HANDSFREE_AG_CURRENT_DEVICE_UPDATE = + 'usual.event.bluetooth.handsfree.ag.CURRENT_DEVICE_UPDATE', + COMMON_EVENT_BLUETOOTH_HANDSFREE_AG_AUDIO_STATE_UPDATE = + 'usual.event.bluetooth.handsfree.ag.AUDIO_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSOURCE_CONNECT_STATE_UPDATE = + 'usual.event.bluetooth.a2dpsource.CONNECT_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSOURCE_CURRENT_DEVICE_UPDATE = + 'usual.event.bluetooth.a2dpsource.CURRENT_DEVICE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSOURCE_PLAYING_STATE_UPDATE = + 'usual.event.bluetooth.a2dpsource.PLAYING_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSOURCE_AVRCP_CONNECT_STATE_UPDATE = + 'usual.event.bluetooth.a2dpsource.AVRCP_CONNECT_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSOURCE_CODEC_VALUE_UPDATE = + 'usual.event.bluetooth.a2dpsource.CODEC_VALUE_UPDATE', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_DISCOVERED = 'usual.event.bluetooth.remotedevice.DISCOVERED', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_CLASS_VALUE_UPDATE = + 'usual.event.bluetooth.remotedevice.CLASS_VALUE_UPDATE', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_ACL_CONNECTED = 'usual.event.bluetooth.remotedevice.ACL_CONNECTED', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_ACL_DISCONNECTED = 'usual.event.bluetooth.remotedevice.ACL_DISCONNECTED', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_NAME_UPDATE = 'usual.event.bluetooth.remotedevice.NAME_UPDATE', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_PAIR_STATE = 'usual.event.bluetooth.remotedevice.PAIR_STATE', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_BATTERY_VALUE_UPDATE = + 'usual.event.bluetooth.remotedevice.BATTERY_VALUE_UPDATE', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_SDP_RESULT = 'usual.event.bluetooth.remotedevice.SDP_RESULT', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_UUID_VALUE = 'usual.event.bluetooth.remotedevice.UUID_VALUE', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_PAIRING_REQ = 'usual.event.bluetooth.remotedevice.PAIRING_REQ', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_PAIRING_CANCEL = 'usual.event.bluetooth.remotedevice.PAIRING_CANCEL', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_CONNECT_REQ = 'usual.event.bluetooth.remotedevice.CONNECT_REQ', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_CONNECT_REPLY = 'usual.event.bluetooth.remotedevice.CONNECT_REPLY', + COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_CONNECT_CANCEL = 'usual.event.bluetooth.remotedevice.CONNECT_CANCEL', + COMMON_EVENT_BLUETOOTH_HANDSFREEUNIT_CONNECT_STATE_UPDATE = + 'usual.event.bluetooth.handsfreeunit.CONNECT_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_HANDSFREEUNIT_AUDIO_STATE_UPDATE = + 'usual.event.bluetooth.handsfreeunit.AUDIO_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_HANDSFREEUNIT_AG_COMMON_EVENT = 'usual.event.bluetooth.handsfreeunit.AG_COMMON_EVENT', + COMMON_EVENT_BLUETOOTH_HANDSFREEUNIT_AG_CALL_STATE_UPDATE = + 'usual.event.bluetooth.handsfreeunit.AG_CALL_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_HOST_STATE_UPDATE = 'usual.event.bluetooth.host.STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_HOST_REQ_DISCOVERABLE = 'usual.event.bluetooth.host.REQ_DISCOVERABLE', + COMMON_EVENT_BLUETOOTH_HOST_REQ_ENABLE = 'usual.event.bluetooth.host.REQ_ENABLE', + COMMON_EVENT_BLUETOOTH_HOST_REQ_DISABLE = 'usual.event.bluetooth.host.REQ_DISABLE', + COMMON_EVENT_BLUETOOTH_HOST_SCAN_MODE_UPDATE = 'usual.event.bluetooth.host.SCAN_MODE_UPDATE', + COMMON_EVENT_BLUETOOTH_HOST_DISCOVERY_STARTED = 'usual.event.bluetooth.host.DISCOVERY_STARTED', + COMMON_EVENT_BLUETOOTH_HOST_DISCOVERY_FINISHED = 'usual.event.bluetooth.host.DISCOVERY_FINISHED', + COMMON_EVENT_BLUETOOTH_HOST_NAME_UPDATE = 'usual.event.bluetooth.host.NAME_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSINK_CONNECT_STATE_UPDATE = 'usual.event.bluetooth.a2dpsink.CONNECT_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSINK_PLAYING_STATE_UPDATE = 'usual.event.bluetooth.a2dpsink.PLAYING_STATE_UPDATE', + COMMON_EVENT_BLUETOOTH_A2DPSINK_AUDIO_STATE_UPDATE = 'usual.event.bluetooth.a2dpsink.AUDIO_STATE_UPDATE', + COMMON_EVENT_NFC_ACTION_ADAPTER_STATE_CHANGED = 'usual.event.nfc.action.ADAPTER_STATE_CHANGED', + COMMON_EVENT_NFC_ACTION_RF_FIELD_ON_DETECTED = 'usual.event.nfc.action.RF_FIELD_ON_DETECTED', + COMMON_EVENT_NFC_ACTION_RF_FIELD_OFF_DETECTED = 'usual.event.nfc.action.RF_FIELD_OFF_DETECTED', + COMMON_EVENT_DISCHARGING = 'usual.event.DISCHARGING', + COMMON_EVENT_CHARGING = 'usual.event.CHARGING', + COMMON_EVENT_CHARGE_TYPE_CHANGED = 'usual.event.CHARGE_TYPE_CHANGED', + COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED = 'usual.event.DEVICE_IDLE_MODE_CHANGED', + COMMON_EVENT_CHARGE_IDLE_MODE_CHANGED = 'usual.event.CHARGE_IDLE_MODE_CHANGED', + COMMON_EVENT_DEVICE_IDLE_EXEMPTION_LIST_UPDATED = 'usual.event.DEVICE_IDLE_EXEMPTION_LIST_UPDATED', + COMMON_EVENT_POWER_SAVE_MODE_CHANGED = 'usual.event.POWER_SAVE_MODE_CHANGED', + COMMON_EVENT_USER_ADDED = 'usual.event.USER_ADDED', + COMMON_EVENT_USER_REMOVED = 'usual.event.USER_REMOVED', + COMMON_EVENT_ABILITY_ADDED = 'common.event.ABILITY_ADDED', + COMMON_EVENT_ABILITY_REMOVED = 'common.event.ABILITY_REMOVED', + COMMON_EVENT_ABILITY_UPDATED = 'common.event.ABILITY_UPDATED', + COMMON_EVENT_LOCATION_MODE_STATE_CHANGED = 'usual.event.location.MODE_STATE_CHANGED', + COMMON_EVENT_IVI_SLEEP = 'common.event.IVI_SLEEP', + COMMON_EVENT_IVI_PAUSE = 'common.event.IVI_PAUSE', + COMMON_EVENT_IVI_STANDBY = 'common.event.IVI_STANDBY', + COMMON_EVENT_IVI_LASTMODE_SAVE = 'common.event.IVI_LASTMODE_SAVE', + COMMON_EVENT_IVI_VOLTAGE_ABNORMAL = 'common.event.IVI_VOLTAGE_ABNORMAL', + COMMON_EVENT_IVI_HIGH_TEMPERATURE = 'common.event.IVI_HIGH_TEMPERATURE', + COMMON_EVENT_IVI_EXTREME_TEMPERATURE = 'common.event.IVI_EXTREME_TEMPERATURE', + COMMON_EVENT_IVI_TEMPERATURE_ABNORMAL = 'common.event.IVI_TEMPERATURE_ABNORMAL', + COMMON_EVENT_IVI_VOLTAGE_RECOVERY = 'common.event.IVI_VOLTAGE_RECOVERY', + COMMON_EVENT_IVI_TEMPERATURE_RECOVERY = 'common.event.IVI_TEMPERATURE_RECOVERY', + COMMON_EVENT_IVI_ACTIVE = 'common.event.IVI_ACTIVE', + COMMON_EVENT_USB_STATE = 'usual.event.hardware.usb.action.USB_STATE', + COMMON_EVENT_USB_PORT_CHANGED = 'usual.event.hardware.usb.action.USB_PORT_CHANGED', + COMMON_EVENT_USB_DEVICE_ATTACHED = 'usual.event.hardware.usb.action.USB_DEVICE_ATTACHED', + COMMON_EVENT_USB_DEVICE_DETACHED = 'usual.event.hardware.usb.action.USB_DEVICE_DETACHED', + COMMON_EVENT_USB_ACCESSORY_ATTACHED = 'usual.event.hardware.usb.action.USB_ACCESSORY_ATTACHED', + COMMON_EVENT_USB_ACCESSORY_DETACHED = 'usual.event.hardware.usb.action.USB_ACCESSORY_DETACHED', + COMMON_EVENT_DISK_REMOVED = 'usual.event.data.DISK_REMOVED', + COMMON_EVENT_DISK_UNMOUNTED = 'usual.event.data.DISK_UNMOUNTED', + COMMON_EVENT_DISK_MOUNTED = 'usual.event.data.DISK_MOUNTED', + COMMON_EVENT_DISK_BAD_REMOVAL = 'usual.event.data.DISK_BAD_REMOVAL', + COMMON_EVENT_DISK_UNMOUNTABLE = 'usual.event.data.DISK_UNMOUNTABLE', + COMMON_EVENT_DISK_EJECT = 'usual.event.data.DISK_EJECT', + COMMON_EVENT_VOLUME_REMOVED = 'usual.event.data.VOLUME_REMOVED', + COMMON_EVENT_VOLUME_UNMOUNTED = 'usual.event.data.VOLUME_UNMOUNTED', + COMMON_EVENT_VOLUME_MOUNTED = 'usual.event.data.VOLUME_MOUNTED', + COMMON_EVENT_VOLUME_BAD_REMOVAL = 'usual.event.data.VOLUME_BAD_REMOVAL', + COMMON_EVENT_VOLUME_EJECT = 'usual.event.data.VOLUME_EJECT', + COMMON_EVENT_VISIBLE_ACCOUNTS_UPDATED = 'usual.event.data.VISIBLE_ACCOUNTS_UPDATED', + COMMON_EVENT_ACCOUNT_DELETED = 'usual.event.data.ACCOUNT_DELETED', + COMMON_EVENT_FOUNDATION_READY = 'common.event.FOUNDATION_READY', + COMMON_EVENT_AIRPLANE_MODE_CHANGED = 'usual.event.AIRPLANE_MODE', + COMMON_EVENT_SPLIT_SCREEN = 'common.event.SPLIT_SCREEN', + COMMON_EVENT_SLOT_CHANGE = 'usual.event.SLOT_CHANGE', + COMMON_EVENT_SPN_INFO_CHANGED = 'usual.event.SPN_INFO_CHANGED', + COMMON_EVENT_QUICK_FIX_APPLY_RESULT = 'usual.event.QUICK_FIX_APPLY_RESULT', + COMMON_EVENT_QUICK_FIX_REVOKE_RESULT = 'usual.event.QUICK_FIX_REVOKE_RESULT', + COMMON_EVENT_USER_INFO_UPDATED = 'usual.event.USER_INFO_UPDATED', COMMON_EVENT_HTTP_PROXY_CHANGE = 'usual.event.HTTP_PROXY_CHANGE', + COMMON_EVENT_SIM_STATE_CHANGED = 'usual.event.SIM_STATE_CHANGED', + COMMON_EVENT_SMS_RECEIVE_COMPLETED = 'usual.event.SMS_RECEIVE_COMPLETED', + COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED = 'usual.event.SMS_EMERGENCY_CB_RECEIVE_COMPLETED', + COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED = 'usual.event.SMS_CB_RECEIVE_COMPLETED', + COMMON_EVENT_STK_COMMAND = 'usual.event.STK_COMMAND', + COMMON_EVENT_STK_SESSION_END = 'usual.event.STK_SESSION_END', + COMMON_EVENT_STK_CARD_STATE_CHANGED = 'usual.event.STK_CARD_STATE_CHANGED', + COMMON_EVENT_STK_ALPHA_IDENTIFIER = 'usual.event.STK_ALPHA_IDENTIFIER', + COMMON_EVENT_SMS_WAPPUSH_RECEIVE_COMPLETED = 'usual.event.SMS_WAPPUSH_RECEIVE_COMPLETED', + COMMON_EVENT_OPERATOR_CONFIG_CHANGED = 'usual.event.OPERATOR_CONFIG_CHANGED', + COMMON_EVENT_SIM_CARD_DEFAULT_SMS_SUBSCRIPTION_CHANGED = 'usual.event.SIM.DEFAULT_SMS_SUBSCRIPTION_CHANGED', + COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED = 'usual.event.SIM.DEFAULT_DATA_SUBSCRIPTION_CHANGED', + COMMON_EVENT_SIM_CARD_DEFAULT_MAIN_SUBSCRIPTION_CHANGED = 'usual.event.SIM.DEFAULT_MAIN_SUBSCRIPTION_CHANGED', + COMMON_EVENT_SET_PRIMARY_SLOT_STATUS = 'usual.event.SET_PRIMARY_SLOT_STATUS', + COMMON_EVENT_PRIMARY_SLOT_ROAMING = 'usual.event.PRIMARY_SLOT_ROAMING', + COMMON_EVENT_SIM_CARD_DEFAULT_VOICE_SUBSCRIPTION_CHANGED = + 'usual.event.SIM.DEFAULT_VOICE_SUBSCRIPTION_CHANGED', + COMMON_EVENT_CALL_STATE_CHANGED = 'usual.event.CALL_STATE_CHANGED', + COMMON_EVENT_CELLULAR_DATA_STATE_CHANGED = 'usual.event.CELLULAR_DATA_STATE_CHANGED', + COMMON_EVENT_NETWORK_STATE_CHANGED = 'usual.event.NETWORK_STATE_CHANGED', + COMMON_EVENT_SIGNAL_INFO_CHANGED = 'usual.event.SIGNAL_INFO_CHANGED', + COMMON_EVENT_INCOMING_CALL_MISSED = 'usual.event.INCOMING_CALL_MISSED', + COMMON_EVENT_RADIO_STATE_CHANGE = 'usual.event.RADIO_STATE_CHANGE', + COMMON_EVENT_DOMAIN_ACCOUNT_STATUS_CHANGED = 'usual.event.DOMAIN_ACCOUNT_STATUS_CHANGED', + COMMON_EVENT_SCREEN_UNLOCKED = 'usual.event.SCREEN_UNLOCKED', + COMMON_EVENT_SCREEN_LOCKED = 'usual.event.SCREEN_LOCKED', + COMMON_EVENT_CONNECTIVITY_CHANGE = 'usual.event.CONNECTIVITY_CHANGE', + COMMON_EVENT_SPECIAL_CODE = 'common.event.SPECIAL_CODE', + COMMON_EVENT_AUDIO_QUALITY_CHANGE = 'usual.event.AUDIO_QUALITY_CHANGE', + COMMON_EVENT_PRIVACY_STATE_CHANGED = 'usual.event.PRIVACY_STATE_CHANGED', + COMMON_EVENT_PACKAGE_INSTALLATION_STARTED = 'usual.event.PACKAGE_INSTALLATION_STARTED', + COMMON_EVENT_DYNAMIC_ICON_CHANGED = 'usual.event.DYNAMIC_ICON_CHANGED', COMMON_EVENT_MINORSMODE_ON = 'usual.event.MINORSMODE_ON', COMMON_EVENT_MINORSMODE_OFF = 'usual.event.MINORSMODE_OFF', - COMMON_EVENT_TIME_CHANGED = 'usual.event.TIME_CHANGED', - COMMON_EVENT_TIMEZONE_CHANGED = 'usual.event.TIMEZONE_CHANGED' + COMMON_EVENT_BUNDLE_RESOURCES_CHANGED = 'usual.event.BUNDLE_RESOURCES_CHANGED', + COMMON_EVENT_DATA_SHARE_READY = 'usual.event.DATA_SHARE_READY', + COMMON_EVENT_VPN_CONNECTION_STATUS_CHANGED = 'usual.event.VPN_CONNECTION_STATUS_CHANGED', + COMMON_EVENT_RESTORE_START = 'usual.event.RESTORE_START', + COMMON_EVENT_MANAGED_BROWSER_POLICY_CHANGED = 'usual.event.MANAGED_BROWSER_POLICY_CHANGED', + COMMON_EVENT_SHORTCUT_CHANGED = 'usual.event.SHORTCUT_CHANGED', + COMMON_EVENT_KIOSK_MODE_ON = 'usual.event.KIOSK_MODE_ON', + COMMON_EVENT_KIOSK_MODE_OFF = 'usual.event.KIOSK_MODE_OFF', + COMMON_EVENT_CUSTOM_CONFIG_POLICY_UPDATED = 'usual.event.CUSTOM_CONFIG_POLICY_UPDATED', + COMMON_EVENT_CUSTOM_ROAMING_REGION_UPDATED = 'usual.event.CUSTOM_ROAMING_REGION_UPDATED', } } diff --git a/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscribeInfo.ets b/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscribeInfo.ets index 1f6d0914..77b8886e 100644 --- a/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscribeInfo.ets +++ b/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscribeInfo.ets @@ -21,3 +21,12 @@ export interface CommonEventSubscribeInfo { priority?: number; publisherBundleName?: string; } + +class CommonEventSubscribeInfoImpl implements CommonEventSubscribeInfo { + public events: Array = {}; + public publisherPermission?: string | undefined; + public publisherDeviceId?: string | undefined; + public userId?: number | undefined; + public priority?: number | undefined; + public publisherBundleName?: string | undefined; +} \ No newline at end of file diff --git a/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets b/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets index fa4607b2..abd4f8ea 100644 --- a/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets +++ b/interfaces/kits/ani/common_event/ets/commonEvent/commonEventSubscriber.ets @@ -13,14 +13,479 @@ * limitations under the License. */ +import hilog from '@ohos.hilog'; +import { AsyncCallback, BusinessError } from '@ohos.base'; +import { CommonEventSubscribeInfo } from 'commonEvent.commonEventSubscribeInfo'; + +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() + +type ResolveCallback = (data: T) => void; +type RejectCallback = (err: Error) => void; +const TAG: string = 'commonEventSubscriber'; export interface CommonEventSubscriber { - subscriberInstanceWrapper : long; + getCode(callback: AsyncCallback): void; + getCode(): Promise; getCodeSync(): number; + setCode(code: number, callback: AsyncCallback): void; + setCode(code: number): Promise; + setCodeSync(code: number): void; + getData(callback: AsyncCallback): void; + getData(): Promise; + getDataSync(): string; + setData(data: string, callback: AsyncCallback): void; + setData(data: string): Promise; + setDataSync(data: string): void; + setCodeAndData(code: number, data: string, callback: AsyncCallback): void; + setCodeAndData(code: number, data: string): Promise; + setCodeAndDataSync(code: number, data: string): void; + isOrderedCommonEvent(callback: AsyncCallback): void; + isOrderedCommonEvent(): Promise; + isOrderedCommonEventSync(): boolean; + isStickyCommonEvent(callback: AsyncCallback): void; + isStickyCommonEvent(): Promise; + isStickyCommonEventSync(): boolean; + abortCommonEvent(callback: AsyncCallback): void; + abortCommonEvent(): Promise; + abortCommonEventSync(): void; + clearAbortCommonEvent(callback: AsyncCallback): void; + clearAbortCommonEvent(): Promise; + clearAbortCommonEventSync(): void; + getAbortCommonEvent(callback: AsyncCallback): void; + getAbortCommonEvent(): Promise; + getAbortCommonEventSync(): boolean; + getSubscribeInfo(callback: AsyncCallback): void; + getSubscribeInfo(): Promise; + getSubscribeInfoSync(): CommonEventSubscribeInfo; + finishCommonEvent(callback: AsyncCallback): void; + finishCommonEvent(): Promise; } class CommonEventSubscriberInner implements CommonEventSubscriber { - public native subscriberInstanceWrapper : long = 0; + static {loadLibrary("ani_commoneventmanager.z")} + private subscriberInstanceWrapper: long = 0; + + public native nativeGetCode(): number; + public native nativeSetCode(code: int): int; + public native nativeGetData(): string; + public native nativeSetData(data: string): int; + public native nativeSetCodeAndData(code: int, data: string): int; + public native nativeIsOrderedCommonEvent(): boolean; + public native nativeIsStickyCommonEvent(): boolean; + public native nativeAbortCommonEvent(): int; + public native nativeClearAbortCommonEvent(): int; + public native nativeGetAbortCommonEvent(): boolean; + public native nativeGetSubscribeInfo(): CommonEventSubscribeInfo; + public native nativeFinishCommonEvent(): int; + + public getCode(callback: AsyncCallback): void { + let p = taskpool.execute((): number => { return this.nativeGetCode(); }); + p.then((data: NullishType): void => { + let ret : number = data as number; + callback(null, ret); + }, (error: Error): void => { + let ret: number = -1; + let err: BusinessError = error as BusinessError; + callback(err, ret); + }); + } + + public getCode(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): number => { return this.nativeGetCode(); }); + p.then((data: NullishType): void => { + let ret : number = data as number; + resolve(ret); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + public getCodeSync(): number { - return 2; + let ret : number = 0; + try { + ret = this.nativeGetCode() as number; + return ret; + } catch (err) { + return ret; + } + } + + public setCode(code: number, callback: AsyncCallback): void { + let pcode: Int = code.toInt(); + let p = taskpool.execute((): int => { return this.nativeSetCode(pcode); }); + p.then((data: NullishType): void => { + callback(null, undefined); + }, (error: Error): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }); + } + + public setCode(code: number): Promise { + let pcode: Int = code.toInt(); + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): int => { return this.nativeSetCode(pcode); }); + p.then((data: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public setCodeSync(code: number): void { + try { + let pcode: Int = code.toInt(); + this.nativeSetCode(pcode); + return; + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + } + } + + public getData(callback: AsyncCallback): void { + let p = taskpool.execute((): string => { return this.nativeGetData(); }); + p.then((data: NullishType): void => { + let ret : string = data as string; + callback(null, ret); + }, (error: Object): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }) + } + + public getData(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback):void => { + let p = taskpool.execute((): string => { return this.nativeGetData(); }); + p.then((data :NullishType): void => { + let ret : string = data as string; + resolve(ret); + }, (err:Error): void => { + reject(err); + }); + }); + return pPromise; + } + + public getDataSync(): string { + let ret : string = ''; + try { + ret = this.nativeGetData() as string; + return ret; + } catch (err) { + return ret; + } + } + + public setData(data: string, callback: AsyncCallback): void { + let p = taskpool.execute((): int => { return this.nativeSetData(data); }); + p.then((e: NullishType): void => { + callback(null, undefined); + }, (error: Error): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }) + } + + public setData(data: string): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): int => { return this.nativeSetData(data); }); + p.then((data: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public setDataSync(data: string): void { + try { + this.nativeSetData(data); + return; + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + } + } + + public setCodeAndData(code: number, data: string, callback: AsyncCallback): void { + let pcode: Int = code.toInt(); + let p = taskpool.execute((): int => { return this.nativeSetCodeAndData(pcode, data); }); + p.then((e: NullishType): void => { + callback(null, undefined); + }, (error: Error): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }) + } + + public setCodeAndData(code: number, data: string): Promise { + let pcode: Int = code.toInt(); + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): int => { return this.nativeSetCodeAndData(pcode, data); }); + p.then((data: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public setCodeAndDataSync(code: number, data: string): void { + try { + let pcode: Int = code.toInt(); + this.nativeSetCodeAndData(pcode, data); + return; + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + } + } + + public isOrderedCommonEvent(callback: AsyncCallback): void { + let p = taskpool.execute((): boolean => { return this.nativeIsOrderedCommonEvent(); }); + p.then((data: NullishType): void => { + let ret : boolean = data as boolean; + callback(null, ret); + }, (error: Error): void => { + let ret : boolean = false; + let err: BusinessError = error as BusinessError; + callback(err, ret); + }) + } + + public isOrderedCommonEvent(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): boolean => { return this.nativeIsOrderedCommonEvent(); }); + p.then((data: NullishType): void => { + let ret : boolean = data as boolean; + resolve(ret); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public isOrderedCommonEventSync(): boolean { + try { + return this.nativeIsOrderedCommonEvent(); + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + return false; + } + } + + public isStickyCommonEvent(callback: AsyncCallback): void { + let p = taskpool.execute((): boolean => { return this.nativeIsStickyCommonEvent(); }); + p.then((data: NullishType): void => { + let ret : boolean = data as boolean; + callback(null, ret); + }, (error: Error): void => { + let ret : boolean = false; + let err: BusinessError = error as BusinessError; + callback(err, ret); + }) + } + + public isStickyCommonEvent(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): boolean => { return this.nativeIsStickyCommonEvent(); }); + p.then((data: NullishType): void => { + let ret : boolean = data as boolean; + resolve(ret); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public isStickyCommonEventSync(): boolean { + try { + return this.nativeIsStickyCommonEvent(); + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + return false; + } + } + + public abortCommonEvent(callback: AsyncCallback): void { + let p = taskpool.execute((): int => { return this.nativeAbortCommonEvent(); }); + p.then((data: NullishType): void => { + callback(null, undefined); + }, (error: Error): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }); + } + + public abortCommonEvent(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): int => { return this.nativeAbortCommonEvent(); }); + p.then((data: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public abortCommonEventSync(): void { + try { + this.nativeAbortCommonEvent(); + return; + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + } + } + + public clearAbortCommonEvent(callback: AsyncCallback): void { + let p = taskpool.execute((): int => { return this.nativeClearAbortCommonEvent(); }); + p.then((data: NullishType): void => { + callback(null, undefined); + }, (error: Error): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }); + } + + public clearAbortCommonEvent(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): int => { return this.nativeClearAbortCommonEvent(); }); + p.then((data: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public clearAbortCommonEventSync(): void { + try { + this.nativeClearAbortCommonEvent(); + return; + } catch (err) { + hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); + } + } + + public getAbortCommonEvent(callback: AsyncCallback): void { + let p = taskpool.execute((): boolean => { return this.nativeGetAbortCommonEvent(); }); + p.then((data: NullishType): void => { + let ret : boolean = data as boolean; + callback(null, ret); + }, (error: Error): void => { + let ret : boolean = false; + let err: BusinessError = error as BusinessError; + callback(err, ret); + }) + } + + public getAbortCommonEvent(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): boolean => { return this.nativeGetAbortCommonEvent(); }); + p.then((data: NullishType): void => { + let ret : boolean = data as boolean; + resolve(ret); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public getAbortCommonEventSync(): boolean { + let ret : boolean = false; + try { + ret = this.nativeGetAbortCommonEvent() as boolean; + return ret; + } catch (err) { + return ret; + } + } + + public getSubscribeInfo(callback: AsyncCallback): void { + let p = taskpool.execute((): CommonEventSubscribeInfo => { return this.nativeGetSubscribeInfo(); }); + p.then((data: NullishType): void => { + let ret : CommonEventSubscribeInfo = data as CommonEventSubscribeInfo; + callback(null, ret); + }, (error: Error): void => { + let ret : CommonEventSubscribeInfo ; + let err: BusinessError = error as BusinessError; + callback(err, ret); + }) + } + + public getSubscribeInfo(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, + reject: RejectCallback): void => { + let p = taskpool.execute((): CommonEventSubscribeInfo => { return this.nativeGetSubscribeInfo(); }); + p.then((data: NullishType): void => { + let ret : CommonEventSubscribeInfo = data as CommonEventSubscribeInfo; + resolve(ret); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + public getSubscribeInfoSync(): CommonEventSubscribeInfo { + return this.nativeGetSubscribeInfo(); + } + + public finishCommonEvent(callback: AsyncCallback): void { + let p = taskpool.execute((): int => { return this.nativeFinishCommonEvent(); }); + p.then((data: NullishType): void => { + callback(null, undefined); + }, (error: Error): void => { + let err: BusinessError = error as BusinessError; + callback(err, undefined); + }); + } + + public finishCommonEvent(): Promise { + let pPromise = new Promise((resolve: ResolveCallback, reject: RejectCallback): void => { + let p = taskpool.execute((): int => { return this.nativeFinishCommonEvent(); }); + p.then((data: NullishType): void => { + resolve(undefined); + }, (error: Error): void => { + reject(error); + }); + }); + return pPromise; + } + + 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.h b/interfaces/kits/ani/common_event/include/ani_common_event.h index 4c6b5b13..cb266d94 100644 --- a/interfaces/kits/ani/common_event/include/ani_common_event.h +++ b/interfaces/kits/ani/common_event/include/ani_common_event.h @@ -32,6 +32,7 @@ public: void SetEnv(ani_env* env); void SetVm(ani_vm* etsVm); void SetCallback(const ani_object& callback); + ani_object GetCallback(); void ClearEnv(); private: @@ -58,6 +59,8 @@ struct subscriberInstanceInfo { std::shared_ptr commonEventResult = nullptr; }; +std::shared_ptr GetSubscriber(ani_env* env, ani_ref subscribeRef); +std::shared_ptr GetAsyncCommonEventResult (ani_env* env, ani_ref subscribeRef); std::shared_ptr GetSubscriberByWrapper(SubscriberInstanceWrapper* wrapper); } // namespace EventManagerFwkAni diff --git a/interfaces/kits/ani/common_event/include/ani_common_event_throw_error.h b/interfaces/kits/ani/common_event/include/ani_common_event_throw_error.h new file mode 100644 index 00000000..c9acaa1e --- /dev/null +++ b/interfaces/kits/ani/common_event/include/ani_common_event_throw_error.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef BASE_NOTIFICATION_COMMON_EVENT_MANAGER_INCLUDE_ANI_COMMON_EVENT_ERROR_H +#define BASE_NOTIFICATION_COMMON_EVENT_MANAGER_INCLUDE_ANI_COMMON_EVENT_ERROR_H + +#include +#include +#include "ces_inner_error_code.h" +#include "event_log_wrapper.h" + +namespace OHOS { +namespace EventManagerFwkAni { +static const std::unordered_map ERROR_CODE_TO_MESSAGE { + {Notification::ERR_NOTIFICATION_CES_COMMON_PERMISSION_DENIED, + "The application dose not have permission to call the interface"}, + {Notification::ERR_NOTIFICATION_CES_COMMON_NOT_SYSTEM_APP, "The application is not system application"}, + {Notification::ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID, "The param input is invalid"}, + {Notification::ERR_NOTIFICATION_CES_COMMON_SYSTEMCAP_NOT_SUPPORT, "The want action send by event is null"}, + {Notification::ERR_NOTIFICATION_CES_SANDBOX_NOT_SUPPORT, "The sandbox application can not send common event"}, + {Notification::ERR_NOTIFICATION_CES_WANT_ACTION_IS_NULL, "The want action send by event is null"}, + {Notification::ERR_NOTIFICATION_CES_EVENT_FREQ_TOO_HIGH, "The common event send frequency too high"}, + {Notification::ERR_NOTIFICATION_CES_NOT_SA_SYSTEM_APP, + "The application can not send common event, it may be not SA app or System app"}, + {Notification::ERR_NOTIFICATION_CES_NO_SUBSCRIBER, "The subscriber can not found"}, + {Notification::ERR_NOTIFICATION_CES_USERID_INVALID, "he usreId is invalid"}, + {Notification::ERR_NOTIFICATION_SEND_ERROR, "The message send error"}, + {Notification::ERR_NOTIFICATION_CESM_ERROR, "The CEMS error"}, + {Notification::ERR_NOTIFICATION_SYS_ERROR, "The system error"}, +}; + +inline std::string FindCesErrMsg(const int32_t errCode) +{ + auto findMsg = ERROR_CODE_TO_MESSAGE.find(errCode); + if (findMsg == ERROR_CODE_TO_MESSAGE.end()) { + EVENT_LOGE("FindCesErrMsg Inner error."); + return "Inner error."; + } + return findMsg->second; +} + +} // namespace EventManagerFwkAni +} // OHOS +#endif // BASE_NOTIFICATION_COMMON_EVENT_MANAGER_INCLUDE_ANI_COMMON_EVENT_ERROR_H \ 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 0a4002e1..b24e577a 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 @@ -21,6 +21,7 @@ #include #include +#include "ani_common_event.h" #include "common_event_manager.h" namespace OHOS { @@ -31,22 +32,30 @@ using CommonEventData = OHOS::EventFwk::CommonEventData; class AniCommonEventUtils { public: static void GetStdString(ani_env* env, ani_string str, std::string& result); + static ani_status GetAniString(ani_env* env, const std::string str, ani_string &aniStr); static void GetStdStringArrayClass(ani_env* env, ani_object arrayObj, std::vector& strings); static void ConvertCommonEventPublishData(ani_env* env, ani_object optionsObject, EventFwk::Want& want, EventFwk::CommonEventData& commonEventData, EventFwk::CommonEventPublishInfo& commonEventPublishInfo); static void ConvertCommonEventSubscribeInfo( ani_env* env, ani_object infoObject, CommonEventSubscribeInfo& subscribeInfo); + static void GetCommonEventSubscribeInfoToEts( + ani_env* env, std::shared_ptr subscriber, ani_object &infoObject); static void ConvertCommonEventDataToEts(ani_env* env, ani_object& ani_data, const CommonEventData& commonEventData); static bool GetStringOrUndefined(ani_env* env, ani_object param, const char* name, std::string& res); + static bool GetDoubleOrUndefined(ani_env* env, ani_object param, const char* name, int32_t& res); static bool GetIntOrUndefined(ani_env* env, ani_object param, const char* name, int32_t& res); static bool GetBooleanOrUndefined(ani_env* env, ani_object param, const char* name, bool& res); static bool GetStringArrayOrUndefined( ani_env* env, ani_object param, const char* name, std::vector& res); + static bool GetWantParamsOrUndefined( + ani_env* env, ani_object param, const char* name, AAFwk::WantParams& wantParams); static void CreateNewObjectByClass(ani_env* env, const char* className, ani_class &cls, ani_object& ani_data); template 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 ani_object GetAniStringArray(ani_env *env, std::vector strs); + static ani_object newArrayClass(ani_env *env, int length); }; } // 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 13dda4b7..e110a44b 100644 --- a/interfaces/kits/ani/common_event/src/ani_common_event.cpp +++ b/interfaces/kits/ani/common_event/src/ani_common_event.cpp @@ -16,7 +16,10 @@ #include "ani_common_event.h" #include "ani_common_event_utils.h" +#include "ani_common_event_throw_error.h" +#include "ces_inner_error_code.h" #include "event_log_wrapper.h" +#include "sts_error_utils.h" namespace OHOS { namespace EventManagerFwkAni { @@ -53,62 +56,92 @@ static uint32_t publishWithOptionsExecute(ani_env* env, ani_string eventId, ani_ CommonEventPublishInfo commonEventPublishInfo; Want want; want.SetAction(eventIdStr); - commonEventData.SetWant(want); - AniCommonEventUtils::ConvertCommonEventPublishData( env, optionsObject, want, commonEventData, commonEventPublishInfo); + commonEventData.SetWant(want); auto errorCode = CommonEventManager::NewPublishCommonEvent(commonEventData, commonEventPublishInfo); EVENT_LOGI("publishWithOptionsExecute result: %{public}d.", errorCode); return errorCode; } +static uint32_t publishAsUserExecute(ani_env* env, ani_string eventId, ani_int userId) +{ + EVENT_LOGD("publishAsUserExecute call."); + std::string eventIdStr; + AniCommonEventUtils::GetStdString(env, eventId, eventIdStr); + EVENT_LOGD("publishAsUserExecute eventIdStr: %{public}s, userId: %{public}d", eventIdStr.c_str(), userId); + + CommonEventData commonEventData; + CommonEventPublishInfo commonEventPublishInfo; + Want want; + want.SetAction(eventIdStr); + commonEventData.SetWant(want); + + auto errorCode = CommonEventManager::NewPublishCommonEventAsUser(commonEventData, commonEventPublishInfo, userId); + EVENT_LOGD("publishAsUserExecute result: %{public}d.", errorCode); + return errorCode; +} + +static uint32_t publishAsUserWithOptionsExecute(ani_env* env, ani_string eventId, ani_int userId, + ani_object optionsObject) +{ + EVENT_LOGD("publishAsUserWithOptionsExecute call."); + std::string eventIdStr; + AniCommonEventUtils::GetStdString(env, eventId, eventIdStr); + EVENT_LOGD("publishAsUserWithOptionsExecute eventIdStr: %{public}s, userId: %{public}d", + eventIdStr.c_str(), userId); + + CommonEventData commonEventData; + CommonEventPublishInfo commonEventPublishInfo; + Want want; + want.SetAction(eventIdStr); + commonEventData.SetWant(want); + + AniCommonEventUtils::ConvertCommonEventPublishData( + env, optionsObject, want, commonEventData, commonEventPublishInfo); + auto errorCode = CommonEventManager::NewPublishCommonEventAsUser(commonEventData, commonEventPublishInfo, userId); + EVENT_LOGD("publishAsUserWithOptionsExecute result: %{public}d.", errorCode); + return errorCode; +} + static ani_ref createSubscriberExecute(ani_env* env, ani_object infoObject) { EVENT_LOGI("createSubscriberExecute call."); CommonEventSubscribeInfo subscribeInfo; AniCommonEventUtils::ConvertCommonEventSubscribeInfo(env, infoObject, subscribeInfo); + subscribeInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::ThreadMode::HANDLER); auto ret = ANI_OK; auto wrapper = new (std::nothrow) SubscriberInstanceWrapper(subscribeInfo); + if (wrapper == nullptr) { + return nullptr; + } ani_class cls; ret = env->FindClass("LcommonEvent/commonEventSubscriber/CommonEventSubscriberInner;", &cls); if (ret != ANI_OK) { EVENT_LOGE("createSubscriberExecute FindClass error. result: %{public}d.", ret); + delete wrapper; + wrapper = 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; } 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; } - 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); - return nullptr; - } - - 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); - 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); - return nullptr; - } EVENT_LOGI("createSubscriberExecute end."); - return resultRef; + return subscriberObj; } static uint32_t subscribeExecute(ani_env* env, ani_ref subscribeRef, ani_object callback) @@ -156,11 +189,36 @@ static uint32_t subscribeExecute(ani_env* env, ani_ref subscribeRef, ani_object } subscriberInstance->SetVm(etsVm); auto result = CommonEventManager::NewSubscribeCommonEvent(subscriberInstance); - + if (result == ANI_OK) { + EVENT_LOGD("result is ANI_OK"); + std::lock_guard lock(subscriberInsMutex); + subscriberInstances[subscriberInstance] = subscriberInstance->GoAsyncCommonEvent(); + } else { + subscriberInstance = nullptr; + } EVENT_LOGI("subscribeExecute result: %{public}d.", result); return result; } +static int32_t removeSubscriberInstance(ani_env* env, SubscriberInstanceWrapper* wrapper) +{ + int32_t result = ERR_OK; + std::lock_guard lock(subscriberInsMutex); + for (auto iter = subscriberInstances.begin(); iter != subscriberInstances.end();) { + if (iter->first.get() == wrapper->GetSubscriber().get()) { + result = CommonEventManager::NewUnSubscribeCommonEvent(iter->first); + ani_ref callbackRef = static_cast(iter->first->GetCallback()); + if (result == ANI_OK && callbackRef != nullptr) { + env->GlobalReference_Delete(callbackRef); + } + iter = subscriberInstances.erase(iter); + } else { + ++iter; + } + } + return result; +} + static uint32_t unsubscribeExecute(ani_env* env, ani_ref subscribeRef) { EVENT_LOGI("unsubscribeExecute call."); @@ -186,11 +244,84 @@ static uint32_t unsubscribeExecute(ani_env* env, ani_ref subscribeRef) EVENT_LOGE("subscriberInstance is null."); return ANI_INVALID_ARGS; } - auto result = CommonEventManager::NewUnSubscribeCommonEvent(subscriberInstance); + auto result = removeSubscriberInstance(env, wrapper); EVENT_LOGI("unsubscribeExecute result: %{public}d.", result); return result; } +static uint32_t removeStickyCommonEventExecute(ani_env* env, ani_string eventId) +{ + EVENT_LOGD("removeStickyCommonEventExecute call"); + std::string eventIdStr; + AniCommonEventUtils::GetStdString(env, eventId, eventIdStr); + EVENT_LOGD("removeStickyCommonEventExecute eventIdStr: %{public}s.", eventIdStr.c_str()); + int returncode = CommonEventManager::RemoveStickyCommonEvent(eventIdStr); + if (returncode != ERR_OK) { + EVENT_LOGE("removeStickyCommonEventExecute failed with error: %{public}d", returncode); + OHOS::AbilityRuntime::ThrowStsError(env, returncode, FindCesErrMsg(returncode)); + } + EVENT_LOGD("removeStickyCommonEventExecute result: %{public}d.", returncode); + return returncode; +} + +static uint32_t setStaticSubscriberStateExecute(ani_env* env, ani_boolean enable) +{ + EVENT_LOGD("setStaticSubscriberStateExecute call"); + int returncode = CommonEventManager::SetStaticSubscriberState(enable); + if (returncode != ERR_OK) { + EVENT_LOGE("setStaticSubscriberStateExecute failed with error: %{public}d", returncode); + if (returncode != Notification::ERR_NOTIFICATION_CES_COMMON_NOT_SYSTEM_APP && + returncode != Notification::ERR_NOTIFICATION_SEND_ERROR) { + returncode = Notification::ERR_NOTIFICATION_CESM_ERROR; + } + OHOS::AbilityRuntime::ThrowStsError(env, returncode, FindCesErrMsg(returncode)); + } + EVENT_LOGD("setStaticSubscriberStateExecute result: %{public}d", returncode); + return returncode; +} + +static uint32_t setStaticSubscriberStateWithEventsExecute(ani_env* env, ani_boolean enable, ani_object events) +{ + EVENT_LOGD("setStaticSubscriberStateWithEventsExecute call"); + std::vector eventList; + AniCommonEventUtils::GetStdStringArrayClass(env, events, eventList); + int returncode = (events == nullptr) ? + CommonEventManager::SetStaticSubscriberState(enable) : + CommonEventManager::SetStaticSubscriberState(eventList, enable); + if (returncode != ERR_OK) { + EVENT_LOGE("setStaticSubscriberStateWithEventsExecute failed with error: %{public}d", returncode); + if (returncode != Notification::ERR_NOTIFICATION_CES_COMMON_NOT_SYSTEM_APP && + returncode != Notification::ERR_NOTIFICATION_SEND_ERROR) { + returncode = Notification::ERR_NOTIFICATION_CESM_ERROR; + } + OHOS::AbilityRuntime::ThrowStsError(env, returncode, FindCesErrMsg(returncode)); + } + EVENT_LOGD("setStaticSubscriberStateWithEventsExecute result: %{public}d.", returncode); + return returncode; +} + +std::shared_ptr GetSubscriber(ani_env* env, ani_ref subscribeRef) +{ + EVENT_LOGD("GetSubscriber excute"); + auto ret = ANI_OK; + + ani_long wrapper_long {}; + ret = env->Object_GetPropertyByName_Long( + static_cast(subscribeRef), "subscriberInstanceWrapper", &wrapper_long); + if (ret != ANI_OK) { + EVENT_LOGE("subscribeExecute Object_GetPropertyByName_Long error. result: %{public}d.", ret); + return nullptr; + } + + SubscriberInstanceWrapper* wrapper = nullptr; + wrapper = reinterpret_cast(wrapper_long); + if (wrapper == nullptr) { + EVENT_LOGE("unsubscribeExecute wrapper is null."); + return nullptr; + } + return GetSubscriberByWrapper(wrapper); +} + std::shared_ptr GetSubscriberByWrapper(SubscriberInstanceWrapper* wrapper) { if (wrapper->GetSubscriber() == nullptr) { @@ -215,6 +346,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) @@ -231,13 +365,13 @@ void SubscriberInstance::OnReceiveEvent(const CommonEventData& data) } ani_env* etsEnv; - ani_status aniResult = ANI_ERROR; - ani_options aniArgs { 0, nullptr }; - aniResult = etsVm_->AttachCurrentThread(&aniArgs, ANI_VERSION_1, &etsEnv); + ani_status aniResult = ANI_OK; + aniResult = etsVm_->GetEnv(ANI_VERSION_1, &etsEnv); if (aniResult != ANI_OK) { - EVENT_LOGE("subscribeCallbackThreadFunciton FunctionalObject_Call error. result: %{public}d.", aniResult); + EVENT_LOGE("subscribeCallbackThreadFunciton GetEnv error. result: %{public}d.", aniResult); return; } + ani_object ani_data {}; AniCommonEventUtils::ConvertCommonEventDataToEts(etsEnv, ani_data, data); @@ -247,7 +381,7 @@ void SubscriberInstance::OnReceiveEvent(const CommonEventData& data) EVENT_LOGE("subscribeCallbackThreadFunciton GetNull error. result: %{public}d.", aniResult); } - auto fnObject = reinterpret_cast(static_cast(callback_)); + auto fnObject = reinterpret_cast(reinterpret_cast(callback_)); if (fnObject == nullptr) { EVENT_LOGE("subscribeCallbackThreadFunciton fnObject is null."); return; @@ -259,13 +393,6 @@ void SubscriberInstance::OnReceiveEvent(const CommonEventData& data) aniResult = etsEnv->FunctionalObject_Call(fnObject, args.size(), args.data(), &result); if (aniResult != ANI_OK) { EVENT_LOGE("subscribeCallbackThreadFunciton FunctionalObject_Call error. result: %{public}d.", aniResult); - return; - } - - aniResult = etsVm_->DetachCurrentThread(); - if (aniResult != ANI_OK) { - EVENT_LOGE("subscribeCallbackThreadFunciton DetachCurrentThread error. result: %{public}d.", aniResult); - return; } } @@ -293,6 +420,12 @@ void SubscriberInstance::SetCallback(const ani_object& callback) callback_ = callback; } +ani_object SubscriberInstance::GetCallback() +{ + std::lock_guard lockRef(callbackMutex_); + return callback_; +} + void SubscriberInstance::ClearEnv() { EVENT_LOGD("Env expired, clear SubscriberInstance env"); @@ -321,30 +454,261 @@ std::shared_ptr SubscriberInstanceWrapper::GetSubscriber() return subscriber; } -extern "C" { -ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) +static void clean([[maybe_unused]] ani_env *env, [[maybe_unused]] ani_object object) { - EVENT_LOGI("ANI_Constructor call."); - ani_env* env; - ani_status status = ANI_ERROR; - if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { - EVENT_LOGE("Unsupported ANI_VERSION_1."); - return ANI_ERROR; + ani_long ptr; + if (ANI_OK != env->Object_GetFieldByName_Long(object, "ptr", &ptr)) { + return; } + SubscriberInstanceWrapper* wrapper = nullptr; + wrapper = reinterpret_cast(ptr); + if (wrapper == nullptr) { + EVENT_LOGE("clean wrapper is null."); + return; + } + auto result = removeSubscriberInstance(env, wrapper); + EVENT_LOGD("clean result: %{public}d.", result); + return; +} - ani_namespace kitNs; - status = env->FindNamespace("L@ohos/commonEventManager/commonEventManager;", &kitNs); - if (status != ANI_OK) { - EVENT_LOGE("Not found L@ohos/commonEventManager/commonEventManager."); - return ANI_INVALID_ARGS; +std::shared_ptr GetAsyncCommonEventResult(ani_env* env, ani_object object) +{ + EVENT_LOGD("subscriberInstance GetAsyncCommonEventResult."); + auto subscriberInstance = GetSubscriber(env, object); + if (subscriberInstance == nullptr) { + EVENT_LOGE("subscriberInstance is null."); + return nullptr; + } + if (subscriberInstances.size() == 0) { + EVENT_LOGE("subscriberInstances is null."); + return nullptr; + } + std::lock_guard lock(subscriberInsMutex); + for (auto subscriberRes : subscriberInstances) { + if (subscriberRes.first.get() == subscriberInstance.get()) { + return subscriberInstances[subscriberRes.first]; + } + } + return nullptr; +} + +static ani_double getCode(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance getCode."); + auto subscriberRes = GetAsyncCommonEventResult(env, object); + int32_t code = 0; + if (subscriberRes != nullptr) { + code = subscriberRes->GetCode(); + } + ani_double returncode = static_cast(code); + return returncode; +} + +static uint32_t setCode(ani_env *env, ani_object object, ani_int code) +{ + EVENT_LOGD("subscriberInstance setCode."); + int32_t returncode = 0; + auto subscriberRes = GetAsyncCommonEventResult(env, object); + if (subscriberRes == nullptr) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + bool returnBoolean = subscriberRes->SetCode(code); + if (!returnBoolean) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + return returncode; +} + +static ani_string getData(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance getData."); + auto subscriberRes = GetAsyncCommonEventResult(env, object); + std::string str = ""; + if (subscriberRes != nullptr) { + str = subscriberRes->GetData(); + } + ani_string aniResult = nullptr; + AniCommonEventUtils::GetAniString(env, str, aniResult); + return aniResult; +} + +static uint32_t setData(ani_env *env, ani_object object, ani_string data) +{ + EVENT_LOGD("subscriberInstance setData."); + int32_t returncode = 0; + auto subscriberRes = GetAsyncCommonEventResult(env, object); + if (subscriberRes == nullptr) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + std::string stdData; + AniCommonEventUtils::GetStdString(env, data, stdData); + ani_boolean returnBoolean = static_cast(subscriberRes->SetData(stdData)); + if (!returnBoolean) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + return returncode; +} + +static uint32_t setCodeAndData(ani_env *env, ani_object object, ani_int code, ani_string data) +{ + EVENT_LOGD("subscriberInstance setCodeAndData."); + int32_t returncode = 0; + auto subscriberRes = GetAsyncCommonEventResult(env, object); + if (subscriberRes == nullptr) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + std::string stdData; + int32_t intCode = static_cast(code); + AniCommonEventUtils::GetStdString(env, data, stdData); + bool returnBoolean = subscriberRes->SetCodeAndData(intCode, stdData); + if (!returnBoolean) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + return returncode; +} + +static ani_boolean isOrderedCommonEvent(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance isOrderedCommonEvent."); + auto subscriberRes = GetAsyncCommonEventResult(env, object); + ani_boolean returnBoolean = ANI_FALSE; + if (subscriberRes != nullptr) { + returnBoolean = subscriberRes->IsOrderedCommonEvent() ? ANI_TRUE : ANI_FALSE; + } + return returnBoolean; +} + +static ani_boolean isStickyCommonEvent(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance isStickyCommonEvent."); + auto subscriberRes = GetAsyncCommonEventResult(env, object); + ani_boolean returnBoolean = ANI_FALSE; + if (subscriberRes != nullptr) { + returnBoolean = subscriberRes->IsStickyCommonEvent() ? ANI_TRUE : ANI_FALSE; + } + return returnBoolean; +} + +static uint32_t abortCommonEvent(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance abortCommonEvent."); + int32_t returncode = 0; + auto subscriberRes = GetAsyncCommonEventResult(env, object); + if (subscriberRes == nullptr) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + if (!(subscriberRes->AbortCommonEvent())) { + return returncode; + } + return returncode; +} + +static uint32_t clearAbortCommonEvent(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance clearAbortCommonEvent."); + int32_t returncode = 0; + auto subscriberRes = GetAsyncCommonEventResult(env, object); + if (subscriberRes == nullptr) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + if (!(subscriberRes->ClearAbortCommonEvent())) { + return returncode; + } + return returncode; +} + +static ani_boolean getAbortCommonEvent(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance getAbortCommonEvent."); + auto subscriberRes = GetAsyncCommonEventResult(env, object); + ani_boolean returnBoolean = ANI_FALSE; + if (subscriberRes != nullptr) { + returnBoolean = subscriberRes->GetAbortCommonEvent() ? ANI_TRUE : ANI_FALSE; } + return returnBoolean; +} +static ani_object getSubscribeInfo(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance getSubscribeInfo."); + auto subscriberInstance = GetSubscriber(env, object); + ani_object infoObject {}; + if (subscriberInstance == nullptr) { + EVENT_LOGE("subscriberInstance is null."); + ani_ref nullObject; + env->GetNull(&nullObject); + return static_cast(nullObject); + } + AniCommonEventUtils::GetCommonEventSubscribeInfoToEts(env, subscriberInstance, infoObject); + if (infoObject == nullptr) { + EVENT_LOGE("infoObject is null."); + ani_ref nullObject; + env->GetNull(&nullObject); + return static_cast(nullObject); + } + return infoObject; +} + +static uint32_t finishCommonEvent(ani_env *env, ani_object object) +{ + EVENT_LOGD("subscriberInstance finishCommonEvent."); + auto subscriberRes = GetAsyncCommonEventResult(env, object); + int32_t returncode = 0; + if (subscriberRes == nullptr) { + EVENT_LOGE("subscriberRes is null"); + return returncode; + } + if (!(subscriberRes->FinishCommonEvent())) { + return returncode; + } + return returncode; +} + +static std::array commonEventSubscriberFunctions = { + ani_native_function{"nativeGetCode", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::getCode)}, + ani_native_function{"nativeSetCode", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::setCode)}, + ani_native_function{"nativeGetData", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::getData)}, + ani_native_function{"nativeSetData", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::setData)}, + ani_native_function{"nativeSetCodeAndData", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::setCodeAndData)}, + ani_native_function{"nativeIsOrderedCommonEvent", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::isOrderedCommonEvent)}, + ani_native_function{"nativeIsStickyCommonEvent", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::isStickyCommonEvent)}, + ani_native_function{"nativeAbortCommonEvent", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::abortCommonEvent)}, + ani_native_function{"nativeClearAbortCommonEvent", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::clearAbortCommonEvent)}, + ani_native_function{"nativeGetAbortCommonEvent", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::getAbortCommonEvent)}, + ani_native_function{"nativeGetSubscribeInfo", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::getSubscribeInfo)}, + ani_native_function{"nativeFinishCommonEvent", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::finishCommonEvent)}, +}; + +ani_status init(ani_env *env, ani_namespace kitNs) +{ + ani_status status = ANI_ERROR; std::array methods = { ani_native_function { "publishExecute", "Lstd/core/String;:I", reinterpret_cast(OHOS::EventManagerFwkAni::publishExecute) }, ani_native_function { "publishWithOptionsExecute", "Lstd/core/String;LcommonEvent/commonEventPublishData/CommonEventPublishData;:I", reinterpret_cast(OHOS::EventManagerFwkAni::publishWithOptionsExecute) }, + ani_native_function { "publishAsUserExecute", "Lstd/core/String;I:I", + reinterpret_cast(OHOS::EventManagerFwkAni::publishAsUserExecute) }, + ani_native_function { "publishAsUserWithOptionsExecute", + "Lstd/core/String;ILcommonEvent/commonEventPublishData/CommonEventPublishData;:I", + reinterpret_cast(OHOS::EventManagerFwkAni::publishAsUserWithOptionsExecute) }, ani_native_function { "createSubscriberExecute", "LcommonEvent/commonEventSubscribeInfo/CommonEventSubscribeInfo;:LcommonEvent/commonEventSubscriber/" "CommonEventSubscriber;", @@ -353,6 +717,12 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) "subscribeExecute", nullptr, reinterpret_cast(OHOS::EventManagerFwkAni::subscribeExecute) }, ani_native_function { "unsubscribeExecute", "LcommonEvent/commonEventSubscriber/CommonEventSubscriber;:I", reinterpret_cast(OHOS::EventManagerFwkAni::unsubscribeExecute) }, + ani_native_function { "removeStickyCommonEventExecute", "Lstd/core/String;:I", + reinterpret_cast(OHOS::EventManagerFwkAni::removeStickyCommonEventExecute) }, + ani_native_function { "setStaticSubscriberStateExecute", "Z:I", + reinterpret_cast(OHOS::EventManagerFwkAni::setStaticSubscriberStateExecute) }, + ani_native_function { "setStaticSubscriberStateWithEventsExecute", nullptr, + reinterpret_cast(OHOS::EventManagerFwkAni::setStaticSubscriberStateWithEventsExecute) }, }; status = env->Namespace_BindNativeFunctions(kitNs, methods.data(), methods.size()); @@ -360,7 +730,59 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) EVENT_LOGE("Cannot bind native methods to L@ohos/event/common_event_manager/commonEventManager"); return ANI_INVALID_TYPE; } + return status; +} +extern "C" { +ANI_EXPORT ani_status ANI_Constructor(ani_vm* vm, uint32_t* result) +{ + EVENT_LOGI("ANI_Constructor call."); + ani_env* env; + ani_status status = ANI_ERROR; + if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { + EVENT_LOGE("Unsupported ANI_VERSION_1."); + return ANI_ERROR; + } + + ani_namespace kitNs; + status = env->FindNamespace("L@ohos/commonEventManager/commonEventManager;", &kitNs); + if (status != ANI_OK) { + EVENT_LOGE("Not found L@ohos/commonEventManager/commonEventManager."); + return ANI_INVALID_ARGS; + } + status = init(env, kitNs); + if (status != ANI_OK) { + EVENT_LOGE("Cannot bind native methods to L@ohos/events/emitter/emitter"); + 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; + } + + ani_class commonEventSubscriberCls; + status = env->FindClass("LcommonEvent/commonEventSubscriber/CommonEventSubscriberInner;", + &commonEventSubscriberCls); + if (status != ANI_OK) { + EVENT_LOGE("Not found LcommonEvent/commonEventSubscriber/CommonEventSubscriberInner"); + return ANI_INVALID_ARGS; + } + status = env->Class_BindNativeMethods(commonEventSubscriberCls, commonEventSubscriberFunctions.data(), + commonEventSubscriberFunctions.size()); + if (status != ANI_OK) { + EVENT_LOGE("Cannot bind native methods to LcommonEvent/commonEventSubscriber/CommonEventSubscriberInner"); + 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 496552f9..e683d11d 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 "ani_common_want.h" #include "event_log_wrapper.h" namespace OHOS { @@ -41,6 +42,20 @@ void AniCommonEventUtils::GetStdString(ani_env* env, ani_string str, std::string result.resize(sz); } +ani_status AniCommonEventUtils::GetAniString(ani_env* env, const std::string str, ani_string& aniStr) +{ + if (env == nullptr) { + EVENT_LOGE("GetAniStringByString fail, env is nullptr"); + return ANI_INVALID_ARGS; + } + ani_status status = env->String_NewUTF8(str.c_str(), str.size(), &aniStr); + if (status != ANI_OK) { + EVENT_LOGE("String_NewUTF8 failed %{public}d", status); + return status; + } + return status; +} + void AniCommonEventUtils::GetStdStringArrayClass(ani_env* env, ani_object arrayObj, std::vector& strings) { ani_double length; @@ -99,6 +114,36 @@ bool AniCommonEventUtils::GetStringOrUndefined(ani_env* env, ani_object param, c return true; } +bool AniCommonEventUtils::GetDoubleOrUndefined(ani_env* env, ani_object param, const char* name, int32_t& res) +{ + ani_ref obj = nullptr; + ani_boolean isUndefined = true; + ani_status status = ANI_ERROR; + + if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) { + EVENT_LOGE("status : %{public}d", status); + return false; + } + if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) { + EVENT_LOGE("status : %{public}d", status); + return false; + } + if (isUndefined) { + EVENT_LOGW("%{public}s : undefined", name); + return false; + } + + ani_double result = 0; + if ((status = env->Object_CallMethodByName_Double(reinterpret_cast(obj), "unboxed", nullptr, &result)) + != ANI_OK) { + EVENT_LOGE("status : %{public}d", status); + return false; + } + + res = static_cast(result); + return true; +} + bool AniCommonEventUtils::GetIntOrUndefined(ani_env* env, ani_object param, const char* name, int32_t& res) { ani_ref obj = nullptr; @@ -119,7 +164,7 @@ bool AniCommonEventUtils::GetIntOrUndefined(ani_env* env, ani_object param, cons } ani_int result = 0; - if ((status = env->Object_CallMethodByName_Int(reinterpret_cast(obj), "intValue", nullptr, &result)) != + if ((status = env->Object_CallMethodByName_Int(reinterpret_cast(obj), "unboxed", nullptr, &result)) != ANI_OK) { EVENT_LOGE("status : %{public}d", status); return false; @@ -183,12 +228,39 @@ bool AniCommonEventUtils::GetStringArrayOrUndefined( return true; } +bool AniCommonEventUtils::GetWantParamsOrUndefined( + ani_env* env, ani_object param, const char* name, AAFwk::WantParams& wantParams) +{ + ani_ref obj = nullptr; + ani_boolean isUndefined = true; + ani_status status = ANI_ERROR; + if ((status = env->Object_GetPropertyByName_Ref(param, name, &obj)) != ANI_OK) { + EVENT_LOGE("status : %{public}d", status); + return false; + } + if ((status = env->Reference_IsUndefined(obj, &isUndefined)) != ANI_OK) { + EVENT_LOGE("status : %{public}d", status); + return false; + } + if (isUndefined) { + EVENT_LOGW("%{public}s : undefined", name); + return false; + } + + if (!UnwrapWantParams(env, obj, wantParams)) { + EVENT_LOGE("GetWantParamsOrUndefined UnwrapWantParams error."); + return false; + } + + return true; +} + void AniCommonEventUtils::ConvertCommonEventPublishData(ani_env* env, ani_object optionsObject, Want& want, CommonEventData &commonEventData, CommonEventPublishInfo &commonEventPublishInfo) { // Get the code. int32_t code; - if (GetIntOrUndefined(env, optionsObject, "code", code)) { + if (GetDoubleOrUndefined(env, optionsObject, "code", code)) { EVENT_LOGI("ConvertCommonEventPublishData code: %{public}d.", code); commonEventData.SetCode(code); } else { @@ -241,6 +313,13 @@ void AniCommonEventUtils::ConvertCommonEventPublishData(ani_env* env, ani_object } // Get the parameters [Record] + AAFwk::WantParams wantParams; + if (GetWantParamsOrUndefined(env, optionsObject, "parameters", wantParams)) { + EVENT_LOGI("ConvertCommonEventPublishData parameters success."); + want.SetParams(wantParams); + } else { + EVENT_LOGI("ConvertCommonEventPublishData parameters not exit"); + } } void AniCommonEventUtils::ConvertCommonEventSubscribeInfo( @@ -289,7 +368,7 @@ void AniCommonEventUtils::ConvertCommonEventSubscribeInfo( // Get the userId. int32_t userId; - if (GetIntOrUndefined(env, infoObject, "userId", userId)) { + if (GetDoubleOrUndefined(env, infoObject, "userId", userId)) { EVENT_LOGI("ConvertCommonEventPublishData userId: %{public}d.", userId); commonEventSubscribeInfo.SetUserId(userId); } else { @@ -298,7 +377,7 @@ void AniCommonEventUtils::ConvertCommonEventSubscribeInfo( // Get the priority. int32_t priority; - if (GetIntOrUndefined(env, infoObject, "priority", priority)) { + if (GetDoubleOrUndefined(env, infoObject, "priority", priority)) { EVENT_LOGI("ConvertCommonEventPublishData priority: %{public}d.", priority); commonEventSubscribeInfo.SetPriority(priority); } else { @@ -308,6 +387,110 @@ void AniCommonEventUtils::ConvertCommonEventSubscribeInfo( subscribeInfo = commonEventSubscribeInfo; } +void AniCommonEventUtils::GetCommonEventSubscribeInfoToEts( + ani_env* env, std::shared_ptr subscriber, ani_object &infoObject) +{ + ani_class cls = nullptr; + ani_status status = ANI_ERROR; + CreateNewObjectByClass(env, "LcommonEvent/commonEventSubscribeInfo/CommonEventSubscribeInfoImpl;", cls, infoObject); + if ((infoObject == nullptr) || (cls == nullptr)) { + EVENT_LOGE("CommonEventSubscribeInfoToAni infoObject or cls is null."); + return; + } + if (subscriber == nullptr) { + EVENT_LOGE("subscriber is null."); + return; + } + + // set events [Array] + ani_object eventsParamRef = GetAniStringArray(env, subscriber->GetSubscribeInfo().GetMatchingSkills().GetEvents()); + CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(events), eventsParamRef); + + ani_string string = nullptr; + // set publisherPermission [string] + status = env->String_NewUTF8( + subscriber->GetSubscribeInfo().GetPermission().c_str(), + subscriber->GetSubscribeInfo().GetPermission().size(), &string); + CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(publisherPermission), string); + + // set publisherDeviceId [string] + status = env->String_NewUTF8( + subscriber->GetSubscribeInfo().GetDeviceId().c_str(), + subscriber->GetSubscribeInfo().GetDeviceId().size(), &string); + CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(publisherDeviceId), string); + + // set publisherBundleName [string] + status = env->String_NewUTF8( + subscriber->GetSubscribeInfo().GetPublisherBundleName().c_str(), + subscriber->GetSubscribeInfo().GetPublisherBundleName().size(), &string); + CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(publisherBundleName), string); + + // set userId [number] + ani_object userIdObject; + CreateAniDoubleObject(env, userIdObject, static_cast(subscriber->GetSubscribeInfo().GetUserId())); + CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(userId), userIdObject); + + // set priority [number] + ani_object priorityObject; + CreateAniDoubleObject(env, priorityObject, static_cast(subscriber->GetSubscribeInfo().GetPriority())); + CallSetter(env, cls, infoObject, SETTER_METHOD_NAME(priority), priorityObject); +} + +ani_object AniCommonEventUtils::GetAniStringArray(ani_env *env, std::vector strs) +{ + if (env == nullptr) { + EVENT_LOGE("GetAniStringArray fail, env is nullptr or strs is empty"); + return nullptr; + } + int length = strs.size(); + ani_object arrayObj = newArrayClass(env, length); + if (arrayObj == nullptr) { + return nullptr; + } + ani_size i = 0; + for (auto &str : strs) { + EVENT_LOGI("GetAniStringArray: %{public}s", str.c_str()); + ani_string aniStr; + if ((env->String_NewUTF8(str.c_str(), str.size(), &aniStr) != ANI_OK) || aniStr == nullptr) { + EVENT_LOGE("String_NewUTF8 faild"); + return nullptr; + } + ani_status status = env->Object_CallMethodByName_Void(arrayObj, "$_set", "ILstd/core/Object;:V", i, aniStr); + if (status != ANI_OK) { + EVENT_LOGE("Object_CallMethodByName_Void failed %{public}d", status); + return nullptr; + } + i++; + } + return arrayObj; +} + +ani_object AniCommonEventUtils::newArrayClass(ani_env *env, int length) +{ + EVENT_LOGD("newArrayClass call"); + if (env == nullptr || length < 0) { + EVENT_LOGE("CreateDouble fail, env is nullptr or length is less than zero"); + return nullptr; + } + ani_class arrayCls = nullptr; + if (ANI_OK != env->FindClass("Lescompat/Array;", &arrayCls)) { + EVENT_LOGE("FindClass Lescompat/Array; Failed"); + return nullptr; + } + ani_method arrayCtor; + if (ANI_OK != env->Class_FindMethod(arrayCls, "", "I:V", &arrayCtor)) { + EVENT_LOGE("Class_FindMethod Failed"); + return nullptr; + } + ani_object arrayObj = nullptr; + if (ANI_OK != env->Object_New(arrayCls, arrayCtor, &arrayObj, length)) { + EVENT_LOGE("Object_New Array Faild"); + return nullptr; + } + EVENT_LOGD("newArrayClass end"); + return arrayObj; +} + void AniCommonEventUtils::CreateNewObjectByClass( ani_env* env, const char* className, ani_class& cls, ani_object& ani_data) { @@ -444,6 +627,8 @@ void AniCommonEventUtils::ConvertCommonEventDataToEts( CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(code), codeObject); // set parameters [Record] + ani_ref wantParamRef = WrapWantParams(env, commonEventData.GetWant().GetParams()); + CallSetter(env, cls, ani_data, SETTER_METHOD_NAME(parameters), wantParamRef); } } // namespace EventManagerFwkAni -- Gitee From e96bc9ed4497477678cf13900ea8bbc280707b59 Mon Sep 17 00:00:00 2001 From: heguokai <275503077@qq.com> Date: Tue, 8 Jul 2025 17:39:31 +0800 Subject: [PATCH 2/2] modify ets Signed-off-by: heguokai <275503077@qq.com> --- .../kits/ani/common_event/ets/@ohos.commonEventManager.ets | 1 + 1 file changed, 1 insertion(+) diff --git a/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets b/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets index 9c43774b..c89172b7 100644 --- a/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets +++ b/interfaces/kits/ani/common_event/ets/@ohos.commonEventManager.ets @@ -339,6 +339,7 @@ namespace commonEventManager { COMMON_EVENT_VPN_CONNECTION_STATUS_CHANGED = 'usual.event.VPN_CONNECTION_STATUS_CHANGED', COMMON_EVENT_RESTORE_START = 'usual.event.RESTORE_START', COMMON_EVENT_MANAGED_BROWSER_POLICY_CHANGED = 'usual.event.MANAGED_BROWSER_POLICY_CHANGED', + COMMON_EVENT_DEFAULT_APPLICATION_CHANGED = 'usual.event.DEFAULT_APPLICATION_CHANGED', COMMON_EVENT_SHORTCUT_CHANGED = 'usual.event.SHORTCUT_CHANGED', COMMON_EVENT_KIOSK_MODE_ON = 'usual.event.KIOSK_MODE_ON', COMMON_EVENT_KIOSK_MODE_OFF = 'usual.event.KIOSK_MODE_OFF', -- Gitee