use crate::ble::{self, Callback};
use crate::bluetooth::{Event, EventSink, Ref};
#[cfg(feature = "classic")]
use crate::jni::Env;
use crate::jni::{JObject, Vm};
use crate::runtime::Runtime;
use futures_channel::oneshot;
use std::collections::{BTreeSet, HashMap};
use std::sync::{Arc, Mutex, Weak};
use webbluetooth_core::chooser::DeviceChooser;
use webbluetooth_core::error::{Availability, Error, Result};
use webbluetooth_core::filter::{Advertisement, RequestDeviceOptions};
use webbluetooth_core::gatt::{CharacteristicProperties, WriteType};
use webbluetooth_core::registry::DeviceRegistry;
use webbluetooth_core::scan::{self, ScanHub};
use webbluetooth_core::state::ManagerState;
use webbluetooth_core::uuid::BluetoothUuid;
#[derive(Clone, Debug)]
pub struct Handle(Arc<HandleData>);
#[derive(Debug)]
struct HandleData {
object: Ref,
uuid: BluetoothUuid,
properties: u32,
}
impl Handle {
fn as_ptr(&self) -> JObject {
self.0.object.as_ptr()
}
}
pub fn attribute_uuid(handle: &Handle) -> Result<BluetoothUuid> {
Ok(handle.0.uuid)
}
#[allow(dead_code)]
#[derive(Debug, Default, Clone)]
pub struct RestoredScan {
pub device_ids: Vec<String>,
pub scan_services: Vec<BluetoothUuid>,
pub scan_allow_duplicates: bool,
}
pub fn init(vm: Vm, context: JObject) -> Result<()> {
Runtime::init(vm, context)
.map(|_| ())
.map_err(|e| Error::NotSupported(format!("could not start the Android runtime: {e}")))
}
struct DeviceData {
device: Ref,
gatt: Option<Ref>,
callback: Option<Arc<Callback>>,
mtu: i32,
}
#[derive(Default)]
struct Pending {
connect: Vec<oneshot::Sender<Result<()>>>,
services: Vec<oneshot::Sender<Result<()>>>,
read: Vec<oneshot::Sender<Result<Vec<u8>>>>,
write: Vec<oneshot::Sender<Result<()>>>,
notify: Vec<oneshot::Sender<Result<bool>>>,
read_descriptor: Vec<oneshot::Sender<Result<Vec<u8>>>>,
write_descriptor: Vec<oneshot::Sender<Result<()>>>,
rssi: Vec<oneshot::Sender<Result<i32>>>,
phy: Vec<oneshot::Sender<Result<(i32, i32)>>>,
}
impl Pending {
fn fail(&mut self, error: &Error) {
fn drain<T>(slots: &mut Vec<oneshot::Sender<Result<T>>>, error: &Error) {
for tx in slots.drain(..) {
let _ = tx.send(Err(error.clone()));
}
}
drain(&mut self.connect, error);
drain(&mut self.services, error);
drain(&mut self.read, error);
drain(&mut self.write, error);
drain(&mut self.notify, error);
drain(&mut self.read_descriptor, error);
drain(&mut self.write_descriptor, error);
drain(&mut self.rssi, error);
}
}
pub struct Inner {
devices: DeviceRegistry<DeviceData>,
pending: Mutex<HashMap<String, Pending>>,
notifications: Mutex<HashMap<usize, Vec<webbluetooth_core::backlog::Sender<Vec<u8>>>>>,
hub: ScanHub,
sightings: Mutex<HashMap<String, Option<String>>>,
scan_callback: Mutex<Option<Callback>>,
#[cfg(feature = "classic")]
classic_receiver: Mutex<Option<Callback>>,
}
struct Sink(Weak<Inner>);
impl EventSink for Sink {
fn emit(&self, event: Event) {
if let Some(inner) = self.0.upgrade() {
inner.handle(event);
}
}
}
impl Inner {
pub fn new(show_power_alert: bool) -> Arc<Self> {
Self::with_restoration(show_power_alert, None, BTreeSet::new())
}
pub fn with_restoration(
_show_power_alert: bool,
_restore_identifier: Option<&str>,
_restore_allowed: BTreeSet<BluetoothUuid>,
) -> Arc<Self> {
Arc::new_cyclic(|_weak: &Weak<Inner>| {
Inner {
devices: DeviceRegistry::default(),
pending: Mutex::new(HashMap::new()),
notifications: Mutex::new(HashMap::new()),
hub: ScanHub::new(),
sightings: Mutex::new(HashMap::new()),
scan_callback: Mutex::new(None),
#[cfg(feature = "classic")]
classic_receiver: Mutex::new(None),
}
})
}
fn runtime(&self) -> Result<&'static Runtime> {
Runtime::get().ok_or_else(|| {
Error::NotSupported(
"the Android backend is not started — call webbluetooth::android::init(vm, context)"
.into(),
)
})
}
fn handle(&self, event: Event) {
match event {
#[cfg(feature = "classic")]
Event::ClassicDiscovered {
address,
name,
class_of_device,
} => {
if self.hub.is_watching() {
self.sightings
.lock()
.unwrap()
.insert(address.clone(), name.clone());
let advertisement = Advertisement {
class_of_device: class_of_device
.map(webbluetooth_core::ClassOfDevice::from_raw),
local_name: name,
tx_power: None,
appearance: None,
is_connectable: Some(true),
service_uuids: Vec::new(),
overflow_service_uuids: Vec::new(),
solicited_service_uuids: Vec::new(),
manufacturer_data: HashMap::new(),
service_data: HashMap::new(),
rssi: webbluetooth_core::filter::UNAVAILABLE_RSSI,
raw: None,
};
self.hub.publish(
&address,
advertisement.local_name.as_deref(),
&advertisement,
);
}
}
#[cfg(feature = "classic")]
Event::ClassicDiscoveryFinished => {}
Event::Discovered {
address,
name,
rssi,
service_uuids,
manufacturer_data,
service_data,
class_of_device,
connectable,
} => {
#[cfg(not(feature = "classic"))]
let _ = class_of_device;
if !self.hub.is_watching() {
return;
}
let advertisement = Advertisement {
#[cfg(feature = "classic")]
class_of_device: class_of_device
.map(webbluetooth_core::ClassOfDevice::from_raw),
local_name: name.clone(),
tx_power: None,
appearance: None,
is_connectable: Some(connectable),
service_uuids: service_uuids
.iter()
.filter_map(|u| BluetoothUuid::parse(u).ok())
.collect(),
overflow_service_uuids: Vec::new(),
solicited_service_uuids: Vec::new(),
manufacturer_data: manufacturer_data.into_iter().collect(),
service_data: service_data
.into_iter()
.filter_map(|(u, d)| Some((BluetoothUuid::parse(&u).ok()?, d)))
.collect(),
rssi,
raw: None,
};
self.sightings
.lock()
.unwrap()
.insert(address.clone(), name.clone());
self.hub.publish(&address, name.as_deref(), &advertisement);
}
Event::ScanFailed { code } => {
self.hub.close_all();
let _ = code;
}
Event::ConnectionStateChanged {
gatt,
status,
connected,
} => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
if connected && status == ble::GATT_SUCCESS {
self.devices.update(&id, |d| d.connected = true);
self.resolve(&id, |p| &mut p.connect, Ok(()));
} else {
let error = Error::Network(format!("the link dropped (GATT status {status})"));
self.pending
.lock()
.unwrap()
.entry(id.clone())
.or_default()
.fail(&error);
self.devices.update(&id, |d| d.inner.gatt = None);
self.devices.mark_disconnected(&id);
}
}
Event::ServicesDiscovered { gatt, status } => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.services, gatt_result(status, ()));
}
Event::CharacteristicRead {
gatt,
value,
status,
..
} => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.read, gatt_result(status, value));
}
Event::CharacteristicWritten { gatt, status, .. } => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.write, gatt_result(status, ()));
}
Event::CharacteristicChanged {
characteristic,
value,
..
} => {
let key = characteristic.key();
let mut subscribers = self.notifications.lock().unwrap();
if let Some(list) = subscribers.get_mut(&key) {
list.retain(|tx| tx.send(value.clone()).is_ok());
if list.is_empty() {
subscribers.remove(&key);
}
}
}
Event::DescriptorRead {
gatt,
value,
status,
..
} => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.read_descriptor, gatt_result(status, value));
}
Event::DescriptorWritten { gatt, status, .. } => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.write_descriptor, gatt_result(status, ()));
self.resolve(&id, |p| &mut p.notify, gatt_result(status, true));
}
Event::PhyChanged {
gatt,
tx,
rx,
status,
} => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.phy, gatt_result(status, (tx, rx)));
}
Event::MtuChanged { gatt, mtu, .. } => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.devices.update(&id, |d| d.inner.mtu = mtu);
}
Event::RssiRead { gatt, rssi, status } => {
let Some(id) = self.id_for_gatt(&gatt) else {
return;
};
self.resolve(&id, |p| &mut p.rssi, gatt_result(status, rssi));
}
Event::ServicesChanged { gatt } => {
if let Some(id) = self.id_for_gatt(&gatt) {
self.devices.mark_services_changed(&id);
}
}
_ => {}
}
}
fn id_for_gatt(&self, gatt: &Ref) -> Option<String> {
let key = gatt.key();
self.devices
.find(|d| d.inner.gatt.as_ref().is_some_and(|g| g.key() == key))
}
fn resolve<T>(
&self,
id: &str,
slot: impl Fn(&mut Pending) -> &mut Vec<oneshot::Sender<Result<T>>>,
value: Result<T>,
) where
T: Clone,
{
let mut pending = self.pending.lock().unwrap();
let entry = pending.entry(id.to_owned()).or_default();
for tx in slot(entry).drain(..) {
let _ = tx.send(value.clone());
}
}
fn enqueue<T>(
&self,
id: &str,
slot: impl Fn(&mut Pending) -> &mut Vec<oneshot::Sender<Result<T>>>,
) -> oneshot::Receiver<Result<T>> {
let (tx, rx) = oneshot::channel();
let mut pending = self.pending.lock().unwrap();
slot(pending.entry(id.to_owned()).or_default()).push(tx);
rx
}
fn ble_adapter(&self) -> Result<ble::Adapter> {
let runtime = self.runtime()?;
ble::Adapter::open(runtime).map_err(|e| {
match e {
crate::runtime::Error::MissingClass(_) => {
Error::NotAvailable(Availability::Unsupported)
}
other => Error::Network(format!("could not reach the Bluetooth adapter: {other}")),
}
})
}
pub fn state(&self) -> ManagerState {
if Runtime::get().is_none() {
return ManagerState::Unauthorized;
}
let Ok(adapter) = self.ble_adapter() else {
return ManagerState::Unsupported;
};
let Ok(runtime) = self.runtime() else {
return ManagerState::Unauthorized;
};
let Ok(env) = runtime.env() else {
return ManagerState::Unauthorized;
};
if adapter.is_enabled(env) {
ManagerState::PoweredOn
} else {
ManagerState::PoweredOff
}
}
pub async fn settled_state(&self) -> ManagerState {
self.state()
}
pub async fn require_powered_on(&self) -> Result<()> {
self.state().require_powered_on()
}
pub fn restored(&self) -> Option<RestoredScan> {
None
}
pub fn scan_hub(&self) -> &ScanHub {
&self.hub
}
pub fn set_radio_scanning(self: &Arc<Self>, on: bool) -> Result<()> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let scanner = adapter.scanner(env).map_err(jni_error)?;
if scanner.is_null() {
return Err(Error::NotAvailable(Availability::PoweredOff));
}
if let Some(callback) = self.scan_callback.lock().unwrap().take() {
let _ = ble::stop_scan(env, scanner, callback.as_ptr());
}
if !on {
#[cfg(feature = "classic")]
self.stop_classic_discovery(env)?;
return Ok(());
}
let scan_services: Vec<String> = self
.hub
.scan_services()
.iter()
.map(|u| u.as_str().to_owned())
.collect();
let callback = Callback::new(
runtime,
"dev.webbluetooth.ScanCallback",
crate::scan_callback_dex(),
&crate::bluetooth::scan_natives(),
Arc::new(Sink(Arc::downgrade(self))),
)
.map_err(jni_error)?;
ble::start_scan(env, scanner, callback.as_ptr(), &scan_services)
.map_err(|e| Error::Network(format!("could not start scanning: {e}")))?;
*self.scan_callback.lock().unwrap() = Some(callback);
#[cfg(feature = "classic")]
self.start_classic_discovery(runtime)?;
Ok(())
}
#[cfg(feature = "classic")]
fn start_classic_discovery(self: &Arc<Self>, runtime: &'static Runtime) -> Result<()> {
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let callback = Callback::new(
runtime,
"dev.webbluetooth.ClassicDiscoveryReceiver",
crate::classic_discovery_receiver_dex(),
&crate::bluetooth::classic_discovery_natives(),
Arc::new(Sink(Arc::downgrade(self))),
)
.map_err(jni_error)?;
let filter = ble::classic_discovery_filter(env).map_err(jni_error)?;
ble::register_classic_receiver(env, callback.as_ptr(), filter).map_err(jni_error)?;
ble::start_classic_discovery(env, adapter.as_ptr()).map_err(jni_error)?;
*self.classic_receiver.lock().unwrap() = Some(callback);
Ok(())
}
#[cfg(feature = "classic")]
fn stop_classic_discovery(&self, env: Env) -> Result<()> {
if let Some(callback) = self.classic_receiver.lock().unwrap().take() {
let _ = ble::unregister_classic_receiver(env, callback.as_ptr());
}
let adapter = self.ble_adapter()?;
ble::cancel_classic_discovery(env, adapter.as_ptr()).map_err(jni_error)
}
pub async fn request_device(
self: &Arc<Self>,
options: RequestDeviceOptions,
chooser: &dyn DeviceChooser,
) -> Result<String> {
options.validate()?;
self.require_powered_on().await?;
let allowed = options.grant();
let id = scan::choose(
&self.hub,
options,
chooser,
|on| self.set_radio_scanning(on),
|| {},
)
.await?;
let Some(name) = self.sightings.lock().unwrap().get(&id).cloned() else {
return Err(Error::NotFound(format!(
"the chooser returned {id:?}, which was not among the devices it was offered"
)));
};
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let device = adapter.remote_device(env, &id).map_err(jni_error)?;
let device =
Ref::new(env, device).ok_or_else(|| Error::NotFound(format!("no device at {id}")))?;
self.devices.insert(
&id,
name,
allowed,
false,
DeviceData {
device,
gatt: None,
callback: None,
mtu: 23,
},
);
Ok(id)
}
webbluetooth_core::registry::forward_to_registry!();
pub async fn phy(&self, id: &str) -> Result<webbluetooth_core::ConnectionPhy> {
let rx = {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let rx = self.enqueue(id, |p| &mut p.phy);
ble::read_phy(env, gatt.as_ptr()).map_err(jni_error)?;
rx
};
let (tx, rx_phy) = rx
.await
.map_err(|_| Error::Aborted("reading the PHY was cancelled".into()))??;
Ok(webbluetooth_core::ConnectionPhy {
tx: phy_from_android(tx),
rx: phy_from_android(rx_phy),
})
}
pub async fn set_preferred_phy(
&self,
id: &str,
tx: webbluetooth_core::Phy,
rx: webbluetooth_core::Phy,
) -> Result<webbluetooth_core::ConnectionPhy> {
const NO_PREFERRED: i32 = 0;
let reply = {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let reply = self.enqueue(id, |p| &mut p.phy);
ble::set_preferred_phy(env, gatt.as_ptr(), phy_mask(tx), phy_mask(rx), NO_PREFERRED)
.map_err(jni_error)?;
reply
};
let (got_tx, got_rx) = reply
.await
.map_err(|_| Error::Aborted("the PHY request was cancelled".into()))??;
Ok(webbluetooth_core::ConnectionPhy {
tx: phy_from_android(got_tx),
rx: phy_from_android(got_rx),
})
}
pub async fn pair(&self, id: &str) -> Result<webbluetooth_core::Pairing> {
const BOND_NONE: i32 = 10;
const BOND_BONDED: i32 = 12;
if self.bond_state(id)? == BOND_BONDED {
return Ok(webbluetooth_core::Pairing::AlreadyPaired);
}
{
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let device = self.devices.get(id, |d| d.inner.device.clone())?;
if !ble::create_bond(env, device.as_ptr()).map_err(jni_error)? {
return Err(Error::Network(
"createBond was refused; the device may be out of range".into(),
));
}
}
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
loop {
match self.bond_state(id)? {
BOND_BONDED => return Ok(webbluetooth_core::Pairing::Paired),
BOND_NONE => {
return Err(Error::Network(
"pairing ended without a bond; it was refused or cancelled".into(),
))
}
_ => {}
}
if std::time::Instant::now() >= deadline {
return Err(Error::Aborted("pairing was not answered".into()));
}
webbluetooth_core::timer::sleep(std::time::Duration::from_millis(250)).await;
}
}
pub async fn is_paired(&self, id: &str) -> Result<bool> {
const BOND_BONDED: i32 = 12;
Ok(self.bond_state(id)? == BOND_BONDED)
}
fn bond_state(&self, id: &str) -> Result<i32> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let device = self.devices.get(id, |d| d.inner.device.clone())?;
ble::bond_state(env, device.as_ptr()).map_err(jni_error)
}
pub async fn adapters(&self) -> Result<Vec<webbluetooth_core::AdapterInfo>> {
Ok(vec![self.adapter_info().await?])
}
pub async fn adapter(&self) -> Result<webbluetooth_core::AdapterInfo> {
self.adapter_info().await
}
async fn adapter_info(&self) -> Result<webbluetooth_core::AdapterInfo> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
Ok(webbluetooth_core::AdapterInfo {
id: webbluetooth_core::adapter::DEFAULT_ADAPTER.to_owned(),
name: adapter.name(env),
address: adapter
.address(env)
.filter(|a| !webbluetooth_core::adapter::is_placeholder_address(a)),
powered: adapter.is_enabled(env),
is_default: true,
})
}
pub async fn select_adapter(&self, id: &str) -> Result<()> {
if id == webbluetooth_core::adapter::DEFAULT_ADAPTER {
return Ok(());
}
Err(Error::NotSupported(format!(
"Android exposes one default adapter and no way to choose another, \
so {id:?} cannot be selected"
)))
}
pub async fn connection_parameters(
&self,
id: &str,
) -> Result<webbluetooth_core::ConnectionParameters> {
let _ = self.is_connected(id);
Err(Error::NotSupported(
"Android does not report negotiated connection parameters".into(),
))
}
pub async fn adopt_device(
&self,
id: &str,
allowed: webbluetooth_core::registry::Grant,
) -> Result<String> {
if !webbluetooth_core::address::is_bluetooth_address(id) {
return Err(Error::NotFound(format!(
"{id:?} is not a Bluetooth address"
)));
}
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let device = adapter
.remote_device(env, &id.to_uppercase())
.map_err(|e| Error::NotFound(format!("getRemoteDevice({id:?}) failed: {e}")))?;
let device =
Ref::new(env, device).ok_or_else(|| Error::NotFound(format!("no device at {id}")))?;
self.devices.insert(
id,
None,
allowed,
false,
DeviceData {
device,
gatt: None,
callback: None,
mtu: 23,
},
);
Ok(id.to_owned())
}
#[cfg(feature = "classic")]
pub async fn bonded_classic_devices(&self) -> Result<Vec<String>> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
adapter.bonded_device_addresses(env).map_err(jni_error)
}
#[cfg(feature = "classic")]
pub async fn classic_service_uuids(&self, id: &str) -> Result<Vec<BluetoothUuid>> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let device = adapter.remote_device(env, id).map_err(jni_error)?;
Ok(adapter
.device_service_uuids(env, device)
.map_err(jni_error)?
.into_iter()
.filter_map(|uuid| BluetoothUuid::parse(&uuid).ok())
.collect())
}
async fn gatt_lock(&self, id: &str) -> Result<futures_util::lock::OwnedMutexGuard<()>> {
self.devices.gatt_lock(id).await
}
pub fn forget(&self, id: &str) {
if let Some(device) = self.devices.remove(id) {
if let (Ok(runtime), Some(gatt)) = (self.runtime(), device.inner.gatt) {
if let Ok(env) = runtime.env() {
let _ = ble::disconnect(env, gatt.as_ptr());
let _ = ble::close(env, gatt.as_ptr());
}
}
}
}
fn gatt(&self, id: &str) -> Result<Ref> {
self.devices
.get(id, |d| d.inner.gatt.clone())?
.ok_or_else(|| Error::InvalidState("the device is not connected".into()))
}
pub fn service_is_primary(&self, _handle: &Handle) -> bool {
true
}
pub fn characteristic_properties(&self, handle: &Handle) -> CharacteristicProperties {
CharacteristicProperties(handle.0.properties)
}
pub fn cached_value(&self, handle: &Handle) -> Option<Vec<u8>> {
let env = self.runtime().ok()?.env().ok()?;
ble::characteristic_value(env, handle.as_ptr())
}
pub fn is_notifying(&self, handle: &Handle) -> bool {
self.notifications
.lock()
.unwrap()
.contains_key(&handle.0.object.key())
}
pub async fn connect(self: &Arc<Self>, id: &str) -> Result<()> {
self.require_powered_on().await?;
if self.is_connected(id) {
return Ok(());
}
let rx = {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let device = self.devices.get(id, |d| d.inner.device.clone())?;
let callback = Arc::new(
Callback::new(
runtime,
"dev.webbluetooth.GattCallback",
crate::gatt_callback_dex(),
&crate::bluetooth::gatt_natives(),
Arc::new(Sink(Arc::downgrade(self))),
)
.map_err(jni_error)?,
);
let rx = self.enqueue(id, |p| &mut p.connect);
let gatt = ble::connect_gatt(env, runtime, device.as_ptr(), callback.as_ptr())
.map_err(jni_error)?;
let gatt = Ref::new(env, gatt)
.ok_or_else(|| Error::Network("connectGatt returned null".into()))?;
self.devices.update(id, |d| {
d.inner.gatt = Some(gatt);
d.inner.callback = Some(callback.clone());
});
rx
};
rx.await
.map_err(|_| Error::Aborted("connect was cancelled".into()))??;
let rx = {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let _ = ble::request_mtu(env, gatt.as_ptr(), 517);
let rx = self.enqueue(id, |p| &mut p.services);
ble::discover_services(env, gatt.as_ptr()).map_err(jni_error)?;
rx
};
rx.await
.map_err(|_| Error::Aborted("service discovery was cancelled".into()))?
}
pub fn disconnect(&self, id: &str) {
if let (Ok(runtime), Ok(gatt)) = (self.runtime(), self.gatt(id)) {
if let Ok(env) = runtime.env() {
let _ = ble::disconnect(env, gatt.as_ptr());
}
}
}
pub async fn discover_services(
&self,
id: &str,
uuid: Option<&BluetoothUuid>,
) -> Result<Vec<Handle>> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let list = ble::services(env, gatt.as_ptr()).map_err(jni_error)?;
Ok(collect(env, list, uuid, 0))
}
pub async fn discover_included_services(
&self,
id: &str,
service: &Handle,
uuid: Option<&BluetoothUuid>,
) -> Result<Vec<Handle>> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let list = ble::service_included_services(env, service.as_ptr()).map_err(jni_error)?;
Ok(collect(env, list, uuid, 0))
}
pub async fn discover_characteristics(
&self,
id: &str,
service: &Handle,
uuid: Option<&BluetoothUuid>,
) -> Result<Vec<Handle>> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let list = ble::service_characteristics(env, service.as_ptr()).map_err(jni_error)?;
Ok(collect_characteristics(env, list, uuid))
}
pub async fn discover_descriptors(
&self,
id: &str,
characteristic: &Handle,
uuid: Option<&BluetoothUuid>,
) -> Result<Vec<Handle>> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let list =
ble::characteristic_descriptors(env, characteristic.as_ptr()).map_err(jni_error)?;
Ok(collect(env, list, uuid, 0))
}
pub async fn read_characteristic(&self, id: &str, handle: &Handle) -> Result<Vec<u8>> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let rx = self.enqueue(id, |p| &mut p.read);
if !ble::read_characteristic(env, gatt.as_ptr(), handle.as_ptr()).map_err(jni_error)? {
return Err(Error::Network("readCharacteristic was refused".into()));
}
rx.await
.map_err(|_| Error::Aborted("read was cancelled".into()))?
}
pub async fn write_characteristic(
&self,
id: &str,
handle: &Handle,
value: &[u8],
write_type: WriteType,
) -> Result<()> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let kind = match write_type {
WriteType::WithResponse => ble::WRITE_TYPE_DEFAULT,
WriteType::WithoutResponse => ble::WRITE_TYPE_NO_RESPONSE,
};
let rx = self.enqueue(id, |p| &mut p.write);
if !ble::write_characteristic(env, gatt.as_ptr(), handle.as_ptr(), value, kind)
.map_err(jni_error)?
{
return Err(Error::Network("writeCharacteristic was refused".into()));
}
rx.await
.map_err(|_| Error::Aborted("write was cancelled".into()))?
}
pub async fn set_notify(&self, id: &str, handle: &Handle, enabled: bool) -> Result<bool> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let properties = CharacteristicProperties(handle.0.properties);
let rx = self.enqueue(id, |p| &mut p.notify);
let wrote = ble::set_notify(
env,
gatt.as_ptr(),
handle.as_ptr(),
enabled,
enabled && !properties.notify() && properties.indicate(),
)
.map_err(jni_error)?;
if !wrote {
return Ok(enabled);
}
rx.await
.map_err(|_| Error::Aborted("subscribe was cancelled".into()))?
}
pub fn subscribe(&self, handle: &Handle) -> webbluetooth_core::backlog::Receiver<Vec<u8>> {
let (tx, rx) = webbluetooth_core::backlog::channel();
self.notifications
.lock()
.unwrap()
.entry(handle.0.object.key())
.or_default()
.push(tx);
rx
}
pub async fn read_descriptor(&self, id: &str, handle: &Handle) -> Result<Vec<u8>> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let rx = self.enqueue(id, |p| &mut p.read_descriptor);
if !ble::read_descriptor(env, gatt.as_ptr(), handle.as_ptr()).map_err(jni_error)? {
return Err(Error::Network("readDescriptor was refused".into()));
}
rx.await
.map_err(|_| Error::Aborted("descriptor read was cancelled".into()))?
}
pub async fn write_descriptor(&self, id: &str, handle: &Handle, value: &[u8]) -> Result<()> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let rx = self.enqueue(id, |p| &mut p.write_descriptor);
if !ble::write_descriptor(env, gatt.as_ptr(), handle.as_ptr(), value).map_err(jni_error)? {
return Err(Error::Network("writeDescriptor was refused".into()));
}
rx.await
.map_err(|_| Error::Aborted("descriptor write was cancelled".into()))?
}
pub async fn read_rssi(&self, id: &str) -> Result<i32> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
let rx = self.enqueue(id, |p| &mut p.rssi);
if !ble::read_remote_rssi(env, gatt.as_ptr()).map_err(jni_error)? {
return Err(Error::Network("readRemoteRssi was refused".into()));
}
rx.await
.map_err(|_| Error::Aborted("RSSI read was cancelled".into()))?
}
pub async fn request_connection_priority(
&self,
id: &str,
priority: webbluetooth_core::ConnectionPriority,
) -> Result<()> {
use webbluetooth_core::ConnectionPriority as P;
let value = match priority {
P::Balanced => 0,
P::High => 1,
P::LowPower => 2,
};
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
if !ble::request_connection_priority(env, gatt.as_ptr(), value).map_err(jni_error)? {
return Err(Error::Network(
"requestConnectionPriority was refused".into(),
));
}
Ok(())
}
pub async fn request_mtu(&self, id: &str, mtu: u16) -> Result<()> {
let _guard = self.gatt_lock(id).await?;
let env = self.runtime()?.env().map_err(jni_error)?;
let gatt = self.gatt(id)?;
if !ble::request_mtu(env, gatt.as_ptr(), mtu as i32).map_err(jni_error)? {
return Err(Error::Network("requestMtu was refused".into()));
}
Ok(())
}
pub fn max_write_len(&self, id: &str, _write_type: WriteType) -> Result<usize> {
Ok(self.devices.get(id, |d| d.inner.mtu)?.max(23) as usize - 3)
}
pub async fn l2cap_target(&self, id: &str, psm: u16) -> Result<crate::jni::JObject> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let device = self.devices.get(id, |d| d.inner.device.clone())?;
let socket =
ble::create_l2cap_channel(env, device.as_ptr(), psm as i32).map_err(jni_error)?;
if socket.is_null() {
return Err(Error::NotSupported(
"createL2capChannel is unavailable — it needs API 29 or newer".into(),
));
}
Ok(socket)
}
#[cfg(feature = "rfcomm")]
pub async fn rfcomm_target(
&self,
id: &str,
service_uuid: &str,
) -> Result<(crate::jni::JObject, String)> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let device = self.devices.get(id, |d| d.inner.device.clone())?;
let socket =
ble::create_rfcomm_socket(env, device.as_ptr(), service_uuid).map_err(jni_error)?;
if socket.is_null() {
return Err(Error::NotSupported(
"createRfcommSocketToServiceRecord returned no socket".into(),
));
}
let peer = ble::device_address(env, device.as_ptr()).unwrap_or_default();
Ok((socket, peer))
}
#[cfg(feature = "classic-l2cap")]
pub async fn classic_l2cap_target(
&self,
id: &str,
psm: u16,
) -> Result<(crate::jni::JObject, String)> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let device = self.devices.get(id, |d| d.inner.device.clone())?;
let socket = ble::create_classic_l2cap_socket(env, device.as_ptr(), psm as i32)
.map_err(jni_error)?;
if socket.is_null() {
return Err(Error::NotSupported(
"createL2capSocket is unavailable on this Android release".into(),
));
}
let peer = ble::device_address(env, device.as_ptr()).unwrap_or_default();
Ok((socket, peer))
}
#[cfg(feature = "rfcomm")]
pub async fn listen_rfcomm(
&self,
name: &str,
service_uuid: &str,
) -> Result<crate::rfcomm::RfcommListener> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let socket =
ble::listen_rfcomm(env, adapter.as_ptr(), name, service_uuid).map_err(jni_error)?;
let Some(server) = crate::bluetooth::Ref::new(env, socket) else {
return Err(Error::Network("the RFCOMM server socket vanished".into()));
};
crate::rfcomm::RfcommListener::new(server, 0).map_err(Error::Network)
}
#[cfg(feature = "classic-l2cap")]
pub async fn listen_classic_l2cap(
&self,
secure: bool,
) -> Result<crate::classic_l2cap::ClassicL2capListener> {
let runtime = self.runtime()?;
let env = runtime.env().map_err(jni_error)?;
let adapter = self.ble_adapter()?;
let socket = ble::listen_l2cap(env, adapter.as_ptr(), secure).map_err(jni_error)?;
if socket.is_null() {
return Err(Error::NotSupported(
"listenUsingL2capChannel is unavailable — it needs API 29 or newer".into(),
));
}
let psm = ble::server_socket_psm(env, socket).map_err(jni_error)? as u16;
let Some(server) = crate::bluetooth::Ref::new(env, socket) else {
return Err(Error::Network("the L2CAP server socket vanished".into()));
};
crate::classic_l2cap::ClassicL2capListener::new(server, psm).map_err(Error::Network)
}
}
fn gatt_result<T>(status: i32, value: T) -> Result<T> {
if status == ble::GATT_SUCCESS {
Ok(value)
} else {
Err(match status {
2 => Error::Security("read not permitted".into()),
3 => Error::Security("write not permitted".into()),
5 | 15 => Error::Security("the link must be encrypted — pair the device first".into()),
6 => Error::NotSupported("the peer does not support that request".into()),
13 => Error::InvalidModification("wrong attribute value length".into()),
_ => Error::Network(format!("the operation failed (GATT status {status})")),
})
}
}
fn jni_error(e: crate::runtime::Error) -> Error {
Error::Network(e.to_string())
}
fn collect(
env: crate::jni::Env,
list: JObject,
want: Option<&BluetoothUuid>,
properties: u32,
) -> Vec<Handle> {
let mut out = Vec::new();
ble::for_each(env, list, |item| {
let Some(raw) = ble::attribute_uuid(env, item) else {
return;
};
let Ok(uuid) = BluetoothUuid::parse(&raw) else {
return;
};
if want.is_some_and(|w| *w != uuid) {
return;
}
if let Some(object) = Ref::new(env, item) {
out.push(Handle(Arc::new(HandleData {
object,
uuid,
properties,
})));
}
});
out
}
fn collect_characteristics(
env: crate::jni::Env,
list: JObject,
want: Option<&BluetoothUuid>,
) -> Vec<Handle> {
let mut out = Vec::new();
ble::for_each(env, list, |item| {
let Some(raw) = ble::attribute_uuid(env, item) else {
return;
};
let Ok(uuid) = BluetoothUuid::parse(&raw) else {
return;
};
if want.is_some_and(|w| *w != uuid) {
return;
}
let properties = ble::characteristic_properties(env, item) as u32;
if let Some(object) = Ref::new(env, item) {
out.push(Handle(Arc::new(HandleData {
object,
uuid,
properties,
})));
}
});
out
}
pub fn authorization() -> webbluetooth_core::Authorization {
match Runtime::get() {
None => webbluetooth_core::Authorization::NotDetermined,
Some(runtime) => match ble::Adapter::open(runtime) {
Ok(_) => webbluetooth_core::Authorization::Allowed,
Err(_) => webbluetooth_core::Authorization::Denied,
},
}
}
fn phy_from_android(value: i32) -> webbluetooth_core::Phy {
const PHY_LE_2M: i32 = 2;
const PHY_LE_CODED: i32 = 3;
match value {
PHY_LE_2M => webbluetooth_core::Phy::Le2M,
PHY_LE_CODED => webbluetooth_core::Phy::LeCoded,
_ => webbluetooth_core::Phy::Le1M,
}
}
fn phy_mask(phy: webbluetooth_core::Phy) -> i32 {
match phy {
webbluetooth_core::Phy::Le1M => 1,
webbluetooth_core::Phy::Le2M => 2,
webbluetooth_core::Phy::LeCoded => 4,
}
}