Rename observer mode to observe mode

Bug: b/315131060
Test: Ran CTS tests on CF
Change-Id: I8ef39a8dca3240ab0ed5c06608985cf4e91ce690
diff --git a/tools/casimir/src/controller.rs b/tools/casimir/src/controller.rs
index 457f8d3..d00a033 100644
--- a/tools/casimir/src/controller.rs
+++ b/tools/casimir/src/controller.rs
@@ -221,7 +221,7 @@
     pub nfcee_state: NfceeState,
     pub rf_state: RfState,
     pub rf_poll_responses: Vec<RfPollResponse>,
-    pub passive_observer_mode: nci::PassiveObserverMode,
+    pub passive_observe_mode: nci::PassiveObserveMode,
     pub start_time: std::time::Instant,
 }
 
@@ -719,7 +719,7 @@
                 nfcee_state: NfceeState::Disabled,
                 rf_state: RfState::Idle,
                 rf_poll_responses: vec![],
-                passive_observer_mode: nci::PassiveObserverMode::Disable,
+                passive_observe_mode: nci::PassiveObserveMode::Disable,
                 start_time: Instant::now(),
             }),
         }
@@ -1322,32 +1322,32 @@
         Ok(())
     }
 
-    async fn android_passive_observer_mode(
+    async fn android_passive_observe_mode(
         &self,
-        cmd: nci::AndroidPassiveObserverModeCommand,
+        cmd: nci::AndroidPassiveObserveModeCommand,
     ) -> Result<()> {
-        info!("[{}] ANDROID_PASSIVE_OBSERVER_MODE_CMD", self.id);
-        info!("     Mode: {:?}", cmd.get_passive_observer_mode());
+        info!("[{}] ANDROID_PASSIVE_OBSERVE_MODE_CMD", self.id);
+        info!("     Mode: {:?}", cmd.get_passive_observe_mode());
 
         let mut state = self.state.lock().await;
-        state.passive_observer_mode = cmd.get_passive_observer_mode();
-        self.send_control(nci::AndroidPassiveObserverModeResponseBuilder {
+        state.passive_observe_mode = cmd.get_passive_observe_mode();
+        self.send_control(nci::AndroidPassiveObserveModeResponseBuilder {
             status: nci::Status::Ok,
         })
         .await?;
         Ok(())
     }
 
-    async fn android_query_passive_observer_mode(
+    async fn android_query_passive_observe_mode(
         &self,
-        _cmd: nci::AndroidQueryPassiveObserverModeCommand,
+        _cmd: nci::AndroidQueryPassiveObserveModeCommand,
     ) -> Result<()> {
-        info!("[{}] ANDROID_QUERY_PASSIVE_OBSERVER_MODE_CMD", self.id);
+        info!("[{}] ANDROID_QUERY_PASSIVE_OBSERVE_MODE_CMD", self.id);
 
         let state = self.state.lock().await;
-        self.send_control(nci::AndroidQueryPassiveObserverModeResponseBuilder {
+        self.send_control(nci::AndroidQueryPassiveObserveModeResponseBuilder {
             status: nci::Status::Ok,
-            passive_observer_mode: state.passive_observer_mode,
+            passive_observe_mode: state.passive_observe_mode,
         })
         .await?;
         Ok(())
@@ -1388,11 +1388,11 @@
             },
             ProprietaryPacket(packet) => match packet.specialize() {
                 AndroidPacket(packet) => match packet.specialize() {
-                    AndroidPassiveObserverModeCommand(cmd) => {
-                        self.android_passive_observer_mode(cmd).await
+                    AndroidPassiveObserveModeCommand(cmd) => {
+                        self.android_passive_observe_mode(cmd).await
                     }
-                    AndroidQueryPassiveObserverModeCommand(cmd) => {
-                        self.android_query_passive_observer_mode(cmd).await
+                    AndroidQueryPassiveObserveModeCommand(cmd) => {
+                        self.android_query_passive_observe_mode(cmd).await
                     }
                     _ => {
                         unimplemented!("unsupported android oid {:?}", packet.get_android_sub_oid())
@@ -1575,8 +1575,8 @@
         // Android proprietary extension for polling frame notifications.
         // The NFCC should send the NCI_ANDROID_POLLING_FRAME_NTF to the Host
         // after each polling loop frame
-        // This notification is independent of whether Passive Observer Mode is
-        // active or not. When Passive Observer Mode is active, the NFCC
+        // This notification is independent of whether Passive Observe Mode is
+        // active or not. When Passive Observe Mode is active, the NFCC
         // should always send this notification before proceeding with the
         // transaction.
         self.send_control(nci::AndroidPollingLoopNotificationBuilder {
@@ -1594,10 +1594,10 @@
         })
         .await?;
 
-        // When the Passive Observer Mode is active, the NFCC shall not respond
+        // When the Passive Observe Mode is active, the NFCC shall not respond
         // to any poll requests during the polling loop in Listen Mode, until
         // explicitly authorized by the Host.
-        if state.passive_observer_mode == nci::PassiveObserverMode::Enable {
+        if state.passive_observe_mode == nci::PassiveObserveMode::Enable {
             return Ok(());
         }
 
diff --git a/tools/casimir/src/nci_packets.pdl b/tools/casimir/src/nci_packets.pdl
index 2479283..6d3f2bf 100644
--- a/tools/casimir/src/nci_packets.pdl
+++ b/tools/casimir/src/nci_packets.pdl
@@ -73,9 +73,9 @@
 }
 
 enum AndroidSubOpcodeId : 8 {
-  PASSIVE_OBSERVER_MODE = 0x2,
+  PASSIVE_OBSERVE_MODE = 0x2,
   POLLING_FRAME = 0x3,
-  QUERY_PASSIVE_OBSERVER_MODE = 0x4,
+  QUERY_PASSIVE_OBSERVE_MODE = 0x4,
 }
 
 enum Status : 8 {
@@ -828,25 +828,25 @@
   _payload_,
 }
 
-enum PassiveObserverMode : 8 {
+enum PassiveObserveMode : 8 {
   DISABLE = 0x0,
   ENABLE = 0x1,
 }
 
-packet AndroidPassiveObserverModeCommand : AndroidPacket(mt = COMMAND, android_sub_oid = PASSIVE_OBSERVER_MODE) {
-  passive_observer_mode: PassiveObserverMode,
+packet AndroidPassiveObserveModeCommand : AndroidPacket(mt = COMMAND, android_sub_oid = PASSIVE_OBSERVE_MODE) {
+  passive_observe_mode: PassiveObserveMode,
 }
 
-packet AndroidPassiveObserverModeResponse : AndroidPacket(mt = RESPONSE, android_sub_oid = PASSIVE_OBSERVER_MODE) {
+packet AndroidPassiveObserveModeResponse : AndroidPacket(mt = RESPONSE, android_sub_oid = PASSIVE_OBSERVE_MODE) {
   status: Status,
 }
 
-packet AndroidQueryPassiveObserverModeCommand : AndroidPacket(mt = COMMAND, android_sub_oid = QUERY_PASSIVE_OBSERVER_MODE) {
+packet AndroidQueryPassiveObserveModeCommand : AndroidPacket(mt = COMMAND, android_sub_oid = QUERY_PASSIVE_OBSERVE_MODE) {
 }
 
-packet AndroidQueryPassiveObserverModeResponse : AndroidPacket(mt = RESPONSE, android_sub_oid = QUERY_PASSIVE_OBSERVER_MODE) {
+packet AndroidQueryPassiveObserveModeResponse : AndroidPacket(mt = RESPONSE, android_sub_oid = QUERY_PASSIVE_OBSERVE_MODE) {
   status: Status,
-  passive_observer_mode: PassiveObserverMode,
+  passive_observe_mode: PassiveObserveMode,
 }
 
 enum PollingFrameType : 8 {