diff --git a/frameworks/ets/ani/observer/ets/@ohos.telephony.observer.ets b/frameworks/ets/ani/observer/ets/@ohos.telephony.observer.ets
index 63e0381cc38426b3997d2d744dad76b52344b777..e933f03d0c35fadc9a28282748d127a81d55d207 100644
--- a/frameworks/ets/ani/observer/ets/@ohos.telephony.observer.ets
+++ b/frameworks/ets/ani/observer/ets/@ohos.telephony.observer.ets
@@ -37,121 +37,246 @@ export default namespace observer {
   type SimState = sim.SimState;
   type CallState = call.CallState;
 
-  export native function onCellularDataFlowChange(callback: Callback<DataFlowType>): void;
-  export native function onCellularDataFlowChangeOptions(options: ObserverOptions, callback: Callback<DataFlowType>): void;
-  export native function offCellularDataFlowChange(callback?: Callback<DataFlowType>): void;
-  export native function onIccAccountInfoChange(callback: Callback<void>): void;
-  export native function offIccAccountInfoChange(callback?: Callback<void>): void;
-  export native function onSimStateChange(callback: Callback<SimStateData>): void;
-  export native function onSimStateChangeOptions(options: ObserverOptions, callback: Callback<SimStateData>): void;
-  export native function offSimStateChange(callback?: Callback<SimStateData>): void;
-  export native function onSignalInfoChange(callback: Callback<Array<SignalInformation>>): void;
-  export native function onSignalInfoChangeOptions(options: ObserverOptions, callback: Callback<Array<SignalInformation>>): void;
-  export native function offSignalInfoChange(callback?: Callback<Array<SignalInformation>>): void;
-  export native function onCellInfoChange(callback: Callback<Array<CellInformation>>): void;
-  export native function onCellInfoChangeOptions(options: ObserverOptions, callback: Callback<Array<CellInformation>>): void;
-  export native function offCellInfoChange(callback?: Callback<Array<CellInformation>>): void;
-  export native function onCellularDataConnectionStateChange(callback: Callback<DataConnectionStateInfo>): void;
-  export native function onCellularDataConnectionStateChangeOptions(options: ObserverOptions, callback: Callback<DataConnectionStateInfo>): void;
-  export native function offCellularDataConnectionStateChange(callback?: Callback<DataConnectionStateInfo>): void;
-
-  export native function onNetworkStateChange(callback: Callback<NetworkState>): void;
-  export native function onNetworkStateChangeOptions(options: ObserverOptions, callback: Callback<NetworkState>): void;
-  export native function offNetworkStateChange(callback?: Callback<NetworkState>): void;
-
-  export native function onCallStateChange(callback: Callback<CallStateInfo>): void;
-  export native function onCallStateChangeOptions(options: ObserverOptions, callback: Callback<CallStateInfo>): void;
-  export native function offCallStateChange(callback?: Callback<CallStateInfo>): void;
-
-
-  export function on(type: string, callback: Object): void {
-    if (type == 'cellularDataFlowChange') {
-      onCellularDataFlowChange(callback as Callback<DataFlowType>)
-    } else if (type == 'iccAccountInfoChange') {
-      onIccAccountInfoChange(callback as Callback<void>)
-    } else if (type == 'simStateChange') {
-      onSimStateChange(callback as Callback<SimStateData>)
-    } else if (type == 'signalInfoChange') {
-      onSignalInfoChange(callback as Callback<Array<SignalInformation>>)
-    } else if (type == 'cellInfoChange') {
-      onCellInfoChange(callback as Callback<Array<CellInformation>>)
-    } else if (type == 'cellularDataConnectionStateChange') {
-      onCellularDataConnectionStateChange(callback as Callback<DataConnectionStateInfo>)
-    } else if (type == 'networkStateChange') {
-      onNetworkStateChange(callback as Callback<NetworkState>)
-    } else if (type == 'callStateChange') {
-      onCallStateChange(callback as Callback<CallStateInfo>)
-    }
-  }
-
-  export function on(type: string, options: ObserverOptions, callback: Object): void {
-    if (type == 'cellularDataFlowChange') {
-      onCellularDataFlowChangeOptions(options, callback as Callback<DataFlowType>)
-    } else if (type == 'simStateChange') {
-      onSimStateChangeOptions(options, callback as Callback<SimStateData>)
-    } else if (type == 'signalInfoChange') {
-      onSignalInfoChangeOptions(options, callback as Callback<Array<SignalInformation>>)
-    } else if (type == 'cellInfoChange') {
-      onCellInfoChangeOptions(options, callback as Callback<Array<CellInformation>>)
-    } else if (type == 'cellularDataConnectionStateChange') {
-      onCellularDataConnectionStateChangeOptions(options, callback as Callback<DataConnectionStateInfo>)
-    } else if (type == 'networkStateChange') {
-      onNetworkStateChangeOptions(options, callback as Callback<NetworkState>)
-    } else if (type == 'callStateChange') {
-      onCallStateChangeOptions(options, callback as Callback<CallStateInfo>)
-    } 
-  }
-
-  export function off(type: string, callback?: Object): void {
-    if (type == 'cellularDataFlowChange') {
-      if (callback == undefined) {
-        offCellularDataFlowChange()
-      } else {
-        offCellularDataFlowChange(callback as Callback<DataFlowType>)
-      }
-    } else if (type == 'iccAccountInfoChange') {
-      if (callback == undefined) {
-        offIccAccountInfoChange()
-      } else {
-        offIccAccountInfoChange(callback as Callback<void>)
-      }
-    } else if (type == 'simStateChange') {
-      if (callback == undefined) {
-        offSimStateChange()
-      } else {
-        offSimStateChange(callback as Callback<SimStateData>)
-      }
-    } else if (type == 'signalInfoChange') {
-      if (callback == undefined) {
-        offSignalInfoChange()
-      } else {
-        offSignalInfoChange(callback as Callback<Array<SignalInformation>>)
-      }
-    } else if (type == 'cellInfoChange') {
-      if (callback == undefined) {
-        offCellInfoChange()
-      } else {
-        offCellInfoChange(callback as Callback<Array<CellInformation>>)
-      }
-    } else if (type == 'cellularDataConnectionStateChange') {
-      if (callback == undefined) {
-        offCellularDataConnectionStateChange()
-      } else {
-        offCellularDataConnectionStateChange(callback as Callback<DataConnectionStateInfo>)
-      }
-    } else if (type == 'networkStateChange') {
-      if (callback == undefined) {
-        offNetworkStateChange()
-      } else {
-        offNetworkStateChange(callback as Callback<NetworkState>)
-      }
-    } else if (type == 'callStateChange') {
-      if (callback == undefined) {
-        offCallStateChange()
-      } else {
-        offCallStateChange(callback as Callback<CallStateInfo>)
-      }
+  export native function nativeOnCellularDataFlowChange(callback: Callback<DataFlowType>): void;
+  export native function nativeOnCellularDataFlowChangeOptions(options: ObserverOptions, callback: Callback<DataFlowType>): void;
+  export native function nativeOffCellularDataFlowChange(callback?: Callback<DataFlowType>): void;
+  export native function nativeOnIccAccountInfoChange(callback: Callback<void>): void;
+  export native function nativeOffIccAccountInfoChange(callback?: Callback<void>): void;
+  export native function nativeOnSimStateChange(callback: Callback<SimStateData>): void;
+  export native function nativeOnSimStateChangeOptions(options: ObserverOptions, callback: Callback<SimStateData>): void;
+  export native function nativeOffSimStateChange(callback?: Callback<SimStateData>): void;
+  export native function nativeOnSignalInfoChange(callback: Callback<Array<SignalInformation>>): void;
+  export native function nativeOnSignalInfoChangeOptions(options: ObserverOptions, callback: Callback<Array<SignalInformation>>): void;
+  export native function nativeOffSignalInfoChange(callback?: Callback<Array<SignalInformation>>): void;
+  export native function nativeOnCellInfoChange(callback: Callback<Array<CellInformation>>): void;
+  export native function nativeOnCellInfoChangeOptions(options: ObserverOptions, callback: Callback<Array<CellInformation>>): void;
+  export native function nativeOffCellInfoChange(callback?: Callback<Array<CellInformation>>): void;
+  export native function nativeOnCellularDataConnectionStateChange(callback: Callback<DataConnectionStateInfo>): void;
+  export native function nativeOnCellularDataConnectionStateChangeOptions(options: ObserverOptions, callback: Callback<DataConnectionStateInfo>): void;
+  export native function nativeOffCellularDataConnectionStateChange(callback?: Callback<DataConnectionStateInfo>): void;
+  export native function nativeOnNetworkStateChange(callback: Callback<NetworkState>): void;
+  export native function nativeOnNetworkStateChangeOptions(options: ObserverOptions, callback: Callback<NetworkState>): void;
+  export native function nativeOffNetworkStateChange(callback?: Callback<NetworkState>): void;
+  export native function nativeOnCallStateChange(callback: Callback<CallStateInfo>): void;
+  export native function nativeOnCallStateChangeOptions(options: ObserverOptions, callback: Callback<CallStateInfo>): void;
+  export native function nativeOffCallStateChange(callback?: Callback<CallStateInfo>): void;
+
+  export function onCellularDataFlowChange(
+    type: 'cellularDataFlowChange', callback: Callback<DataFlowType>): void {
+    if (type != 'cellularDataFlowChange') {
+      throw new Error('Invalid event type: ' + type);
+
+    }
+    nativeOnCellularDataFlowChange(callback)
+  }
+
+  export function onIccAccountInfoChange(
+    type: 'iccAccountInfoChange', callback: Callback<void>): void {
+    if (type != 'iccAccountInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnIccAccountInfoChange(callback)
+  }
+
+  export function onSimStateChange(
+    type: 'simStateChange', callback: Callback<SimStateData>): void {
+    if (type != 'simStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnSimStateChange(callback)
+  }
+
+  export function onSignalInfoChange(
+    type: 'signalInfoChange', callback: Callback<Array<SignalInformation>>): void {
+    if (type != 'signalInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnSignalInfoChange(callback)
+  }
+
+  export function onCellInfoChange(
+    type: 'cellInfoChange', callback: Callback<Array<CellInformation>>): void {
+    if (type != 'cellInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCellInfoChange(callback)
+  }
+
+  export function onCellularDataConnectionStateChange(
+    type: 'cellularDataConnectionStateChange',
+    callback: Callback<DataConnectionStateInfo>): void {
+    if (type != 'cellularDataConnectionStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCellularDataConnectionStateChange(callback)
+  }
+
+  export function onNetworkStateChange(
+    type: 'networkStateChange', callback: Callback<NetworkState>): void {
+    if (type != 'networkStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnNetworkStateChange(callback)
+  }
+
+  export function onCallStateChange(
+    type: 'callStateChange', callback: Callback<CallStateInfo>): void {
+    if (type != 'callStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCallStateChange(callback)
+  }
+
+  export function onCellularDataFlowChangeWithOptions(
+    type: 'cellularDataFlowChange', options: ObserverOptions, callback: Callback<DataFlowType>): void {
+    if (type != 'cellularDataFlowChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCellularDataFlowChangeOptions(options, callback)
+  }
+
+  export function onSimStateChangeWithOptions(
+    type: 'simStateChange', options: ObserverOptions, callback: Callback<SimStateData>): void {
+    if (type != 'simStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnSimStateChangeOptions(options, callback)
+  }
+
+  export function onSignalInfoChangeWithOptions(
+    type: 'signalInfoChange', options: ObserverOptions, callback: Callback<Array<SignalInformation>>): void {
+    if (type != 'signalInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnSignalInfoChangeOptions(options, callback)
+  }
+
+  export function onCellInfoChangeWithOptions(
+    type: 'cellInfoChange', options: ObserverOptions, callback: Callback<Array<CellInformation>>): void {
+    if (type != 'cellInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCellInfoChangeOptions(options, callback)
+  }
+
+  export function onCellularDataConnectionStateChangeWithOptions(
+    type: 'cellularDataConnectionStateChange',
+    options: ObserverOptions, 
+    callback: Callback<DataConnectionStateInfo>): void {
+    if (type != 'cellularDataConnectionStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCellularDataConnectionStateChangeOptions(options, callback)
+  }
+
+  export function onNetworkStateChangeWithOptions(
+    type: 'networkStateChange', options: ObserverOptions, callback: Callback<NetworkState>): void {
+    if (type != 'networkStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnNetworkStateChangeOptions(options, callback)
+  }
+
+  export function onCallStateChangeWithOptions(
+    type: 'callStateChange', options: ObserverOptions, callback: Callback<CallStateInfo>): void {
+    if (type != 'callStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOnCallStateChangeOptions(options, callback)
+  }
+
+  overload on {
+    onCellularDataFlowChange,
+    onIccAccountInfoChange,
+    onSimStateChange,
+    onSignalInfoChange,
+    onCellInfoChange,
+    onCellularDataConnectionStateChange,
+    onNetworkStateChange,
+    onCallStateChange,
+    onCellularDataFlowChangeWithOptions,
+    onSimStateChangeWithOptions,
+    onSignalInfoChangeWithOptions,
+    onCellInfoChangeWithOptions,
+    onCellularDataConnectionStateChangeWithOptions,
+    onNetworkStateChangeWithOptions,
+    onCallStateChangeWithOptions
+  }
+
+  export function offCellularDataFlowChange(
+    type: 'cellularDataFlowChange', callback?: Callback<DataFlowType>): void {
+    if (type != 'cellularDataFlowChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffCellularDataFlowChange(callback)
+  }
+
+  export function offIccAccountInfoChange(
+    type: 'iccAccountInfoChange', callback?: Callback<void>): void {
+    if (type != 'iccAccountInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffIccAccountInfoChange(callback)
+  }
+
+  export function offSimStateChange(
+    type: 'simStateChange', callback?: Callback<SimStateData>): void {
+    if (type != 'simStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffSimStateChange(callback)
+  }
+
+  export function offSignalInfoChange(
+    type: 'signalInfoChange', callback?: Callback<Array<SignalInformation>>): void {
+    if (type != 'signalInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffSignalInfoChange(callback)
+  }
+
+  export function offCellInfoChange(
+    type: 'cellInfoChange', callback?: Callback<Array<CellInformation>>): void {
+    if (type != 'cellInfoChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffCellInfoChange(callback)
+  }
+
+  export function offCellularDataConnectionStateChange(
+    type: 'cellularDataConnectionStateChange',
+    callback?: Callback<DataConnectionStateInfo>): void {
+    if (type != 'cellularDataConnectionStateChange') {
+      throw new Error('Invalid event type: ' + type);
     }
+    nativeOffCellularDataConnectionStateChange(callback)
+  }
+
+  export function offNetworkStateChange(
+    type: 'networkStateChange', callback?: Callback<NetworkState>): void {
+    if (type != 'networkStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffNetworkStateChange(callback)
+  }
+
+  export function offCallStateChange(
+    type: 'callStateChange', callback?: Callback<CallStateInfo>): void {
+    if (type != 'callStateChange') {
+      throw new Error('Invalid event type: ' + type);
+    }
+    nativeOffCallStateChange(callback)
+  }
+
+  overload off {
+    offCellularDataFlowChange,
+    offIccAccountInfoChange,
+    offSimStateChange,
+    offSignalInfoChange,
+    offCellInfoChange,
+    offCellularDataConnectionStateChange,
+    offNetworkStateChange,
+    offCallStateChange
   }
 
   export interface SimStateData {
diff --git a/frameworks/ets/ani/observer/src/lib.rs b/frameworks/ets/ani/observer/src/lib.rs
index 2a24f702024d675568ff8324beb3acafb8131be9..adb2cf1aa800ea85fb9607a937e06f0f9734a74a 100644
--- a/frameworks/ets/ani/observer/src/lib.rs
+++ b/frameworks/ets/ani/observer/src/lib.rs
@@ -11,38 +11,38 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+mod bridge;
+mod log;
 mod observer;
 mod register;
-mod bridge;
 mod wrapper;
-mod log;
 
 ani_rs::ani_constructor! {
     namespace "L@ohos/telephony/observer/observer"
     [
-        "onCellularDataFlowChange": observer::on_cellular_data_flow_change,
-        "offCellularDataFlowChange": observer::off_cellular_data_flow_change,
-        "onCellularDataFlowChangeOptions": observer::on_cellular_data_flow_change_option,
-        "onIccAccountInfoChange": observer::on_icc_account_info_change,
-        "offIccAccountInfoChange": observer::off_icc_account_info_change,
-        "onSimStateChange": observer::on_sim_state_change,
-        "onSimStateChangeOptions": observer::on_sim_state_change_option,
-        "offSimStateChange": observer::off_sim_state_change,
-        "onSignalInfoChange": observer::on_signal_info_change,
-        "onSignalInfoChangeOptions": observer::on_signal_info_change_option,
-        "offSignalInfoChange": observer::off_signal_info_change,
-        "onCellInfoChange": observer::on_cell_info_change,
-        "onCellInfoChangeOptions": observer::on_cell_info_change_option,
-        "offCellInfoChange": observer::off_cell_info_change,
-        "onCellularDataConnectionStateChange": observer::on_cellular_data_connection_state_change,
-        "onCellularDataConnectionStateChangeOptions": observer::on_cellular_data_connection_state_change_option,
-        "offCellularDataConnectionStateChange": observer::off_cellular_data_connection_state_change,
-        "onNetworkStateChange": observer::on_network_state_change,
-        "onNetworkStateChangeOptions": observer::on_network_state_change_option,
-        "offNetworkStateChange": observer::off_network_state_change,
-        "onCallStateChange": observer::on_call_state_change,
-        "onCallStateChangeOptions": observer::on_call_state_change_option,
-        "offCallStateChange": observer::off_call_state_change,
+        "nativeOnCellularDataFlowChange": observer::on_cellular_data_flow_change,
+        "nativeOffCellularDataFlowChange": observer::off_cellular_data_flow_change,
+        "nativeOnCellularDataFlowChangeOptions": observer::on_cellular_data_flow_change_option,
+        "nativeOnIccAccountInfoChange": observer::on_icc_account_info_change,
+        "nativeOffIccAccountInfoChange": observer::off_icc_account_info_change,
+        "nativeOnSimStateChange": observer::on_sim_state_change,
+        "nativeOnSimStateChangeOptions": observer::on_sim_state_change_option,
+        "nativeOffSimStateChange": observer::off_sim_state_change,
+        "nativeOnSignalInfoChange": observer::on_signal_info_change,
+        "nativeOnSignalInfoChangeOptions": observer::on_signal_info_change_option,
+        "nativeOffSignalInfoChange": observer::off_signal_info_change,
+        "nativeOnCellInfoChange": observer::on_cell_info_change,
+        "nativeOnCellInfoChangeOptions": observer::on_cell_info_change_option,
+        "nativeOffCellInfoChange": observer::off_cell_info_change,
+        "nativeOnCellularDataConnectionStateChange": observer::on_cellular_data_connection_state_change,
+        "nativeOnCellularDataConnectionStateChangeOptions": observer::on_cellular_data_connection_state_change_option,
+        "nativeOffCellularDataConnectionStateChange": observer::off_cellular_data_connection_state_change,
+        "nativeOnNetworkStateChange": observer::on_network_state_change,
+        "nativeOnNetworkStateChangeOptions": observer::on_network_state_change_option,
+        "nativeOffNetworkStateChange": observer::off_network_state_change,
+        "nativeOnCallStateChange": observer::on_call_state_change,
+        "nativeOnCallStateChangeOptions": observer::on_call_state_change_option,
+        "nativeOffCallStateChange": observer::off_call_state_change,
     ]
 }
 
diff --git a/frameworks/ets/ani/observer/src/register.rs b/frameworks/ets/ani/observer/src/register.rs
index 67786912cfcb26aeffd02d00002e83d58b67df1a..d3105e4e46e08c0b6fa72788a2cdce814ccc4127 100644
--- a/frameworks/ets/ani/observer/src/register.rs
+++ b/frameworks/ets/ani/observer/src/register.rs
@@ -134,7 +134,7 @@ impl Register {
     pub fn register(&self, listener: EventListener) -> Result<(), BusinessError> {
         if !wrapper::ffi::IsValidSlotIdEx(listener.slot_id, listener.event_type.to_u32()) {
             telephony_error!("Register slotId {} is invalid", listener.slot_id);
-            return Err(BusinessError::PARAMETER);
+            return Err(BusinessError::new_static(8300001, "Invalid parameter value."));
         }
 
         let mut inner = self.inner.lock().unwrap();