Method connect

src/winrtble/peripheral.rs:393–442

Creates a connection to the device. This is a synchronous operation; if this method returns Ok there has been successful connection. Note that peripherals allow only one connection at a time. Operations that attempt to communicate with a device will fail until it is connected.

(&self)

    /// Ok there has been successful connection. Note that peripherals allow only one connection at
    /// a time. Operations that attempt to communicate with a device will fail until it is connected.
    async fn connect(&self) -> Result<()> {
        let adapter_clone = self.shared.adapter.clone();
        let address = self.shared.address;

        let connection_status_changed = Box::new({
            let shared_clone = Arc::downgrade(&self.shared);
            move |is_connected| {
                if let Some(shared) = shared_clone.upgrade() {
                    shared.connected.store(is_connected, Ordering::Relaxed);
                }

                if !is_connected {
                    if let Some(adapter) = adapter_clone.upgrade() {
                        adapter.emit(CentralEvent::DeviceDisconnected(address.into()));
                    }
                }
            }
        });

        let max_pdu_size_changed = Box::new({
            let shared_clone = Arc::downgrade(&self.shared);
            move |mtu| {
                if let Some(shared) = shared_clone.upgrade() {
                    shared.mtu.store(mtu, Ordering::Relaxed);
                }
            }
        });

        let device = BLEDevice::new(
            self.shared.address,
            connection_status_changed,
            max_pdu_size_changed,
        )
        .await?;

        device.connect().await?;
        // Query the system-cached device name (GAP name) and update local_name
        if let Ok(name) = device.name() {
            let name_str = name.to_string();
            if !name_str.is_empty() {
                let mut local_name_guard = self.shared.local_name.write().unwrap();
                *local_name_guard = Some(name_str);
            }
        }
        let mut d = self.shared.device.lock().await;
        *d = Some(device);
        self.shared.connected.store(true, Ordering::Relaxed);
        self.emit_event(CentralEvent::DeviceConnected(self.shared.address.into()));
        Ok(())
    }

    /// Terminates a connection to the device. This is a synchronous operation.
    async fn disconnect(&self) -> Result<()> {