mirror of
https://github.com/mudita/MuditaOS.git
synced 2026-05-03 05:15:26 -04:00
270 lines
8.3 KiB
C++
270 lines
8.3 KiB
C++
// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
|
|
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
|
|
|
|
#include "BluetoothWorker.hpp"
|
|
#include "Device.hpp"
|
|
#include "Service/Bus.hpp"
|
|
#include <Bluetooth/Device.hpp>
|
|
#include <Bluetooth/Error.hpp>
|
|
#include <log/log.hpp>
|
|
#include <service-bluetooth/BluetoothMessage.hpp>
|
|
#include <vector>
|
|
|
|
extern "C"
|
|
{
|
|
#include "btstack.h"
|
|
#include "hci.h"
|
|
};
|
|
|
|
btstack_packet_callback_registration_t cb_handler;
|
|
|
|
std::vector<Devicei> devices;
|
|
|
|
static auto start_scan() -> int;
|
|
static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
|
|
|
|
static auto getDeviceIndexForAddress(std::vector<Devicei> &devs, bd_addr_t addr) -> int
|
|
{
|
|
int j;
|
|
for (j = 0; j < devs.size(); j++) {
|
|
if (bd_addr_cmp(addr, devs[j].address) == 0) {
|
|
return j;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
enum STATE
|
|
{
|
|
INIT,
|
|
ACTIVE,
|
|
DONE
|
|
};
|
|
enum STATE state = INIT;
|
|
|
|
namespace Bt::GAP
|
|
{
|
|
static sys::Service *ownerService = nullptr;
|
|
|
|
void setOwnerService(sys::Service *service)
|
|
{
|
|
ownerService = service;
|
|
}
|
|
|
|
auto register_scan() -> Error
|
|
{
|
|
LOG_INFO("GAP register scan!");
|
|
/// -> this have to be called prior to power on!
|
|
hci_set_inquiry_mode(INQUIRY_MODE_RSSI_AND_EIR);
|
|
cb_handler.callback = &packet_handler;
|
|
hci_add_event_handler(&cb_handler);
|
|
return Error();
|
|
}
|
|
|
|
auto scan() -> Error
|
|
{
|
|
LOG_INFO("Start scan if active: %d: %d", hci_get_state(), state);
|
|
if (hci_get_state() == HCI_STATE_WORKING) {
|
|
if (int ret = start_scan(); ret != 0) {
|
|
LOG_ERROR("Start scan error!: 0x%X", ret);
|
|
return Error(Error::LibraryError, ret);
|
|
}
|
|
}
|
|
else {
|
|
return Error(Error::NotReady);
|
|
}
|
|
return Error();
|
|
}
|
|
|
|
void stop_scan()
|
|
{
|
|
gap_inquiry_force_stop();
|
|
LOG_INFO("Scan stopped!");
|
|
}
|
|
|
|
auto set_visibility(bool visibility) -> Error
|
|
{
|
|
gap_discoverable_control(static_cast<uint8_t>(visibility));
|
|
LOG_INFO("Visibility: %s", visibility ? "true" : "false");
|
|
return Error();
|
|
}
|
|
|
|
auto do_pairing(uint8_t *addr) -> bool
|
|
{
|
|
if (hci_get_state() == HCI_STATE_WORKING) {
|
|
gap_dedicated_bonding(addr, 0);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
} // namespace Bt::GAP
|
|
|
|
#define INQUIRY_INTERVAL 5
|
|
static auto start_scan() -> int
|
|
{
|
|
LOG_INFO("Starting inquiry scan..");
|
|
return gap_inquiry_start(INQUIRY_INTERVAL);
|
|
}
|
|
|
|
static auto has_more_remote_name_requests() -> int
|
|
{
|
|
int i;
|
|
for (i = 0; i < devices.size(); i++) {
|
|
if (devices[i].state == REMOTE_NAME_REQUEST) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void do_next_remote_name_request()
|
|
{
|
|
int i;
|
|
for (i = 0; i < devices.size(); i++) {
|
|
// remote name request
|
|
if (devices[i].state == REMOTE_NAME_REQUEST) {
|
|
devices[i].state = REMOTE_NAME_INQUIRED;
|
|
LOG_INFO("Get remote name of %s...", bd_addr_to_str(devices[i].address));
|
|
gap_remote_name_request(
|
|
devices[i].address, devices[i].pageScanRepetitionMode, devices[i].clockOffset | 0x8000);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void continue_remote_names()
|
|
{
|
|
if (has_more_remote_name_requests() != 0) {
|
|
do_next_remote_name_request();
|
|
return;
|
|
}
|
|
start_scan();
|
|
}
|
|
|
|
static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)
|
|
{
|
|
UNUSED(channel);
|
|
UNUSED(size);
|
|
|
|
bd_addr_t addr;
|
|
int i;
|
|
int index;
|
|
|
|
if (packet_type != HCI_EVENT_PACKET) {
|
|
return;
|
|
}
|
|
|
|
uint8_t event = hci_event_packet_get_type(packet);
|
|
|
|
switch (state) {
|
|
/* @text In INIT, an inquiry scan is started, and the application transits to
|
|
* ACTIVE state.
|
|
*/
|
|
case INIT:
|
|
switch (event) {
|
|
case BTSTACK_EVENT_STATE:
|
|
if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING) {
|
|
state = ACTIVE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
/* @text In ACTIVE, the following events are processed:
|
|
* - GAP Inquiry result event: BTstack provides a unified inquiry result that contain
|
|
* Class of Device (CoD), page scan mode, clock offset. RSSI and name (from EIR) are optional.
|
|
* - Inquiry complete event: the remote name is requested for devices without a fetched
|
|
* name. The state of a remote name can be one of the following:
|
|
* REMOTE_NAME_REQUEST, REMOTE_NAME_INQUIRED, or REMOTE_NAME_FETCHED.
|
|
* - Remote name request complete event: the remote name is stored in the table and the
|
|
* state is updated to REMOTE_NAME_FETCHED. The query of remote names is continued.
|
|
*/
|
|
case ACTIVE:
|
|
switch (event) {
|
|
|
|
case GAP_EVENT_INQUIRY_RESULT: {
|
|
gap_event_inquiry_result_get_bd_addr(packet, addr);
|
|
index = getDeviceIndexForAddress(devices, addr);
|
|
if (index >= 0) {
|
|
break; // already in our list
|
|
}
|
|
|
|
Devicei dev;
|
|
dev.address_set(&addr);
|
|
dev.pageScanRepetitionMode = gap_event_inquiry_result_get_page_scan_repetition_mode(packet);
|
|
dev.clockOffset = gap_event_inquiry_result_get_clock_offset(packet);
|
|
// print info
|
|
LOG_INFO("Device found: %s ", bd_addr_to_str(addr));
|
|
LOG_INFO("with COD: 0x%06x, ", (unsigned int)gap_event_inquiry_result_get_class_of_device(packet));
|
|
LOG_INFO("pageScan %d, ", dev.pageScanRepetitionMode);
|
|
LOG_INFO("clock offset 0x%04x", dev.clockOffset);
|
|
if (gap_event_inquiry_result_get_rssi_available(packet) != 0u) {
|
|
LOG_INFO(", rssi %d dBm", (int8_t)gap_event_inquiry_result_get_rssi(packet));
|
|
}
|
|
if (gap_event_inquiry_result_get_name_available(packet) != 0u) {
|
|
char name_buffer[240];
|
|
int name_len = gap_event_inquiry_result_get_name_len(packet);
|
|
memcpy(name_buffer, gap_event_inquiry_result_get_name(packet), name_len);
|
|
name_buffer[name_len] = 0;
|
|
LOG_INFO(", name '%s'", name_buffer);
|
|
dev.name = std::string{name_buffer};
|
|
dev.state = REMOTE_NAME_FETCHED;
|
|
}
|
|
else {
|
|
dev.state = REMOTE_NAME_REQUEST;
|
|
}
|
|
devices.push_back(dev);
|
|
auto msg = std::make_shared<BluetoothScanResultMessage>(devices);
|
|
sys::Bus::SendUnicast(msg, "ApplicationSettings", Bt::GAP::ownerService);
|
|
sys::Bus::SendUnicast(msg, "ApplicationSettingsNew", Bt::GAP::ownerService);
|
|
|
|
} break;
|
|
|
|
case GAP_EVENT_INQUIRY_COMPLETE:
|
|
for (i = 0; i < devices.size(); i++) {
|
|
// retry remote name request
|
|
if (devices[i].state == REMOTE_NAME_INQUIRED)
|
|
devices[i].state = REMOTE_NAME_REQUEST;
|
|
}
|
|
continue_remote_names();
|
|
break;
|
|
|
|
case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE: {
|
|
reverse_bd_addr(&packet[3], addr);
|
|
index = getDeviceIndexForAddress(devices, addr);
|
|
if (index >= 0) {
|
|
if (packet[2] == 0) {
|
|
LOG_INFO("Name: '%s'", &packet[9]);
|
|
devices[index].state = REMOTE_NAME_FETCHED;
|
|
devices[index].name = reinterpret_cast<char *>(&packet[9]);
|
|
}
|
|
else {
|
|
LOG_INFO("Failed to get name: page timeout");
|
|
}
|
|
}
|
|
if (index + 1 == devices.size()) {
|
|
LOG_INFO("Scanned all");
|
|
state = DONE;
|
|
gap_inquiry_stop();
|
|
break;
|
|
}
|
|
continue_remote_names();
|
|
} break;
|
|
case GAP_EVENT_DEDICATED_BONDING_COMPLETED: {
|
|
auto result = packet[2];
|
|
auto msg = std::make_shared<BluetoothPairResultMessage>(result == 0u);
|
|
sys::Bus::SendUnicast(msg, "ApplicationSettings", Bt::GAP::ownerService);
|
|
sys::Bus::SendUnicast(msg, "ApplicationSettingsNew", Bt::GAP::ownerService);
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|