diff --git a/frameworks/ets/taihe/BUILD.gn b/frameworks/ets/taihe/BUILD.gn
index 471cb9ccbf82801a2f673d255afbe1d3951e2dee..6ddd5b904107106d7b2973a35841a536a1e2b03e 100644
--- a/frameworks/ets/taihe/BUILD.gn
+++ b/frameworks/ets/taihe/BUILD.gn
@@ -12,21 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 import("//build/config/components/ets_frontend/ets2abc_config.gni")
 import("//build/ohos.gni")
 import("//build/ohos/taihe_idl/taihe.gni")
 
-copy_taihe_idl("copy_telephonycall") {
-  sources = [ "idl/ohos.telephony.call.taihe" ]
-}
-
 subsystem_name = "telephony"
 part_name = "call_manager"
 taihe_generated_file_path = "$taihe_file_path/out/$subsystem_name/$part_name"
 
+copy_taihe_idl("copy_telephony_call") {
+  sources = [ "idl/ohos.telephony.call.taihe" ]
+}
+
 ohos_taihe("run_taihe") {
   taihe_generated_file_path = "$taihe_generated_file_path"
-  deps = [ ":copy_telephonycall" ]
+  deps = [ ":copy_telephony_call" ]
   outputs = [
     "$taihe_generated_file_path/src/ohos.telephony.call.ani.cpp",
     "$taihe_generated_file_path/src/ohos.telephony.call.abi.c",
@@ -38,30 +39,41 @@ taihe_shared_library("telephony_call_taihe_native") {
   part_name = "$part_name"
   subsystem_name = "$subsystem_name"
   sources = get_target_outputs(":run_taihe")
-  include_dirs = [ "../../js/napi/include" ]
+  include_dirs = [
+    "include",
+    "//base/telephony/call_manager/interfaces/innerkits",
+  ]
   sources += [
     "src/ani_constructor.cpp",
     "src/ohos.telephony.call.impl.cpp",
+    "src/ani_call_ability_callback.cpp",
+    "src/ani_call_manager_callback.cpp",
   ]
   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 = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "init:libbegetutil",
     "ability_base:base",
     "ability_base:want",
     "ability_runtime:ability_manager",
-    "ability_runtime:napi_common",
-    "c_utils:utils",
+    "ability_runtime:ani_common",
     "core_service:libtel_common",
     "core_service:tel_core_service_api",
-    "hilog:libhilog",
-    "image_framework:image",
-    "image_framework:image_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
diff --git a/frameworks/ets/taihe/idl/ohos.telephony.call.taihe b/frameworks/ets/taihe/idl/ohos.telephony.call.taihe
index 7d5b70c95b1728f86aa28a8ac5f22ac80c435fc9..2823f3032c5806516ec389dc92a02538dd02596c 100644
--- a/frameworks/ets/taihe/idl/ohos.telephony.call.taihe
+++ b/frameworks/ets/taihe/idl/ohos.telephony.call.taihe
@@ -13,51 +13,68 @@
  * limitations under the License.
  */
 
-@!sts_inject_into_module("import Context from 'application.Context';")
 @!namespace("@ohos.telephony.call", "call")
 @!sts_inject("""
-static { loadLibrary("telephony_call_taihe_native.z") } 
+static { loadLibrary("telephony_call_taihe_native.z") }
 """)
 
-@gen_async("makeCall")
-@gen_promise("makeCall")
-function MakeCallSync(phoneNumber: String): void;
+@!sts_inject_into_module("import Context from 'application.Context';")
 
-@gen_promise("makeCall")
-function MakeCallSync2(context: @sts_type("Context") Opaque, phoneNumber: String): void;
+@!sts_inject_into_module("import {AsyncCallback , Callback} from '@ohos.base';")
 
-function HasVoiceCapability(): bool;
+@!sts_inject_into_module("import image from '@ohos.multimedia.image';")
 
-@gen_async("formatPhoneNumber")
-@gen_promise("formatPhoneNumber")
-function FormatPhoneNumberSync(phoneNumber: String, options: NumberFormatOptions): void;
+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,
+}
 
-@gen_async("formatPhoneNumber")
-function FormatPhoneNumberSync2(phoneNumber: String): void;
+enum VoNRState: i32 {
+    VONR_STATE_OFF = 0,
+    VONR_STATE_ON = 1,
+}
 
-function GetCallStateSync(): CallState;
+enum AudioDeviceType: i32 {
+    DEVICE_EARPIECE = 0,
+    DEVICE_SPEAKER = 1,
+    DEVICE_WIRED_HEADSET = 2,
+    DEVICE_BLUETOOTH_SCO = 3,
+    DEVICE_DISTRIBUTED_AUTOMOTIVE = 4,
+}
 
-function HasCallSync(): bool;
+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 CallState: i32 {
-    CALL_STATE_UNKNOWN = -1,
-    CALL_STATE_IDLE = 0,
-    CALL_STATE_RINGING = 1,
-    CALL_STATE_OFFHOOK = 2,
-    CALL_STATE_ANSWERED = 3
+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 DetailedCallState: i32 {
-     CALL_STATUS_ACTIVE = 0,
-    CALL_STATUS_HOLDING = 1,
-    CALL_STATUS_DIALING = 2,
-    CALL_STATUS_ALERTING = 3,
-    CALL_STATUS_INCOMING = 4,
-    CALL_STATUS_WAITING = 5,
-    CALL_STATUS_DISCONNECTED = 6,
-    CALL_STATUS_DISCONNECTING = 7,
-    CALL_STATUS_IDLE = 8
+enum ConferenceState: i32 {
+    TEL_CONFERENCE_IDLE = 0,
+    TEL_CONFERENCE_ACTIVE = 1,
+    TEL_CONFERENCE_DISCONNECTING = 2,
+    TEL_CONFERENCE_DISCONNECTED = 3,
 }
 
 enum CallType: i32 {
@@ -68,34 +85,54 @@ enum CallType: i32 {
     TYPE_VOIP = 4,
 }
 
-struct CallAttributeOptions {
-    callType: CallType;
-    callId: i32;
-    callState: DetailedCallState;
+enum VideoStateType: i32 {
+    TYPE_VOICE = 0,
+    TYPE_VIDEO = 3,
+    TYPE_VIDEO_SEND_ONLY = 1,
+    TYPE_VIDEO_RECEIVE_ONLY = 2,
+    TYPE_VIDEO_BIDIRECTIONAL = 4,
 }
 
-struct PeerDimensionsDetail {
-    callId: i32;
+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,
 }
 
-struct CameraCapabilities {
-    callId: i32;
+enum DeviceDirection: i32 {
+    DEVICE_DIRECTION_0 = 0,
+    DEVICE_DIRECTION_90 = 90,
+    DEVICE_DIRECTION_180 = 180,
+    DEVICE_DIRECTION_270 = 270,
 }
 
-struct ImsCallModeInfo {
-    callId: i32;
-}
-
-struct CallSessionEvent {
-    callId: i32;
+enum CallSessionEventId: i32 {
+    EVENT_CONTROL_CAMERA_FAILURE = 0,
+    EVENT_CONTROL_CAMERA_READY = 1,
+    EVENT_DISPLAY_SURFACE_RELEASED = 100,
+    EVENT_PREVIEW_SURFACE_RELEASED = 101,
 }
 
-struct NumberFormatOptions {
-    countryCode: String;
+enum DetailedCallState: i32 {
+    CALL_STATUS_ACTIVE = 0,
+    CALL_STATUS_HOLDING = 1,
+    CALL_STATUS_DIALING = 2,
+    CALL_STATUS_ALERTING = 3,
+    CALL_STATUS_INCOMING = 4,
+    CALL_STATUS_WAITING = 5,
+    CALL_STATUS_DISCONNECTED = 6,
+    CALL_STATUS_DISCONNECTING = 7,
+    CALL_STATUS_IDLE = 8,
 }
 
-struct CallEventOptions {
-    eventId: CallAbilityEventId;
+enum CallRestrictionMode: i32 {
+    RESTRICTION_MODE_DEACTIVATION = 0,
+    RESTRICTION_MODE_ACTIVATION = 1,
 }
 
 enum CallAbilityEventId: i32 {
@@ -109,9 +146,39 @@ enum CallAbilityEventId: i32 {
     EVENT_SHOW_FLOAT_WINDOW = 8,
 }
 
-struct DisconnectedDetails {
-    reason: DisconnectedReason;
-    message: String;
+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 {
@@ -193,17 +260,28 @@ enum DisconnectedReason: i32 {
     SIM_PIN_NEED = 1027,
     CALL_NOT_ALLOW = 1029,
     SIM_INVALID = 1045,
-    UNKNOWN = 1279
+    UNKNOWN = 1279,
 }
 
-struct MmiCodeResults {
-    result: MmiCodeResult;
-    message: String;
+enum MarkType: i32 {
+    MARK_TYPE_NONE = 0,
+    MARK_TYPE_CRANK = 1,
+    MARK_TYPE_FRAUD = 2,
+    MARK_TYPE_EXPRESS = 3,
+    MARK_TYPE_PROMOTE_SALES = 4,
+    MARK_TYPE_HOUSE_AGENT = 5,
+    MARK_TYPE_INSURANCE = 6,
+    MARK_TYPE_TAXI = 7,
+    MARK_TYPE_CUSTOM = 8,
+    MARK_TYPE_OTHERS = 9,
+    MARK_TYPE_YELLOW_PAGE = 10,
+    MARK_TYPE_ENTERPRISE = 11,
 }
 
-enum MmiCodeResult: i32 {
-    MMI_CODE_SUCCESS = 0,
-    MMI_CODE_FAILED = 1
+struct AudioDevice {
+    deviceType: AudioDeviceType;
+    address: Optional<String>;
+    deviceName: Optional<String>;
 }
 
 struct AudioDeviceCallbackInfo {
@@ -212,16 +290,362 @@ struct AudioDeviceCallbackInfo {
     isMuted: bool;
 }
 
-struct AudioDevice {
-    deviceType: AudioDeviceType;
-    address: Optional<String>;
-    deviceName: Optional<String>;
+struct CallTransferInfo {
+    transferNum: String;
+    type: CallTransferType;
+    settingType: CallTransferSettingType;
+    startHour: Optional<i32>;
+    startMinute: Optional<i32>;
+    endHour: Optional<i32>;
+    endMinute: Optional<i32>;
 }
 
-enum AudioDeviceType: i32 {
-    DEVICE_EARPIECE,
-    DEVICE_SPEAKER,
-    DEVICE_WIRED_HEADSET,
-    DEVICE_BLUETOOTH_SCO,
-    DEVICE_DISTRIBUTED_AUTOMOTIVE
-}
\ No newline at end of file
+struct CallAttributeOptions {
+    accountNumber: String;
+    speakerphoneOn: bool;
+    accountId: i32;
+    videoState: VideoStateType;
+    startTime: i32;
+    isEcc: bool;
+    callType: CallType;
+    callId: i32;
+    callState: DetailedCallState;
+    conferenceState: ConferenceState;
+    voipCallAttribute: Optional<VoipCallAttribute>;
+    crsType: i32;
+    originalCallType: i32;
+    numberLocation: Optional<String>;
+    numberMarkInfo: Optional<NumberMarkInfo>;
+    extraParams: Optional<@record Map<String, @sts_type("Object") Opaque>>;
+}
+
+struct VoipCallAttribute {
+    voipCallId: String;
+    userName: String;
+    userProfile: @sts_type("image.PixelMap")Opaque;
+    extensionId: String;
+    abilityName: String;
+    voipBundleName: String;
+    showBannerForIncomingCall: Optional<bool>;
+    isConferenceCall: Optional<bool>;
+    isVoiceAnswerSupported: Optional<bool>;
+}
+
+struct CallRestrictionInfo {
+    type: CallRestrictionType;
+    password: String;
+    mode: CallRestrictionMode;
+}
+
+struct DialOptions {
+    extras: Optional<bool>;
+    accountId: Optional<i32>;
+    videoState: Optional<VideoStateType>;
+    dialScene: Optional<DialScene>;
+    dialType: Optional<DialType>;
+}
+
+struct DialCallOptions {
+    accountId: Optional<i32>;
+    videoState: Optional<VideoStateType>;
+    dialScene: Optional<DialScene>;
+    dialType: Optional<DialType>;
+    extraParams: Optional<@record Map<String, @sts_type("Object") Opaque>>;
+}
+
+struct RejectMessageOptions {
+    messageContent: String;
+}
+
+struct CallTransferResult {
+    status: TransferStatus;
+    /* The number keyword cannot be used as a variable */
+    /* number: String; */
+    startHour: i32;
+    startMinute: i32;
+    endHour: i32;
+    endMinute: i32;
+}
+
+struct EmergencyNumberOptions {
+    slotId: Optional<i32>;
+}
+
+struct NumberFormatOptions {
+    countryCode: Optional<String>;
+}
+
+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<String>;
+    markCount: Optional<i32>;
+    markSource: Optional<String>;
+    isCloud: Optional<bool>;
+    markDetails: Optional<String>;
+}
+
+struct CallEventOptions {
+    eventId: CallAbilityEventId;
+}
+
+struct MmiCodeResults {
+    result: MmiCodeResult;
+    message: String;
+}
+
+enum MmiCodeResult: i32 {
+    MMI_CODE_SUCCESS = 0,
+    MMI_CODE_FAILED = 1,
+}
+
+@gen_async("makeCall")
+@gen_promise("makeCall")
+function MakeCallSync(phoneNumber: String): void;
+
+@gen_promise("makeCall")
+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;
+
+@gen_async("formatPhoneNumber")
+function FormatPhoneNumberSync2(phoneNumber: String): void;
+
+@gen_async("isImsSwitchEnabled")
+@gen_promise("isImsSwitchEnabled")
+function IsImsSwitchEnabledSync(slotId: i32): bool;
+
+@gen_async("disableImsSwitch")
+@gen_promise("disableImsSwitch")
+function DisableImsSwitchSync(slotId: i32): void;
+
+@gen_async("enableImsSwitch")
+@gen_promise("enableImsSwitch")
+function EnableImsSwitchSync(slotId: i32): void;
+
+@gen_async("updateImsCallMode")
+@gen_promise("updateImsCallMode")
+function UpdateImsCallModeSync(callId: i32, mode: ImsCallMode): void;
+
+@gen_async("joinConference")
+@gen_promise("joinConference")
+function JoinConferenceSync(mainCallId: i32, callNumberList: Array<String>): void;
+
+@gen_async("setAudioDevice")
+@gen_promise("setAudioDevice")
+function SetAudioDeviceSync(device: AudioDevice): void;
+
+@gen_async("cancelMuted")
+@gen_promise("cancelMuted")
+function CancelMutedSync(): void;
+
+@gen_async("setMuted")
+@gen_promise("setMuted")
+function SetMutedSync(): void;
+
+@gen_async("isRinging")
+@gen_promise("isRinging")
+function IsRingingSync(): bool;
+
+@gen_async("setCallTransfer")
+@gen_promise("setCallTransfer")
+function SetCallTransferSync(slotId: i32, info: CallTransferInfo): void;
+
+@gen_async("getCallTransferInfo")
+@gen_promise("getCallTransferInfo")
+function GetCallTransferInfoSync(slotId: i32, type: CallTransferType): CallTransferResult;
+
+@gen_async("setCallRestriction")
+@gen_promise("setCallRestriction")
+function SetCallRestrictionSync(slotId: i32, info: CallRestrictionInfo): void;
+
+@gen_async("getCallRestrictionStatus")
+@gen_promise("getCallRestrictionStatus")
+function GetCallRestrictionStatusSync(slotId: i32, type: CallRestrictionType): RestrictionStatus;
+
+@gen_async("separateConference")
+@gen_promise("separateConference")
+function SeparateConferenceSync(callId: i32): void;
+
+@gen_async("isNewCallAllowed")
+@gen_promise("isNewCallAllowed")
+function IsNewCallAllowedSync(): bool;
+
+@gen_async("isInEmergencyCall")
+@gen_promise("isInEmergencyCall")
+function IsInEmergencyCallSync(): bool;
+
+@gen_async("stopDTMF")
+@gen_promise("stopDTMF")
+function StopDTMFSync(callId: i32): void;
+
+@gen_async("startDTMF")
+@gen_promise("startDTMF")
+function StartDTMFSync(callId: i32, character: String): void;
+
+@gen_async("setCallWaiting")
+@gen_promise("setCallWaiting")
+function SetCallWaitingSync(slotId: i32, activate: bool): void;
+
+@gen_async("getCallWaitingStatus")
+@gen_promise("getCallWaitingStatus")
+function GetCallWaitingStatusSync(slotId: i32): CallWaitingStatus;
+
+@gen_async("getCallIdListForConference")
+@gen_promise("getCallIdListForConference")
+function GetCallIdListForConferenceSync(callId: i32): Array<String>;
+
+@gen_async("getSubCallIdList")
+@gen_promise("getSubCallIdList")
+function GetSubCallIdListSync(callId: i32): Array<String>;
+
+@gen_async("getMainCallId")
+@gen_promise("getMainCallId")
+function GetMainCallIdSync(callId: i32): i32;
+
+@gen_async("combineConference")
+@gen_promise("combineConference")
+function CombineConferenceSync(callId: i32): void;
+
+@gen_async("switchCall")
+@gen_promise("switchCall")
+function SwitchCallSync(callId: i32): void;
+
+@gen_async("unHoldCall")
+@gen_promise("unHoldCall")
+function UnHoldCallSync(callId: i32): void;
+
+@gen_async("holdCall")
+@gen_promise("holdCall")
+function HoldCallSync(callId: i32): void;
+
+@gen_async("formatPhoneNumberToE164")
+@gen_promise("formatPhoneNumberToE164")
+function FormatPhoneNumberToE164Sync(phoneNumber: String, countryCode: String): String;
+
+@gen_async("isEmergencyPhoneNumber")
+function IsEmergencyPhoneNumberSyncDefault(phoneNumber: String, options: EmergencyNumberOptions): bool;
+@gen_promise("isEmergencyPhoneNumber")
+function IsEmergencyPhoneNumberSyncOptional(phoneNumber: String, options: Optional<EmergencyNumberOptions>): bool;
+@gen_async("isEmergencyPhoneNumber")
+function IsEmergencyPhoneNumberSyncPhoneNumber(phoneNumber: String): bool;
+
+@gen_async("muteRinger")
+@gen_promise("muteRinger")
+function MuteRingerSync(): void;
+
+@gen_async("dialCall")
+function DialCallSyncDefault(phoneNumber: String, options: DialCallOptions): bool;
+@gen_promise("dialCall")
+function DialCallSyncOptional(phoneNumber: String, options: Optional<DialCallOptions>): bool;
+@gen_async("dialCall")
+function DialCallSyncPhoneNumber(phoneNumber: String): bool;
+
+@gen_async("getCallState")
+@gen_promise("getCallState")
+function GetCallStateSync(): CallState;
+
+@gen_async("hasCall")
+@gen_promise("hasCall")
+function HasCallSync(): bool;
+
+@gen_async("sendCallUiEvent")
+@gen_promise("sendCallUiEvent")
+function SendCallUiEventSync(callId: i32, eventName: String): void;
+
+@gen_async("inputDialerSpecialCode")
+@gen_promise("inputDialerSpecialCode")
+function InputDialerSpecialCodeSync(inputCode: String): void;
+
+@gen_async("canSetCallTransferTime")
+@gen_promise("canSetCallTransferTime")
+function CanSetCallTransferTimeSync(slotId: i32): bool;
+
+@gen_async("getVoNRState")
+@gen_promise("getVoNRState")
+function GetVoNRStateSync(slotId: i32): VoNRState;
+
+@gen_async("removeMissedIncomingCallNotification")
+@gen_promise("removeMissedIncomingCallNotification")
+function RemoveMissedIncomingCallNotificationSync(): void;
+
+@gen_async("setVoNRState")
+@gen_promise("setVoNRState")
+function SetVoNRStateSync(slotId: i32, state: VoNRState): void;
+
+@gen_async("closeUnfinishedUssd")
+@gen_promise("closeUnfinishedUssd")
+function CloseUnfinishedUssdSync(slotId: i32): void;
+
+@gen_async("setDeviceDirection")
+@gen_promise("setDeviceDirection")
+function SetDeviceDirectionSync(callId: i32, deviceDirection: DeviceDirection): void;
+
+@gen_async("setDisplaySurface")
+@gen_promise("setDisplaySurface")
+function SetDisplaySurfaceSync(callId: i32, surfaceId: String): void;
+
+@gen_async("setPreviewSurface")
+@gen_promise("setPreviewSurface")
+function SetPreviewSurfaceSync(callId: i32, surfaceId: String): void;
+
+@gen_async("controlCamera")
+@gen_promise("controlCamera")
+function ControlCameraSync(callId: i32, cameraId: String): void;
+
+@gen_async("cancelCallUpgrade")
+@gen_promise("cancelCallUpgrade")
+function CancelCallUpgradeSync(callId: i32): void;
+
+@gen_async("kickOutFromConference")
+@gen_promise("kickOutFromConference")
+function KickOutFromConferenceSync(callId: i32): void;
+
+@gen_async("setCallRestrictionPassword")
+@gen_promise("setCallRestrictionPassword")
+function SetCallRestrictionPasswordSync(slotId: i32, oldPassword: String, newPassword: String): void;
+
+@gen_async("postDialProceed")
+@gen_promise("postDialProceed")
+function PostDialProceedSync(callId: i32, proceed: bool): void;
+
+@gen_async("answerCall")
+function AnswerCallSyncDefault(callId: i32): void;
+@gen_promise("answerCall")
+function AnswerCallSyncOptional(callId: Optional<i32>): void;
+@gen_async("answerCall")
+function AnswerCallSyncVoid(): void;
+@gen_promise("answerCall")
+function AnswerCallSync(videoState: VideoStateType, callId: i32): void;
diff --git a/frameworks/ets/taihe/include/ani_call_ability_callback.h b/frameworks/ets/taihe/include/ani_call_ability_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..18f2e42792a079899403279cc68eaab3db417bf3
--- /dev/null
+++ b/frameworks/ets/taihe/include/ani_call_ability_callback.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2021-2022 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 NAPI_CALL_ABILITY_CALLBACK_H
+#define NAPI_CALL_ABILITY_CALLBACK_H
+
+#include "pac_map.h"
+#include "singleton.h"
+
+#include "ani_call_manager_types.h"
+
+namespace OHOS {
+namespace Telephony {
+/*
+ * Data sent asynchronously from the CallManager will be notified to JavaScript
+ * via AniCallAbilityCallback.
+ */
+class AniCallAbilityCallback {
+    DECLARE_DELAYED_SINGLETON(AniCallAbilityCallback)
+
+  public:
+    int32_t RegisterGetWaitingCallback(EventCallback callback);
+    void UnRegisterGetWaitingCallback();
+    int32_t RegisterSetWaitingCallback(EventCallback callback);
+    void UnRegisterSetWaitingCallback();
+    int32_t RegisterGetRestrictionCallback(EventCallback callback);
+    void UnRegisterGetRestrictionCallback();
+    int32_t RegisterSetRestrictionCallback(EventCallback callback);
+    void UnRegisterSetRestrictionCallback();
+    int32_t RegisterSetRestrictionPasswordCallback(EventCallback callback);
+    void UnRegisterSetRestrictionPasswordCallback();
+    int32_t RegisterGetTransferCallback(EventCallback callback, int32_t type);
+    void UnRegisterGetTransferCallback();
+    int32_t RegisterSetTransferCallback(EventCallback callback);
+    void UnRegisterSetTransferCallback();
+    int32_t RegisterCloseUnFinishedUssdCallback(EventCallback callback);
+    void UnRegisterCloseUnFinishedUssdCallback();
+
+    int32_t UpdateAsyncResultsInfo(const CallResultReportId reportId, AppExecFwk::PacMap &resultInfo);
+
+    int32_t RegisterCallStateCallback(EventCallback callback);
+    void UnRegisterCallStateCallback();
+    int32_t RegisterMeeTimeStateCallback(EventCallback callback);
+    void UnRegisterMeeTimeStateCallback();
+    int32_t RegisterCallEventCallback(EventCallback callback);
+    void UnRegisterCallEventCallback();
+    int32_t RegisterDisconnectedCauseCallback(EventCallback callback);
+    void UnRegisterDisconnectedCauseCallback();
+    int32_t RegisterCallOttRequestCallback(EventCallback callback);
+    void UnRegisterCallOttRequestCallback();
+    int32_t RegisterStartRttCallback(EventCallback callback);
+    void UnRegisterStartRttCallback();
+    int32_t RegisterStopRttCallback(EventCallback callback);
+    void UnRegisterStopRttCallback();
+    int32_t RegisterMmiCodeCallback(EventCallback callback);
+    void UnRegisterMmiCodeCallback();
+    int32_t RegisterAudioDeviceCallback(EventCallback callback);
+    void UnRegisterAudioDeviceCallback();
+    int32_t RegisterPostDialDelay(EventCallback callback);
+    void UnRegisterPostDialDelayCallback();
+    int32_t RegisterImsCallModeChangeCallback(EventCallback callback);
+    void UnRegisterImsCallModeChangeCallback();
+    int32_t RegisterCallSessionEventChangeCallback(EventCallback callback);
+    void UnRegisterCallSessionEventChangeCallback();
+    int32_t RegisterPeerDimensionsChangeCallback(EventCallback callback);
+    void UnRegisterPeerDimensionsChangeCallback();
+    int32_t RegisterCameraCapabilitiesChangeCallback(EventCallback callback);
+    void UnRegisterCameraCapabilitiesChangeCallback();
+    int32_t RegisterCallDataUsageChangeCallback(EventCallback callback);
+    void UnRegisterCallDataUsageChangeCallback();
+
+    int32_t UpdateCallStateInfo(const CallAttributeInfo &info);
+    int32_t UpdateMeeTimeStateInfo(const CallAttributeInfo &info);
+    int32_t UpdateCallEvent(const CallEventInfo &info);
+    int32_t UpdateCallDisconnectedCause(const DisconnectedDetails &details);
+    int32_t OttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info);
+    int32_t ReportStartRttInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportStopRttInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t UpdateMmiCodeResultsInfo(const MmiCodeInfo &resultInfo);
+    int32_t UpdateAudioDeviceInfo(const AudioDeviceInfo &resultInfo);
+    int32_t UpdatePostDialDelay(const std::string str);
+    int32_t UpdateImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo);
+    int32_t CallSessionEventChange(const CallSessionEvent &callSessionEvent);
+    int32_t PeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail);
+    int32_t UpdateCameraCapabilities(const CameraCapabilities &cameraCapabilities);
+    int32_t CallDataUsageChange(const int64_t dataUsage);
+
+private:
+    int32_t ReportGetWaitingInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportSetWaitingInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportGetRestrictionInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportSetRestrictionInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportSetRestrictionPassword(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportGetTransferInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportSetTransferInfo(AppExecFwk::PacMap &resultInfo);
+    int32_t ReportCloseUnFinishedUssdInfo(AppExecFwk::PacMap &resultInfo);
+
+    static void ReportWaitAndLimitInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo);
+    static void ReportExecutionResult(AppExecFwk::PacMap &resultInfo, EventCallback &settingInfo);
+    static void ReportSupplementInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo);
+
+    static int32_t ReportCallState(CallAttributeInfo &info, EventCallback stateCallback);
+    static int32_t ReportCallEvent(CallEventInfo &info, EventCallback eventCallback);
+    static int32_t ReportDisconnectedCause(const DisconnectedDetails &details, EventCallback eventCallback);
+    static int32_t ReportCallOtt(EventCallback &settingInfo, AppExecFwk::PacMap &resultInfo,
+        OttCallRequestId requestId);
+    static int32_t ReportStartRtt(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo);
+    static int32_t ReportStopRtt(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo);
+    static int32_t ReportMmiCode(MmiCodeInfo &info, EventCallback eventCallback);
+    static int32_t ReportAudioDeviceInfo(AudioDeviceInfo &info, EventCallback eventCallback);
+    static int32_t ReportPostDialDelay(std::string &postDialStr, EventCallback eventCallback);
+    static int32_t ReportCallMediaModeInfo(CallMediaModeInfo &imsCallModeInfo, EventCallback eventCallback);
+    static int32_t ReportCallSessionEvent(CallSessionEvent &sessionEventOptions, EventCallback eventCallback);
+    static int32_t ReportPeerDimensions(PeerDimensionsDetail &peerDimensionsDetail, EventCallback eventCallback);
+    static int32_t ReportCameraCapabilitiesInfo(CameraCapabilities &cameraCapabilities, EventCallback eventCallback);
+    static int32_t ReportCallDataUsage(int64_t dataUsage, EventCallback eventCallback);
+
+    void ClearCallback();
+
+private:
+    EventCallback getWaitingCallback_;
+    EventCallback setWaitingCallback_;
+    EventCallback getRestrictionCallback_;
+    EventCallback setRestrictionCallback_;
+    EventCallback setRestrictionPasswordCallback_;
+    EventCallback getTransferCallback_;
+    EventCallback setTransferCallback_;
+    EventCallback closeUnfinishedUssdCallback_;
+
+    EventCallback stateCallback_;
+    EventCallback meeTimeStateCallback_;
+    EventCallback eventCallback_;
+    EventCallback callDisconnectCauseCallback_;
+    EventCallback ottRequestCallback_;
+    EventCallback startRttCallback_;
+    EventCallback stopRttCallback_;
+    EventCallback mmiCodeCallback_;
+    EventCallback audioDeviceCallback_;
+    EventCallback postDialDelayCallback_;
+    EventCallback imsCallModeCallback_;
+    EventCallback callSessionEventCallback_;
+    EventCallback peerDimensionsCallback_;
+    EventCallback cameraCapabilitiesCallback_;
+    EventCallback callDataUsageCallback_;
+
+    using CallResultReportIdProcessorFunc = std::function<int32_t(AppExecFwk::PacMap &resultInfo)>;
+    std::map<CallResultReportId, CallResultReportIdProcessorFunc> memberFuncMap_;
+    int32_t getCallTransferReason_ = -1;
+    std::mutex getTransferCallbackMutex_;
+    std::mutex setTransferCallbackMutex_;
+    std::mutex getRestrictionCallbackMutex_;
+    std::mutex setRestrictionPasswordCallbackMutex_;
+    std::mutex closeUnfinishedUssdCallbackMutex_;
+    std::mutex setWaitingCallbackMutex_;
+    std::mutex getWaitingCallbackMutex_;
+
+    std::mutex audioDeviceCallbackMutex_;
+};
+} // namespace Telephony
+} // namespace OHOS
+
+#endif // NAPI_CALL_ABILITY_CALLBACK_H
diff --git a/frameworks/ets/taihe/include/ani_call_manager_callback.h b/frameworks/ets/taihe/include/ani_call_manager_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..3481d6ba698ee07ad1beec37117fd4aed5e5ace1
--- /dev/null
+++ b/frameworks/ets/taihe/include/ani_call_manager_callback.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2021-2022 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 NAPI_CALL_MANAGER_CALLBACK_H
+#define NAPI_CALL_MANAGER_CALLBACK_H
+
+#include <cstdio>
+
+#include "pac_map.h"
+
+#include "call_manager_callback.h"
+
+namespace OHOS {
+namespace Telephony {
+class AniCallManagerCallback : public CallManagerCallback {
+public:
+    AniCallManagerCallback() = default;
+    ~AniCallManagerCallback() = default;
+    int32_t OnCallDetailsChange(const CallAttributeInfo &info) override;
+    int32_t OnMeeTimeDetailsChange(const CallAttributeInfo &info) override;
+    int32_t OnCallEventChange(const CallEventInfo &info) override;
+    int32_t OnCallDisconnectedCause(const DisconnectedDetails &details) override;
+    int32_t OnReportAsyncResults(CallResultReportId reportId, AppExecFwk::PacMap &resultInfo) override;
+    int32_t OnOttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info) override;
+    int32_t OnReportMmiCodeResult(const MmiCodeInfo &info) override;
+    int32_t OnReportAudioDeviceChange(const AudioDeviceInfo &info) override;
+    int32_t OnReportPostDialDelay(const std::string &str) override;
+    int32_t OnUpdateImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo) override;
+    int32_t OnCallSessionEventChange(const CallSessionEvent &callSessionEventOptions) override;
+    int32_t OnPeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail) override;
+    int32_t OnCallDataUsageChange(const int64_t dataUsage) override;
+    int32_t OnUpdateCameraCapabilities(const CameraCapabilities &cameraCapabilities) override;
+};
+} // namespace Telephony
+} // namespace OHOS
+#endif // NAPI_CALL_MANAGER_CALLBACK_H
diff --git a/frameworks/ets/taihe/include/ani_call_manager_types.h b/frameworks/ets/taihe/include/ani_call_manager_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3c3440a81a90e085ff528d743b9eee9ad865276
--- /dev/null
+++ b/frameworks/ets/taihe/include/ani_call_manager_types.h
@@ -0,0 +1,300 @@
+/*
+ * Copyright (C) 2021-2022 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 NATIVE_COMMON_TYPE_H
+#define NATIVE_COMMON_TYPE_H
+
+#include <condition_variable>
+#include <cstdint>
+#include "ani.h"
+#include "call_manager_inner_type.h"
+#include "pac_map.h"
+#include "telephony_errors.h"
+#include "want_params.h"
+
+namespace OHOS {
+namespace Telephony {
+const int16_t BOOL_VALUE_IS_TRUE = 1;
+const int16_t NATIVE_VERSION = 1;
+const int16_t NATIVE_FLAGS = 0;
+const int16_t ZERO_VALUE = 0;
+const int16_t ONLY_ONE_VALUE = 1;
+const int16_t TWO_VALUE_LIMIT = 2;
+const int16_t VALUE_MAXIMUM_LIMIT = 3;
+const int16_t THREE_VALUE_MAXIMUM_LIMIT = 3;
+const int16_t FOUR_VALUE_MAXIMUM_LIMIT = 4;
+const int16_t FIVE_VALUE_MAXIMUM_LIMIT = 5;
+const int16_t ARRAY_INDEX_FIRST = 0;
+const int16_t ARRAY_INDEX_SECOND = 1;
+const int16_t ARRAY_INDEX_THIRD = 2;
+const int16_t ARRAY_INDEX_FOURTH = 3;
+const int16_t DATA_LENGTH_ONE = 1;
+const int16_t DATA_LENGTH_TWO = 2;
+const int16_t DTMF_DEFAULT_OFF = 10;
+const int16_t PHONE_NUMBER_MAXIMUM_LIMIT = 255;
+const int16_t MESSAGE_CONTENT_MAXIMUM_LIMIT = 160;
+const int16_t NAPI_MAX_TIMEOUT_SECOND = 10;
+const int16_t UNKNOWN_EVENT = 0;
+
+class AsyncEvent {
+public:
+    AsyncEvent() {}
+
+    void Wait()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        if (cv_.wait_for(lock, std::chrono::seconds(WAIT_TIME_ONE_SECOND)) ==
+            std::cv_status::timeout) {
+            return;
+        }
+    }
+
+    void Fire()
+    {
+        cv_.notify_one();
+    }
+
+private:
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+
+struct AsyncContext {
+    virtual ~AsyncContext() {}
+    ani_env *env = nullptr;
+    int32_t callId = 0;
+    int32_t resolved = TELEPHONY_ERROR;
+    char number[kMaxNumberLen + 1] = {0};
+    size_t numberLen = 0;
+    size_t valueLen = 0;
+    int32_t errorCode = TELEPHONY_SUCCESS;
+    int32_t eventId = UNKNOWN_EVENT;
+};
+
+struct DialAsyncContext : AsyncContext {
+    int32_t accountId = -1;
+    int32_t videoState = 0;
+    int32_t dialScene = 0;
+    int32_t dialType = 0;
+    AAFwk::WantParams extraParams;
+};
+
+struct AnswerAsyncContext : AsyncContext {
+    int32_t videoState = 0;
+};
+
+struct BoolResultAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    bool enabled = false;
+};
+
+struct IntResultAsyncContext : AsyncContext {
+    int32_t result = 0;
+};
+
+struct RejectAsyncContext : AsyncContext {
+    bool isSendSms = false;
+    std::string messageContent = "";
+};
+
+struct ListAsyncContext : AsyncContext {
+    std::vector<std::u16string> listResult{};
+};
+
+struct SupplementAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    int32_t type = 0;
+    int32_t mode = 0;
+    std::string content = "";
+    bool flag = false;
+    int32_t status = 0;
+    int32_t startHour = 0;
+    int32_t endHour = 0;
+    int32_t startMinute = 0;
+    int32_t endMinute = 0;
+};
+
+struct ImsSwitchAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    bool enabled = false;
+};
+
+struct VoNRSwitchAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    int32_t state = 0;
+};
+
+struct CallRestrictionAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    CallRestrictionInfo info;
+};
+
+struct CallBarringPasswordAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    char oldPassword[kMaxNumberLen + 1] = {0};
+    char newPassword[kMaxNumberLen + 1] = {0};
+};
+
+struct CallTransferAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    CallTransferInfo info;
+};
+
+struct UtilsAsyncContext : AsyncContext {
+    int32_t slotId = 0;
+    bool enabled = false;
+    std::u16string formatNumber = u"";
+    std::string code = "";
+};
+
+struct EventCallback {
+    EventCallback() : context(nullptr), event(nullptr), callbackBeginTime_(0) {}
+    AsyncContext *context = nullptr;
+    AsyncEvent *event = nullptr;
+    time_t callbackBeginTime_;
+};
+
+struct AudioAsyncContext : AsyncContext {
+    bool isMute = false;
+    std::string address = "";
+    int32_t deviceType = 0;
+};
+
+struct VideoAsyncContext : AsyncContext {
+    double zoomRatio = 0;
+    int32_t rotation = 0;
+    int32_t callingUid = 0;
+    int32_t callingPid = 0;
+    std::string cameraId = "";
+    std::string surfaceId = "";
+    std::string picturePath = "";
+    std::u16string callingPackage = u"";
+    char path[kMaxNumberLen + 1] = {0};
+};
+
+struct OttCallAsyncContext : AsyncContext {
+    std::vector<OttCallDetailsInfo> ottVec{};
+};
+
+struct OttEventAsyncContext : AsyncContext {
+    OttCallEventInfo eventInfo;
+};
+
+struct PostDialAsyncContext : AsyncContext {
+    bool proceed = false;
+};
+
+struct VoIPCallStateAsyncContext : AsyncContext {
+    int32_t state = 0;
+};
+
+struct VoIPCallInfoAsyncContext : AsyncContext {
+    int32_t callId = -1;
+    int32_t state = 0;
+    std::string phoneNumber = "";
+};
+struct SendCallUiEventAsyncContext : AsyncContext {
+    std::string eventName = "";
+};
+
+enum CallWaitingStatus {
+    CALL_WAITING_DISABLE = 0,
+    CALL_WAITING_ENABLE,
+};
+
+enum RestrictionStatus {
+    RESTRICTION_DISABLE = 0,
+    RESTRICTION_ENABLE,
+};
+
+enum TransferStatus {
+    TRANSFER_DISABLE = 0,
+    TRANSFER_ENABLE = 1,
+};
+
+struct CallStateWorker {
+    CallAttributeInfo info;
+    EventCallback callback;
+};
+
+struct MeeTimeStateWorker {
+    CallAttributeInfo info;
+    EventCallback callback;
+};
+
+struct CallEventWorker {
+    CallEventInfo info;
+    EventCallback callback;
+};
+
+struct CallSupplementWorker {
+    AppExecFwk::PacMap info;
+    EventCallback callback;
+};
+
+struct CallDisconnectedCauseWorker {
+    DisconnectedDetails details;
+    EventCallback callback;
+};
+
+struct CallOttWorker {
+    OttCallRequestId requestId;
+    AppExecFwk::PacMap info;
+    EventCallback callback;
+};
+
+struct MmiCodeWorker {
+    MmiCodeInfo info;
+    EventCallback callback;
+};
+
+struct AudioDeviceWork {
+    AudioDeviceInfo info;
+    EventCallback callback;
+};
+
+struct PostDialDelayWorker {
+    std::string postDialStr;
+    EventCallback callback;
+};
+
+struct ImsCallModeInfoWorker {
+    CallMediaModeInfo callModeInfo;
+    EventCallback callback;
+};
+
+struct CallSessionEventWorker {
+    CallSessionEvent sessionEvent;
+    EventCallback callback;
+};
+
+struct PeerDimensionsWorker {
+    PeerDimensionsDetail peerDimensionsDetail;
+    EventCallback callback;
+};
+
+struct CallDataUsageWorker {
+    int64_t callDataUsage;
+    EventCallback callback;
+};
+
+struct CameraCapbilitiesWorker {
+    CameraCapabilities cameraCapabilities;
+    EventCallback callback;
+};
+} // namespace Telephony
+} // namespace OHOS
+
+#endif // NAPI_CALL_MANAGER_TYPES_H
diff --git a/frameworks/ets/taihe/src/ani_call_ability_callback.cpp b/frameworks/ets/taihe/src/ani_call_ability_callback.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d902ef3994d3681fd7067c8de5cbb587cdd67bf
--- /dev/null
+++ b/frameworks/ets/taihe/src/ani_call_ability_callback.cpp
@@ -0,0 +1,1231 @@
+/*
+ * Copyright (C) 2021-2022 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.
+ */
+
+#include "ani_call_ability_callback.h"
+#include <securec.h>
+#include "pixel_map.h"
+#include "ani_call_manager_types.h"
+#include "call_manager_errors.h"
+#include "concurrency_helpers.h"
+#include "telephony_log_wrapper.h"
+#include "want_params_wrapper.h"
+
+namespace OHOS {
+namespace Telephony {
+
+using arkts::concurrency_helpers::GetWorkerId;
+using arkts::concurrency_helpers::SendEvent;
+using arkts::concurrency_helpers::WorkStatus;
+
+AniCallAbilityCallback::AniCallAbilityCallback()
+{
+    memberFuncMap_[CallResultReportId::GET_CALL_WAITING_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportGetWaitingInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::SET_CALL_WAITING_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportSetWaitingInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::GET_CALL_RESTRICTION_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportGetRestrictionInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::SET_CALL_RESTRICTION_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportSetRestrictionInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::SET_CALL_RESTRICTION_PWD_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportSetRestrictionPassword(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::GET_CALL_TRANSFER_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportGetTransferInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::SET_CALL_TRANSFER_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportSetTransferInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::CLOSE_UNFINISHED_USSD_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportCloseUnFinishedUssdInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::START_RTT_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportStartRttInfo(resultInfo);
+    };
+    memberFuncMap_[CallResultReportId::STOP_RTT_REPORT_ID] = [this](AppExecFwk::PacMap &resultInfo) {
+        return ReportStopRttInfo(resultInfo);
+    };
+
+    ClearCallback();
+}
+
+AniCallAbilityCallback::~AniCallAbilityCallback()
+{
+    TELEPHONY_LOGI("~AniCallAbilityCallback");
+}
+
+void AniCallAbilityCallback::ClearCallback()
+{
+    (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&closeUnfinishedUssdCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&stateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&meeTimeStateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&eventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&ottRequestCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&mmiCodeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&audioDeviceCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&postDialDelayCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&imsCallModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&callSessionEventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&peerDimensionsCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&cameraCapabilitiesCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    (void)memset_s(&callDataUsageCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+int32_t AniCallAbilityCallback::RegisterGetWaitingCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(getWaitingCallbackMutex_);
+    if (getWaitingCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    getWaitingCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterGetWaitingCallback()
+{
+    std::lock_guard<std::mutex> lock(getWaitingCallbackMutex_);
+    (void)memset_s(&getWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterCloseUnFinishedUssdCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(closeUnfinishedUssdCallbackMutex_);
+    if (closeUnfinishedUssdCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    closeUnfinishedUssdCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCloseUnFinishedUssdCallback()
+{
+    std::lock_guard<std::mutex> lock(closeUnfinishedUssdCallbackMutex_);
+    (void)memset_s(&closeUnfinishedUssdCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterSetWaitingCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(setWaitingCallbackMutex_);
+    if (setWaitingCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    setWaitingCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterSetWaitingCallback()
+{
+    std::lock_guard<std::mutex> lock(setWaitingCallbackMutex_);
+    (void)memset_s(&setWaitingCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterGetRestrictionCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(getRestrictionCallbackMutex_);
+    if (getRestrictionCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    getRestrictionCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterGetRestrictionCallback()
+{
+    std::lock_guard<std::mutex> lock(getRestrictionCallbackMutex_);
+    (void)memset_s(&getRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterSetRestrictionCallback(EventCallback callback)
+{
+    if (setRestrictionCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    setRestrictionCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterSetRestrictionCallback()
+{
+    (void)memset_s(&setRestrictionCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterSetRestrictionPasswordCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(setRestrictionPasswordCallbackMutex_);
+    if (setRestrictionPasswordCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    setRestrictionPasswordCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterSetRestrictionPasswordCallback()
+{
+    std::lock_guard<std::mutex> lock(setRestrictionPasswordCallbackMutex_);
+    (void)memset_s(&setRestrictionPasswordCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterGetTransferCallback(EventCallback callback, int32_t type)
+{
+    std::lock_guard<std::mutex> lock(getTransferCallbackMutex_);
+    getTransferCallback_ = callback;
+    getCallTransferReason_ = type;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterGetTransferCallback()
+{
+    std::lock_guard<std::mutex> lock(getTransferCallbackMutex_);
+    (void)memset_s(&getTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterSetTransferCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(setTransferCallbackMutex_);
+    if (setTransferCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    setTransferCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterSetTransferCallback()
+{
+    std::lock_guard<std::mutex> lock(setTransferCallbackMutex_);
+    (void)memset_s(&setTransferCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::UpdateAsyncResultsInfo(const CallResultReportId reportId,
+    AppExecFwk::PacMap &resultInfo)
+{
+    int32_t result = TELEPHONY_ERR_FAIL;
+    TELEPHONY_LOGI("UpdateAsyncResultsInfo reportId = %{public}d", reportId);
+    auto itFunc = memberFuncMap_.find(reportId);
+    if (itFunc != memberFuncMap_.end() && itFunc->second != nullptr) {
+        auto memberFunc = itFunc->second;
+        result = memberFunc(resultInfo);
+    }
+    return result;
+}
+
+int32_t AniCallAbilityCallback::ReportGetWaitingInfo(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(getWaitingCallbackMutex_);
+    if (getWaitingCallback_.context == nullptr) {
+        TELEPHONY_LOGE("getWaitingCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = getWaitingCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportWaitAndLimitInfo(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(setWaitingCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(getWaitingCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportGetWaitingInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCloseUnFinishedUssdInfo(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(closeUnfinishedUssdCallbackMutex_);
+    if (closeUnfinishedUssdCallback_.context == nullptr) {
+        TELEPHONY_LOGE("closeUnfinishedUssdCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = closeUnfinishedUssdCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportExecutionResult(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(closeUnfinishedUssdCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(closeUnfinishedUssdCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportCloseUnFinishedUssdInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportSetWaitingInfo(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(setWaitingCallbackMutex_);
+    if (setWaitingCallback_.context == nullptr) {
+        TELEPHONY_LOGE("setWaitingCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorker = std::make_shared<CallSupplementWorker>();
+    callSupplementWorker->info = resultInfo;
+    callSupplementWorker->callback = setWaitingCallback_;
+    auto task = [](void *data) {
+        auto value = static_cast<CallSupplementWorker *>(data);
+        ReportExecutionResult(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(setWaitingCallback_.context->env);
+    auto status = SendEvent(setWaitingCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(callSupplementWorker.get()));
+    if (WorkStatus::OK != status) {
+        TELEPHONY_LOGE("napi_send_event: Failed to Send ReportSetWaitingInfo Event");
+        return TELEPHONY_ERROR;
+    }
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportGetRestrictionInfo(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(getRestrictionCallbackMutex_);
+    if (getRestrictionCallback_.context == nullptr) {
+        TELEPHONY_LOGE("getRestrictionCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = getRestrictionCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportWaitAndLimitInfo(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(getRestrictionCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(getRestrictionCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportGetRestrictionInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportSetRestrictionInfo(AppExecFwk::PacMap &resultInfo)
+{
+    if (setRestrictionCallback_.context == nullptr) {
+        TELEPHONY_LOGE("setRestrictionCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = setRestrictionCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportExecutionResult(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(setRestrictionCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(setRestrictionCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportSetRestrictionInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportSetRestrictionPassword(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(setRestrictionPasswordCallbackMutex_);
+    if (setRestrictionPasswordCallback_.context == nullptr) {
+        TELEPHONY_LOGE("setRestrictionPasswordCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = setRestrictionPasswordCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportExecutionResult(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(setRestrictionPasswordCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(setRestrictionPasswordCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportSetRestrictionPassword Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportGetTransferInfo(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(getTransferCallbackMutex_);
+    if (getTransferCallback_.context == nullptr) {
+        TELEPHONY_LOGE("getTransferCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    if (getCallTransferReason_ != resultInfo.GetIntValue("reason")) {
+        TELEPHONY_LOGE("Transfer reason is different, require is %{public}d, now "
+            "is %{public}d",
+            getCallTransferReason_, resultInfo.GetIntValue("reason"));
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = getTransferCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportSupplementInfo(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(getTransferCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(getTransferCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportGetTransferInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportSetTransferInfo(AppExecFwk::PacMap &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(setTransferCallbackMutex_);
+    if (setTransferCallback_.context == nullptr) {
+        TELEPHONY_LOGE("setTransferCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = setTransferCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportExecutionResult(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(setTransferCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(setTransferCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportSetTransferInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::ReportWaitAndLimitInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
+{
+    int32_t result = resultInfo.GetIntValue("result");
+    int32_t status = resultInfo.GetIntValue("status");
+    supplementInfo.context->errorCode = result;
+    if (result != TELEPHONY_SUCCESS) {
+        status = 0;
+    }
+    dynamic_cast<SupplementAsyncContext *>(supplementInfo.context)->status = status;
+}
+
+void AniCallAbilityCallback::ReportExecutionResult(AppExecFwk::PacMap &resultInfo, EventCallback &settingInfo)
+{
+    int32_t result = resultInfo.GetIntValue("result");
+    settingInfo.context->errorCode = result;
+}
+
+void AniCallAbilityCallback::ReportSupplementInfo(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
+{
+    int32_t result = resultInfo.GetIntValue("result");
+    int32_t status = resultInfo.GetIntValue("status");
+    int32_t startHour = resultInfo.GetIntValue("startHour");
+    int32_t endHour = resultInfo.GetIntValue("endHour");
+    int32_t startMinute = resultInfo.GetIntValue("startMinute");
+    int32_t endMinute = resultInfo.GetIntValue("endMinute");
+
+    supplementInfo.context->errorCode = result;
+    if (result != TELEPHONY_SUCCESS) {
+        status = 0;
+    }
+    dynamic_cast<SupplementAsyncContext *>(supplementInfo.context)->status = status;
+    dynamic_cast<SupplementAsyncContext *>(supplementInfo.context)->startHour = startHour;
+    dynamic_cast<SupplementAsyncContext *>(supplementInfo.context)->endHour = endHour;
+    dynamic_cast<SupplementAsyncContext *>(supplementInfo.context)->startMinute = startMinute;
+    dynamic_cast<SupplementAsyncContext *>(supplementInfo.context)->endMinute = endMinute;
+}
+
+int32_t AniCallAbilityCallback::RegisterCallStateCallback(EventCallback callback)
+{
+    if (stateCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    stateCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCallStateCallback()
+{
+    if (stateCallback_.context) {
+        (void)memset_s(&stateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterMeeTimeStateCallback(EventCallback callback)
+{
+    if (meeTimeStateCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    meeTimeStateCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterMeeTimeStateCallback()
+{
+    if (meeTimeStateCallback_.context) {
+        (void)memset_s(&meeTimeStateCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterCallEventCallback(EventCallback callback)
+{
+    if (eventCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    eventCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCallEventCallback()
+{
+    if (eventCallback_.context) {
+        (void)memset_s(&eventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterDisconnectedCauseCallback(EventCallback callback)
+{
+    if (callDisconnectCauseCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    callDisconnectCauseCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterDisconnectedCauseCallback()
+{
+    if (callDisconnectCauseCallback_.context) {
+        (void)memset_s(&callDisconnectCauseCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterCallOttRequestCallback(EventCallback callback)
+{
+    if (ottRequestCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    ottRequestCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCallOttRequestCallback()
+{
+    if (ottRequestCallback_.context) {
+        (void)memset_s(&ottRequestCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterStartRttCallback(EventCallback callback)
+{
+    if (startRttCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    startRttCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterStartRttCallback()
+{
+    (void)memset_s(&startRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterStopRttCallback(EventCallback callback)
+{
+    if (stopRttCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    stopRttCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterStopRttCallback()
+{
+    (void)memset_s(&stopRttCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+}
+
+int32_t AniCallAbilityCallback::RegisterMmiCodeCallback(EventCallback callback)
+{
+    if (mmiCodeCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    mmiCodeCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterMmiCodeCallback()
+{
+    if (mmiCodeCallback_.context) {
+        (void)memset_s(&mmiCodeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterAudioDeviceCallback(EventCallback callback)
+{
+    std::lock_guard<std::mutex> lock(audioDeviceCallbackMutex_);
+    if (audioDeviceCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    audioDeviceCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterAudioDeviceCallback()
+{
+    std::lock_guard<std::mutex> lock(audioDeviceCallbackMutex_);
+    if (audioDeviceCallback_.context) {
+        (void)memset_s(&audioDeviceCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+        TELEPHONY_LOGI("unregister audio device callback end.");
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterPostDialDelay(EventCallback callback)
+{
+    if (postDialDelayCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    postDialDelayCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterPostDialDelayCallback()
+{
+    if (postDialDelayCallback_.context) {
+        (void)memset_s(&postDialDelayCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterImsCallModeChangeCallback(EventCallback callback)
+{
+    if (imsCallModeCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    imsCallModeCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterImsCallModeChangeCallback()
+{
+    if (imsCallModeCallback_.context) {
+        (void)memset_s(&imsCallModeCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterCallSessionEventChangeCallback(EventCallback callback)
+{
+    if (callSessionEventCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    callSessionEventCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCallSessionEventChangeCallback()
+{
+    if (callSessionEventCallback_.context) {
+        (void)memset_s(&callSessionEventCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterPeerDimensionsChangeCallback(EventCallback callback)
+{
+    if (peerDimensionsCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    peerDimensionsCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterPeerDimensionsChangeCallback()
+{
+    if (peerDimensionsCallback_.context) {
+        (void)memset_s(&peerDimensionsCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterCameraCapabilitiesChangeCallback(EventCallback callback)
+{
+    if (cameraCapabilitiesCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    cameraCapabilitiesCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCameraCapabilitiesChangeCallback()
+{
+    if (cameraCapabilitiesCallback_.context) {
+        (void)memset_s(&cameraCapabilitiesCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::RegisterCallDataUsageChangeCallback(EventCallback callback)
+{
+    if (callDataUsageCallback_.context) {
+        TELEPHONY_LOGE("callback already exist!");
+        return CALL_ERR_CALLBACK_ALREADY_EXIST;
+    }
+    callDataUsageCallback_ = callback;
+    return TELEPHONY_SUCCESS;
+}
+
+void AniCallAbilityCallback::UnRegisterCallDataUsageChangeCallback()
+{
+    if (eventCallback_.context) {
+        (void)memset_s(&callDataUsageCallback_, sizeof(EventCallback), 0, sizeof(EventCallback));
+    }
+}
+
+int32_t AniCallAbilityCallback::UpdateCallStateInfo(const CallAttributeInfo &info)
+{
+    if (stateCallback_.context == nullptr) {
+        TELEPHONY_LOGE("stateCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callStateWorkerData = std::make_shared<CallStateWorker>();
+    callStateWorkerData->info = info;
+    callStateWorkerData->callback = stateCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallStateWorker *>(data);
+        ReportCallState(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(stateCallback_.context->env);
+    if (WorkStatus::OK !=
+        SendEvent(stateCallback_.context->env, workerId, task, reinterpret_cast<void *>(&callStateWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportCallState Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateMeeTimeStateInfo(const CallAttributeInfo &info)
+{
+    if (meeTimeStateCallback_.context == nullptr) {
+        TELEPHONY_LOGE("meeTimeStateCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto meeTimeStateWorkerData = std::make_shared<MeeTimeStateWorker>();
+    meeTimeStateWorkerData->info = info;
+    meeTimeStateWorkerData->callback = meeTimeStateCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<MeeTimeStateWorker *>(data);
+        ReportCallState(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(meeTimeStateCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(meeTimeStateCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&meeTimeStateWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send UpdateMeeTimeStateInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateCallEvent(const CallEventInfo &info)
+{
+    if (eventCallback_.context == nullptr) {
+        TELEPHONY_LOGE("eventCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callEventWorkerData = std::make_shared<CallEventWorker>();
+    callEventWorkerData->info = info;
+    callEventWorkerData->callback = eventCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallEventWorker *>(data);
+        ReportCallEvent(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(eventCallback_.context->env);
+    if (WorkStatus::OK !=
+        SendEvent(eventCallback_.context->env, workerId, task, reinterpret_cast<void *>(&callEventWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportCallState Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateCallDisconnectedCause(const DisconnectedDetails &details)
+{
+    if (callDisconnectCauseCallback_.context == nullptr) {
+        TELEPHONY_LOGE("callDisconnectCauseCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callDisconnectedCauseWorkerData = std::make_shared<CallDisconnectedCauseWorker>();
+    callDisconnectedCauseWorkerData->details = details;
+    callDisconnectedCauseWorkerData->callback = callDisconnectCauseCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallDisconnectedCauseWorker *>(data);
+        ReportDisconnectedCause(value->details, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(callDisconnectCauseCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(callDisconnectCauseCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callDisconnectedCauseWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send UpdateCallDisconnectedCause Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::OttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info)
+{
+    if (ottRequestCallback_.context == nullptr) {
+        TELEPHONY_LOGE("ottRequestCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callOttWorkerData = std::make_shared<CallOttWorker>();
+    callOttWorkerData->requestId = requestId;
+    callOttWorkerData->info = info;
+    callOttWorkerData->callback = ottRequestCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallOttWorker *>(data);
+        ReportCallOtt(value->callback, value->info, value->requestId);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(ottRequestCallback_.context->env);
+    if (WorkStatus::OK !=
+        SendEvent(ottRequestCallback_.context->env, workerId, task, reinterpret_cast<void *>(&callOttWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send OttCallRequest Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportStartRttInfo(AppExecFwk::PacMap &resultInfo)
+{
+    if (startRttCallback_.context == nullptr) {
+        TELEPHONY_LOGE("startRttCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = startRttCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportStartRtt(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(startRttCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(startRttCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportStartRttInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportStopRttInfo(AppExecFwk::PacMap &resultInfo)
+{
+    if (stopRttCallback_.context == nullptr) {
+        TELEPHONY_LOGE("ottRequestCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callSupplementWorkerData = std::make_shared<CallSupplementWorker>();
+    callSupplementWorkerData->info = resultInfo;
+    callSupplementWorkerData->callback = stopRttCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSupplementWorker *>(data);
+        ReportStopRtt(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(stopRttCallback_.context->env);
+    if (WorkStatus::OK !=
+        SendEvent(stopRttCallback_.context->env, workerId, task, reinterpret_cast<void *>(&callSupplementWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send ReportStopRttInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateMmiCodeResultsInfo(const MmiCodeInfo &resultInfo)
+{
+    if (mmiCodeCallback_.context == nullptr) {
+        TELEPHONY_LOGE("mmiCodeCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto mmiCodeWorkerData = std::make_shared<MmiCodeWorker>();
+    mmiCodeWorkerData->info = resultInfo;
+    mmiCodeWorkerData->callback = mmiCodeCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<MmiCodeWorker *>(data);
+        ReportMmiCode(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(mmiCodeCallback_.context->env);
+    if (WorkStatus::OK !=
+        SendEvent(mmiCodeCallback_.context->env, workerId, task, reinterpret_cast<void *>(&mmiCodeWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send OttCallRequest Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateAudioDeviceInfo(const AudioDeviceInfo &resultInfo)
+{
+    std::lock_guard<std::mutex> lock(audioDeviceCallbackMutex_);
+    if (audioDeviceCallback_.context == nullptr) {
+        TELEPHONY_LOGE("audioDeviceCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+    auto audioDeviceWorkData = std::make_shared<AudioDeviceWork>();
+    audioDeviceWorkData->info = resultInfo;
+    audioDeviceWorkData->callback = audioDeviceCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<AudioDeviceWork *>(data);
+        ReportAudioDeviceInfo(value->info, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(audioDeviceCallback_.context->env);
+    if (WorkStatus::OK !=
+        SendEvent(audioDeviceCallback_.context->env, workerId, task, reinterpret_cast<void *>(&audioDeviceWorkData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send UpdateAudioDeviceInfo Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdatePostDialDelay(const std::string str)
+{
+    if (postDialDelayCallback_.context == nullptr) {
+        TELEPHONY_LOGE("postDialDelayCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+    auto postDialDelayWorkerData = std::make_shared<PostDialDelayWorker>();
+    postDialDelayWorkerData->postDialStr = str;
+    postDialDelayWorkerData->callback = postDialDelayCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<PostDialDelayWorker *>(data);
+        ReportPostDialDelay(value->postDialStr, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(postDialDelayCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(postDialDelayCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&postDialDelayWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send UpdatePostDialDelay Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo)
+{
+    if (imsCallModeCallback_.context == nullptr) {
+        TELEPHONY_LOGE("imsCallModeCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+    auto imsCallModeInfoWorkerData = std::make_shared<ImsCallModeInfoWorker>();
+    imsCallModeInfoWorkerData->callModeInfo = imsCallModeInfo;
+    imsCallModeInfoWorkerData->callback = imsCallModeCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<ImsCallModeInfoWorker *>(data);
+        ReportCallMediaModeInfo(value->callModeInfo, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(imsCallModeCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(imsCallModeCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&imsCallModeInfoWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send UpdateImsCallModeChange Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::CallSessionEventChange(const CallSessionEvent &callSessionEvent)
+{
+    if (callSessionEventCallback_.context == nullptr) {
+        TELEPHONY_LOGE("callSessionEventCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+    auto callSessionEventWorkerData = std::make_shared<CallSessionEventWorker>();
+    callSessionEventWorkerData->sessionEvent = callSessionEvent;
+    callSessionEventWorkerData->callback = callSessionEventCallback_;
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallSessionEventWorker *>(data);
+        ReportCallSessionEvent(value->sessionEvent, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(callSessionEventCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(callSessionEventCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callSessionEventWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send CallSessionEventChange Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::PeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail)
+{
+    if (peerDimensionsCallback_.context == nullptr) {
+        TELEPHONY_LOGE("peerDimensionsCallback is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto peerDimensionsWorkerData = std::make_shared<PeerDimensionsWorker>();
+    peerDimensionsWorkerData->peerDimensionsDetail = peerDimensionsDetail;
+    peerDimensionsWorkerData->callback = peerDimensionsCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<PeerDimensionsWorker *>(data);
+        ReportPeerDimensions(value->peerDimensionsDetail, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(peerDimensionsCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(peerDimensionsCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&peerDimensionsWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send PeerDimensionsChange Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::UpdateCameraCapabilities(const CameraCapabilities &cameraCapabilities)
+{
+    if (cameraCapabilitiesCallback_.context == nullptr) {
+        TELEPHONY_LOGE("cameraCapabilitiesCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto cameraCapbilitiesWorkerData = std::make_shared<CameraCapbilitiesWorker>();
+    cameraCapbilitiesWorkerData->cameraCapabilities = cameraCapabilities;
+    cameraCapbilitiesWorkerData->callback = cameraCapabilitiesCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CameraCapbilitiesWorker *>(data);
+        ReportCameraCapabilitiesInfo(value->cameraCapabilities, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(cameraCapabilitiesCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(cameraCapabilitiesCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&cameraCapbilitiesWorkerData))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send PeerDimensionsChange Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::CallDataUsageChange(const int64_t dataUsage)
+{
+    if (callDataUsageCallback_.context == nullptr) {
+        TELEPHONY_LOGE("callDataUsageCallback_ is null!");
+        return CALL_ERR_CALLBACK_NOT_EXIST;
+    }
+
+    auto callDataUsageWorkerData = std::make_shared<CallDataUsageWorker>();
+    callDataUsageWorkerData->callDataUsage = dataUsage;
+    callDataUsageWorkerData->callback = callDataUsageCallback_;
+
+    auto task = [](void *data) {
+        auto value = reinterpret_cast<CallDataUsageWorker *>(data);
+        ReportCallDataUsage(value->callDataUsage, value->callback);
+        value->callback.event->Fire();
+    };
+
+    auto workerId = GetWorkerId(callDataUsageCallback_.context->env);
+    if (WorkStatus::OK != SendEvent(cameraCapabilitiesCallback_.context->env, workerId, task,
+        reinterpret_cast<void *>(&callDataUsageCallback_))) {
+        TELEPHONY_LOGE("SendEvent: Failed to Send CallDataUsageChange Event");
+        return TELEPHONY_ERROR;
+    }
+
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCallState(CallAttributeInfo &info, EventCallback stateCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCallEvent(CallEventInfo &info, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportDisconnectedCause(const DisconnectedDetails &details, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCallOtt(EventCallback &settingInfo, AppExecFwk::PacMap &resultInfo,
+    OttCallRequestId requestId)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportStartRtt(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportStopRtt(AppExecFwk::PacMap &resultInfo, EventCallback supplementInfo)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportMmiCode(MmiCodeInfo &info, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportAudioDeviceInfo(AudioDeviceInfo &info, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportPostDialDelay(std::string &postDialStr, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCallMediaModeInfo(CallMediaModeInfo &imsCallModeInfo, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCallSessionEvent(CallSessionEvent &sessionEvent, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCameraCapabilitiesInfo(CameraCapabilities &cameraCapabilities,
+    EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportCallDataUsage(int64_t dataUsage, EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+int32_t AniCallAbilityCallback::ReportPeerDimensions(PeerDimensionsDetail &peerDimensionsDetail,
+    EventCallback eventCallback)
+{
+    return TELEPHONY_SUCCESS;
+}
+
+} // namespace Telephony
+} // namespace OHOS
diff --git a/frameworks/ets/taihe/src/ani_call_manager_callback.cpp b/frameworks/ets/taihe/src/ani_call_manager_callback.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d2d61d7383b57ea747f76dedf69a7a53eceb3591
--- /dev/null
+++ b/frameworks/ets/taihe/src/ani_call_manager_callback.cpp
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2021-2022 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.
+ */
+
+#include "ani_call_manager_callback.h"
+
+#include "call_manager_errors.h"
+#include "telephony_errors.h"
+#include "telephony_log_wrapper.h"
+
+#include "ani_call_ability_callback.h"
+
+namespace OHOS {
+namespace Telephony {
+int32_t AniCallManagerCallback::OnCallDetailsChange(const CallAttributeInfo &info)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateCallStateInfo(info);
+    if (ret == TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGI("UpdateCallStateInfoHandler success! state:%{public}d, "
+            "videoState:%{public}d, "
+            "index:%{public}d, callType:%{public}d",
+            info.callState, info.videoState, info.index, info.callType);
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnMeeTimeDetailsChange(const CallAttributeInfo &info)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateMeeTimeStateInfo(info);
+    if (ret == TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGI("UpdateMeeTimeStateInfoHandler success! state:%{public}d", info.callState);
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnCallEventChange(const CallEventInfo &info)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateCallEvent(info);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("UpdateCallEvent failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("UpdateCallEvent success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnCallDisconnectedCause(const DisconnectedDetails &details)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateCallDisconnectedCause(details);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("UpdateCallDisconnectedCause failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("UpdateCallDisconnectedCause success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnReportAsyncResults(CallResultReportId reportId, AppExecFwk::PacMap &resultInfo)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateAsyncResultsInfo(reportId, resultInfo);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("UpdateAsyncInfo failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("UpdateAsyncInfo success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnReportMmiCodeResult(const MmiCodeInfo &info)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateMmiCodeResultsInfo(info);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("UpdateMmiCodeInfo failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("UpdateMmiCodeInfo success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnOttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->OttCallRequest(requestId, info);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("ott call request failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("ott call request success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnReportAudioDeviceChange(const AudioDeviceInfo &info)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateAudioDeviceInfo(info);
+    if (ret == TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGI("UpdateAudioDeviceInfo success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnReportPostDialDelay(const std::string &str)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdatePostDialDelay(str);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("OnReportPostDialDelay failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("OnReportPostDialDelay success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnUpdateImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo)
+{
+    TELEPHONY_LOGE("OnUpdateImsCallModeChange, callMode:%{public}d", imsCallModeInfo.callMode);
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateImsCallModeChange(imsCallModeInfo);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("OnUpdateImsCallModeReceive failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("OnUpdateImsCallModeReceive success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnCallSessionEventChange(const CallSessionEvent &callSessionEventOptions)
+{
+    int32_t ret =
+        DelayedSingleton<AniCallAbilityCallback>::GetInstance()->CallSessionEventChange(callSessionEventOptions);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("OnCallSessionEventChange failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("OnCallSessionEventChange success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnPeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->PeerDimensionsChange(peerDimensionsDetail);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("OnPeerDimensionsChange failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("OnPeerDimensionsChange success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnCallDataUsageChange(const int64_t dataUsage)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->CallDataUsageChange(dataUsage);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("OnCallDataUsageChange failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("OnCallDataUsageChange success!");
+    }
+    return ret;
+}
+
+int32_t AniCallManagerCallback::OnUpdateCameraCapabilities(const CameraCapabilities &cameraCapabilities)
+{
+    int32_t ret = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UpdateCameraCapabilities(cameraCapabilities);
+    if (ret != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("OnUpdateCameraCapabilities failed! errCode:%{public}d", ret);
+    } else {
+        TELEPHONY_LOGI("OnUpdateCameraCapabilities success!");
+    }
+    return ret;
+}
+} // namespace Telephony
+} // namespace OHOS
diff --git a/frameworks/ets/taihe/src/ani_constructor.cpp b/frameworks/ets/taihe/src/ani_constructor.cpp
index d2d6406956b103090c05d80323033e31098233b4..4eb49595e09b3e754a911626c00cd1db1db532a0 100644
--- a/frameworks/ets/taihe/src/ani_constructor.cpp
+++ b/frameworks/ets/taihe/src/ani_constructor.cpp
@@ -13,19 +13,37 @@
  * limitations under the License.
  */
 
-#include "taihe/runtime.hpp"
 #include "ohos.telephony.call.ani.hpp"
+#include "system_ability_definition.h"
+#include "ani_call_manager_callback.h"
+#include "call_manager_client.h"
+#include "telephony_errors.h"
+
+namespace OHOS {
+namespace Telephony {
+static void InitCallManager()
+{
+	DelayedSingleton<CallManagerClient>::GetInstance()->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
+}
+}
+}
 
 ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result)
 {
-    ani_env *env;
-    if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) {
+    if (vm == nullptr || result == nullptr) {
+        return ANI_ERROR;
+    }
+    ani_env *env = nullptr;
+    if (vm->GetEnv(ANI_VERSION_1, &env) != ANI_OK) {
         return ANI_ERROR;
     }
-    if (ANI_OK != ohos::telephony::call::ANIRegister(env)) {
+    if (ohos::telephony::call::ANIRegister(env) != ANI_OK) {
         std::cerr << "Error from ohos::telephony::call::ANIRegister" << std::endl;
         return ANI_ERROR;
     }
     *result = ANI_VERSION_1;
+
+    OHOS::Telephony::InitCallManager();
+
     return ANI_OK;
 }
\ No newline at end of file
diff --git a/frameworks/ets/taihe/src/ohos.telephony.call.impl.cpp b/frameworks/ets/taihe/src/ohos.telephony.call.impl.cpp
index af538289a765f893499744f33bee55a38b5bd756..afab3c7bb51bde02ea0befb69a5a2db6c742afb5 100644
--- a/frameworks/ets/taihe/src/ohos.telephony.call.impl.cpp
+++ b/frameworks/ets/taihe/src/ohos.telephony.call.impl.cpp
@@ -13,21 +13,78 @@
  * limitations under the License.
  */
 
-#include "ohos.telephony.call.proj.hpp"
 #include "ohos.telephony.call.impl.hpp"
-#include "taihe/runtime.hpp"
-#include "stdexcept"
-
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include "ipc_types.h"
+#include "telephony_types.h"
+#include "ani.h"
+#include "ani_call_ability_callback.h"
+#include "ani_call_manager_types.h"
+#include "ani_common_want.h"
+#include "call_manager_base.h"
 #include "call_manager_client.h"
-#include "telephony_errors.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 <string_ex.h>
+#include "want_params_wrapper.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,
+
+    /* *
+     * 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 const int32_t MAX_PASSWORD_LENGTH = 255;
+
+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<CallManagerClient>::GetInstance()->MakeCall(std::string(phoneNumber));
@@ -39,6 +96,7 @@ void MakeCallSync(::taihe::string_view phoneNumber)
 
 void MakeCallSync2(uintptr_t context, ::taihe::string_view phoneNumber)
 {
+    (void)context;
     auto errCode = OHOS::DelayedSingleton<CallManagerClient>::GetInstance()->MakeCall(std::string(phoneNumber));
     if (errCode != TELEPHONY_ERR_SUCCESS) {
         set_business_error(errCode, "makeCall2 return error");
@@ -53,13 +111,13 @@ bool HasVoiceCapability()
 }
 
 void FormatPhoneNumberSync(::taihe::string_view phoneNumber,
-    ::ohos::telephony::call::NumberFormatOptions const& options)
+    ::ohos::telephony::call::NumberFormatOptions const & options)
 {
     std::u16string phoneNum = OHOS::Str8ToStr16(std::string(phoneNumber));
-    std::u16string countryCode = OHOS::Str8ToStr16(std::string(options.countryCode));
+    std::u16string countryCode = OHOS::Str8ToStr16(std::string(options.countryCode.value_or("")));
     std::u16string formatNum = OHOS::Str8ToStr16("");
-    auto errCode = OHOS::DelayedSingleton<CallManagerClient>::GetInstance()->FormatPhoneNumber(
-        phoneNum, countryCode, formatNum);
+    auto errCode =
+        OHOS::DelayedSingleton<CallManagerClient>::GetInstance()->FormatPhoneNumber(phoneNum, countryCode, formatNum);
     if (errCode != TELEPHONY_ERR_SUCCESS) {
         set_business_error(errCode, "formatPhoneNumber return error");
     }
@@ -71,27 +129,874 @@ 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<CallManagerClient>::GetInstance()->FormatPhoneNumber(
-        phoneNum, countryCode, formatNum);
+    auto errCode =
+        OHOS::DelayedSingleton<CallManagerClient>::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;
 }
 
+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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<ImsCallMode>(mode.get_key());
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::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<std::u16string> callNumberList16;
+    for (size_t i = 0; i < callNumberList.size(); i++) {
+        callNumberList16.push_back(Str8ToStr16(std::string(callNumberList[i])));
+    }
+    int32_t errorCode =
+        DelayedSingleton<CallManagerClient>::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<OHOS::Telephony::AudioDeviceType>(value);
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetAudioDevice(audioDevice);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetAudioDeviceSync SetAudioDevice failed");
+    }
+}
+
+void CancelMutedSync()
+{
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetMuted(false);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "CancelMutedSync SetMuted failed");
+    }
+}
+
+void SetMutedSync()
+{
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetMuted(true);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetMutedSync SetMuted failed");
+    }
+}
+
+bool IsRingingSync()
+{
+    bool enabled = false;
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsRinging(enabled);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "IsRingingSyncc failed");
+    }
+    return enabled;
+}
+
+void SetCallTransferSync(int32_t slotId, ::ohos::telephony::call::CallTransferInfo const & info)
+{
+    int32_t errorCode;
+    CallTransferInfo information;
+
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "SetCallTransferSync slotId is invalid");
+        return;
+    }
+
+    information.endHour = info.endHour.value_or(0);
+    information.startHour = info.startHour.value_or(0);
+    information.startMinute = info.startMinute.value_or(0);
+    information.endMinute = info.endMinute.value_or(0);
+    information.settingType = static_cast<OHOS::Telephony::CallTransferSettingType>(info.settingType.get_value());
+    information.type = static_cast<OHOS::Telephony::CallTransferType>(info.type.get_value());
+    if (memcpy_s(information.transferNum, kMaxNumberLen, info.transferNum.data(), info.transferNum.size()) != EOK) {
+        set_business_error(ERROR_PARAMETER_TYPE_INVALID, "memcpy_s information.transferNum failed");
+        return;
+    }
+
+    errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallTransferInfo(slotId, information);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetCallTransferSync SetCallTransferInfo failed");
+    }
+}
+
+::ohos::telephony::call::CallTransferResult GetCallTransferInfoSync(int32_t slotId,
+    ::ohos::telephony::call::CallTransferType type)
+{
+    ohos::telephony::call::TransferStatus transferStatus =
+        ohos::telephony::call::TransferStatus::key_t::TRANSFER_DISABLE;
+    ohos::telephony::call::CallTransferResult result = { transferStatus, 0, 0, 0, 0 };
+
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "GetCallTransferInfoSync slotId is invalid");
+        return result;
+    }
+
+    auto asyncContext = std::make_shared<SupplementAsyncContext>();
+    asyncContext->slotId = slotId;
+    asyncContext->type = type.get_value();
+    asyncContext->env = taihe::get_env();
+    auto event = std::make_shared<AsyncEvent>();
+
+    EventCallback infoListener;
+    infoListener.context = asyncContext.get();
+    infoListener.event = event.get();
+    asyncContext->errorCode = DelayedSingleton<AniCallAbilityCallback>::GetInstance()->RegisterGetTransferCallback(
+        infoListener, asyncContext->type);
+    if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
+        TELEPHONY_LOGE("RegisterGetTransferCallback failed!");
+        return result;
+    }
+
+    CallTransferType callTranferType = static_cast<CallTransferType>(asyncContext->type);
+    asyncContext->errorCode =
+        DelayedSingleton<CallManagerClient>::GetInstance()->GetCallTransferInfo(slotId, callTranferType);
+
+    event->Wait();
+
+    if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
+        DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UnRegisterGetTransferCallback();
+        TELEPHONY_LOGE("UnRegisterGetTransferCallback failed!");
+        return result;
+    }
+
+    result.status = ::ohos::telephony::call::TransferStatus::from_value(asyncContext->status);
+    result.startHour = asyncContext->startHour;
+    result.startMinute = asyncContext->startMinute;
+    result.endHour = asyncContext->endHour;
+    result.endMinute = asyncContext->endMinute;
+
+    return result;
+}
+
+void SetCallRestrictionSync(int32_t slotId, ::ohos::telephony::call::CallRestrictionInfo const & info)
+{
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "SetCallRestrictionSync slotId is invalid");
+        return;
+    }
+
+    CallRestrictionInfo infores;
+    infores.mode = static_cast<OHOS::Telephony::CallRestrictionMode>(info.mode.get_value());
+    std::copy(info.password.begin(), info.password.end(), infores.password);
+    infores.fac = static_cast<OHOS::Telephony::CallRestrictionType>(info.type.get_value());
+
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallRestriction(slotId, infores);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetCallRestrictionSync failed");
+    }
+}
+
+::ohos::telephony::call::RestrictionStatus GetCallRestrictionStatusSync(int32_t slotId,
+    ::ohos::telephony::call::CallRestrictionType type)
+{
+    int32_t ret = 0;
+    auto asyncContext = std::make_shared<SupplementAsyncContext>();
+    asyncContext->slotId = slotId;
+    asyncContext->type = type.get_value();
+    asyncContext->env = taihe::get_env();
+
+    auto event = std::make_shared<AsyncEvent>();
+
+    if (!IsValidSlotId(asyncContext->slotId)) {
+        asyncContext->errorCode = ERROR_SLOT_ID_INVALID;
+        set_business_error(ERROR_SLOT_ID_INVALID, "GetCallRestrictionStatusSync slotId is invalid");
+        return ::ohos::telephony::call::RestrictionStatus::from_value(ret);
+    }
+
+    EventCallback infoListener;
+    infoListener.context = asyncContext.get();
+    infoListener.event = event.get();
+    asyncContext->errorCode =
+        DelayedSingleton<AniCallAbilityCallback>::GetInstance()->RegisterGetRestrictionCallback(infoListener);
+    if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(asyncContext->errorCode, "RegisterGetRestrictionCallback failed");
+        return ::ohos::telephony::call::RestrictionStatus::from_value(ret);
+    }
+
+    CallRestrictionType callRestrictionType = static_cast<CallRestrictionType>(asyncContext->type);
+    asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallRestriction(
+        asyncContext->slotId, callRestrictionType);
+
+    event->Wait();
+
+    if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
+        DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UnRegisterGetRestrictionCallback();
+        set_business_error(asyncContext->errorCode, "GetCallRestriction failed");
+        return ::ohos::telephony::call::RestrictionStatus::from_value(ret);
+    }
+
+    ret = asyncContext->status;
+    return ::ohos::telephony::call::RestrictionStatus::from_value(ret);
+}
+
+void SeparateConferenceSync(int32_t callId)
+{
+    if (!IsValidSlotId(callId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "SeparateConferenceSync callId is invalid");
+        return;
+    }
+
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SeparateConference(callId);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SeparateConferenceSync callId is invalid");
+    }
+}
+
+bool IsNewCallAllowedSync()
+{
+    bool enabled = false;
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::GetInstance()->StartDtmf(callId, character.c_str()[0]);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "StartDTMFSync callId is invalid");
+    }
+}
+
+void SetCallWaitingSync(int32_t slotId, bool activate)
+{
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "SetCallWaitingSync slotId is invalid");
+        return;
+    }
+
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallWaiting(slotId, activate);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetCallWaitingSync failed");
+    }
+}
+
+::ohos::telephony::call::CallWaitingStatus GetCallWaitingStatusSync(int32_t slotId)
+{
+    int32_t ret = 0;
+    auto asyncContext = std::make_shared<SupplementAsyncContext>();
+    asyncContext->slotId = slotId;
+    asyncContext->env = taihe::get_env();
+
+    auto event = std::make_shared<AsyncEvent>();
+
+    if (!IsValidSlotId(asyncContext->slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "GetCallWaitingStatusSync slotId is invalid");
+        return ::ohos::telephony::call::CallWaitingStatus::from_value(ret);
+    }
+
+    EventCallback infoListener;
+    infoListener.context = asyncContext.get();
+    infoListener.event = event.get();
+    asyncContext->errorCode =
+        DelayedSingleton<AniCallAbilityCallback>::GetInstance()->RegisterGetWaitingCallback(infoListener);
+    if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(asyncContext->errorCode, "RegisterGetWaitingCallback failed!");
+        return ::ohos::telephony::call::CallWaitingStatus::from_value(ret);
+    }
+
+    asyncContext->errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->GetCallWaiting(asyncContext->slotId);
+
+    event->Wait();
+
+    if (asyncContext->errorCode != TELEPHONY_SUCCESS) {
+        DelayedSingleton<AniCallAbilityCallback>::GetInstance()->UnRegisterGetWaitingCallback();
+        set_business_error(asyncContext->errorCode, "GetCallWaiting failed!");
+        return ::ohos::telephony::call::CallWaitingStatus::from_value(ret);
+    }
+
+    ret = asyncContext->status;
+    return ::ohos::telephony::call::CallWaitingStatus::from_value(ret);
+}
+
+::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<std::u16string> messageArray;
+    int32_t errorCode =
+        DelayedSingleton<CallManagerClient>::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<taihe::string> list = {};
+    std::vector<std::u16string> listResult;
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::GetInstance()->FormatPhoneNumberToE164(u16PhoneNumber,
+        u16CountryCode, formatNumber);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "FormatPhoneNumberToE164Sync FormatPhoneNumberToE164 failed");
+    }
+    return Str16ToStr8(formatNumber);
+}
+
+bool IsEmergencyPhoneNumberSyncDefault(::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, "IsEmergencyPhoneNumberSyncDefault slotId is invalid");
+        return enable;
+    }
+
+    std::u16string u16strPhoneNumber = Str8ToStr16(std::string(phoneNumber));
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(u16strPhoneNumber,
+        slotId, enable);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "IsEmergencyPhoneNumberSyncDefault IsEmergencyPhoneNumber failed");
+    }
+    return enable;
+}
+
+bool IsEmergencyPhoneNumberSyncOptional(::taihe::string_view phoneNumber,
+    ::taihe::optional_view<::ohos::telephony::call::EmergencyNumberOptions> options)
+{
+    int32_t slotId = 0;
+    if (!options.has_value()) {
+        slotId = options->slotId.value_or(0);
+    }
+
+    bool enable = false;
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "IsEmergencyPhoneNumberSyncOptional slotId is invalid");
+        return enable;
+    }
+
+    std::u16string u16strPhoneNumber = Str8ToStr16(std::string(phoneNumber));
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(u16strPhoneNumber,
+        slotId, enable);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "IsEmergencyPhoneNumberSyncOptional IsEmergencyPhoneNumber failed");
+    }
+    return enable;
+}
+
+bool IsEmergencyPhoneNumberSyncPhoneNumber(::taihe::string_view phoneNumber)
+{
+    bool enable = false;
+    std::u16string u16strPhoneNumber = Str8ToStr16(std::string(phoneNumber));
+    int32_t errorCode =
+        DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(u16strPhoneNumber, 0, enable);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "IsEmergencyPhoneNumberSyncPhoneNumber IsEmergencyPhoneNumber failed");
+    }
+    return enable;
+}
+
+void MuteRingerSync()
+{
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->MuteRinger();
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "MuteRingerSync MuteRinger failed");
+    }
+}
+
+static ani_object MapToObject(ani_env *env, ::taihe::map<::taihe::string, uintptr_t> &values)
+{
+    ani_object aniObject = nullptr;
+    static const char *className = "Lescompat/Record;";
+    ani_class cls;
+    if (ANI_OK != env->FindClass(className, &cls)) {
+        TELEPHONY_LOGE("Not found '%{public}s'.", className);
+        return aniObject;
+    }
+
+    ani_method aniCtor;
+    if (ANI_OK != env->Class_FindMethod(cls, "<ctor>", ":V", &aniCtor)) {
+        TELEPHONY_LOGE("Class_GetMethod <ctor> Failed '%{public}s'.", className);
+        return aniObject;
+    }
+    if (ANI_OK != env->Object_New(cls, aniCtor, &aniObject)) {
+        TELEPHONY_LOGE("Object_New Failed '%{public}s'.", className);
+        return aniObject;
+    }
+    ani_method setter;
+    if (ANI_OK != env->Class_FindMethod(cls, "$_set", nullptr, &setter)) {
+        TELEPHONY_LOGE("Class_GetMethod set Failed '%{public}s'.", className);
+        return aniObject;
+    }
+
+    ani_string stringAni = nullptr;
+    for (auto &value : values) {
+        if (ANI_OK != env->String_NewUTF8(value.first.c_str(), value.first.size(), &stringAni)) {
+            TELEPHONY_LOGE("String_NewUTF8 Failed");
+            break;
+        }
+        ani_string aniKey = stringAni;
+        ani_object aniObjVal = reinterpret_cast<ani_object>(value.second);
+        if (env->Object_CallMethod_Void(aniObject, setter, aniKey, aniObjVal) != ANI_OK) {
+            TELEPHONY_LOGE("Object_CallMethodByName_Void  $_set Faild ");
+            break;
+        }
+    }
+    return aniObject;
+}
+
+bool DialCallSyncDefault(::taihe::string_view phoneNumber, ::ohos::telephony::call::DialCallOptions const & options)
+{
+    auto accountId = options.accountId.value_or(0);
+    if (!IsValidSlotId(accountId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "DialCallSyncDefault MuteRinger failed");
+        return false;
+    }
+
+    TELEPHONY_LOGI("DialCallSyncDefault enter");
+    std::string phoneNumberString(phoneNumber.c_str());
+    std::u16string tmpPhoneNumber = Str8ToStr16(phoneNumberString);
+    bool isEmergencyNumber = false;
+    if (!(DelayedSingleton<CallManagerClient>::GetInstance()->IsEmergencyPhoneNumber(tmpPhoneNumber, accountId,
+        isEmergencyNumber) == TELEPHONY_SUCCESS &&
+        isEmergencyNumber)) {
+        int32_t state;
+        DelayedSingleton<CallManagerClient>::GetInstance()->GetVoIPCallState(state);
+        if (state == (int32_t)CallStateToApp::CALL_STATE_OFFHOOK ||
+            state == (int32_t)CallStateToApp::CALL_STATE_RINGING) {
+            set_business_error(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT,
+                "DialCallSyncDefault VoIP CALL is active, cannot dial now");
+            return false;
+        }
+    }
+
+    OHOS::AppExecFwk::PacMap dialInfo;
+    dialInfo.PutIntValue("accountId", accountId);
+    auto videoState = options.videoState.value_or(ohos::telephony::call::VideoStateType::from_value(0)).get_value();
+    dialInfo.PutIntValue("videoState", videoState);
+    auto dialScene = options.dialScene.value_or(ohos::telephony::call::DialScene::from_value(0)).get_value();
+    dialInfo.PutIntValue("dialScene", dialScene);
+    auto dialType = options.dialType.value_or(ohos::telephony::call::DialType::from_value(0)).get_value();
+    dialInfo.PutIntValue("dialType", dialType);
+
+    auto optionsMap = options.extraParams.value_or(::taihe::map<::taihe::string, uintptr_t>{});
+    ani_env *env = ::taihe::get_env();
+    auto recordObj = MapToObject(env, optionsMap);
+    AAFwk::WantParams wantParams;
+    if (!AppExecFwk::UnwrapWantParams(env, recordObj, wantParams)) {
+        set_business_error(ERROR_PARAMETER_TYPE_INVALID, "UnwrapWantParams failed");
+        return false;
+    }
+    dialInfo.PutStringValue("extraParams", AAFwk::WantParamWrapper(wantParams).ToString());
+    int32_t errorCode =
+        DelayedSingleton<CallManagerClient>::GetInstance()->DialCall(Str8ToStr16(phoneNumberString), dialInfo);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "DialCallSyncDefault DialCall failed");
+        return false;
+    }
+    return true;
+}
+
+bool DialCallSyncOptional(::taihe::string_view phoneNumber,
+    ::taihe::optional_view<::ohos::telephony::call::DialCallOptions> options)
+{
+    ::ohos::telephony::call::DialCallOptions opt = ::ohos::telephony::call::DialCallOptions{};
+    if (options.has_value()) {
+        opt = options.value();
+    }
+
+    return DialCallSyncDefault(phoneNumber, opt);
+}
+
+bool DialCallSyncPhoneNumber(::taihe::string_view phoneNumber)
+{
+    ::ohos::telephony::call::DialCallOptions opt = ::ohos::telephony::call::DialCallOptions{};
+    return DialCallSyncDefault(phoneNumber, opt);
+}
+
 ::ohos::telephony::call::CallState GetCallStateSync()
 {
-    int32_t callState = static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN);
-    callState = OHOS::DelayedSingleton<CallManagerClient>::GetInstance()->GetCallState();
-    return static_cast<::ohos::telephony::call::CallState::key_t>(callState);
+    int32_t stateValue = DelayedSingleton<CallManagerClient>::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()
 {
-    auto ret = OHOS::DelayedSingleton<CallManagerClient>::GetInstance()->HasCall();
-    return static_cast<ani_boolean>(ret);
+    return DelayedSingleton<CallManagerClient>::GetInstance()->HasCall();
+}
+
+void SendCallUiEventSync(int32_t callId, ::taihe::string_view eventName)
+{
+    TELEPHONY_LOGD("SendCallUiEventSync enter");
+    std::string name(eventName.c_str());
+    auto errorCode = DelayedSingleton<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::GetInstance()->SetVoNRState(slotId, state);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetVoNRStateSync SetVoNRState failed");
+    }
+}
+
+void CloseUnfinishedUssdSync(int32_t slotId)
+{
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "CloseUnfinishedUssdSync slotId is invalid");
+        return;
+    }
+
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->CloseUnFinishedUssd(slotId);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "CloseUnfinishedUssdSync CloseUnFinishedUssd failed");
+    }
+}
+
+void SetDeviceDirectionSync(int32_t callId, ::ohos::telephony::call::DeviceDirection deviceDirection)
+{
+    int32_t rotation = deviceDirection.get_value();
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::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<CallManagerClient>::GetInstance()->CancelCallUpgrade(callId);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "CancelCallUpgradeSync CancelCallUpgrade failed");
+    }
+}
+
+void KickOutFromConferenceSync(int32_t callId)
+{
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->KickOutFromConference(callId);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "KickOutFromConferenceSync KickOutFromConference failed");
+    }
+}
+
+void SetCallRestrictionPasswordSync(int32_t slotId, ::taihe::string_view oldPassword, ::taihe::string_view newPassword)
+{
+    if (oldPassword.size() > MAX_PASSWORD_LENGTH || newPassword.size() > MAX_PASSWORD_LENGTH) {
+        set_business_error(ERROR_PARAMETER_TYPE_INVALID, "SetCallRestrictionPasswordSync password too long");
+        return;
+    }
+
+    if (!IsValidSlotId(slotId)) {
+        set_business_error(ERROR_SLOT_ID_INVALID, "SetCallRestrictionPasswordSync slotId is invalid");
+        return;
+    }
+
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->SetCallRestrictionPassword(slotId,
+        CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, oldPassword.c_str(), newPassword.c_str());
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "SetCallRestrictionPasswordSync SetCallRestrictionPassword failed");
+    }
+}
+
+void PostDialProceedSync(int32_t callId, bool proceed)
+{
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->PostDialProceed(callId, proceed);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "PostDialProceedSync PostDialProceed failed");
+    }
+}
+
+void AnswerCallSyncDefault(int32_t callId)
+{
+    TELEPHONY_LOGI("AnswerCallSyncDefault enter");
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->AnswerCall(callId, 0);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "AnswerCallSyncDefault AnswerCall failed");
+    }
+}
+
+void AnswerCallSyncOptional(::taihe::optional_view<int32_t> callId)
+{
+    TELEPHONY_LOGI("AnswerCallSyncOptional enter");
+    int32_t callIdValue = callId.value_or(static_cast<int32_t>(DEFAULT_SIM_SLOT_ID));
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->AnswerCall(callIdValue, 0);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "AnswerCallSyncOptional AnswerCall failed");
+    }
+}
+
+void AnswerCallSyncVoid()
+{
+    TELEPHONY_LOGI("AnswerCallSyncVoid enter");
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->AnswerCall(0, 0);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "AnswerCallSyncVoid AnswerCall failed");
+    }
+}
+
+void AnswerCallSync(::ohos::telephony::call::VideoStateType videoState, int32_t callId)
+{
+    TELEPHONY_LOGI("answerCallVideoState enter");
+    int32_t videoStateValue = videoState.get_value();
+    int32_t errorCode = DelayedSingleton<CallManagerClient>::GetInstance()->AnswerCall(callId, videoStateValue);
+    if (errorCode != TELEPHONY_SUCCESS) {
+        set_business_error(errorCode, "answerCallVideoState AnswerCall failed");
+    }
 }
-} //namespace
+} // namespace
 
 // Since these macros are auto-generate, lint will cause false positive.
 // NOLINTBEGIN
@@ -100,6 +1005,60 @@ 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_IsImsSwitchEnabledSync(IsImsSwitchEnabledSync);
+TH_EXPORT_CPP_API_DisableImsSwitchSync(DisableImsSwitchSync);
+TH_EXPORT_CPP_API_EnableImsSwitchSync(EnableImsSwitchSync);
+TH_EXPORT_CPP_API_UpdateImsCallModeSync(UpdateImsCallModeSync);
+TH_EXPORT_CPP_API_JoinConferenceSync(JoinConferenceSync);
+TH_EXPORT_CPP_API_SetAudioDeviceSync(SetAudioDeviceSync);
+TH_EXPORT_CPP_API_CancelMutedSync(CancelMutedSync);
+TH_EXPORT_CPP_API_SetMutedSync(SetMutedSync);
+TH_EXPORT_CPP_API_IsRingingSync(IsRingingSync);
+TH_EXPORT_CPP_API_SetCallTransferSync(SetCallTransferSync);
+TH_EXPORT_CPP_API_GetCallTransferInfoSync(GetCallTransferInfoSync);
+TH_EXPORT_CPP_API_SetCallRestrictionSync(SetCallRestrictionSync);
+TH_EXPORT_CPP_API_GetCallRestrictionStatusSync(GetCallRestrictionStatusSync);
+TH_EXPORT_CPP_API_SeparateConferenceSync(SeparateConferenceSync);
+TH_EXPORT_CPP_API_IsNewCallAllowedSync(IsNewCallAllowedSync);
+TH_EXPORT_CPP_API_IsInEmergencyCallSync(IsInEmergencyCallSync);
+TH_EXPORT_CPP_API_StopDTMFSync(StopDTMFSync);
+TH_EXPORT_CPP_API_StartDTMFSync(StartDTMFSync);
+TH_EXPORT_CPP_API_SetCallWaitingSync(SetCallWaitingSync);
+TH_EXPORT_CPP_API_GetCallWaitingStatusSync(GetCallWaitingStatusSync);
+TH_EXPORT_CPP_API_GetCallIdListForConferenceSync(GetCallIdListForConferenceSync);
+TH_EXPORT_CPP_API_GetSubCallIdListSync(GetSubCallIdListSync);
+TH_EXPORT_CPP_API_GetMainCallIdSync(GetMainCallIdSync);
+TH_EXPORT_CPP_API_CombineConferenceSync(CombineConferenceSync);
+TH_EXPORT_CPP_API_SwitchCallSync(SwitchCallSync);
+TH_EXPORT_CPP_API_UnHoldCallSync(UnHoldCallSync);
+TH_EXPORT_CPP_API_HoldCallSync(HoldCallSync);
+TH_EXPORT_CPP_API_FormatPhoneNumberToE164Sync(FormatPhoneNumberToE164Sync);
+TH_EXPORT_CPP_API_IsEmergencyPhoneNumberSyncDefault(IsEmergencyPhoneNumberSyncDefault);
+TH_EXPORT_CPP_API_IsEmergencyPhoneNumberSyncOptional(IsEmergencyPhoneNumberSyncOptional);
+TH_EXPORT_CPP_API_IsEmergencyPhoneNumberSyncPhoneNumber(IsEmergencyPhoneNumberSyncPhoneNumber);
+TH_EXPORT_CPP_API_MuteRingerSync(MuteRingerSync);
+TH_EXPORT_CPP_API_DialCallSyncDefault(DialCallSyncDefault);
+TH_EXPORT_CPP_API_DialCallSyncOptional(DialCallSyncOptional);
+TH_EXPORT_CPP_API_DialCallSyncPhoneNumber(DialCallSyncPhoneNumber);
 TH_EXPORT_CPP_API_GetCallStateSync(GetCallStateSync);
 TH_EXPORT_CPP_API_HasCallSync(HasCallSync);
+TH_EXPORT_CPP_API_SendCallUiEventSync(SendCallUiEventSync);
+TH_EXPORT_CPP_API_InputDialerSpecialCodeSync(InputDialerSpecialCodeSync);
+TH_EXPORT_CPP_API_CanSetCallTransferTimeSync(CanSetCallTransferTimeSync);
+TH_EXPORT_CPP_API_GetVoNRStateSync(GetVoNRStateSync);
+TH_EXPORT_CPP_API_RemoveMissedIncomingCallNotificationSync(RemoveMissedIncomingCallNotificationSync);
+TH_EXPORT_CPP_API_SetVoNRStateSync(SetVoNRStateSync);
+TH_EXPORT_CPP_API_CloseUnfinishedUssdSync(CloseUnfinishedUssdSync);
+TH_EXPORT_CPP_API_SetDeviceDirectionSync(SetDeviceDirectionSync);
+TH_EXPORT_CPP_API_SetDisplaySurfaceSync(SetDisplaySurfaceSync);
+TH_EXPORT_CPP_API_SetPreviewSurfaceSync(SetPreviewSurfaceSync);
+TH_EXPORT_CPP_API_ControlCameraSync(ControlCameraSync);
+TH_EXPORT_CPP_API_CancelCallUpgradeSync(CancelCallUpgradeSync);
+TH_EXPORT_CPP_API_KickOutFromConferenceSync(KickOutFromConferenceSync);
+TH_EXPORT_CPP_API_SetCallRestrictionPasswordSync(SetCallRestrictionPasswordSync);
+TH_EXPORT_CPP_API_PostDialProceedSync(PostDialProceedSync);
+TH_EXPORT_CPP_API_AnswerCallSyncDefault(AnswerCallSyncDefault);
+TH_EXPORT_CPP_API_AnswerCallSyncOptional(AnswerCallSyncOptional);
+TH_EXPORT_CPP_API_AnswerCallSyncVoid(AnswerCallSyncVoid);
+TH_EXPORT_CPP_API_AnswerCallSync(AnswerCallSync);
 // NOLINTEND
\ No newline at end of file