use crate::ble;
use crate::bluetooth::{Event, EventSink, Ref};
use crate::runtime::Runtime;
use futures_channel::oneshot;
use futures_core::Stream;
use std::collections::HashMap;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, Weak};
use std::task::{Context, Poll};
use webbluetooth_core::error::{Availability, Error, Result};
use webbluetooth_core::gatt::CharacteristicProperties as Properties;
use webbluetooth_core::peripheral::{
cccd_uuid, Advertising, AttError, Permissions, RestoredPeripheral, Service, Write,
};
use webbluetooth_core::uuid::{BluetoothUuid, IntoUuid};
#[derive(Debug, Clone)]
pub struct RemoteCentral {
device: Ref,
id: String,
}
impl RemoteCentral {
fn new(device: Ref) -> Self {
let id = Runtime::get()
.and_then(|r| r.env().ok())
.and_then(|env| ble::device_address(env, device.as_ptr()))
.unwrap_or_default();
Self { device, id }
}
pub fn id(&self) -> &str {
&self.id
}
pub fn is_identified(&self) -> bool {
!self.id.is_empty()
}
pub fn max_notification_length(&self) -> usize {
20
}
}
pub struct ReadRequest {
inner: Arc<Inner>,
central: RemoteCentral,
request_id: i32,
offset: usize,
characteristic: BluetoothUuid,
answered: bool,
}
impl ReadRequest {
pub fn characteristic(&self) -> &BluetoothUuid {
&self.characteristic
}
pub fn central(&self) -> &RemoteCentral {
&self.central
}
pub fn offset(&self) -> usize {
self.offset
}
pub fn respond(mut self, value: &[u8]) -> Result<()> {
if self.offset > value.len() {
self.answer(AttError::InvalidOffset, &[]);
return Err(Error::InvalidModification(format!(
"read offset {} is past the end of a {}-byte value",
self.offset,
value.len()
)));
}
self.answer(AttError::Success, &value[self.offset..]);
Ok(())
}
pub fn reject(mut self, error: AttError) {
self.answer(error, &[]);
}
fn answer(&mut self, result: AttError, value: &[u8]) {
if self.answered {
return;
}
self.answered = true;
self.inner.respond(
&self.central.device,
self.request_id,
result,
self.offset,
value,
);
}
}
impl Drop for ReadRequest {
fn drop(&mut self) {
self.answer(AttError::RequestNotSupported, &[]);
}
}
impl std::fmt::Debug for ReadRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ReadRequest")
.field("characteristic", &self.characteristic.as_str())
.field("offset", &self.offset)
.finish()
}
}
pub struct WriteRequest {
inner: Arc<Inner>,
central: RemoteCentral,
request_id: i32,
writes: Vec<Write>,
response_needed: bool,
answered: bool,
}
impl WriteRequest {
pub fn writes(&self) -> &[Write] {
&self.writes
}
pub fn central(&self) -> &RemoteCentral {
&self.central
}
pub fn accept(mut self) {
self.answer(AttError::Success);
}
pub fn reject_all(mut self, error: AttError) {
self.answer(error);
}
fn answer(&mut self, result: AttError) {
if self.answered {
return;
}
self.answered = true;
if !self.response_needed {
return;
}
let offset = self.writes.first().map(|w| w.offset).unwrap_or(0);
self.inner
.respond(&self.central.device, self.request_id, result, offset, &[]);
}
}
impl Drop for WriteRequest {
fn drop(&mut self) {
self.answer(AttError::RequestNotSupported);
}
}
impl std::fmt::Debug for WriteRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("WriteRequest")
.field("writes", &self.writes.len())
.finish()
}
}
#[derive(Debug)]
pub enum Request {
Read(ReadRequest),
Write(WriteRequest),
Subscribed {
central: RemoteCentral,
characteristic: BluetoothUuid,
},
Unsubscribed {
central: RemoteCentral,
characteristic: BluetoothUuid,
},
ReadyToNotify,
ChannelOpened(crate::l2cap::L2capChannel),
}
const REQUEST_BACKLOG: usize = 1024;
pub struct Requests {
rx: webbluetooth_core::backlog::Receiver<Request>,
}
impl Requests {
pub fn lost(&self) -> u64 {
self.rx.lost()
}
}
impl Stream for Requests {
type Item = Request;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Request>> {
Pin::new(&mut self.rx).poll_next(cx)
}
}
struct Inner {
server: Mutex<Option<Ref>>,
server_callback: Mutex<Option<ble::Callback>>,
advertise_callback: Mutex<Option<ble::Callback>>,
service_waiters: Mutex<Vec<oneshot::Sender<Result<()>>>>,
advertising_waiters: Mutex<Vec<oneshot::Sender<Result<()>>>>,
ready_waiters: Mutex<Vec<oneshot::Sender<()>>>,
subscribers: Mutex<HashMap<BluetoothUuid, Vec<RemoteCentral>>>,
published: Mutex<HashMap<usize, BluetoothUuid>>,
cccds: Mutex<HashMap<usize, BluetoothUuid>>,
requests: Mutex<Option<webbluetooth_core::backlog::Sender<Request>>>,
advertising: AtomicBool,
l2cap: Mutex<HashMap<u16, (Ref, Arc<AtomicBool>)>>,
}
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 {
fn handle(self: &Arc<Self>, event: Event) {
match event {
Event::ServiceAdded { status } => {
let result = if status == ble::GATT_SUCCESS {
Ok(())
} else {
Err(Error::Network(format!(
"could not publish service (status {status})"
)))
};
for tx in self.service_waiters.lock().unwrap().drain(..) {
let _ = tx.send(result.clone());
}
}
Event::AdvertisingStarted { error } => {
let result = match error {
None => {
self.advertising.store(true, Ordering::Release);
Ok(())
}
Some(code) => Err(Error::Network(format!(
"could not start advertising: {}",
describe_advertise_error(code)
))),
};
for tx in self.advertising_waiters.lock().unwrap().drain(..) {
let _ = tx.send(result.clone());
}
}
Event::ReadRequest {
device,
request_id,
offset,
characteristic,
} => {
let uuid = self.name_of(&characteristic);
let central = RemoteCentral::new(device);
self.send(Request::Read(ReadRequest {
inner: self.clone(),
central,
request_id,
offset: offset.max(0) as usize,
characteristic: uuid,
answered: false,
}));
}
Event::WriteRequest {
device,
request_id,
characteristic,
response_needed,
offset,
value,
..
} => {
let uuid = self.name_of(&characteristic);
let central = RemoteCentral::new(device);
self.send(Request::Write(WriteRequest {
inner: self.clone(),
central,
request_id,
writes: vec![Write {
characteristic: uuid,
offset: offset.max(0) as usize,
value,
}],
response_needed,
answered: false,
}));
}
Event::DescriptorReadRequest {
device,
request_id,
offset,
descriptor,
} => {
let central = RemoteCentral::new(device);
let is_subscribed = self
.cccds
.lock()
.unwrap()
.get(&descriptor.key())
.map(|uuid| self.is_subscribed(uuid, ¢ral))
.unwrap_or(false);
let value: &[u8] = if is_subscribed {
&[0x01, 0x00]
} else {
&[0x00, 0x00]
};
self.respond(
¢ral.device,
request_id,
AttError::Success,
offset.max(0) as usize,
value,
);
}
Event::DescriptorWriteRequest {
device,
request_id,
descriptor,
response_needed,
offset,
value,
} => {
let central = RemoteCentral::new(device);
let owner = self.cccds.lock().unwrap().get(&descriptor.key()).cloned();
if response_needed {
self.respond(
¢ral.device,
request_id,
AttError::Success,
offset.max(0) as usize,
&[],
);
}
let Some(characteristic) = owner else { return };
let enabling = value.first().is_some_and(|b| *b != 0);
let mut subscribers = self.subscribers.lock().unwrap();
let list = subscribers.entry(characteristic).or_default();
if enabling {
if !list.iter().any(|c| c.id == central.id) {
list.push(central.clone());
}
} else {
list.retain(|c| c.id != central.id);
}
drop(subscribers);
self.send(if enabling {
Request::Subscribed {
central,
characteristic,
}
} else {
Request::Unsubscribed {
central,
characteristic,
}
});
}
Event::NotificationSent { .. } => {
for tx in self.ready_waiters.lock().unwrap().drain(..) {
let _ = tx.send(());
}
self.send(Request::ReadyToNotify);
}
Event::ServerConnectionStateChanged { device, connected } => {
if connected {
return;
}
let central = RemoteCentral::new(device);
let mut subscribers = self.subscribers.lock().unwrap();
let dropped: Vec<BluetoothUuid> = subscribers
.iter()
.filter(|(_, list)| list.iter().any(|c| c.id == central.id))
.map(|(uuid, _)| *uuid)
.collect();
for uuid in &dropped {
if let Some(list) = subscribers.get_mut(uuid) {
list.retain(|c| c.id != central.id);
}
}
drop(subscribers);
for characteristic in dropped {
self.send(Request::Unsubscribed {
central: central.clone(),
characteristic,
});
}
}
_ => {}
}
}
fn send(&self, request: Request) {
let tx = self.requests.lock().unwrap().clone();
if let Some(tx) = tx {
if tx.send(request).is_err() {
*self.requests.lock().unwrap() = None;
}
}
}
fn name_of(&self, characteristic: &Ref) -> BluetoothUuid {
if let Some(uuid) = self.published.lock().unwrap().get(&characteristic.key()) {
return *uuid;
}
Runtime::get()
.and_then(|r| r.env().ok())
.and_then(|env| ble::attribute_uuid(env, characteristic.as_ptr()))
.and_then(|s| BluetoothUuid::parse(&s).ok())
.unwrap_or_else(|| BluetoothUuid::from_u16(0))
}
fn is_subscribed(&self, characteristic: &BluetoothUuid, central: &RemoteCentral) -> bool {
self.subscribers
.lock()
.unwrap()
.get(characteristic)
.is_some_and(|list| list.iter().any(|c| c.id == central.id))
}
fn respond(
&self,
device: &Ref,
request_id: i32,
status: AttError,
offset: usize,
value: &[u8],
) {
let (Some(runtime), Some(server)) = (Runtime::get(), self.server.lock().unwrap().clone())
else {
return;
};
let Ok(env) = runtime.env() else { return };
let _ = ble::server_send_response(
env,
server.as_ptr(),
device.as_ptr(),
request_id,
status as i32,
offset as i32,
value,
);
}
async fn require_powered_on(&self) -> Result<()> {
let runtime = Runtime::get().ok_or_else(|| {
Error::NotSupported(
"the Android backend is not started — call webbluetooth::android::init(vm, context)"
.into(),
)
})?;
let env = runtime.env().map_err(|e| Error::Network(e.to_string()))?;
let adapter = ble::Adapter::open(runtime)
.map_err(|_| Error::NotAvailable(Availability::Unsupported))?;
if adapter.is_enabled(env) {
Ok(())
} else {
Err(Error::NotAvailable(Availability::PoweredOff))
}
}
}
fn describe_advertise_error(code: i32) -> &'static str {
match code {
1 => "the advertising payload is larger than 31 bytes",
2 => "too many advertisers are already running",
3 => "this peripheral is already advertising",
4 => "an internal error",
5 => "this device does not support advertising",
_ => "an unknown error",
}
}
#[derive(Clone)]
pub struct Peripheral {
inner: Arc<Inner>,
}
impl Peripheral {
pub fn new() -> (Self, Requests) {
Self::build(None)
}
pub fn with_restoration(_restoration: webbluetooth_core::Restoration) -> (Self, Requests) {
Self::build(None)
}
fn build(_identifier: Option<String>) -> (Self, Requests) {
let (tx, rx) = webbluetooth_core::backlog::bounded(
REQUEST_BACKLOG,
webbluetooth_core::backlog::Overflow::KeepOldest,
);
let inner = Arc::new_cyclic(|_weak: &Weak<Inner>| Inner {
server: Mutex::new(None),
server_callback: Mutex::new(None),
advertise_callback: Mutex::new(None),
service_waiters: Mutex::new(Vec::new()),
advertising_waiters: Mutex::new(Vec::new()),
ready_waiters: Mutex::new(Vec::new()),
subscribers: Mutex::new(HashMap::new()),
published: Mutex::new(HashMap::new()),
cccds: Mutex::new(HashMap::new()),
requests: Mutex::new(Some(tx)),
advertising: AtomicBool::new(false),
l2cap: Mutex::new(HashMap::new()),
});
(Self { inner }, Requests { rx })
}
pub async fn availability(&self) -> std::result::Result<(), Availability> {
match self.inner.require_powered_on().await {
Ok(()) => Ok(()),
Err(Error::NotAvailable(a)) => Err(a),
Err(_) => Err(Availability::Unknown),
}
}
fn server(&self) -> Result<Ref> {
if let Some(server) = self.inner.server.lock().unwrap().clone() {
return Ok(server);
}
let runtime = Runtime::get()
.ok_or_else(|| Error::NotSupported("the Android backend is not started".into()))?;
let env = runtime.env().map_err(|e| Error::Network(e.to_string()))?;
let callback = ble::Callback::new(
runtime,
"dev.webbluetooth.GattServerCallback",
crate::gatt_server_callback_dex(),
&crate::bluetooth::server_natives(),
Arc::new(Sink(Arc::downgrade(&self.inner))),
)
.map_err(|e| Error::Network(e.to_string()))?;
let server = ble::open_gatt_server(env, runtime, callback.as_ptr())
.map_err(|e| Error::Network(e.to_string()))?;
let server = Ref::new(env, server).ok_or(Error::NotAvailable(Availability::Unsupported))?;
*self.inner.server_callback.lock().unwrap() = Some(callback);
*self.inner.server.lock().unwrap() = Some(server.clone());
Ok(server)
}
pub async fn publish(&self, service: Service) -> Result<PublishedService> {
service.validate()?;
self.inner.require_powered_on().await?;
let runtime = Runtime::get()
.ok_or_else(|| Error::NotSupported("the Android backend is not started".into()))?;
let env = runtime.env().map_err(|e| Error::Network(e.to_string()))?;
let server = self.server()?;
let java_service = ble::new_service(env, service.uuid.as_str(), service.primary)
.map_err(|e| Error::Network(e.to_string()))?;
let mut published = Vec::new();
for definition in &service.characteristics {
let characteristic = ble::new_characteristic(
env,
definition.uuid.as_str(),
definition.properties,
definition.permissions,
)
.map_err(|e| Error::Network(e.to_string()))?;
if let Some(value) = &definition.value {
ble::set_value(env, characteristic, value)
.map_err(|e| Error::Network(e.to_string()))?;
}
for d in &definition.descriptors {
let descriptor = ble::new_descriptor(env, d.uuid.as_str(), Permissions::READABLE)
.map_err(|e| Error::Network(e.to_string()))?;
ble::set_value(env, descriptor, &d.value)
.map_err(|e| Error::Network(e.to_string()))?;
ble::characteristic_add_descriptor(env, characteristic, descriptor)
.map_err(|e| Error::Network(e.to_string()))?;
}
let properties = Properties(definition.properties);
if properties.notify() || properties.indicate() {
let cccd = ble::new_descriptor(
env,
cccd_uuid().as_str(),
Permissions::READABLE | Permissions::WRITEABLE,
)
.map_err(|e| Error::Network(e.to_string()))?;
ble::set_value(env, cccd, &[0x00, 0x00])
.map_err(|e| Error::Network(e.to_string()))?;
ble::characteristic_add_descriptor(env, characteristic, cccd)
.map_err(|e| Error::Network(e.to_string()))?;
if let Some(cccd) = Ref::new(env, cccd) {
self.inner
.cccds
.lock()
.unwrap()
.insert(cccd.key(), definition.uuid);
std::mem::forget(cccd);
}
}
ble::service_add_characteristic(env, java_service, characteristic)
.map_err(|e| Error::Network(e.to_string()))?;
if let Some(handle) = Ref::new(env, characteristic) {
self.inner
.published
.lock()
.unwrap()
.insert(handle.key(), definition.uuid);
published.push(PublishedCharacteristic {
inner: self.inner.clone(),
uuid: definition.uuid,
handle,
});
}
}
let rx = {
let (tx, rx) = oneshot::channel();
self.inner.service_waiters.lock().unwrap().push(tx);
rx
};
ble::server_add_service(env, server.as_ptr(), java_service)
.map_err(|e| Error::Network(e.to_string()))?;
rx.await
.map_err(|_| Error::Aborted("publishing was cancelled".into()))??;
let handle = Ref::new(env, java_service)
.ok_or_else(|| Error::Aborted("the published service vanished".into()))?;
Ok(PublishedService {
inner: self.inner.clone(),
uuid: service.uuid,
handle,
characteristics: published,
})
}
pub fn unpublish_all(&self) {
if let (Some(runtime), Some(server)) =
(Runtime::get(), self.inner.server.lock().unwrap().clone())
{
if let Ok(env) = runtime.env() {
let _ = ble::server_clear_services(env, server.as_ptr());
}
}
self.inner.published.lock().unwrap().clear();
self.inner.cccds.lock().unwrap().clear();
self.inner.subscribers.lock().unwrap().clear();
}
pub async fn start_advertising(&self, advertising: Advertising) -> Result<()> {
self.inner.require_powered_on().await?;
let runtime = Runtime::get()
.ok_or_else(|| Error::NotSupported("the Android backend is not started".into()))?;
let env = runtime.env().map_err(|e| Error::Network(e.to_string()))?;
let adapter = ble::Adapter::open(runtime)
.map_err(|_| Error::NotAvailable(Availability::Unsupported))?;
let advertiser = adapter
.advertiser(env)
.map_err(|e| Error::Network(e.to_string()))?;
if advertiser.is_null() {
return Err(Error::NotSupported(
"this device cannot advertise — no BluetoothLeAdvertiser".into(),
));
}
let callback = ble::Callback::new(
runtime,
"dev.webbluetooth.AdvertiseCallback",
crate::advertise_callback_dex(),
&crate::bluetooth::advertise_natives(),
Arc::new(Sink(Arc::downgrade(&self.inner))),
)
.map_err(|e| Error::Network(e.to_string()))?;
let services: Vec<String> = advertising
.services
.iter()
.map(|u| u.as_str().to_owned())
.collect();
let rx = {
let (tx, rx) = oneshot::channel();
self.inner.advertising_waiters.lock().unwrap().push(tx);
rx
};
ble::start_advertising(
env,
advertiser,
callback.as_ptr(),
advertising.local_name.is_some(),
&services,
true,
ble::advertise_mode(advertising.interval.map(|(_, max)| max)),
)
.map_err(|e| Error::Network(e.to_string()))?;
*self.inner.advertise_callback.lock().unwrap() = Some(callback);
rx.await
.map_err(|_| Error::Aborted("advertising was cancelled".into()))?
}
pub fn stop_advertising(&self) {
let Some(callback) = self.inner.advertise_callback.lock().unwrap().take() else {
return;
};
if let Some(runtime) = Runtime::get() {
if let Ok(env) = runtime.env() {
if let Ok(adapter) = ble::Adapter::open(runtime) {
if let Ok(advertiser) = adapter.advertiser(env) {
let _ = ble::stop_advertising(env, advertiser, callback.as_ptr());
}
}
}
}
self.inner.advertising.store(false, Ordering::Release);
}
pub fn is_advertising(&self) -> bool {
self.inner.advertising.load(Ordering::Acquire)
}
pub async fn publish_l2cap_channel(
&self,
encryption_required: bool,
) -> Result<webbluetooth_core::Psm> {
self.inner.require_powered_on().await?;
let runtime = Runtime::get()
.ok_or_else(|| Error::NotSupported("the Android backend is not started".into()))?;
let env = runtime.env().map_err(|e| Error::Network(e.to_string()))?;
let adapter = ble::Adapter::open(runtime)
.map_err(|_| Error::NotAvailable(Availability::Unsupported))?;
let socket = ble::listen_l2cap(env, adapter.as_ptr(), encryption_required)
.map_err(|e| Error::Network(e.to_string()))?;
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(|e| Error::Network(e.to_string()))? as u16;
let Some(socket) = Ref::new(env, socket) else {
return Err(Error::Network("the listening socket vanished".into()));
};
let stop = Arc::new(AtomicBool::new(false));
self.inner
.l2cap
.lock()
.unwrap()
.insert(psm, (socket.clone(), stop.clone()));
let inner = self.inner.clone();
std::thread::Builder::new()
.name(format!("webbluetooth-l2cap-accept-{psm}"))
.spawn(move || {
let Some(runtime) = Runtime::get() else {
return;
};
let Ok(env) = runtime.env() else { return };
while !stop.load(Ordering::Acquire) {
let Ok(accepted) = ble::server_socket_accept(env, socket.as_ptr()) else {
break;
};
if accepted.is_null() {
break;
}
if let Ok(channel) = crate::l2cap::from_accepted(accepted, psm) {
inner.send(Request::ChannelOpened(channel));
}
}
runtime.vm().detach();
})
.map_err(|e| Error::Network(format!("could not start the accept thread: {e}")))?;
Ok(psm)
}
pub async fn unpublish_l2cap_channel(&self, psm: webbluetooth_core::Psm) -> Result<()> {
let Some((socket, stop)) = self.inner.l2cap.lock().unwrap().remove(&psm) else {
return Ok(());
};
stop.store(true, Ordering::Release);
if let Some(runtime) = Runtime::get() {
if let Ok(env) = runtime.env() {
let _ = ble::server_socket_close(env, socket.as_ptr());
}
}
Ok(())
}
pub async fn restored_state(&self) -> Option<RestoredPeripheral> {
None
}
}
impl std::fmt::Debug for Peripheral {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Peripheral")
.field("advertising", &self.is_advertising())
.finish()
}
}
pub struct PublishedService {
inner: Arc<Inner>,
uuid: BluetoothUuid,
handle: Ref,
characteristics: Vec<PublishedCharacteristic>,
}
impl PublishedService {
pub fn uuid(&self) -> &BluetoothUuid {
&self.uuid
}
pub fn characteristics(&self) -> Vec<PublishedCharacteristic> {
self.characteristics.to_vec()
}
pub fn characteristic(&self, uuid: impl IntoUuid) -> Option<PublishedCharacteristic> {
let uuid = uuid.into_uuid().ok()?;
self.characteristics
.iter()
.find(|c| c.uuid == uuid)
.cloned()
}
pub fn unpublish(self) {
if let (Some(runtime), Some(server)) =
(Runtime::get(), self.inner.server.lock().unwrap().clone())
{
if let Ok(env) = runtime.env() {
let _ = ble::server_remove_service(env, server.as_ptr(), self.handle.as_ptr());
}
}
let mut published = self.inner.published.lock().unwrap();
for c in &self.characteristics {
published.remove(&c.handle.key());
}
}
}
impl std::fmt::Debug for PublishedService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PublishedService")
.field("uuid", &self.uuid.as_str())
.field("characteristics", &self.characteristics.len())
.finish()
}
}
#[derive(Clone)]
pub struct PublishedCharacteristic {
inner: Arc<Inner>,
uuid: BluetoothUuid,
handle: Ref,
}
impl PublishedCharacteristic {
pub fn uuid(&self) -> &BluetoothUuid {
&self.uuid
}
pub fn subscribers(&self) -> Vec<RemoteCentral> {
self.inner
.subscribers
.lock()
.unwrap()
.get(&self.uuid)
.cloned()
.unwrap_or_default()
}
pub fn try_notify(&self, value: &[u8]) -> bool {
self.try_notify_centrals(value, &self.subscribers())
}
pub fn try_notify_centrals(&self, value: &[u8], centrals: &[RemoteCentral]) -> bool {
let (Some(runtime), Some(server)) =
(Runtime::get(), self.inner.server.lock().unwrap().clone())
else {
return false;
};
let Ok(env) = runtime.env() else { return false };
let indicate = false;
let mut all = true;
for central in centrals {
all &= ble::server_notify(
env,
server.as_ptr(),
central.device.as_ptr(),
self.handle.as_ptr(),
indicate,
value,
)
.unwrap_or(false);
}
all
}
pub async fn notify(&self, value: &[u8]) -> Result<()> {
let centrals = self.subscribers();
if centrals.is_empty() {
return Ok(());
}
loop {
if self.try_notify_centrals(value, ¢rals) {
return Ok(());
}
let rx = {
let (tx, rx) = oneshot::channel();
self.inner.ready_waiters.lock().unwrap().push(tx);
rx
};
rx.await
.map_err(|_| Error::Aborted("notification was cancelled".into()))?;
}
}
}
impl std::fmt::Debug for PublishedCharacteristic {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PublishedCharacteristic")
.field("uuid", &self.uuid.as_str())
.field("subscribers", &self.subscribers().len())
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
use webbluetooth_core::peripheral::{Characteristic, Descriptor};
use webbluetooth_core::uuid::characteristics;
#[test]
fn a_fixed_value_may_also_be_writable() {
assert!(Characteristic::new(characteristics::BATTERY_LEVEL)
.unwrap()
.read()
.write()
.value([50])
.validate()
.is_ok());
}
#[test]
fn a_characteristic_still_needs_a_property() {
assert!(Characteristic::new(characteristics::BATTERY_LEVEL)
.unwrap()
.validate()
.is_err());
}
#[test]
fn the_cccd_cannot_be_declared_by_hand() {
let err = Descriptor {
uuid: cccd_uuid(),
value: vec![0, 0],
is_string: false,
}
.validate()
.unwrap_err();
assert!(err.to_string().contains("automatically"), "got {err}");
}
#[test]
fn any_other_descriptor_is_accepted() {
assert!(Descriptor::user_description("x").validate().is_ok());
assert!(Descriptor::presentation_format([0u8; 7]).validate().is_ok());
assert!(Descriptor {
uuid: BluetoothUuid::from_u16(0x2908),
value: vec![0],
is_string: false,
}
.validate()
.is_ok());
assert!(Descriptor {
uuid: BluetoothUuid::from_u16(0x2901),
value: Vec::new(),
is_string: true,
}
.validate()
.is_err());
}
#[test]
fn advertise_errors_are_explained() {
assert!(describe_advertise_error(1).contains("31 bytes"));
assert!(describe_advertise_error(5).contains("does not support"));
}
}