From ce05367383d8ef857e5ea38d4aa135c14157b76c Mon Sep 17 00:00:00 2001 From: wulei0903 <360633228@qq.com> Date: Tue, 26 Aug 2025 20:16:50 +0800 Subject: [PATCH] =?UTF-8?q?taihe=E8=AF=AD=E6=B3=95=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wulei0903 <360633228@qq.com> --- frameworks/ets/taihe/BUILD.gn | 15 +- .../ets/taihe/idl/ohos.telephony.call.taihe | 714 ++++++++++---- .../include/taihe_call_ability_callback.h | 20 + .../taihe/src/ohos.telephony.call.impl.cpp | 895 +++++++++++++++++- .../taihe/src/taihe_call_ability_callback.cpp | 92 ++ .../taihe/src/taihe_call_manager_callback.cpp | 10 +- 6 files changed, 1526 insertions(+), 220 deletions(-) diff --git a/frameworks/ets/taihe/BUILD.gn b/frameworks/ets/taihe/BUILD.gn index b7385528..2b0ef5b3 100644 --- a/frameworks/ets/taihe/BUILD.gn +++ b/frameworks/ets/taihe/BUILD.gn @@ -41,6 +41,7 @@ taihe_shared_library("telephony_call_taihe_native") { sources = get_target_outputs(":run_taihe") include_dirs = [ "${call_manager_path}/frameworks/ets/taihe/include", + "//base/telephony/call_manager/interfaces/innerkits", ] sources += [ "src/ani_constructor.cpp", @@ -52,13 +53,14 @@ taihe_shared_library("telephony_call_taihe_native") { ] deps = [ ":run_taihe", - "//base/telephony/call_manager/frameworks/native:tel_call_manager_api" + "//base/telephony/call_manager:tel_call_manager", + "//base/telephony/call_manager/frameworks/native:tel_call_manager_api", ] external_deps = [ "ability_base:base", "ability_base:want", "ability_runtime:ability_manager", - "ability_runtime:napi_common", + "ability_runtime:ani_common", "c_utils:utils", "core_service:libtel_common", "core_service:tel_core_service_api", @@ -68,8 +70,17 @@ taihe_shared_library("telephony_call_taihe_native") { "init:libbegetutil", "libuv:uv", "napi:ace_napi", + "runtime_core:ani_helpers", + "runtime_core:libarkruntime", ] + cflags_cc = [ + "-Wall", + "-fPIC", + "-frtti", + ] + remove_configs = [ "//build/config/compiler:no_rtti" ] + sanitize = { cfi = false cfi_cross_dso = false diff --git a/frameworks/ets/taihe/idl/ohos.telephony.call.taihe b/frameworks/ets/taihe/idl/ohos.telephony.call.taihe index a4f04daf..9e71b7c5 100644 --- a/frameworks/ets/taihe/idl/ohos.telephony.call.taihe +++ b/frameworks/ets/taihe/idl/ohos.telephony.call.taihe @@ -14,28 +14,67 @@ */ @!sts_inject_into_module("import Context from 'application.Context';") +@!sts_inject_into_module("import {AsyncCallback , Callback} from '@ohos.base';") +@!sts_inject_into_module("import image from '@ohos.multimedia.image';") @!namespace("@ohos.telephony.call", "call") @!sts_inject(""" static { loadLibrary("telephony_call_taihe_native.z") } """) -@!sts_inject_into_module("import Context from 'application.Context';") -@!sts_inject_into_module("import {AsyncCallback , Callback} from '@ohos.base';") -@!sts_inject_into_module("import image from '@ohos.multimedia.image';") -enum CallState: i32 { - CALL_STATE_UNKNOWN = -1, - CALL_STATE_IDLE = 0, - CALL_STATE_RINGING = 1, - CALL_STATE_OFFHOOK = 2, - CALL_STATE_ANSWERED = 3 + +enum ImsCallMode: i32 { + CALL_MODE_AUDIO_ONLY = 0, + CALL_MODE_SEND_ONLY = 1, + CALL_MODE_RECEIVE_ONLY = 2, + CALL_MODE_SEND_RECEIVE = 3, + CALL_MODE_VIDEO_PAUSED = 4, } -enum VideoStateType: i32 { - TYPE_VOICE = 0, - TYPE_VIDEO, - TYPE_VIDEO_SEND_ONLY = 1, - TYPE_VIDEO_RECEIVE_ONLY, - TYPE_VIDEO_BIDIRECTIONAL, + +enum VoNRState: i32 { + VONR_STATE_OFF = 0, + VONR_STATE_ON = 1, +} + +enum AudioDeviceType: i32 { + DEVICE_EARPIECE = 0, + DEVICE_SPEAKER = 1, + DEVICE_WIRED_HEADSET = 2, + DEVICE_BLUETOOTH_SCO = 3, + DEVICE_DISTRIBUTED_AUTOMOTIVE = 4, +} + +enum CallRestrictionType: i32 { + RESTRICTION_TYPE_ALL_INCOMING = 0, + RESTRICTION_TYPE_ALL_OUTGOING = 1, + RESTRICTION_TYPE_INTERNATIONAL = 2, + RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME = 3, + RESTRICTION_TYPE_ROAMING_INCOMING = 4, + RESTRICTION_TYPE_ALL_CALLS = 5, + RESTRICTION_TYPE_OUTGOING_SERVICES = 6, + RESTRICTION_TYPE_INCOMING_SERVICES = 7, +} + +enum CallTransferType: i32 { + TRANSFER_TYPE_UNCONDITIONAL = 0, + TRANSFER_TYPE_BUSY = 1, + TRANSFER_TYPE_NO_REPLY = 2, + TRANSFER_TYPE_NOT_REACHABLE = 3, +} + +enum CallTransferSettingType: i32 { + CALL_TRANSFER_DISABLE = 0, + CALL_TRANSFER_ENABLE = 1, + CALL_TRANSFER_REGISTRATION = 3, + CALL_TRANSFER_ERASURE = 4, +} + +enum ConferenceState: i32 { + TEL_CONFERENCE_IDLE = 0, + TEL_CONFERENCE_ACTIVE = 1, + TEL_CONFERENCE_DISCONNECTING = 2, + TEL_CONFERENCE_DISCONNECTED = 3, } + enum CallType: i32 { TYPE_CS = 0, TYPE_IMS = 1, @@ -43,6 +82,40 @@ enum CallType: i32 { TYPE_ERR_CALL = 3, TYPE_VOIP = 4, } + +enum VideoStateType: i32 { + TYPE_VOICE = 0, + TYPE_VIDEO = 3, + TYPE_VIDEO_SEND_ONLY = 1, + TYPE_VIDEO_RECEIVE_ONLY = 2, + TYPE_VIDEO_BIDIRECTIONAL = 4, +} + +enum VideoRequestResultType: i32 { + TYPE_REQUEST_SUCCESS = 0, + TYPE_REQUEST_FAILURE = 1, + TYPE_REQUEST_INVALID = 2, + TYPE_REQUEST_TIMED_OUT = 3, + TYPE_REQUEST_REJECTED_BY_REMOTE = 4, + TYPE_REQUEST_UPGRADE_CANCELED = 5, + TYPE_DOWNGRADE_RTP_OR_RTCP_TIMEOUT = 100, + TYPE_DOWNGRADE_RTP_AND_RTCP_TIMEOUT = 101, +} + +enum DeviceDirection: i32 { + DEVICE_DIRECTION_0 = 0, + DEVICE_DIRECTION_90 = 90, + DEVICE_DIRECTION_180 = 180, + DEVICE_DIRECTION_270 = 270, +} + +enum CallSessionEventId: i32 { + EVENT_CONTROL_CAMERA_FAILURE = 0, + EVENT_CONTROL_CAMERA_READY = 1, + EVENT_DISPLAY_SURFACE_RELEASED = 100, + EVENT_PREVIEW_SURFACE_RELEASED = 101, +} + enum DetailedCallState: i32 { CALL_STATUS_ACTIVE = 0, CALL_STATUS_HOLDING = 1, @@ -52,14 +125,14 @@ enum DetailedCallState: i32 { CALL_STATUS_WAITING = 5, CALL_STATUS_DISCONNECTED = 6, CALL_STATUS_DISCONNECTING = 7, - CALL_STATUS_IDLE = 8 + CALL_STATUS_IDLE = 8, } -enum ConferenceState: i32 { - TEL_CONFERENCE_IDLE = 0, - TEL_CONFERENCE_ACTIVE, - TEL_CONFERENCE_DISCONNECTING, - TEL_CONFERENCE_DISCONNECTED, + +enum CallRestrictionMode: i32 { + RESTRICTION_MODE_DEACTIVATION = 0, + RESTRICTION_MODE_ACTIVATION = 1, } + enum CallAbilityEventId: i32 { EVENT_DIAL_NO_CARRIER = 1, EVENT_INVALID_FDN_NUMBER = 2, @@ -70,6 +143,42 @@ enum CallAbilityEventId: i32 { EVENT_SHOW_FULL_SCREEN = 7, EVENT_SHOW_FLOAT_WINDOW = 8, } + +enum CallState: i32 { + CALL_STATE_UNKNOWN = -1, + CALL_STATE_IDLE = 0, + CALL_STATE_RINGING = 1, + CALL_STATE_OFFHOOK = 2, + CALL_STATE_ANSWERED = 3, +} + +enum DialScene: i32 { + CALL_NORMAL = 0, + CALL_PRIVILEGED = 1, + CALL_EMERGENCY = 2, +} + +enum DialType: i32 { + DIAL_CARRIER_TYPE = 0, + DIAL_VOICE_MAIL_TYPE = 1, + DIAL_OTT_TYPE = 2, +} + +enum CallWaitingStatus: i32 { + CALL_WAITING_DISABLE = 0, + CALL_WAITING_ENABLE = 1, +} + +enum RestrictionStatus: i32 { + RESTRICTION_DISABLE = 0, + RESTRICTION_ENABLE = 1, +} + +enum TransferStatus: i32 { + TRANSFER_DISABLE = 0, + TRANSFER_ENABLE = 1, +} + enum DisconnectedReason: i32 { UNASSIGNED_NUMBER = 1, NO_ROUTE_TO_DESTINATION = 3, @@ -149,100 +258,9 @@ enum DisconnectedReason: i32 { SIM_PIN_NEED = 1027, CALL_NOT_ALLOW = 1029, SIM_INVALID = 1045, - UNKNOWN = 1279 -} -enum MmiCodeResult: i32 { - MMI_CODE_SUCCESS = 0, - MMI_CODE_FAILED = 1 -} -enum AudioDeviceType: i32 { - DEVICE_EARPIECE, - DEVICE_SPEAKER, - DEVICE_WIRED_HEADSET, - DEVICE_BLUETOOTH_SCO, - DEVICE_DISTRIBUTED_AUTOMOTIVE -} -enum VideoRequestResultType: i32 { - TYPE_REQUEST_SUCCESS = 0, - TYPE_REQUEST_FAILURE, - TYPE_REQUEST_INVALID, - TYPE_REQUEST_TIMED_OUT, - TYPE_REQUEST_REJECTED_BY_REMOTE, - TYPE_REQUEST_UPGRADE_CANCELED, - TYPE_DOWNGRADE_RTP_OR_RTCP_TIMEOUT = 100, - TYPE_DOWNGRADE_RTP_AND_RTCP_TIMEOUT, -} -enum ImsCallMode: i32 { - CALL_MODE_AUDIO_ONLY = 0, - CALL_MODE_SEND_ONLY, - CALL_MODE_RECEIVE_ONLY, - CALL_MODE_SEND_RECEIVE, - CALL_MODE_VIDEO_PAUSED, -} -enum CallSessionEventId: i32 { - EVENT_CONTROL_CAMERA_FAILURE = 0, - EVENT_CONTROL_CAMERA_READY, - EVENT_DISPLAY_SURFACE_RELEASED = 100, - EVENT_PREVIEW_SURFACE_RELEASED, -} -enum VoNRState: i32 { - VONR_STATE_OFF = 0, - VONR_STATE_ON = 1, -} -enum CallRestrictionType: i32 { - RESTRICTION_TYPE_ALL_INCOMING = 0, - RESTRICTION_TYPE_ALL_OUTGOING = 1, - RESTRICTION_TYPE_INTERNATIONAL = 2, - RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME = 3, - RESTRICTION_TYPE_ROAMING_INCOMING = 4, - RESTRICTION_TYPE_ALL_CALLS = 5, - RESTRICTION_TYPE_OUTGOING_SERVICES = 6, - RESTRICTION_TYPE_INCOMING_SERVICES = 7, -} -enum CallTransferType: i32 { - TRANSFER_TYPE_UNCONDITIONAL = 0, - TRANSFER_TYPE_BUSY = 1, - TRANSFER_TYPE_NO_REPLY = 2, - TRANSFER_TYPE_NOT_REACHABLE = 3, -} -enum CallTransferSettingType: i32 { - CALL_TRANSFER_DISABLE = 0, - CALL_TRANSFER_ENABLE = 1, - CALL_TRANSFER_REGISTRATION = 3, - CALL_TRANSFER_ERASURE = 4, -} -enum DeviceDirection: i32 { - DEVICE_DIRECTION_0 = 0, - DEVICE_DIRECTION_90 = 90, - DEVICE_DIRECTION_180 = 180, - DEVICE_DIRECTION_270 = 270, -} -enum CallRestrictionMode: i32 { - RESTRICTION_MODE_DEACTIVATION = 0, - RESTRICTION_MODE_ACTIVATION = 1, -} -enum DialScene: i32 { - CALL_NORMAL = 0, - CALL_PRIVILEGED = 1, - CALL_EMERGENCY = 2, -} -enum DialType: i32 { - DIAL_CARRIER_TYPE = 0, - DIAL_VOICE_MAIL_TYPE = 1, - DIAL_OTT_TYPE = 2, -} -enum CallWaitingStatus: i32 { - CALL_WAITING_DISABLE = 0, - CALL_WAITING_ENABLE = 1, -} -enum RestrictionStatus: i32 { - RESTRICTION_DISABLE = 0, - RESTRICTION_ENABLE = 1, -} -enum TransferStatus: i32 { - TRANSFER_DISABLE = 0, - TRANSFER_ENABLE = 1, + UNKNOWN = 1279, } + enum MarkType: i32 { MARK_TYPE_NONE = 0, MARK_TYPE_CRANK = 1, @@ -257,84 +275,24 @@ enum MarkType: i32 { MARK_TYPE_YELLOW_PAGE = 10, MARK_TYPE_ENTERPRISE = 11, } -struct NumberFormatOptions { - countryCode: Optional; -} -struct VoipCallAttribute { - voipCallId: String; - userName: String; - userProfile: @sts_type("image.PixelMap") Opaque; - extensionId: String; - abilityName: String; - voipBundleName: String; - showBannerForIncomingCall: Optional; - isConferenceCall: Optional; - isVoiceAnswerSupported: Optional; -} -struct NumberMarkInfo { - markType: MarkType; - markContent: Optional; - markCount: Optional; - markSource: Optional; - isCloud: Optional; - markDetails: Optional; -} -struct CallAttributeOptions { - accountNumber: String; - speakerphoneOn: bool; - accountId: i32; - videoState: VideoStateType; - startTime: f64; - isEcc: bool; - callType: CallType; - callId: i32; - callState: DetailedCallState; - conferenceState: ConferenceState; - crsType: i32; - originalCallType: i32; - numberLocation: Optional; -} -struct CallEventOptions { - eventId: CallAbilityEventId; -} -struct DisconnectedDetails { - reason: DisconnectedReason; - message: String; -} -struct MmiCodeResults { - result: MmiCodeResult; - message: String; + +enum MmiCodeResult: i32 { + MMI_CODE_SUCCESS = 0, + MMI_CODE_FAILED = 1, } + struct AudioDevice { deviceType: AudioDeviceType; address: Optional; deviceName: Optional; } + struct AudioDeviceCallbackInfo { audioDeviceList: Array; currentAudioDevice: AudioDevice; isMuted: bool; } -struct ImsCallModeInfo { - callId: i32; - result: VideoRequestResultType; - isRequestInfo: bool; - imsCallMode: ImsCallMode; -} -struct CallSessionEvent { - callId: i32; - eventId: CallSessionEventId; -} -struct PeerDimensionsDetail { - callId: i32; - width: i32; - height: i32; -} -struct CameraCapabilities { - callId: i32; - width: i32; - height: i32; -} + struct CallTransferInfo { transferNum: String; type: CallTransferType; @@ -344,11 +302,44 @@ struct CallTransferInfo { endHour: Optional; endMinute: Optional; } + +struct CallAttributeOptions { + accountNumber: String; + speakerphoneOn: bool; + accountId: i32; + videoState: VideoStateType; + startTime: i32; + isEcc: bool; + callType: CallType; + callId: i32; + callState: DetailedCallState; + conferenceState: ConferenceState; + voipCallAttribute: Optional; + crsType: i32; + originalCallType: i32; + numberLocation: Optional; + numberMarkInfo: Optional; + extraParams: Optional<@record Map>; +} + +struct VoipCallAttribute { + voipCallId: String; + userName: String; + userProfile: @sts_type("image.PixelMap")Opaque; + extensionId: String; + abilityName: String; + voipBundleName: String; + showBannerForIncomingCall: Optional; + isConferenceCall: Optional; + isVoiceAnswerSupported: Optional; +} + struct CallRestrictionInfo { type: CallRestrictionType; password: String; mode: CallRestrictionMode; } + struct DialOptions { extras: Optional; accountId: Optional; @@ -356,6 +347,7 @@ struct DialOptions { dialScene: Optional; dialType: Optional; } + struct DialCallOptions { accountId: Optional; videoState: Optional; @@ -363,32 +355,370 @@ struct DialCallOptions { dialType: Optional; extraParams: Optional<@record Map>; } + struct RejectMessageOptions { messageContent: String; } + +struct CallTransferResult { + status: TransferStatus; + teleNumber: String; + startHour: i32; + startMinute: i32; + endHour: i32; + endMinute: i32; +} + struct EmergencyNumberOptions { slotId: Optional; } -@gen_async("makeCall") -@gen_promise("makeCall") -function makeCallSync(phoneNumber: String): void; -@gen_promise("makeCall") -function makeCallSync2(context: @sts_type("Context") Opaque, phoneNumber: String): void; +struct NumberFormatOptions { + countryCode: Optional; +} + +struct DisconnectedDetails { + reason: DisconnectedReason; + message: String; +} + +struct ImsCallModeInfo { + callId: i32; + result: VideoRequestResultType; + isRequestInfo: bool; + imsCallMode: ImsCallMode; +} + +struct CallSessionEvent { + callId: i32; + eventId: CallSessionEventId; +} + +struct PeerDimensionsDetail { + callId: i32; + width: i32; + height: i32; +} + +struct CameraCapabilities { + callId: i32; + width: i32; + height: i32; +} + +struct NumberMarkInfo { + markType: MarkType; + markContent: Optional; + markCount: Optional; + markSource: Optional; + isCloud: Optional; + markDetails: Optional; +} + +struct CallEventOptions { + eventId: CallAbilityEventId; +} + +struct MmiCodeResults { + result: MmiCodeResult; + message: String; +} + +@static_overload("makeCall") +@async function MakeCallCallback(phoneNumber: String): void; +@static_overload("makeCall") +@promise function MakeCallPromise(phoneNumber: String): void; +function MakeCallSync(phoneNumber: String): void; +@static_overload("makeCall") +@promise function MakeCallWithContextPromise(context: @sts_type("Context") Opaque, phoneNumber: String): void; +function MakeCallSync2(context: @sts_type("Context") Opaque, phoneNumber: String): void; function HasVoiceCapability(): bool; -@gen_async("formatPhoneNumber") -@gen_promise("formatPhoneNumber") -function formatPhoneNumberSync(phoneNumber: String, options: NumberFormatOptions): void; +@static_overload("formatPhoneNumber") +@async function FormatPhoneNumberCallback(phoneNumber: String, options: NumberFormatOptions): void; +@static_overload("formatPhoneNumber") +@promise function FormatPhoneNumberPromise(phoneNumber: String, options: NumberFormatOptions): void; +function FormatPhoneNumberSync(phoneNumber: String, options: NumberFormatOptions): void; + +@static_overload("formatPhoneNumber") +@async function FormatPhoneNumberNoFormatCallback(phoneNumber: String): void; +function FormatPhoneNumberSync2(phoneNumber: String): void; + +@static_overload("isImsSwitchEnabled") +@async function IsImsSwitchEnabledCallback(slotId: i32): bool; +@static_overload("isImsSwitchEnabled") +@promise function IsImsSwitchEnabledPromise(slotId: i32): bool; +function IsImsSwitchEnabledSync(slotId: i32): bool; + +@static_overload("disableImsSwitch") +@async function DisableImsSwitchCallback(slotId: i32): void; +@static_overload("disableImsSwitch") +@promise function DisableImsSwitchPromise(slotId: i32): void; +function DisableImsSwitchSync(slotId: i32): void; + +@static_overload("enableImsSwitch") +@async function EnableImsSwitchCallback(slotId: i32): void; +@static_overload("enableImsSwitch") +@promise function EnableImsSwitchPromise(slotId: i32): void; +function EnableImsSwitchSync(slotId: i32): void; + +@static_overload("updateImsCallMode") +@async function UpdateImsCallModeCallback(callId: i32, mode: ImsCallMode): void; +@static_overload("updateImsCallMode") +@promise function UpdateImsCallModePromise(callId: i32, mode: ImsCallMode): void; +function UpdateImsCallModeSync(callId: i32, mode: ImsCallMode): void; + +@static_overload("joinConference") +@async function JoinConferenceCallback(mainCallId: i32, callNumberList: Array): void; +@static_overload("joinConference") +@promise function JoinConferencePromise(mainCallId: i32, callNumberList: Array): void; +function JoinConferenceSync(mainCallId: i32, callNumberList: Array): void; + +@static_overload("setAudioDevice") +@async function SetAudioDeviceCallback(device: AudioDevice): void; +@static_overload("setAudioDevice") +@promise function SetAudioDevicePromise(device: AudioDevice): void; +function SetAudioDeviceSync(device: AudioDevice): void; + +@static_overload("cancelMuted") +@async function CancelMutedCallback(): void; +@static_overload("cancelMuted") +@promise function CancelMutedPromise(): void; +function CancelMutedSync(): void; + +@static_overload("setMuted") +@async function SetMutedCallback(): void; +@static_overload("setMuted") +@promise function SetMutedPromise(): void; +function SetMutedSync(): void; + +@static_overload("isRinging") +@async function IsRingingCallback(): bool; +@static_overload("isRinging") +@promise function IsRingingPromise(): bool; +function IsRingingSync(): bool; + +@static_overload("separateConference") +@async function SeparateConferenceCallback(callId: i32): void; +@static_overload("separateConference") +@promise function SeparateConferencePromise(callId: i32): void; +function SeparateConferenceSync(callId: i32): void; + +@static_overload("isNewCallAllowed") +@async function IsNewCallAllowedCallback(): bool; +@static_overload("isNewCallAllowed") +@promise function IsNewCallAllowedPromise(): bool; +function IsNewCallAllowedSync(): bool; + +@static_overload("isInEmergencyCall") +@async function IsInEmergencyCallCallback(): bool; +@static_overload("isInEmergencyCall") +@promise function IsInEmergencyCallPromise(): bool; +function IsInEmergencyCallSync(): bool; + +@static_overload("stopDTMF") +@async function StopDTMFCallback(callId: i32): void; +@static_overload("stopDTMF") +@promise function StopDTMFPromise(callId: i32): void; +function StopDTMFSync(callId: i32): void; + +@static_overload("startDTMF") +@async function StartDTMFCallback(callId: i32, character: String): void; +@static_overload("startDTMF") +@promise function StartDTMFPromise(callId: i32, character: String): void; +function StartDTMFSync(callId: i32, character: String): void; + +@static_overload("getCallIdListForConference") +@async function GetCallIdListForConferenceCallback(callId: i32): Array; +@static_overload("getCallIdListForConference") +@promise function GetCallIdListForConferencePromise(callId: i32): Array; +function GetCallIdListForConferenceSync(callId: i32): Array; -@gen_async("formatPhoneNumber") -function formatPhoneNumberSync2(phoneNumber: String): void; +@static_overload("getSubCallIdList") +@async function GetSubCallIdListCallback(callId: i32): Array; +@static_overload("getSubCallIdList") +@promise function GetSubCallIdListPromise(callId: i32): Array; +function GetSubCallIdListSync(callId: i32): Array; -function getCallStateSync(): CallState; +@static_overload("getMainCallId") +@async function GetMainCallIdCallback(callId: i32): i32; +@static_overload("getMainCallId") +@promise function GetMainCallIdPromise(callId: i32): i32; +function GetMainCallIdSync(callId: i32): i32; +@static_overload("combineConference") +@async function CombineConferenceCallback(callId: i32): void; +@static_overload("combineConference") +@promise function CombineConferencePromise(callId: i32): void; +function CombineConferenceSync(callId: i32): void; + +@static_overload("switchCall") +@async function SwitchCallCallback(callId: i32): void; +@static_overload("switchCall") +@promise function SwitchCallPromise(callId: i32): void; +function SwitchCallSync(callId: i32): void; + +@static_overload("unHoldCall") +@async function UnHoldCallCallback(callId: i32): void; +@static_overload("unHoldCall") +@promise function UnHoldCallPromise(callId: i32): void; +function UnHoldCallSync(callId: i32): void; + +@static_overload("holdCall") +@async function HoldCallCallback(callId: i32): void; +@static_overload("holdCall") +@promise function HoldCallPromise(callId: i32): void; +function HoldCallSync(callId: i32): void; + +@static_overload("formatPhoneNumberToE164") +@async function FormatPhoneNumberToE164Callback(phoneNumber: String, countryCode: String): String; +@static_overload("formatPhoneNumberToE164") +@promise function FormatPhoneNumberToE164Promise(phoneNumber: String, countryCode: String): String; +function FormatPhoneNumberToE164Sync(phoneNumber: String, countryCode: String): String; + +@static_overload("isEmergencyPhoneNumber") +@async function IsEmergencyPhoneNumberDefaultCallback(phoneNumber: String, options: EmergencyNumberOptions): bool; +function IsEmergencyPhoneNumberDefaultSync(phoneNumber: String, options: EmergencyNumberOptions): bool; +@static_overload("isEmergencyPhoneNumber") +@promise function IsEmergencyPhoneNumberOptionalPromise(phoneNumber: String, options: Optional): bool; +function IsEmergencyPhoneNumberOptionalSync(phoneNumber: String, options: Optional): bool; +@static_overload("isEmergencyPhoneNumber") +@async function IsEmergencyPhoneNumberCallback(phoneNumber: String): bool; +function IsEmergencyPhoneNumberSync(phoneNumber: String): bool; + +@static_overload("muteRinger") +@async function MuteRingerCallback(): void; +@static_overload("muteRinger") +@promise function MuteRingerPromise(): void; +function MuteRingerSync(): void; + +@static_overload("getCallState") +@async function GetCallStateCallback(): CallState; +@static_overload("getCallState") +@promise function GetCallStatePromise(): CallState; +function GetCallStateSync(): CallState; + +@static_overload("hasCall") +@async function HasCallCallback(): bool; +@static_overload("hasCall") +@promise function HasCallPromise(): bool; function HasCallSync(): bool; +@static_overload("sendCallUiEvent") +@async function SendCallUiEventCallback(callId: i32, eventName: String): void; +@static_overload("sendCallUiEvent") +@promise function SendCallUiEventPromise(callId: i32, eventName: String): void; +function SendCallUiEventSync(callId: i32, eventName: String): void; + +@static_overload("inputDialerSpecialCode") +@async function InputDialerSpecialCodeCallback(inputCode: String): void; +@static_overload("inputDialerSpecialCode") +@promise function InputDialerSpecialCodePromise(inputCode: String): void; +function InputDialerSpecialCodeSync(inputCode: String): void; + +@static_overload("canSetCallTransferTime") +@async function CanSetCallTransferTimeCallback(slotId: i32): bool; +@static_overload("canSetCallTransferTime") +@promise function CanSetCallTransferTimePromise(slotId: i32): bool; +function CanSetCallTransferTimeSync(slotId: i32): bool; + +@static_overload("getVoNRState") +@async function GetVoNRStateCallback(slotId: i32): VoNRState; +@static_overload("getVoNRState") +@promise function GetVoNRStatePromise(slotId: i32): VoNRState; +function GetVoNRStateSync(slotId: i32): VoNRState; + +@static_overload("removeMissedIncomingCallNotification") +@async function RemoveMissedIncomingCallNotificationCallback(): void; +@static_overload("removeMissedIncomingCallNotification") +@promise function RemoveMissedIncomingCallNotificationPromise(): void; +function RemoveMissedIncomingCallNotificationSync(): void; + +@static_overload("setVoNRState") +@async function SetVoNRStateCallback(slotId: i32, state: VoNRState): void; +@static_overload("setVoNRState") +@promise function SetVoNRStatePromise(slotId: i32, state: VoNRState): void; +function SetVoNRStateSync(slotId: i32, state: VoNRState): void; + +@static_overload("setDeviceDirection") +@async function SetDeviceDirectionCallback(callId: i32, deviceDirection: DeviceDirection): void; +@static_overload("setDeviceDirection") +@promise function SetDeviceDirectionPromise(callId: i32, deviceDirection: DeviceDirection): void; +function SetDeviceDirectionSync(callId: i32, deviceDirection: DeviceDirection): void; + +@static_overload("setDisplaySurface") +@async function SetDisplaySurfaceCallback(callId: i32, surfaceId: String): void; +@static_overload("setDisplaySurface") +@promise function SetDisplaySurfacePromise(callId: i32, surfaceId: String): void; +function SetDisplaySurfaceSync(callId: i32, surfaceId: String): void; + +@static_overload("setPreviewSurface") +@async function SetPreviewSurfaceCallback(callId: i32, surfaceId: String): void; +@static_overload("setPreviewSurface") +@promise function SetPreviewSurfacePromise(callId: i32, surfaceId: String): void; +function SetPreviewSurfaceSync(callId: i32, surfaceId: String): void; + +@static_overload("controlCamera") +@async function ControlCameraCallback(callId: i32, cameraId: String): void; +@static_overload("controlCamera") +@promise function ControlCameraPromise(callId: i32, cameraId: String): void; +function ControlCameraSync(callId: i32, cameraId: String): void; + +@static_overload("cancelCallUpgrade") +@async function CancelCallUpgradeCallback(callId: i32): void; +@static_overload("cancelCallUpgrade") +@promise function CancelCallUpgradePromise(callId: i32): void; +function CancelCallUpgradeSync(callId: i32): void; + +@static_overload("kickOutFromConference") +@async function KickOutFromConferenceCallback(callId: i32): void; +@static_overload("kickOutFromConference") +@promise function KickOutFromConferencePromise(callId: i32): void; +function KickOutFromConferenceSync(callId: i32): void; + +@static_overload("postDialProceed") +@async function PostDialProceedCallback(callId: i32, proceed: bool): void; +@static_overload("postDialProceed") +@promise function PostDialProceedPromise(callId: i32, proceed: bool): void; +function PostDialProceedSync(callId: i32, proceed: bool): void; + +@static_overload("answerCall") +@async function AnswerCallDefaultCallback(callId: i32): void; +function AnswerCallDefaultSync(callId: i32): void; +@static_overload("answerCall") +@promise function AnswerCallOptionalPromise(callId: Optional): void; +function AnswerCallOptionalSync(callId: Optional): void; +@static_overload("answerCall") +@async function AnswerCallVoidCallback(): void; +function AnswerCallVoidSync(): void; + +@static_overload("rejectCall") +@async function RejectCallDefaultCallback(callId: i32, options: RejectMessageOptions): void; +function RejectCallDefaultDefaultSync(callId: i32, options: RejectMessageOptions): void; +@static_overload("rejectCall") +@promise function RejectCallOptionalPromise(callId: Optional,options: Optional): void; +function RejectCallOptionalSync(callId: Optional,options: Optional): void; +@static_overload("rejectCall") +@async function RejectCallWithCallIdCallback(callId: i32): void; +function RejectCallWithCallIdSync(callId: i32): void; +@static_overload("rejectCall") +@async function RejectCallWithVoidCallback(): void; +function RejectCallWithVoidSync(): void; +@static_overload("rejectCall") +@async function RejectCallWithRejectMessageCallback(options: RejectMessageOptions): void; +function RejectCallWithRejectMessageSync(options: RejectMessageOptions): void; + +@static_overload("hangUpCall") +@async function HangUpCallCallback(callId: i32): void; +function HangUpCallSync(callId: i32): void; +@static_overload("hangUpCall") +@promise function HangUpCallPromise(callId: Optional): void; +function HangUpCallOptionalSync(callId: Optional): void; +@static_overload("hangUpCall") +@async function HangUpCallWithVoidCallback(): void; +function HangUpCallWithVoidSync(): void; + @!sts_inject(""" export function on(type: string, cb: (arg_0: Object) => void) { switch(type) { diff --git a/frameworks/ets/taihe/include/taihe_call_ability_callback.h b/frameworks/ets/taihe/include/taihe_call_ability_callback.h index 20f7d3fe..31c71963 100644 --- a/frameworks/ets/taihe/include/taihe_call_ability_callback.h +++ b/frameworks/ets/taihe/include/taihe_call_ability_callback.h @@ -23,6 +23,8 @@ #include "ohos.telephony.call.proj.hpp" #include "ohos.telephony.call.impl.hpp" +#include "pac_map.h" + namespace OHOS { namespace Telephony { @@ -64,6 +66,18 @@ public: // 相机能力变化回调 int32_t UpdateCameraCapabilities(const CameraCapabilities &capabilities); + // set/get状态回调 + int32_t UpdateAsyncResultsInfo(const CallResultReportId reportId, AppExecFwk::PacMap &resultInfo); + + void WaitAsyncResults(); + + ::ohos::telephony::call::CallTransferResult transferInfo_ = { + ohos::telephony::call::TransferStatus::key_t::TRANSFER_DISABLE, + "", 0, 0, 0, 0 + }; + ::ohos::telephony::call::CallWaitingStatus waitingStatus_ = ::ohos::telephony::call::CallWaitingStatus::key_t::CALL_WAITING_DISABLE; + ::ohos::telephony::call::RestrictionStatus restrictionStatus_ = ::ohos::telephony::call::RestrictionStatus::key_t::RESTRICTION_DISABLE; + ::taihe::optional> callStateCallback_; ::taihe::optional> callEventCallback_;; ::taihe::optional +#include +#include +#include +#include "ipc_types.h" +#include "telephony_types.h" +#include "ani.h" +#include "ani_common_want.h" +#include "call_manager_base.h" +#include "call_manager_client.h" +#include "call_manager_errors.h" +#include "call_manager_inner_type.h" +#include "ohos.telephony.call.proj.hpp" +#include "string_utils.h" #include "taihe/runtime.hpp" +#include "telephony_log_wrapper.h" +#include "want_params_wrapper.h" #include "stdexcept" - -#include "call_manager_client.h" #include "telephony_errors.h" -#include "telephony_log_wrapper.h" +#include "telephony_types.h" #include - #include "taihe_call_manager.h" #include "taihe_call_ability_callback.h" using namespace taihe; +using namespace OHOS; using namespace OHOS::Telephony; + namespace { +// To be implemented. + +enum AniError : int32_t { + /* * + * Indicates there is no error. + */ + ERROR_NONE = 0, + + /* * + * Indicates the default value of NAPI error. + */ + ERROR_DEFAULT = -1, -void makeCallSync(::taihe::string_view phoneNumber) + /* * + * Indicates the service is unavailable. + */ + ERROR_SERVICE_UNAVAILABLE = -2, + + /* * + * Indicates the count of parameter is error. + */ + ERROR_PARAMETER_COUNTS_INVALID = -4, + + /* * + * Indicates the type of parameter is error. + */ + ERROR_PARAMETER_TYPE_INVALID = -5, + + /* * + * Indicates the native API execute failed. + */ + ERROR_NATIVE_API_EXECUTE_FAIL = -6, + + /* * + * Indicates the slot id is invalid. + */ + ERROR_SLOT_ID_INVALID = 202, +}; + +static inline bool IsValidSlotId(int32_t slotId) +{ + return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT)); +} + +void MakeCallSync(::taihe::string_view phoneNumber) { auto errCode = OHOS::DelayedSingleton::GetInstance()->MakeCall(std::string(phoneNumber)); if (errCode != TELEPHONY_ERR_SUCCESS) { @@ -39,8 +98,9 @@ void makeCallSync(::taihe::string_view phoneNumber) return; } -void makeCallSync2(uintptr_t context, ::taihe::string_view phoneNumber) +void MakeCallSync2(uintptr_t context, ::taihe::string_view phoneNumber) { + (void)context; auto errCode = OHOS::DelayedSingleton::GetInstance()->MakeCall(std::string(phoneNumber)); if (errCode != TELEPHONY_ERR_SUCCESS) { set_business_error(errCode, "makeCall2 return error"); @@ -54,38 +114,386 @@ bool HasVoiceCapability() return static_cast(ret); } -void formatPhoneNumberSync( - ::taihe::string_view phoneNumber, ::ohos::telephony::call::NumberFormatOptions const& options) +void FormatPhoneNumberSync(::taihe::string_view phoneNumber, + ::ohos::telephony::call::NumberFormatOptions const & options) { std::u16string phoneNum = OHOS::Str8ToStr16(std::string(phoneNumber)); std::u16string countryCode = OHOS::Str8ToStr16(std::string(options.countryCode.value_or("cn"))); std::u16string formatNum = OHOS::Str8ToStr16(""); - auto errCode = OHOS::DelayedSingleton::GetInstance()->FormatPhoneNumber( - phoneNum, countryCode, formatNum); + auto errCode = + OHOS::DelayedSingleton::GetInstance()->FormatPhoneNumber(phoneNum, countryCode, formatNum); if (errCode != TELEPHONY_ERR_SUCCESS) { set_business_error(errCode, "formatPhoneNumber return error"); } return; } -void formatPhoneNumberSync2(::taihe::string_view phoneNumber) +void FormatPhoneNumberSync2(::taihe::string_view phoneNumber) { std::u16string phoneNum = OHOS::Str8ToStr16(std::string(phoneNumber)); std::u16string countryCode = OHOS::Str8ToStr16(""); std::u16string formatNum = OHOS::Str8ToStr16(""); - auto errCode = OHOS::DelayedSingleton::GetInstance()->FormatPhoneNumber( - phoneNum, countryCode, formatNum); + auto errCode = + OHOS::DelayedSingleton::GetInstance()->FormatPhoneNumber(phoneNum, countryCode, formatNum); if (errCode != TELEPHONY_ERR_SUCCESS) { - set_business_error(errCode, "formatPhoneNumber2 return error"); + set_business_error(errCode, "FormatPhoneNumber return error"); } return; } -::ohos::telephony::call::CallState getCallStateSync() +bool IsImsSwitchEnabledSync(int32_t slotId) +{ + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "IsImsSwitchEnabledSync slotId is invalid"); + return false; + } + + bool enabled = false; + int32_t errorCode = DelayedSingleton::GetInstance()->IsImsSwitchEnabled(slotId, enabled); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsImsSwitchEnabledSync slotId is invalid"); + } + return enabled; +} + +void DisableImsSwitchSync(int32_t slotId) +{ + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "DisableImsSwitchSync slotId is invalid"); + return; + } + int32_t errorCode = DelayedSingleton::GetInstance()->DisableImsSwitch(slotId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "DisableImsSwitchSync DisableImsSwitch failed"); + } +} + +void EnableImsSwitchSync(int32_t slotId) +{ + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "EnableImsSwitchSync slotId is invalid"); + return; + } + int32_t errorCode = DelayedSingleton::GetInstance()->EnableImsSwitch(slotId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "EnableImsSwitchSync EnableImsSwitch failed"); + } +} + +void UpdateImsCallModeSync(int32_t callId, ::ohos::telephony::call::ImsCallMode mode) +{ + ImsCallMode Mode = static_cast(mode.get_key()); + int32_t errorCode = DelayedSingleton::GetInstance()->UpdateImsCallMode(callId, Mode); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "UpdateImsCallModeSync UpdateImsCallMode failed"); + } +} + +void JoinConferenceSync(int32_t mainCallId, ::taihe::array_view<::taihe::string> callNumberList) +{ + std::vector callNumberList16; + for (size_t i = 0; i < callNumberList.size(); i++) { + callNumberList16.push_back(Str8ToStr16(std::string(callNumberList[i]))); + } + int32_t errorCode = + DelayedSingleton::GetInstance()->JoinConference(mainCallId, callNumberList16); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "JoinConferenceSync JoinConference failed"); + } +} + +void SetAudioDeviceSync(::ohos::telephony::call::AudioDevice const & device) +{ + AudioDevice audioDevice; + if (device.address->size() > kMaxAddressLen) { + set_business_error(ERROR_PARAMETER_TYPE_INVALID, "address is not too long"); + return; + } + + const ::taihe::string &deviceAddress = device.address.value_or(""); + if (memcpy_s(audioDevice.address, kMaxAddressLen, deviceAddress.data(), deviceAddress.size()) != EOK) { + set_business_error(TELEPHONY_ERROR, "memcpy_s audioDevice.address failed"); + return; + } + const ::taihe::string &deviceNameTrans = device.deviceName.value_or(""); + if (memcpy_s(audioDevice.deviceName, kMaxDeviceNameLen, deviceNameTrans.data(), deviceNameTrans.size()) != EOK) { + set_business_error(TELEPHONY_ERROR, "memcpy_s audioDevice.deviceName failed"); + return; + } + int32_t value = device.deviceType.get_value(); + audioDevice.deviceType = static_cast(value); + int32_t errorCode = DelayedSingleton::GetInstance()->SetAudioDevice(audioDevice); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SetAudioDeviceSync SetAudioDevice failed"); + } +} + +void CancelMutedSync() +{ + int32_t errorCode = DelayedSingleton::GetInstance()->SetMuted(false); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "CancelMutedSync SetMuted failed"); + } +} + +void SetMutedSync() +{ + int32_t errorCode = DelayedSingleton::GetInstance()->SetMuted(true); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SetMutedSync SetMuted failed"); + } +} + +bool IsRingingSync() +{ + bool enabled = false; + int32_t errorCode = DelayedSingleton::GetInstance()->IsRinging(enabled); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsRingingSyncc failed"); + } + return enabled; +} + +void SeparateConferenceSync(int32_t callId) +{ + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "SeparateConferenceSync callId is invalid"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->SeparateConference(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SeparateConferenceSync callId is invalid"); + } +} + +bool IsNewCallAllowedSync() +{ + bool enabled = false; + int32_t errorCode = DelayedSingleton::GetInstance()->IsNewCallAllowed(enabled); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsNewCallAllowedSync enabled is invalid"); + } + return enabled; +} + +bool IsInEmergencyCallSync() +{ + bool enabled = false; + int32_t errorCode = DelayedSingleton::GetInstance()->IsInEmergencyCall(enabled); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsInEmergencyCallSync enabled is invalid"); + } + return enabled; +} + +void StopDTMFSync(int32_t callId) +{ + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "StopDTMFSync callId is invalid"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->StopDtmf(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "StopDTMFSync callId is invalid"); + } +} + +void StartDTMFSync(int32_t callId, ::taihe::string_view character) +{ + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "StartDTMFSync callId is invalid"); + return; + } + if (character.empty()) { + set_business_error(ERROR_PARAMETER_TYPE_INVALID, "StartDTMFSync character is empty"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->StartDtmf(callId, character.c_str()[0]); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "StartDTMFSync callId is invalid"); + } +} + +::taihe::array<::taihe::string> GetCallIdListForConferenceSync(int32_t callId) +{ + taihe::array<::taihe::string> megArr = {}; + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "GetCallIdListForConferenceSync callId is invalid"); + return megArr; + } + + std::vector messageArray; + int32_t errorCode = + DelayedSingleton::GetInstance()->GetCallIdListForConference(callId, messageArray); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "GetCallIdListForConferenceSync callId is invalid"); + } + + for (size_t i = 0; i < messageArray.size(); i++) { + megArr[i] = Str16ToStr8(messageArray[i]); + } + return megArr; +} + +::taihe::array<::taihe::string> GetSubCallIdListSync(int32_t callId) +{ + taihe::array list = {}; + std::vector listResult; + int32_t errorCode = DelayedSingleton::GetInstance()->GetSubCallIdList(callId, listResult); + if (errorCode == TELEPHONY_SUCCESS) { + for (unsigned int i = 0; i < listResult.size(); i++) { + list[i] = Str16ToStr8(listResult[i]); + } + } else { + set_business_error(errorCode, "GetSubCallIdListSync GetSubCallIdList failed"); + } + return list; +} + +int32_t GetMainCallIdSync(int32_t callId) +{ + int32_t result = 0; + int32_t errorCode = DelayedSingleton::GetInstance()->GetMainCallId(callId, result); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "GetMainCallIdSync GetMainCallId failed"); + } + return result; +} + +void CombineConferenceSync(int32_t callId) +{ + int32_t errorCode = DelayedSingleton::GetInstance()->CombineConference(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "CombineConferenceSync CombineConference failed"); + } +} + +void SwitchCallSync(int32_t callId) +{ + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "SwitchCallSync callId is invalid"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->SwitchCall(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SwitchCallSync callId is invalid"); + } +} + +void UnHoldCallSync(int32_t callId) +{ + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "UnHoldCallSync callId is invalid"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->UnHoldCall(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "UnHoldCallSync callId is invalid"); + } +} + +void HoldCallSync(int32_t callId) +{ + if (!IsValidSlotId(callId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "HoldCallSync callId is invalid"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->HoldCall(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "HoldCallSync callId is invalid"); + } +} + +::taihe::string FormatPhoneNumberToE164Sync(::taihe::string_view phoneNumber, ::taihe::string_view countryCode) +{ + std::u16string formatNumber = u""; + std::u16string u16PhoneNumber = Str8ToStr16(std::string(phoneNumber)); + std::u16string u16CountryCode = Str8ToStr16(std::string(countryCode)); + int32_t errorCode = DelayedSingleton::GetInstance()->FormatPhoneNumberToE164(u16PhoneNumber, + u16CountryCode, formatNumber); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "FormatPhoneNumberToE164Sync FormatPhoneNumberToE164 failed"); + } + return Str16ToStr8(formatNumber); +} + +bool IsEmergencyPhoneNumberDefaultSync(::taihe::string_view phoneNumber, + ::ohos::telephony::call::EmergencyNumberOptions const & options) +{ + bool enable = false; + auto slotId = options.slotId.value_or(0); + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "IsEmergencyPhoneNumberDefaultSync slotId is invalid"); + return enable; + } + + std::u16string u16strPhoneNumber = Str8ToStr16(std::string(phoneNumber)); + int32_t errorCode = DelayedSingleton::GetInstance()->IsEmergencyPhoneNumber(u16strPhoneNumber, + slotId, enable); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsEmergencyPhoneNumberDefaultSync IsEmergencyPhoneNumber failed"); + } + return enable; +} + +bool IsEmergencyPhoneNumberOptionalSync(::taihe::string_view phoneNumber, + ::taihe::optional_view<::ohos::telephony::call::EmergencyNumberOptions> options) +{ + int32_t slotId = 0; + if (!options.has_value()) { + slotId = options.value().slotId.value_or(0); + } + + bool enable = false; + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "IsEmergencyPhoneNumberOptionalSync slotId is invalid"); + return enable; + } + + std::u16string u16strPhoneNumber = Str8ToStr16(std::string(phoneNumber)); + int32_t errorCode = DelayedSingleton::GetInstance()->IsEmergencyPhoneNumber(u16strPhoneNumber, + slotId, enable); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsEmergencyPhoneNumberOptionalSync IsEmergencyPhoneNumber failed"); + } + return enable; +} + +bool IsEmergencyPhoneNumberSync(::taihe::string_view phoneNumber) +{ + bool enable = false; + std::u16string u16strPhoneNumber = Str8ToStr16(std::string(phoneNumber)); + int32_t errorCode = + DelayedSingleton::GetInstance()->IsEmergencyPhoneNumber(u16strPhoneNumber, 0, enable); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "IsEmergencyPhoneNumberSync IsEmergencyPhoneNumber failed"); + } + return enable; +} + +void MuteRingerSync() +{ + int32_t errorCode = DelayedSingleton::GetInstance()->MuteRinger(); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "MuteRingerSync MuteRinger failed"); + } +} + +::ohos::telephony::call::CallState GetCallStateSync() { - int32_t callState = static_cast(CallStateToApp::CALL_STATE_UNKNOWN); - callState = OHOS::DelayedSingleton::GetInstance()->GetCallState(); - return static_cast<::ohos::telephony::call::CallState::key_t>(callState); + int32_t stateValue = DelayedSingleton::GetInstance()->GetCallState(); + ::ohos::telephony::call::CallState state = ::ohos::telephony::call::CallState::from_value(stateValue); + if (!state.is_valid()) { + set_business_error(stateValue, "GetCallStateSync failed"); + } + + return state; } bool HasCallSync() @@ -94,6 +502,255 @@ bool HasCallSync() return static_cast(ret); } +void SendCallUiEventSync(int32_t callId, ::taihe::string_view eventName) +{ + TELEPHONY_LOGD("SendCallUiEventSync enter"); + std::string name(eventName.c_str()); + auto errorCode = DelayedSingleton::GetInstance()->SendCallUiEvent(callId, name); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SendCallUiEventSync failed"); + } +} + +void InputDialerSpecialCodeSync(::taihe::string_view inputCode) +{ + std::string specialCode(inputCode.c_str()); + int32_t errorCode = DelayedSingleton::GetInstance()->InputDialerSpecialCode(specialCode); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "InputDialerSpecialCodeSync InputDialerSpecialCode failed"); + } +} + +bool CanSetCallTransferTimeSync(int32_t slotId) +{ + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "CanSetCallTransferTimeSync slotId is invalid"); + return false; + } + + bool enabled = false; + int32_t errorCode = DelayedSingleton::GetInstance()->CanSetCallTransferTime(slotId, enabled); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "CanSetCallTransferTimeSync CanSetCallTransferTime failed"); + } + return enabled; +} + +::ohos::telephony::call::VoNRState GetVoNRStateSync(int32_t slotId) +{ + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "GetVoNRStateSync slotId is invalid"); + return ::ohos::telephony::call::VoNRState::key_t(0); + } + + int32_t state; + int32_t errorCode = DelayedSingleton::GetInstance()->GetVoNRState(slotId, state); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "GetVoNRStateSync GetVoNRState failed"); + return ::ohos::telephony::call::VoNRState::key_t(0); + } + return ::ohos::telephony::call::VoNRState::key_t(state); +} + +void RemoveMissedIncomingCallNotificationSync() +{ + int32_t errorCode = DelayedSingleton::GetInstance()->RemoveMissedIncomingCallNotification(); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "RemoveMissedIncomingCallNotificationSync \ + RemoveMissedIncomingCallNotification failed"); + } +} + +void SetVoNRStateSync(int32_t slotId, ::ohos::telephony::call::VoNRState state) +{ + if (!IsValidSlotId(slotId)) { + set_business_error(ERROR_SLOT_ID_INVALID, "SetVoNRStateSync slotId is invalid"); + return; + } + + int32_t errorCode = DelayedSingleton::GetInstance()->SetVoNRState(slotId, state); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SetVoNRStateSync SetVoNRState failed"); + } +} + +void SetDeviceDirectionSync(int32_t callId, ::ohos::telephony::call::DeviceDirection deviceDirection) +{ + int32_t rotation = deviceDirection.get_value(); + int32_t errorCode = DelayedSingleton::GetInstance()->SetDeviceDirection(callId, rotation); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SetDeviceDirectionSync SetDeviceDirection failed"); + } +} + +void SetDisplaySurfaceSync(int32_t callId, ::taihe::string_view surfaceId) +{ + std::string strSurfaceId(surfaceId); + int32_t errorCode = DelayedSingleton::GetInstance()->SetDisplayWindow(callId, strSurfaceId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SetDisplaySurfaceSync SetDisplayWindow failed"); + } +} + +void SetPreviewSurfaceSync(int32_t callId, ::taihe::string_view surfaceId) +{ + std::string strSurfaceId(surfaceId); + int32_t errorCode = DelayedSingleton::GetInstance()->SetPreviewWindow(callId, strSurfaceId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "SetPreviewSurfaceSync SetPreviewWindow failed"); + } +} + +void ControlCameraSync(int32_t callId, ::taihe::string_view cameraId) +{ + int32_t errorCode = + DelayedSingleton::GetInstance()->ControlCamera(callId, Str8ToStr16(std::string(cameraId))); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "ControlCameraSync ControlCamera failed"); + } +} + +void CancelCallUpgradeSync(int32_t callId) +{ + int32_t errorCode = DelayedSingleton::GetInstance()->CancelCallUpgrade(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "CancelCallUpgradeSync CancelCallUpgrade failed"); + } +} + +void KickOutFromConferenceSync(int32_t callId) +{ + int32_t errorCode = DelayedSingleton::GetInstance()->KickOutFromConference(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "KickOutFromConferenceSync KickOutFromConference failed"); + } +} + +void PostDialProceedSync(int32_t callId, bool proceed) +{ + int32_t errorCode = DelayedSingleton::GetInstance()->PostDialProceed(callId, proceed); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "PostDialProceedSync PostDialProceed failed"); + } +} + +void AnswerCallDefaultSync(int32_t callId) +{ + TELEPHONY_LOGI("AnswerCallDefaultSync enter"); + int32_t errorCode = DelayedSingleton::GetInstance()->AnswerCall(callId, 0); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "AnswerCallDefaultSync AnswerCall failed"); + } +} + +void AnswerCallOptionalSync(::taihe::optional_view callId) +{ + TELEPHONY_LOGI("AnswerCallOptionalSync enter"); + int32_t callIdValue = callId.value_or(static_cast(DEFAULT_SIM_SLOT_ID)); + int32_t errorCode = DelayedSingleton::GetInstance()->AnswerCall(callIdValue, 0); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "AnswerCallOptionalSync AnswerCall failed"); + } +} + +void AnswerCallVoidSync() +{ + TELEPHONY_LOGI("AnswerCallVoidSync enter"); + int32_t errorCode = DelayedSingleton::GetInstance()->AnswerCall(0, 0); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "AnswerCallVoidSync AnswerCall failed"); + } +} + +void RejectCallDefaultDefaultSync(int32_t callId, ::ohos::telephony::call::RejectMessageOptions options) +{ + TELEPHONY_LOGI("RejectCallDefaultDefaultSync enter"); + int32_t errorCode = DelayedSingleton::GetInstance()->RejectCall( + callId, false, Str8ToStr16(std::string(options.messageContent))); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "RejectCallDefaultDefaultSync RejectCall failed"); + } +} + +void RejectCallOptionalSync(::taihe::optional_view callId,::taihe::optional_view<::ohos::telephony::call::RejectMessageOptions> options) +{ + TELEPHONY_LOGI("RejectCallOptionalSync enter"); + int32_t callIdValue = callId.value_or(static_cast(DEFAULT_SIM_SLOT_ID)); + std::string message = ""; + if (options.has_value()) { + message = std::string(options.value().messageContent); + } + + int32_t errorCode = DelayedSingleton::GetInstance()->RejectCall( + callIdValue, false, Str8ToStr16(std::string(message))); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "RejectCallOptionalSync RejectCall failed"); + } +} + +void RejectCallWithCallIdSync(int32_t callId) +{ + TELEPHONY_LOGI("RejectCallWithCallIdSync enter"); + std::string message = ""; + int32_t errorCode = DelayedSingleton::GetInstance()->RejectCall( + callId, false, Str8ToStr16(std::string(message))); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "RejectCallWithCallIdSync RejectCall failed"); + } +} + +void RejectCallWithVoidSync() +{ + TELEPHONY_LOGI("RejectCallWithVoidSync enter"); + int32_t callId = DEFAULT_SIM_SLOT_ID; + std::string message = ""; + int32_t errorCode = DelayedSingleton::GetInstance()->RejectCall( + callId, false, Str8ToStr16(std::string(message))); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "RejectCallWithVoidSync RejectCall failed"); + } +} + +void RejectCallWithRejectMessageSync(::ohos::telephony::call::RejectMessageOptions options) +{ + TELEPHONY_LOGI("RejectCallWithRejectMessageSync enter"); + int32_t callId = DEFAULT_SIM_SLOT_ID; + int32_t errorCode = DelayedSingleton::GetInstance()->RejectCall( + callId, false, Str8ToStr16(std::string(options.messageContent))); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "RejectCallWithRejectMessageSync RejectCall failed"); + } +} + +void HangUpCallSync(int32_t callId) +{ + TELEPHONY_LOGI("HangUpCallSync enter"); + int32_t errorCode = DelayedSingleton::GetInstance()->HangUpCall(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "HangUpCallSync HangUpCall failed"); + } +} + +void HangUpCallOptionalSync(::taihe::optional_view callId) +{ + TELEPHONY_LOGI("HangUpCallSync enter"); + int32_t callIdValue = callId.value_or(static_cast(DEFAULT_SIM_SLOT_ID)); + int32_t errorCode = DelayedSingleton::GetInstance()->HangUpCall(callIdValue); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "HangUpCallOptionalSync HangUpCall failed"); + } +} + +void HangUpCallWithVoidSync() +{ + TELEPHONY_LOGI("HangUpCallWithVoidSync enter"); + int32_t callId = DEFAULT_SIM_SLOT_ID; + int32_t errorCode = DelayedSingleton::GetInstance()->HangUpCall(callId); + if (errorCode != TELEPHONY_SUCCESS) { + set_business_error(errorCode, "HangUpCallWithVoidSync HangUpCall failed"); + } +} + void onCallDetailsChange( ::taihe::callback_view callback) { @@ -268,17 +925,209 @@ void offCameraCapabilitiesChange( TaiheCallAbilityCallback::GetInstance().cameraCapabilitiesCallback_.reset(); return; } + } // namespace // Since these macros are auto-generate, lint will cause false positive. // NOLINTBEGIN -TH_EXPORT_CPP_API_makeCallSync(makeCallSync); -TH_EXPORT_CPP_API_makeCallSync2(makeCallSync2); +TH_EXPORT_CPP_API_MakeCallCallback(MakeCallSync); +TH_EXPORT_CPP_API_MakeCallPromise(MakeCallSync); +TH_EXPORT_CPP_API_MakeCallSync(MakeCallSync); +TH_EXPORT_CPP_API_MakeCallWithContextPromise(MakeCallSync2); +TH_EXPORT_CPP_API_MakeCallSync2(MakeCallSync2); TH_EXPORT_CPP_API_HasVoiceCapability(HasVoiceCapability); -TH_EXPORT_CPP_API_formatPhoneNumberSync(formatPhoneNumberSync); -TH_EXPORT_CPP_API_formatPhoneNumberSync2(formatPhoneNumberSync2); -TH_EXPORT_CPP_API_getCallStateSync(getCallStateSync); + +TH_EXPORT_CPP_API_FormatPhoneNumberCallback(FormatPhoneNumberSync); +TH_EXPORT_CPP_API_FormatPhoneNumberPromise(FormatPhoneNumberSync); +TH_EXPORT_CPP_API_FormatPhoneNumberSync(FormatPhoneNumberSync); + +TH_EXPORT_CPP_API_FormatPhoneNumberNoFormatCallback(FormatPhoneNumberSync2); +TH_EXPORT_CPP_API_FormatPhoneNumberSync2(FormatPhoneNumberSync2); + +TH_EXPORT_CPP_API_IsImsSwitchEnabledCallback(IsImsSwitchEnabledSync); +TH_EXPORT_CPP_API_IsImsSwitchEnabledPromise(IsImsSwitchEnabledSync); +TH_EXPORT_CPP_API_IsImsSwitchEnabledSync(IsImsSwitchEnabledSync); + +TH_EXPORT_CPP_API_DisableImsSwitchCallback(DisableImsSwitchSync); +TH_EXPORT_CPP_API_DisableImsSwitchPromise(DisableImsSwitchSync); +TH_EXPORT_CPP_API_DisableImsSwitchSync(DisableImsSwitchSync); + +TH_EXPORT_CPP_API_EnableImsSwitchCallback(EnableImsSwitchSync); +TH_EXPORT_CPP_API_EnableImsSwitchPromise(EnableImsSwitchSync); +TH_EXPORT_CPP_API_EnableImsSwitchSync(EnableImsSwitchSync); + +TH_EXPORT_CPP_API_UpdateImsCallModeCallback(UpdateImsCallModeSync); +TH_EXPORT_CPP_API_UpdateImsCallModePromise(UpdateImsCallModeSync); +TH_EXPORT_CPP_API_UpdateImsCallModeSync(UpdateImsCallModeSync); + +TH_EXPORT_CPP_API_JoinConferenceCallback(JoinConferenceSync); +TH_EXPORT_CPP_API_JoinConferencePromise(JoinConferenceSync); +TH_EXPORT_CPP_API_JoinConferenceSync(JoinConferenceSync); + +TH_EXPORT_CPP_API_SetAudioDeviceCallback(SetAudioDeviceSync); +TH_EXPORT_CPP_API_SetAudioDevicePromise(SetAudioDeviceSync); +TH_EXPORT_CPP_API_SetAudioDeviceSync(SetAudioDeviceSync); + +TH_EXPORT_CPP_API_CancelMutedCallback(CancelMutedSync); +TH_EXPORT_CPP_API_CancelMutedPromise(CancelMutedSync); +TH_EXPORT_CPP_API_CancelMutedSync(CancelMutedSync); + +TH_EXPORT_CPP_API_SetMutedCallback(SetMutedSync); +TH_EXPORT_CPP_API_SetMutedPromise(SetMutedSync); +TH_EXPORT_CPP_API_SetMutedSync(SetMutedSync); + +TH_EXPORT_CPP_API_IsRingingCallback(IsRingingSync); +TH_EXPORT_CPP_API_IsRingingPromise(IsRingingSync); +TH_EXPORT_CPP_API_IsRingingSync(IsRingingSync); + +TH_EXPORT_CPP_API_SeparateConferenceCallback(SeparateConferenceSync); +TH_EXPORT_CPP_API_SeparateConferencePromise(SeparateConferenceSync); +TH_EXPORT_CPP_API_SeparateConferenceSync(SeparateConferenceSync); + +TH_EXPORT_CPP_API_IsNewCallAllowedCallback(IsNewCallAllowedSync); +TH_EXPORT_CPP_API_IsNewCallAllowedPromise(IsNewCallAllowedSync); +TH_EXPORT_CPP_API_IsNewCallAllowedSync(IsNewCallAllowedSync); + +TH_EXPORT_CPP_API_IsInEmergencyCallCallback(IsInEmergencyCallSync); +TH_EXPORT_CPP_API_IsInEmergencyCallPromise(IsInEmergencyCallSync); +TH_EXPORT_CPP_API_IsInEmergencyCallSync(IsInEmergencyCallSync); + +TH_EXPORT_CPP_API_StopDTMFCallback(StopDTMFSync); +TH_EXPORT_CPP_API_StopDTMFPromise(StopDTMFSync); +TH_EXPORT_CPP_API_StopDTMFSync(StopDTMFSync); + +TH_EXPORT_CPP_API_StartDTMFCallback(StartDTMFSync); +TH_EXPORT_CPP_API_StartDTMFPromise(StartDTMFSync); +TH_EXPORT_CPP_API_StartDTMFSync(StartDTMFSync); + +TH_EXPORT_CPP_API_GetCallIdListForConferenceCallback(GetCallIdListForConferenceSync); +TH_EXPORT_CPP_API_GetCallIdListForConferencePromise(GetCallIdListForConferenceSync); +TH_EXPORT_CPP_API_GetCallIdListForConferenceSync(GetCallIdListForConferenceSync); + +TH_EXPORT_CPP_API_GetSubCallIdListCallback(GetSubCallIdListSync); +TH_EXPORT_CPP_API_GetSubCallIdListPromise(GetSubCallIdListSync); +TH_EXPORT_CPP_API_GetSubCallIdListSync(GetSubCallIdListSync); + +TH_EXPORT_CPP_API_GetMainCallIdCallback(GetMainCallIdSync); +TH_EXPORT_CPP_API_GetMainCallIdPromise(GetMainCallIdSync); +TH_EXPORT_CPP_API_GetMainCallIdSync(GetMainCallIdSync); + +TH_EXPORT_CPP_API_CombineConferenceCallback(CombineConferenceSync); +TH_EXPORT_CPP_API_CombineConferencePromise(CombineConferenceSync); +TH_EXPORT_CPP_API_CombineConferenceSync(CombineConferenceSync); + +TH_EXPORT_CPP_API_SwitchCallCallback(SwitchCallSync); +TH_EXPORT_CPP_API_SwitchCallPromise(SwitchCallSync); +TH_EXPORT_CPP_API_SwitchCallSync(SwitchCallSync); + +TH_EXPORT_CPP_API_UnHoldCallCallback(UnHoldCallSync); +TH_EXPORT_CPP_API_UnHoldCallPromise(UnHoldCallSync); +TH_EXPORT_CPP_API_UnHoldCallSync(UnHoldCallSync); + +TH_EXPORT_CPP_API_HoldCallCallback(HoldCallSync); +TH_EXPORT_CPP_API_HoldCallPromise(HoldCallSync); +TH_EXPORT_CPP_API_HoldCallSync(HoldCallSync); + +TH_EXPORT_CPP_API_FormatPhoneNumberToE164Callback(FormatPhoneNumberToE164Sync); +TH_EXPORT_CPP_API_FormatPhoneNumberToE164Promise(FormatPhoneNumberToE164Sync); +TH_EXPORT_CPP_API_FormatPhoneNumberToE164Sync(FormatPhoneNumberToE164Sync); + +TH_EXPORT_CPP_API_IsEmergencyPhoneNumberDefaultCallback(IsEmergencyPhoneNumberDefaultSync); +TH_EXPORT_CPP_API_IsEmergencyPhoneNumberDefaultSync(IsEmergencyPhoneNumberDefaultSync); +TH_EXPORT_CPP_API_IsEmergencyPhoneNumberOptionalPromise(IsEmergencyPhoneNumberOptionalSync); +TH_EXPORT_CPP_API_IsEmergencyPhoneNumberOptionalSync(IsEmergencyPhoneNumberOptionalSync); +TH_EXPORT_CPP_API_IsEmergencyPhoneNumberCallback(IsEmergencyPhoneNumberSync); +TH_EXPORT_CPP_API_IsEmergencyPhoneNumberSync(IsEmergencyPhoneNumberSync); + +TH_EXPORT_CPP_API_MuteRingerCallback(MuteRingerSync); +TH_EXPORT_CPP_API_MuteRingerPromise(MuteRingerSync); +TH_EXPORT_CPP_API_MuteRingerSync(MuteRingerSync); + +TH_EXPORT_CPP_API_GetCallStateCallback(GetCallStateSync); +TH_EXPORT_CPP_API_GetCallStatePromise(GetCallStateSync); +TH_EXPORT_CPP_API_GetCallStateSync(GetCallStateSync); + +TH_EXPORT_CPP_API_HasCallCallback(HasCallSync); +TH_EXPORT_CPP_API_HasCallPromise(HasCallSync); TH_EXPORT_CPP_API_HasCallSync(HasCallSync); + +TH_EXPORT_CPP_API_SendCallUiEventCallback(SendCallUiEventSync); +TH_EXPORT_CPP_API_SendCallUiEventPromise(SendCallUiEventSync); +TH_EXPORT_CPP_API_SendCallUiEventSync(SendCallUiEventSync); + +TH_EXPORT_CPP_API_InputDialerSpecialCodeCallback(InputDialerSpecialCodeSync); +TH_EXPORT_CPP_API_InputDialerSpecialCodePromise(InputDialerSpecialCodeSync); +TH_EXPORT_CPP_API_InputDialerSpecialCodeSync(InputDialerSpecialCodeSync); + +TH_EXPORT_CPP_API_CanSetCallTransferTimeCallback(CanSetCallTransferTimeSync); +TH_EXPORT_CPP_API_CanSetCallTransferTimePromise(CanSetCallTransferTimeSync); +TH_EXPORT_CPP_API_CanSetCallTransferTimeSync(CanSetCallTransferTimeSync); + +TH_EXPORT_CPP_API_GetVoNRStateCallback(GetVoNRStateSync); +TH_EXPORT_CPP_API_GetVoNRStatePromise(GetVoNRStateSync); +TH_EXPORT_CPP_API_GetVoNRStateSync(GetVoNRStateSync); + +TH_EXPORT_CPP_API_RemoveMissedIncomingCallNotificationCallback(RemoveMissedIncomingCallNotificationSync); +TH_EXPORT_CPP_API_RemoveMissedIncomingCallNotificationPromise(RemoveMissedIncomingCallNotificationSync); +TH_EXPORT_CPP_API_RemoveMissedIncomingCallNotificationSync(RemoveMissedIncomingCallNotificationSync); + +TH_EXPORT_CPP_API_SetVoNRStateCallback(SetVoNRStateSync); +TH_EXPORT_CPP_API_SetVoNRStatePromise(SetVoNRStateSync); +TH_EXPORT_CPP_API_SetVoNRStateSync(SetVoNRStateSync); + +TH_EXPORT_CPP_API_SetDeviceDirectionCallback(SetDeviceDirectionSync); +TH_EXPORT_CPP_API_SetDeviceDirectionPromise(SetDeviceDirectionSync); +TH_EXPORT_CPP_API_SetDeviceDirectionSync(SetDeviceDirectionSync); + +TH_EXPORT_CPP_API_SetDisplaySurfaceCallback(SetDisplaySurfaceSync); +TH_EXPORT_CPP_API_SetDisplaySurfacePromise(SetDisplaySurfaceSync); +TH_EXPORT_CPP_API_SetDisplaySurfaceSync(SetDisplaySurfaceSync); + +TH_EXPORT_CPP_API_SetPreviewSurfaceCallback(SetPreviewSurfaceSync); +TH_EXPORT_CPP_API_SetPreviewSurfacePromise(SetPreviewSurfaceSync); +TH_EXPORT_CPP_API_SetPreviewSurfaceSync(SetPreviewSurfaceSync); + +TH_EXPORT_CPP_API_ControlCameraCallback(ControlCameraSync); +TH_EXPORT_CPP_API_ControlCameraPromise(ControlCameraSync); +TH_EXPORT_CPP_API_ControlCameraSync(ControlCameraSync); + +TH_EXPORT_CPP_API_CancelCallUpgradeCallback(CancelCallUpgradeSync); +TH_EXPORT_CPP_API_CancelCallUpgradePromise(CancelCallUpgradeSync); +TH_EXPORT_CPP_API_CancelCallUpgradeSync(CancelCallUpgradeSync); + +TH_EXPORT_CPP_API_KickOutFromConferenceCallback(KickOutFromConferenceSync); +TH_EXPORT_CPP_API_KickOutFromConferencePromise(KickOutFromConferenceSync); +TH_EXPORT_CPP_API_KickOutFromConferenceSync(KickOutFromConferenceSync); + +TH_EXPORT_CPP_API_PostDialProceedCallback(PostDialProceedSync); +TH_EXPORT_CPP_API_PostDialProceedPromise(PostDialProceedSync); +TH_EXPORT_CPP_API_PostDialProceedSync(PostDialProceedSync); + +TH_EXPORT_CPP_API_AnswerCallDefaultCallback(AnswerCallDefaultSync); +TH_EXPORT_CPP_API_AnswerCallDefaultSync(AnswerCallDefaultSync); +TH_EXPORT_CPP_API_AnswerCallOptionalPromise(AnswerCallOptionalSync); +TH_EXPORT_CPP_API_AnswerCallOptionalSync(AnswerCallOptionalSync); +TH_EXPORT_CPP_API_AnswerCallVoidCallback(AnswerCallVoidSync); +TH_EXPORT_CPP_API_AnswerCallVoidSync(AnswerCallVoidSync); + +TH_EXPORT_CPP_API_RejectCallDefaultCallback(RejectCallDefaultDefaultSync); +TH_EXPORT_CPP_API_RejectCallDefaultDefaultSync(RejectCallDefaultDefaultSync); +TH_EXPORT_CPP_API_RejectCallOptionalPromise(RejectCallOptionalSync); +TH_EXPORT_CPP_API_RejectCallOptionalSync(RejectCallOptionalSync); +TH_EXPORT_CPP_API_RejectCallWithCallIdCallback(RejectCallWithCallIdSync); +TH_EXPORT_CPP_API_RejectCallWithCallIdSync(RejectCallWithCallIdSync); +TH_EXPORT_CPP_API_RejectCallWithVoidCallback(RejectCallWithVoidSync); +TH_EXPORT_CPP_API_RejectCallWithVoidSync(RejectCallWithVoidSync); +TH_EXPORT_CPP_API_RejectCallWithRejectMessageCallback(RejectCallWithRejectMessageSync); +TH_EXPORT_CPP_API_RejectCallWithRejectMessageSync(RejectCallWithRejectMessageSync); + +TH_EXPORT_CPP_API_HangUpCallCallback(HangUpCallSync); +TH_EXPORT_CPP_API_HangUpCallSync(HangUpCallSync); +TH_EXPORT_CPP_API_HangUpCallPromise(HangUpCallOptionalSync); +TH_EXPORT_CPP_API_HangUpCallOptionalSync(HangUpCallOptionalSync); +TH_EXPORT_CPP_API_HangUpCallWithVoidCallback(HangUpCallWithVoidSync); +TH_EXPORT_CPP_API_HangUpCallWithVoidSync(HangUpCallWithVoidSync); + TH_EXPORT_CPP_API_onCallDetailsChange(onCallDetailsChange); TH_EXPORT_CPP_API_offCallDetailsChange(offCallDetailsChange); TH_EXPORT_CPP_API_onCallEventChange(onCallEventChange); diff --git a/frameworks/ets/taihe/src/taihe_call_ability_callback.cpp b/frameworks/ets/taihe/src/taihe_call_ability_callback.cpp index 971d94a0..30e8a1f6 100644 --- a/frameworks/ets/taihe/src/taihe_call_ability_callback.cpp +++ b/frameworks/ets/taihe/src/taihe_call_ability_callback.cpp @@ -14,9 +14,11 @@ */ #include "taihe_call_ability_callback.h" +#include "taihe/string.hpp" #include "telephony_log_wrapper.h" #include "telephony_errors.h" #include "util.h" +#include "call_manager_base.h" namespace OHOS { namespace Telephony { @@ -197,5 +199,95 @@ int32_t TaiheCallAbilityCallback::UpdateCameraCapabilities(const CameraCapabilit return TELEPHONY_ERR_FAIL; } +// set/get状态回调 +int32_t TaiheCallAbilityCallback::UpdateAsyncResultsInfo(const CallResultReportId reportId, AppExecFwk::PacMap &resultInfo) +{ + std::lock_guard lock(callbackMutex_); + int32_t result = TELEPHONY_ERR_FAIL; + TELEPHONY_LOGI("UpdateAsyncResultsInfo reportId = %{public}d", reportId); + switch (reportId) { + case CallResultReportId::GET_CALL_WAITING_REPORT_ID: { + result = ReportGetWaitingInfo(resultInfo); + break; + } + case CallResultReportId::GET_CALL_RESTRICTION_REPORT_ID: { + result = ReportGetRestrictionInfo(resultInfo); + break; + } + case CallResultReportId::GET_CALL_TRANSFER_REPORT_ID: { + result = ReportGetTransferInfo(resultInfo); + break; + } + default: + TELEPHONY_LOGI("UpdateAsyncResultsInfo reportId %{public}d is unsupport", reportId);; + } + + isAsyncResultsReady_ = true; + cv_.notify_one(); + return result; +} + +void TaiheCallAbilityCallback::WaitAsyncResults() +{ + std::unique_lock lock(callbackMutex_); + while (!isAsyncResultsReady_) { + TELEPHONY_LOGI("UpdateAsyncResultsInfo::wait(), isAsyncResultsReady_ = false"); + if (cv_.wait_for(lock, std::chrono::seconds(WAIT_TIME_ONE_SECOND)) == std::cv_status::timeout) { + break; + } + } + isAsyncResultsReady_ = false; +} + +int32_t TaiheCallAbilityCallback::ReportGetWaitingInfo(AppExecFwk::PacMap &resultInfo) +{ + int32_t result = resultInfo.GetIntValue("result"); + int32_t status = resultInfo.GetIntValue("status"); + + if (result != TELEPHONY_SUCCESS) { + status = 0; + } + waitingStatus_.from_value(status); + + return result; +} + +int32_t TaiheCallAbilityCallback::ReportGetRestrictionInfo(AppExecFwk::PacMap &resultInfo) +{ + int32_t result = resultInfo.GetIntValue("result"); + int32_t status = resultInfo.GetIntValue("status"); + + if (result != TELEPHONY_SUCCESS) { + status = 0; + } + restrictionStatus_.from_value(status); + + return result; +} + +int32_t TaiheCallAbilityCallback::ReportGetTransferInfo(AppExecFwk::PacMap &resultInfo) +{ + int32_t result = resultInfo.GetIntValue("result"); + int32_t status = resultInfo.GetIntValue("status"); + std::string teleNumber = resultInfo.GetStringValue("teleNumber"); + int32_t startHour = resultInfo.GetIntValue("startHour"); + int32_t endHour = resultInfo.GetIntValue("endHour"); + int32_t startMinute = resultInfo.GetIntValue("startMinute"); + int32_t endMinute = resultInfo.GetIntValue("endMinute"); + + if (result != TELEPHONY_SUCCESS) { + status = 0; + } + + transferInfo_.status.from_value(status); + transferInfo_.teleNumber = teleNumber; + transferInfo_.startHour = startHour; + transferInfo_.endHour = endHour; + transferInfo_.startMinute = startMinute; + transferInfo_.endMinute = endMinute; + + return result; +} + } // namespace Telephony } // namespace OHOS \ No newline at end of file diff --git a/frameworks/ets/taihe/src/taihe_call_manager_callback.cpp b/frameworks/ets/taihe/src/taihe_call_manager_callback.cpp index 7052a6ea..670c80d4 100644 --- a/frameworks/ets/taihe/src/taihe_call_manager_callback.cpp +++ b/frameworks/ets/taihe/src/taihe_call_manager_callback.cpp @@ -164,9 +164,13 @@ int32_t TaiheCallManagerCallback::OnMeeTimeDetailsChange(const CallAttributeInfo int32_t TaiheCallManagerCallback::OnReportAsyncResults(CallResultReportId reportId, AppExecFwk::PacMap &resultInfo) { TELEPHONY_LOGI("OnReportAsyncResults reportId:%{public}d", reportId); - // 这里可以根据具体需求处理异步结果 - // 目前暂时返回成功，后续可以根据业务需求进行扩展 - return TELEPHONY_SUCCESS; + int32_t ret = TaiheCallAbilityCallback::GetInstance().UpdateAsyncResultsInfo(reportId, resultInfo); + if (ret != TELEPHONY_SUCCESS) { + TELEPHONY_LOGE("OnReportAsyncResults failed! errCode:%{public}d", ret); + } else { + TELEPHONY_LOGI("OnReportAsyncResults success!"); + } + return ret; } int32_t TaiheCallManagerCallback::OnOttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info) -- Gitee