jeka/utun2
1
0 Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
1529dfd04bb9ef58b13d669674cf347da82e2c50
utun2/lib/ble/ble_winrt.cpp
T
evgeny ba1c4cf160 Add cross-platform BLE transport and Bluetooth settings 
Integrate shared C transport with desktop and Android frontends, add radio probes and detailed Windows diagnostics, and fix GUI build dependencies and early configuration startup errors.
2026-10-29 10:51:19 +01:00

531 lines
35 KiB
C++
Raw Blame History

/* WinRT backend: события Windows сериализуются в uasync через ограниченный mailbox.
* Каждая отправка адресована link/subscribedClient; одна незавершённая операция на link.
* Слабые ссылки в WinRT handlers и отменяемый posted_task исключают обращения к уничтоженному core. */
#include "ble_backend.h"
#include "../u_async.h"
#include "../mem.h"
#include "../debug_config.h"
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Foundation.Collections.h>
#include <winrt/Windows.Devices.Bluetooth.h>
#include <winrt/Windows.Devices.Bluetooth.Advertisement.h>
#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
#include <winrt/Windows.Storage.Streams.h>
#include <array>
#include <algorithm>
#include <vector>
#include <deque>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <cstring>
#include <cstdio>
using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::Devices::Bluetooth;
using namespace Windows::Devices::Bluetooth::Advertisement;
using namespace Windows::Devices::Bluetooth::GenericAttributeProfile;
using namespace Windows::Storage::Streams;
static constexpr auto CAT = DEBUG_CATEGORY_DISCOVERY;
static const char* bluetooth_error(BluetoothError error) {
switch (error) {
case BluetoothError::Success: return "Success";
case BluetoothError::RadioNotAvailable: return "RadioNotAvailable";
case BluetoothError::ResourceInUse: return "ResourceInUse";
case BluetoothError::DeviceNotConnected: return "DeviceNotConnected";
case BluetoothError::DisabledByPolicy: return "DisabledByPolicy";
case BluetoothError::NotSupported: return "NotSupported";
case BluetoothError::DisabledByUser: return "DisabledByUser";
case BluetoothError::ConsentRequired: return "ConsentRequired";
case BluetoothError::TransportNotSupported: return "TransportNotSupported";
default: return "OtherError";
}
}
/* Вызывать только из catch; сохраняем контекст и HRESULT вместо немого catch(...). */
static std::string exception_reason(const char* phase, ble_link_id id = 0) {
char prefix[192];
try { throw; }
catch (const hresult_error& e) {
std::snprintf(prefix, sizeof(prefix), "BLE WinRT phase=%s link=%llu HRESULT=0x%08x: ",
phase, (unsigned long long)id, (unsigned)e.code().value);
return prefix + to_string(e.message());
} catch (const std::exception& e) {
return std::string("BLE WinRT phase=") + phase + ": " + e.what();
} catch (...) { return std::string("BLE WinRT phase=") + phase + ": unknown exception"; }
}
struct WinState;
struct WinLink {
ble_link_id id = 0;
std::string endpoint;
hstring device_id;
bool outgoing = false, opened = false, sending = false;
BluetoothLEDevice device{nullptr};
GattDeviceService service{nullptr};
GattCharacteristic rx{nullptr}, tx{nullptr};
GattSession session{nullptr};
GattSubscribedClient subscriber{nullptr};
IAsyncInfo operation{nullptr};
GattCharacteristic::ValueChanged_revoker value_changed;
GattSession::SessionStatusChanged_revoker session_changed;
GattSession::MaxPduSizeChanged_revoker pdu_changed;
};
struct WriteDeferral {
Deferral value;
explicit WriteDeferral(Deferral v) : value(v) {}
~WriteDeferral() { try { value.Complete(); } catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("write deferral").c_str()); } }
};
struct WinState : std::enable_shared_from_this<WinState> {
struct UASYNC* ua = nullptr;
struct ble_transport* owner = nullptr;
uint16_t company = 0;
std::mutex mutex;
std::deque<std::function<void(WinState&)>> events;
struct posted_task* posted = nullptr;
bool stopped = false, failed = false, overflow = false, apartment = false, scan_ready = false, service_ready = false;
IAsyncInfo startup{nullptr};
BluetoothLEAdvertisementWatcher watcher{nullptr};
BluetoothLEAdvertisementPublisher publisher{nullptr};
GattServiceProvider provider{nullptr};
GattLocalCharacteristic local_rx{nullptr}, local_tx{nullptr};
BluetoothLEAdvertisementWatcher::Received_revoker received;
BluetoothLEAdvertisementWatcher::Stopped_revoker scan_stopped;
BluetoothLEAdvertisementPublisher::StatusChanged_revoker publish_changed;
GattServiceProvider::AdvertisementStatusChanged_revoker service_changed;
GattLocalCharacteristic::WriteRequested_revoker write_requested;
GattLocalCharacteristic::SubscribedClientsChanged_revoker subscriptions_changed;
std::map<ble_link_id, std::unique_ptr<WinLink>> links;
std::array<uint8_t, BLE_BROADCAST_MAX> broadcast{};
size_t broadcast_size = 0;
bool broadcast_enabled = false;
uint64_t publish_generation = 0;
static void dispatch(void* arg) {
auto& s = *static_cast<WinState*>(arg);
std::deque<std::function<void(WinState&)>> batch;
bool overloaded;
{ std::lock_guard guard(s.mutex); s.posted = nullptr; batch.swap(s.events); overloaded = s.overflow; s.overflow = false; }
if (overloaded) { s.fail("WinRT event queue overflow"); return; }
DEBUG_TRACE(CAT, "BLE WinRT dispatch events=%zu links=%zu", batch.size(), s.links.size());
for (auto& event : batch) {
if (s.stopped || s.failed) break;
try { event(s); }
catch (...) { s.fail(exception_reason("event dispatch").c_str()); }
}
}
void post(std::function<void(WinState&)> event) {
std::lock_guard guard(mutex);
if (stopped) return;
if (events.size() >= 256) {
if (!overflow) DEBUG_ERROR(CAT, "BLE WinRT event mailbox full queued=%zu limit=256", events.size());
overflow = true;
}
else events.push_back(std::move(event));
if (posted) return;
posted = static_cast<struct posted_task*>(u_calloc(1, sizeof(struct posted_task)));
if (!posted) { overflow = true; DEBUG_ERROR(CAT, "BLE WinRT event allocation failed"); return; }
posted->callback = dispatch; posted->arg = this; uasync_post_reserved(ua, posted);
}
WinLink* link(ble_link_id id) { auto it = links.find(id); return it == links.end() ? nullptr : it->second.get(); }
void fail(const char* reason) {
if (failed) return;
failed = true; DEBUG_ERROR(CAT, "BLE WinRT failed: %s", reason); ble_backend_status(owner, 0, reason);
}
void error(ble_link_id id, const char* reason) {
DEBUG_WARN(CAT, "BLE WinRT link=%llu failed: %s", (unsigned long long)id, reason);
ble_backend_closed(owner, id, reason);
}
void radio_error(const char* phase, BluetoothError error) {
char reason[192];
std::snprintf(reason, sizeof(reason), "%s: BluetoothError=%d (%s)", phase, (int)error, bluetooth_error(error));
fail(reason);
}
template<typename Result, typename Callback>
void await(const char* phase, const IAsyncOperation<Result>& operation, ble_link_id id, Callback callback) {
const bool fragment = !std::strcmp(phase, "write frame") || !std::strcmp(phase, "indicate frame");
if (!fragment) DEBUG_DEBUG(CAT, "BLE WinRT async begin phase=%s link=%llu", phase, (unsigned long long)id);
if (id) { auto* l = link(id); if (!l) { operation.Cancel(); return; } l->operation = operation; }
else startup = operation;
auto weak = weak_from_this();
operation.Completed([weak, id, phase, fragment, callback](const IAsyncOperation<Result>& op, AsyncStatus status) {
if (auto s = weak.lock()) s->post([id, op, status, phase, fragment, callback](WinState& self) {
auto* l = id ? self.link(id) : nullptr;
if (id && !l) {
DEBUG_DEBUG(CAT, "BLE WinRT stale completion phase=%s link=%llu status=%d", phase, (unsigned long long)id, (int)status);
return;
}
if (l) l->operation = nullptr; else self.startup = nullptr;
if (status != AsyncStatus::Completed) {
char reason[192];
std::snprintf(reason, sizeof(reason), "phase=%s async_status=%d HRESULT=0x%08x", phase, (int)status,
(unsigned)op.ErrorCode().value);
if (id) self.error(id, reason); else self.fail(reason);
return;
}
if (!fragment) DEBUG_DEBUG(CAT, "BLE WinRT async complete phase=%s link=%llu", phase, (unsigned long long)id);
callback(self, op.GetResults());
});
});
}
static IBuffer buffer(const uint8_t* data, size_t len) {
DataWriter writer; writer.WriteBytes(array_view<const uint8_t>(data, data + len)); return writer.DetachBuffer();
}
static std::vector<uint8_t> bytes(const IBuffer& buffer) {
if (buffer.Length() > BLE_VALUE_MAX) throw hresult_invalid_argument();
std::vector<uint8_t> result(buffer.Length()); DataReader::FromBuffer(buffer).ReadBytes(result); return result;
}
void ready() {
DEBUG_DEBUG(CAT, "BLE WinRT readiness scan=%d service=%d", scan_ready, service_ready);
if (scan_ready && service_ready) ble_backend_status(owner, 1, "WinRT scan/GATT ready");
}
void watch_session(WinLink& l) {
auto weak = weak_from_this(); auto id = l.id;
l.session_changed = l.session.SessionStatusChanged(auto_revoke, [weak, id](auto const&, GattSessionStatusChangedEventArgs const& a) {
auto status = a.Status(); auto error = a.Error();
if (auto s = weak.lock()) s->post([id, status, error](WinState& s) {
DEBUG_DEBUG(CAT, "BLE WinRT session link=%llu status=%d error=%d (%s)",
(unsigned long long)id, (int)status, (int)error, bluetooth_error(error));
if (status == GattSessionStatus::Closed && s.link(id)) s.error(id, "GATT session closed");
});
});
l.pdu_changed = l.session.MaxPduSizeChanged(auto_revoke, [weak, id](auto const& session, auto const&) {
auto mtu = session.MaxPduSize();
if (auto s = weak.lock()) s->post([id, mtu](WinState&) {
DEBUG_DEBUG(CAT, "BLE WinRT negotiated PDU changed link=%llu mtu=%u", (unsigned long long)id, (unsigned)mtu);
});
});
}
WinLink* incoming(const GattSession& session) {
hstring key = session.DeviceId().Id();
for (auto& [id, l] : links) if (l->device_id == key) return l->outgoing ? nullptr : l.get();
std::string endpoint = to_string(key);
if (endpoint.size() >= BLE_ENDPOINT_MAX || links.size() >= BLE_LINKS_MAX) {
DEBUG_WARN(CAT, "BLE WinRT incoming endpoint/connection limit"); return nullptr;
}
struct ble_endpoint ep{}; std::memcpy(ep.id, endpoint.c_str(), endpoint.size() + 1);
ble_link_id id = ble_backend_incoming(owner, &ep); if (!id) return nullptr;
auto l = std::make_unique<WinLink>(); l->id = id; l->endpoint = endpoint; l->device_id = key; l->session = session;
DEBUG_DEBUG(CAT, "BLE WinRT incoming link=%llu endpoint=%s mtu=%u", (unsigned long long)id, endpoint.c_str(), session.MaxPduSize());
auto* result = l.get(); links.emplace(id, std::move(l)); watch_session(*result); return result;
}
void subscriptions() {
DEBUG_DEBUG(CAT, "BLE WinRT subscriptions clients=%u links=%zu", local_tx.SubscribedClients().Size(), links.size());
std::vector<ble_link_id> active;
for (auto const& client : local_tx.SubscribedClients()) {
auto* l = incoming(client.Session()); if (!l) continue;
l->subscriber = client; active.push_back(l->id);
if (!l->opened) {
DEBUG_DEBUG(CAT, "BLE WinRT subscribed link=%llu notification_max=%u", (unsigned long long)l->id, client.MaxNotificationSize());
l->opened = true; ble_backend_opened(owner, l->id, client.MaxNotificationSize() + 3);
}
}
std::vector<ble_link_id> gone;
for (auto& [id, l] : links) if (!l->outgoing && l->opened && std::find(active.begin(), active.end(), id) == active.end()) gone.push_back(id);
for (auto id : gone) error(id, "indication subscription removed");
}
void make_server() {
await("create GATT service", GattServiceProvider::CreateAsync(guid(BLE_SERVICE_UUID)), 0, [](WinState& s, GattServiceProviderResult const& result) {
if (result.Error() != BluetoothError::Success) { s.radio_error("create GATT service", result.Error()); return; }
s.provider = result.ServiceProvider();
GattLocalCharacteristicParameters parameters;
parameters.CharacteristicProperties(GattCharacteristicProperties::Write);
parameters.WriteProtectionLevel(GattProtectionLevel::Plain);
s.await("create RX characteristic", s.provider.Service().CreateCharacteristicAsync(guid(BLE_RX_UUID), parameters), 0,
[](WinState& s, GattLocalCharacteristicResult const& result) {
if (result.Error() != BluetoothError::Success) { s.radio_error("create RX characteristic", result.Error()); return; }
s.local_rx = result.Characteristic(); s.make_tx();
});
});
}
void make_tx() {
GattLocalCharacteristicParameters parameters; parameters.CharacteristicProperties(GattCharacteristicProperties::Indicate);
parameters.ReadProtectionLevel(GattProtectionLevel::Plain);
await("create TX characteristic", provider.Service().CreateCharacteristicAsync(guid(BLE_TX_UUID), parameters), 0,
[](WinState& s, GattLocalCharacteristicResult const& result) {
if (result.Error() != BluetoothError::Success) { s.radio_error("create TX characteristic", result.Error()); return; }
s.local_tx = result.Characteristic(); s.start_server();
});
}
void start_server() {
auto weak = weak_from_this();
write_requested = local_rx.WriteRequested(auto_revoke, [weak](auto const&, GattWriteRequestedEventArgs const& args) {
try {
auto deferral = std::make_shared<WriteDeferral>(args.GetDeferral());
auto request = args.GetRequestAsync(); auto session = args.Session();
request.Completed([weak, deferral, session](auto const& operation, AsyncStatus status) {
if (auto s = weak.lock()) s->post([deferral, session, operation, status](WinState& s) {
if (status != AsyncStatus::Completed) {
DEBUG_WARN(CAT, "BLE WinRT GetRequest status=%d HRESULT=0x%08x", (int)status, (unsigned)operation.ErrorCode().value);
return;
}
auto request = operation.GetResults(); if (!request) { DEBUG_WARN(CAT, "BLE WinRT expired write request"); return; }
if (request.Offset() || request.Option() != GattWriteOption::WriteWithResponse || request.Value().Length() > BLE_VALUE_MAX) {
DEBUG_WARN(CAT, "BLE WinRT invalid write offset=%u option=%d bytes=%u", request.Offset(),
(int)request.Option(), request.Value().Length());
request.RespondWithProtocolError(0x06); return;
}
auto* l = s.incoming(session);
if (!l) { request.RespondWithProtocolError(0x08); return; }
auto id = l->id; auto data = bytes(request.Value());
DEBUG_TRACE(CAT, "BLE WinRT RX write link=%llu bytes=%zu", (unsigned long long)id, data.size());
ble_backend_received(s.owner, id, data.data(), data.size());
if (s.link(id)) request.Respond(); else request.RespondWithProtocolError(0x08);
});
});
} catch (...) {
auto reason = exception_reason("WriteRequested");
if (auto s = weak.lock()) s->post([reason](WinState& s) { s.fail(reason.c_str()); });
}
});
subscriptions_changed = local_tx.SubscribedClientsChanged(auto_revoke, [weak](auto const&, auto const&) {
if (auto s = weak.lock()) s->post([](WinState& s) { s.subscriptions(); });
});
service_changed = provider.AdvertisementStatusChanged(auto_revoke, [weak](auto const&, auto const& args) {
auto status = args.Status(); auto error = args.Error();
if (auto s = weak.lock()) s->post([status, error](WinState& s) {
DEBUG_DEBUG(CAT, "BLE WinRT service advertising state=%d error=%d (%s)", (int)status, (int)error, bluetooth_error(error));
if (status == GattServiceProviderAdvertisementStatus::Started) { s.service_ready = true; s.ready(); }
else if (status == GattServiceProviderAdvertisementStatus::Aborted) s.radio_error("GATT advertising aborted", error);
else DEBUG_INFO(CAT, "BLE WinRT service advertising state=%d", (int)status);
});
});
GattServiceProviderAdvertisingParameters parameters; parameters.IsConnectable(true); parameters.IsDiscoverable(true);
DEBUG_DEBUG(CAT, "BLE WinRT start server service=%s connectable=1 discoverable=1", BLE_SERVICE_UUID);
provider.StartAdvertising(parameters);
watcher = BluetoothLEAdvertisementWatcher(); watcher.ScanningMode(BluetoothLEScanningMode::Active);
received = watcher.Received(auto_revoke, [weak](auto const&, BluetoothLEAdvertisementReceivedEventArgs const& args) {
auto state = weak.lock(); if (!state) return;
bool matching = false;
for (auto const& value : args.Advertisement().ManufacturerData()) if (value.CompanyId() == state->company) matching = true;
if (!matching) return;
state->post([args](WinState& s) {
for (auto const& value : args.Advertisement().ManufacturerData()) {
if (value.CompanyId() != s.company || value.Data().Length() > BLE_BROADCAST_MAX) continue;
struct ble_endpoint ep{};
std::snprintf(ep.id, sizeof(ep.id), "%012llx/%d", (unsigned long long)args.BluetoothAddress(), (int)args.BluetoothAddressType());
auto data = bytes(value.Data());
DEBUG_TRACE(CAT, "BLE WinRT broadcast endpoint=%s company=%04x bytes=%zu rssi=%d", ep.id, s.company,
data.size(), args.RawSignalStrengthInDBm());
ble_backend_broadcast(s.owner, &ep, data.data(), data.size(), args.RawSignalStrengthInDBm());
}
});
});
scan_stopped = watcher.Stopped(auto_revoke, [weak](auto const&, auto const& args) {
auto error = args.Error(); if (auto s = weak.lock()) s->post([error](WinState& s) {
s.radio_error("scan stopped", error);
});
});
watcher.Start();
DEBUG_DEBUG(CAT, "BLE WinRT scan requested mode=active status=%d company=%04x", (int)watcher.Status(), company);
scan_ready = true; ready();
}
void publish() {
DEBUG_DEBUG(CAT, "BLE WinRT publish requested enabled=%d bytes=%zu generation=%llu", broadcast_enabled,
broadcast_size, (unsigned long long)publish_generation);
if (publisher) {
auto status = publisher.Status();
if (status == BluetoothLEAdvertisementPublisherStatus::Started || status == BluetoothLEAdvertisementPublisherStatus::Waiting) {
publisher.Stop(); return;
}
if (status == BluetoothLEAdvertisementPublisherStatus::Stopping) return;
publish_changed.revoke(); publisher = nullptr;
}
if (!broadcast_enabled) return;
BluetoothLEAdvertisement advertisement;
BluetoothLEManufacturerData data; data.CompanyId(company); data.Data(buffer(broadcast.data(), broadcast_size));
advertisement.ManufacturerData().Append(data); publisher = BluetoothLEAdvertisementPublisher(advertisement);
auto weak = weak_from_this(); auto generation = ++publish_generation;
publish_changed = publisher.StatusChanged(auto_revoke, [weak, generation](auto const&, auto const& args) {
auto status = args.Status(); auto error = args.Error();
if (auto s = weak.lock()) s->post([status, error, generation](WinState& s) {
if (generation != s.publish_generation) return;
DEBUG_DEBUG(CAT, "BLE WinRT broadcast state=%d error=%d (%s) generation=%llu", (int)status, (int)error,
bluetooth_error(error), (unsigned long long)generation);
if (status == BluetoothLEAdvertisementPublisherStatus::Aborted) s.radio_error("broadcast publication aborted", error);
else if (status == BluetoothLEAdvertisementPublisherStatus::Stopped) {
ble_backend_advertising(s.owner, BLE_CLOSED, "publisher stopped"); s.publish();
} else if (status == BluetoothLEAdvertisementPublisherStatus::Started) ble_backend_advertising(s.owner, BLE_READY, "publisher started");
else ble_backend_advertising(s.owner, BLE_STARTING, "publisher waiting/stopping");
});
});
publisher.Start();
}
void connect(ble_link_id id, uint64_t address, BluetoothAddressType type) {
DEBUG_DEBUG(CAT, "BLE WinRT connect link=%llu address=%012llx type=%d", (unsigned long long)id, (unsigned long long)address, (int)type);
await("open BLE device", BluetoothLEDevice::FromBluetoothAddressAsync(address, type), id, [id](WinState& s, BluetoothLEDevice const& device) {
auto* l = s.link(id);
if (!device) { s.error(id, "BLE device unavailable"); return; }
l->device = device; l->device_id = device.BluetoothDeviceId().Id();
DEBUG_DEBUG(CAT, "BLE WinRT device link=%llu endpoint=%s status=%d", (unsigned long long)id,
to_string(l->device_id).c_str(), (int)device.ConnectionStatus());
s.await("discover GATT service", device.GetGattServicesForUuidAsync(guid(BLE_SERVICE_UUID), BluetoothCacheMode::Uncached), id,
[id](WinState& s, GattDeviceServicesResult const& result) {
auto protocol = result.ProtocolError();
DEBUG_DEBUG(CAT, "BLE WinRT services link=%llu status=%d ATT_error=%d count=%u", (unsigned long long)id,
(int)result.Status(), protocol ? int(protocol.Value()) : -1,
result.Status() == GattCommunicationStatus::Success ? result.Services().Size() : 0);
if (result.Status() != GattCommunicationStatus::Success || result.Services().Size() != 1) {
s.error(id, "VibeChat GATT service unavailable/ambiguous"); return;
}
auto* l = s.link(id); l->service = result.Services().GetAt(0);
s.await("discover GATT characteristics", l->service.GetCharacteristicsAsync(BluetoothCacheMode::Uncached), id,
[id](WinState& s, GattCharacteristicsResult const& result) {
auto protocol = result.ProtocolError();
DEBUG_DEBUG(CAT, "BLE WinRT characteristics link=%llu status=%d ATT_error=%d count=%u", (unsigned long long)id,
(int)result.Status(), protocol ? int(protocol.Value()) : -1,
result.Status() == GattCommunicationStatus::Success ? result.Characteristics().Size() : 0);
if (result.Status() != GattCommunicationStatus::Success) { s.error(id, "GATT discovery failed"); return; }
auto* l = s.link(id);
for (auto const& ch : result.Characteristics()) {
DEBUG_DEBUG(CAT, "BLE WinRT characteristic link=%llu uuid=%s properties=0x%x", (unsigned long long)id,
to_string(to_hstring(ch.Uuid())).c_str(), (unsigned)ch.CharacteristicProperties());
if (ch.Uuid() == guid(BLE_RX_UUID)) l->rx = ch;
if (ch.Uuid() == guid(BLE_TX_UUID)) l->tx = ch;
}
if (!l->rx || !l->tx) { s.error(id, "RX/TX characteristics missing"); return; }
s.subscribe(id);
});
});
});
}
void subscribe(ble_link_id id) {
auto* l = link(id);
await("open GATT session", GattSession::FromDeviceIdAsync(l->device.BluetoothDeviceId()), id, [id](WinState& s, GattSession const& session) {
auto* l = s.link(id);
if (!session) { s.error(id, "GATT session unavailable"); return; }
l->session = session; session.MaintainConnection(true); s.watch_session(*l);
DEBUG_DEBUG(CAT, "BLE WinRT session opened link=%llu mtu=%u maintain_connection=1", (unsigned long long)id, session.MaxPduSize());
auto weak = s.weak_from_this();
l->value_changed = l->tx.ValueChanged(auto_revoke, [weak, id](auto const&, GattValueChangedEventArgs const& args) {
if (auto s = weak.lock()) s->post([id, args](WinState& s) {
if (!s.link(id)) return;
auto data = bytes(args.CharacteristicValue());
DEBUG_TRACE(CAT, "BLE WinRT RX indication link=%llu bytes=%zu", (unsigned long long)id, data.size());
ble_backend_received(s.owner, id, data.data(), data.size());
});
});
s.await("subscribe indications", l->tx.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue::Indicate), id,
[id](WinState& s, GattCommunicationStatus status) {
DEBUG_DEBUG(CAT, "BLE WinRT subscribe link=%llu status=%d", (unsigned long long)id, (int)status);
if (status != GattCommunicationStatus::Success) { s.error(id, "GATT subscription failed"); return; }
auto* l = s.link(id); l->opened = true; ble_backend_opened(s.owner, id, l->session.MaxPduSize());
});
});
}
void close(ble_link_id id) {
auto it = links.find(id); if (it == links.end()) return;
auto l = std::move(it->second); links.erase(it);
DEBUG_DEBUG(CAT, "BLE WinRT close link=%llu outgoing=%d opened=%d sending=%d pending=%d", (unsigned long long)id,
l->outgoing, l->opened, l->sending, bool(l->operation));
l->value_changed.revoke(); l->session_changed.revoke(); l->pdu_changed.revoke();
try {
if (l->operation) l->operation.Cancel();
if (l->outgoing) {
if (l->session) { l->session.MaintainConnection(false); l->session.Close(); }
if (l->service) l->service.Close();
if (l->device) l->device.Close();
}
} catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("close", id).c_str()); }
}
void shutdown() {
struct posted_task* task;
std::deque<std::function<void(WinState&)>> discarded;
{ std::lock_guard guard(mutex); stopped = true; task = posted; posted = nullptr; discarded.swap(events); }
DEBUG_DEBUG(CAT, "BLE WinRT shutdown links=%zu discarded_events=%zu pending_dispatch=%d", links.size(), discarded.size(), task != nullptr);
discarded.clear();
if (task) uasync_cancel_post(ua, task);
received.revoke(); scan_stopped.revoke(); publish_changed.revoke(); service_changed.revoke();
write_requested.revoke(); subscriptions_changed.revoke();
while (!links.empty()) close(links.begin()->first);
try { if (startup) startup.Cancel(); } catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("cancel startup").c_str()); }
try { if (watcher) watcher.Stop(); } catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("stop scan").c_str()); }
try { if (publisher) publisher.Stop(); } catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("stop publisher").c_str()); }
try { if (provider) provider.StopAdvertising(); } catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("stop server").c_str()); }
watcher = nullptr; publisher = nullptr; provider = nullptr; local_rx = nullptr; local_tx = nullptr; startup = nullptr;
if (apartment) { uninit_apartment(); apartment = false; }
}
};
struct ble_backend { std::shared_ptr<WinState> state; };
extern "C" struct ble_backend* ble_backend_create(struct ble_transport* owner, struct UASYNC* ua, const struct ble_config* cfg) {
if (cfg->adapter) { DEBUG_ERROR(CAT, "BLE WinRT explicit adapter selection unsupported"); return nullptr; }
auto state = std::make_shared<WinState>(); state->owner = owner; state->ua = ua; state->company = cfg->company_id;
try {
DEBUG_DEBUG(CAT, "BLE WinRT initialize company=%04x node=%016llx apartment=MTA", cfg->company_id, (unsigned long long)cfg->node_id);
init_apartment(apartment_type::multi_threaded); state->apartment = true;
state->await("get default adapter", BluetoothAdapter::GetDefaultAsync(), 0, [](WinState& s, BluetoothAdapter const& adapter) {
if (!adapter) { s.fail("no default Bluetooth adapter"); return; }
DEBUG_DEBUG(CAT, "BLE WinRT adapter id=%s address=%012llx BLE=%d central=%d peripheral=%d", to_string(adapter.DeviceId()).c_str(),
(unsigned long long)adapter.BluetoothAddress(), adapter.IsLowEnergySupported(),
adapter.IsCentralRoleSupported(), adapter.IsPeripheralRoleSupported());
try {
auto advertising = adapter.try_as<IBluetoothAdapter3>();
auto phy = adapter.try_as<IBluetoothAdapter4>();
DEBUG_DEBUG(CAT, "BLE WinRT adapter extended_advertising=%d advertisement_max=%d PHY_2M_supported=%d PHY_coded_supported=%d (-1=API unavailable)",
advertising ? int(advertising.IsExtendedAdvertisingSupported()) : -1,
advertising ? int(advertising.MaxAdvertisementDataLength()) : -1,
phy ? int(phy.IsLowEnergyUncoded2MPhySupported()) : -1, phy ? int(phy.IsLowEnergyCodedPhySupported()) : -1);
} catch (...) { DEBUG_WARN(CAT, "%s", exception_reason("optional adapter capabilities").c_str()); }
if (!adapter.IsLowEnergySupported() || !adapter.IsCentralRoleSupported() || !adapter.IsPeripheralRoleSupported()) {
s.fail("adapter lacks BLE central/peripheral support"); return;
}
s.make_server();
});
void* memory = u_malloc(sizeof(ble_backend));
if (!memory) { DEBUG_ERROR(CAT, "BLE WinRT allocation failed"); state->shutdown(); return nullptr; }
return new(memory) ble_backend{state};
} catch (...) { DEBUG_ERROR(CAT, "%s", exception_reason("initialize").c_str()); state->shutdown(); return nullptr; }
}
extern "C" void ble_backend_destroy(struct ble_backend* b) {
if (!b) return;
b->state->shutdown(); b->~ble_backend(); u_free(b);
}
extern "C" int ble_backend_advertise(struct ble_backend* b, const uint8_t* data, size_t len) {
try {
auto& s = *b->state; s.broadcast_enabled = data != nullptr; s.broadcast_size = len;
if (len) std::memcpy(s.broadcast.data(), data, len);
s.publish(); return BLE_OK;
} catch (...) { DEBUG_ERROR(CAT, "%s", exception_reason("advertise").c_str()); return BLE_ERROR; }
}
extern "C" int ble_backend_connect(struct ble_backend* b, ble_link_id id, const struct ble_endpoint* ep) {
unsigned long long address; int type, consumed = 0;
if (std::sscanf(ep->id, "%llx/%d%n", &address, &type, &consumed) != 2 || ep->id[consumed] || address >> 48 || type < 0 || type > 2) {
DEBUG_ERROR(CAT, "BLE invalid WinRT endpoint=%s", ep->id); return BLE_ERROR;
}
try {
auto& s = *b->state; auto l = std::make_unique<WinLink>(); l->id = id; l->endpoint = ep->id; l->outgoing = true;
s.links.emplace(id, std::move(l)); s.connect(id, address, static_cast<BluetoothAddressType>(type)); return BLE_OK;
} catch (...) { DEBUG_ERROR(CAT, "%s", exception_reason("connect", id).c_str()); b->state->close(id); return BLE_ERROR; }
}
extern "C" void ble_backend_close(struct ble_backend* b, ble_link_id id) { b->state->close(id); }
extern "C" int ble_backend_send(struct ble_backend* b, ble_link_id id, const uint8_t* data, size_t len) {
auto& s = *b->state; auto* l = s.link(id);
if (!l || !l->opened || l->sending) {
DEBUG_ERROR(CAT, "BLE invalid WinRT send link=%llu exists=%d opened=%d sending=%d bytes=%zu", (unsigned long long)id,
l != nullptr, l && l->opened, l && l->sending, len);
return BLE_ERROR;
}
try {
DEBUG_TRACE(CAT, "BLE WinRT TX fragment link=%llu outgoing=%d bytes=%zu", (unsigned long long)id, l->outgoing, len);
l->sending = true; auto buffer = WinState::buffer(data, len);
if (l->outgoing) s.await("write frame", l->rx.WriteValueWithResultAsync(buffer, GattWriteOption::WriteWithResponse), id,
[id, len](WinState& s, GattWriteResult const& result) {
auto* l = s.link(id); l->sending = false;
auto protocol = result.ProtocolError();
if (result.Status() != GattCommunicationStatus::Success)
DEBUG_WARN(CAT, "BLE WinRT write failed link=%llu bytes=%zu status=%d ATT_error=%d", (unsigned long long)id,
len, (int)result.Status(), protocol ? int(protocol.Value()) : -1);
else DEBUG_TRACE(CAT, "BLE WinRT write complete link=%llu bytes=%zu", (unsigned long long)id, len);
ble_backend_sent(s.owner, id, result.Status() == GattCommunicationStatus::Success);
});
else s.await("indicate frame", s.local_tx.NotifyValueAsync(buffer, l->subscriber), id, [id, len](WinState& s, GattClientNotificationResult const& result) {
auto* l = s.link(id); l->sending = false;
if (result.Status() != GattCommunicationStatus::Success || result.BytesSent() != len)
DEBUG_WARN(CAT, "BLE WinRT indication failed link=%llu expected=%zu sent=%u status=%d", (unsigned long long)id,
len, result.BytesSent(), (int)result.Status());
else DEBUG_TRACE(CAT, "BLE WinRT indication complete link=%llu bytes=%zu", (unsigned long long)id, len);
ble_backend_sent(s.owner, id, result.Status() == GattCommunicationStatus::Success && result.BytesSent() == len);
});
return BLE_OK;
} catch (...) { l->sending = false; DEBUG_ERROR(CAT, "%s", exception_reason("send", id).c_str()); return BLE_ERROR; }
}
Reference in new issue View Git Blame Copy Permalink