fix: corebluetooth peripheral name

Author: szymonlesisz

src/corebluetooth/adapter.rs

@@ -57,22 +57,28 @@ impl Adapter {
                 match msg {
                     CoreBluetoothEvent::DeviceDiscovered {
                         uuid,
-                        name,
+                        local_name,
+                        advertisement_name,
                         event_receiver,
                     } => {
                         manager_clone.add_peripheral(Peripheral::new(
                             uuid,
-                            name,
+                            local_name,
+                            advertisement_name,
                             Arc::downgrade(&manager_clone),
                             event_receiver,
                             adapter_sender_clone.clone(),
                         ));
                         manager_clone.emit(CentralEvent::DeviceDiscovered(uuid.into()));
                     }
-                    CoreBluetoothEvent::DeviceUpdated { uuid, name } => {
+                    CoreBluetoothEvent::DeviceUpdated {
+                        uuid,
+                        local_name,
+                        advertisement_name,
+                    } => {
                         let id = uuid.into();
                         if let Some(entry) = manager_clone.peripheral_mut(&id) {
-                            entry.value().update_name(&name);
+                            entry.value().update_name(local_name, advertisement_name);
                             manager_clone.emit(CentralEvent::DeviceUpdated(id));
                         }
                     }

src/corebluetooth/central_delegate.rs

@@ -46,7 +46,7 @@ pub enum CentralDelegateEvent {
     },
     DiscoveredPeripheral {
         cbperipheral: Retained<CBPeripheral>,
-        local_name: Option<String>,
+        advertisement_name: Option<String>,
     },
     DiscoveredServices {
         peripheral_uuid: Uuid,
@@ -136,11 +136,11 @@ impl Debug for CentralDelegateEvent {
                 .finish(),
             CentralDelegateEvent::DiscoveredPeripheral {
                 cbperipheral,
-                local_name,
+                advertisement_name,
             } => f
                 .debug_struct("CentralDelegateEvent")
                 .field("cbperipheral", cbperipheral.deref())
-                .field("local_name", local_name)
+                .field("advertisement_name", advertisement_name)
                 .finish(),
             CentralDelegateEvent::DiscoveredServices {
                 peripheral_uuid,
@@ -385,14 +385,14 @@ declare_class!(
                 peripheral_debug(peripheral)
             );
 
-            let local_name = adv_data
+            let advertisement_name = adv_data
                 .get(unsafe { CBAdvertisementDataLocalNameKey })
                 .map(|name| (name as *const AnyObject as *const NSString))
                 .and_then(|name| unsafe { nsstring_to_string(name) });
 
             self.send_event(CentralDelegateEvent::DiscoveredPeripheral {
                 cbperipheral: peripheral.retain(),
-                local_name,
+                advertisement_name,
             });
 
             let rssi_value = rssi.as_i16();

src/corebluetooth/internal.rs

@@ -461,12 +461,14 @@ pub enum CoreBluetoothEvent {
     },
     DeviceDiscovered {
         uuid: Uuid,
-        name: Option<String>,
+        local_name: Option<String>,
+        advertisement_name: Option<String>,
         event_receiver: Receiver<PeripheralEventInternal>,
     },
     DeviceUpdated {
         uuid: Uuid,
-        name: String,
+        local_name: Option<String>,
+        advertisement_name: Option<String>,
     },
     DeviceDisconnected {
         uuid: Uuid,
@@ -569,26 +571,20 @@ impl CoreBluetoothInternal {
     async fn on_discovered_peripheral(
         &mut self,
         peripheral: Retained<CBPeripheral>,
-        local_name: Option<String>,
+        advertisement_name: Option<String>,
     ) {
         let uuid = nsuuid_to_uuid(unsafe { &peripheral.identifier() });
         let peripheral_name = unsafe { peripheral.name() };
-
-        let name = match (peripheral_name.map(|n| n.to_string()), local_name) {
-            (Some(p_name), Some(l_name)) if p_name != l_name => {
-                Some(format!("{p_name} [{l_name}]"))
-            }
-            (Some(p_name), Some(_)) => Some(p_name),
-            (Some(p_name), None) => Some(p_name),
-            (None, Some(l_name)) => Some(l_name),
-            (None, None) => None,
-        };
+        let local_name = peripheral_name
+            .map(|n| n.to_string())
+            .or(advertisement_name.clone());
 
         if self.peripherals.contains_key(&uuid) {
-            if let Some(name) = name {
+            if local_name.is_some() {
                 self.dispatch_event(CoreBluetoothEvent::DeviceUpdated {
                     uuid,
-                    name: name.to_string(),
+                    local_name,
+                    advertisement_name,
                 })
                 .await;
             }
@@ -599,7 +595,8 @@ impl CoreBluetoothInternal {
                 .insert(uuid, PeripheralInternal::new(peripheral, event_sender));
             self.dispatch_event(CoreBluetoothEvent::DeviceDiscovered {
                 uuid,
-                name: name.map(|name| name.to_string()),
+                local_name,
+                advertisement_name,
                 event_receiver,
             })
             .await;
@@ -1096,8 +1093,8 @@ impl CoreBluetoothInternal {
                     CentralDelegateEvent::DidUpdateState{state} => {
                         self.dispatch_event(CoreBluetoothEvent::DidUpdateState{state}).await
                     }
-                    CentralDelegateEvent::DiscoveredPeripheral{cbperipheral, local_name} => {
-                        self.on_discovered_peripheral(cbperipheral, local_name).await
+                    CentralDelegateEvent::DiscoveredPeripheral{cbperipheral, advertisement_name} => {
+                        self.on_discovered_peripheral(cbperipheral, advertisement_name).await
                     }
                     CentralDelegateEvent::DiscoveredServices{peripheral_uuid, services} => {
                         self.on_discovered_services(peripheral_uuid, services)

src/corebluetooth/peripheral.rs

@@ -84,6 +84,7 @@ impl Peripheral {
     pub(crate) fn new(
         uuid: Uuid,
         local_name: Option<String>,
+        advertisement_name: Option<String>,
         manager: Weak<AdapterManager<Self>>,
         event_receiver: Receiver<PeripheralEventInternal>,
         message_sender: Sender<CoreBluetoothMessage>,
@@ -94,7 +95,7 @@ impl Peripheral {
             address: BDAddr::default(),
             address_type: None,
             local_name,
-            advertisement_name: None,
+            advertisement_name,
             tx_power_level: None,
             rssi: None,
             manufacturer_data: HashMap::new(),
@@ -176,8 +177,15 @@ impl Peripheral {
         Self { shared: shared }
     }
 
-    pub(super) fn update_name(&self, name: &str) {
-        self.shared.properties.lock().unwrap().local_name = Some(name.to_string());
+    pub(super) fn update_name(
+        &self,
+        local_name: Option<String>,
+        advertisement_name: Option<String>,
+    ) {
+        if let Ok(mut props) = self.shared.properties.lock() {
+            props.local_name = local_name;
+            props.advertisement_name = advertisement_name;
+        }
     }
 }