pinetime/InfiniTime
1
0
Fork 0
Code Activity

NimbleController : CTS & ANS are now working together (even if the code is not as good as I would like).

Browse source
This commit is contained in:
JF 2020-04-25 15:52:00 +02:00
parent 5fcb90a149
commit 032fad094c
6 changed files with 174 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

47
src/Components/Ble/AlertNotificationClient.cpp
View file

@ -13,19 +13,6 @@ constexpr ble_uuid16_t AlertNotificationClient::newAlertUuid;
constexpr ble_uuid16_t AlertNotificationClient::unreadAlertStatusUuid; constexpr ble_uuid16_t AlertNotificationClient::unreadAlertStatusUuid;
constexpr ble_uuid16_t AlertNotificationClient::controlPointUuid; constexpr ble_uuid16_t AlertNotificationClient::controlPointUuid;
int Pinetime::Controllers::AlertNotificationDiscoveryEventCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_svc *service, void *arg) {
auto client = static_cast<AlertNotificationClient*>(arg);
return client->OnDiscoveryEvent(conn_handle, error, service);
}
int Pinetime::Controllers::AlertNotificationCharacteristicsDiscoveryEventCallback(uint16_t conn_handle,
const struct ble_gatt_error *error,
const struct ble_gatt_chr *chr, void *arg) {
auto client = static_cast<AlertNotificationClient*>(arg);
return client->OnCharacteristicsDiscoveryEvent(conn_handle, error, chr);
}
int Pinetime::Controllers::NewAlertSubcribeCallback(uint16_t conn_handle, int Pinetime::Controllers::NewAlertSubcribeCallback(uint16_t conn_handle,
const struct ble_gatt_error *error, const struct ble_gatt_error *error,
struct ble_gatt_attr *attr, struct ble_gatt_attr *attr,
@ -34,37 +21,23 @@ int Pinetime::Controllers::NewAlertSubcribeCallback(uint16_t conn_handle,
return client->OnNewAlertSubcribe(conn_handle, error, attr); return client->OnNewAlertSubcribe(conn_handle, error, attr);
} }
int Pinetime::Controllers::AlertNotificationDescriptorDiscoveryEventCallback(uint16_t conn_handle,
const struct ble_gatt_error *error,
uint16_t chr_val_handle,
const struct ble_gatt_dsc *dsc,
void *arg) {
NRF_LOG_INFO("ANS VCS");
auto client = static_cast<AlertNotificationClient*>(arg);
return client->OnDescriptorDiscoveryEventCallback(conn_handle, error, chr_val_handle, dsc);
}
AlertNotificationClient::AlertNotificationClient(Pinetime::System::SystemTask& systemTask, AlertNotificationClient::AlertNotificationClient(Pinetime::System::SystemTask& systemTask,
Pinetime::Controllers::NotificationManager& notificationManager) : Pinetime::Controllers::NotificationManager& notificationManager) :
systemTask{systemTask}, notificationManager{notificationManager}{ systemTask{systemTask}, notificationManager{notificationManager}{
} }
void AlertNotificationClient::StartDiscovery(uint16_t connectionHandle) {
ble_gattc_disc_svc_by_uuid(connectionHandle, ((ble_uuid_t*)&ansServiceUuid), AlertNotificationDiscoveryEventCallback, this);
}
bool AlertNotificationClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service) { bool AlertNotificationClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service) {
if(service == nullptr && error->status == BLE_HS_EDONE) { if(service == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("ANS Discovery complete"); NRF_LOG_INFO("ANS Discovery complete");
ble_gattc_disc_all_dscs(connectionHandle, newAlertHandle, ansEndHandle, AlertNotificationDescriptorDiscoveryEventCallback, this);
return true; return true;
} }
if(service != nullptr && ble_uuid_cmp(((ble_uuid_t*)&ansServiceUuid), &service->uuid.u) == 0) { if(service != nullptr && ble_uuid_cmp(((ble_uuid_t*)&ansServiceUuid), &service->uuid.u) == 0) {
NRF_LOG_INFO("ANS discovered : 0x%x", service->start_handle); NRF_LOG_INFO("ANS discovered : 0x%x", service->start_handle);
ble_gattc_disc_all_chrs(connectionHandle, service->start_handle, service->end_handle, AlertNotificationCharacteristicsDiscoveryEventCallback, this); ansStartHandle = service->start_handle;
ansEndHandle = service->end_handle; ansEndHandle = service->end_handle;
isDiscovered = true;
} }
return false; return false;
} }
@ -147,3 +120,19 @@ void AlertNotificationClient::OnNotification(ble_gap_event *event) {
systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification); systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification);
} }
} }
bool AlertNotificationClient::IsDiscovered() const {
return isDiscovered;
}
uint16_t AlertNotificationClient::StartHandle() const {
return ansStartHandle;
}
uint16_t AlertNotificationClient::EndHandle() const {
return ansEndHandle;
}
uint16_t AlertNotificationClient::NewAlerthandle() const {
return newAlertHandle;
}

60
src/Components/Ble/AlertNotificationClient.h
View file

@ -1,4 +1,5 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include <array> #include <array>
#include <host/ble_gap.h> #include <host/ble_gap.h>
@ -6,29 +7,17 @@
namespace Pinetime { namespace Pinetime {
namespace Controllers { namespace Controllers {
int AlertNotificationDiscoveryEventCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_svc *service, void *arg);
int AlertNotificationCharacteristicsDiscoveryEventCallback(uint16_t conn_handle,
const struct ble_gatt_error *error,
const struct ble_gatt_chr *chr, void *arg);
int NewAlertSubcribeCallback(uint16_t conn_handle, int NewAlertSubcribeCallback(uint16_t conn_handle,
const struct ble_gatt_error *error, const struct ble_gatt_error *error,
struct ble_gatt_attr *attr, struct ble_gatt_attr *attr,
void *arg); void *arg);
int AlertNotificationDescriptorDiscoveryEventCallback(uint16_t conn_handle,
const struct ble_gatt_error *error,
uint16_t chr_val_handle,
const struct ble_gatt_dsc *dsc,
void *arg);
class AlertNotificationClient { class AlertNotificationClient {
public: public:
explicit AlertNotificationClient(Pinetime::System::SystemTask& systemTask, Pinetime::Controllers::NotificationManager& notificationManager); explicit AlertNotificationClient(Pinetime::System::SystemTask &systemTask,
Pinetime::Controllers::NotificationManager &notificationManager);
void Init(); void Init();
void StartDiscovery(uint16_t connectionHandle);
bool OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service); bool OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service);
int OnCharacteristicsDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, int OnCharacteristicsDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic); const ble_gatt_chr *characteristic);
@ -36,39 +25,47 @@ namespace Pinetime {
int OnDescriptorDiscoveryEventCallback(uint16_t connectionHandle, const ble_gatt_error *error, int OnDescriptorDiscoveryEventCallback(uint16_t connectionHandle, const ble_gatt_error *error,
uint16_t characteristicValueHandle, const ble_gatt_dsc *descriptor); uint16_t characteristicValueHandle, const ble_gatt_dsc *descriptor);
void OnNotification(ble_gap_event *event); void OnNotification(ble_gap_event *event);
bool IsDiscovered() const;
uint16_t StartHandle() const;
uint16_t EndHandle() const;
static constexpr const ble_uuid16_t &Uuid() { return ansServiceUuid; }
uint16_t NewAlerthandle() const;
private: private:
static constexpr uint16_t ansServiceId {0x1811}; static constexpr uint16_t ansServiceId{0x1811};
static constexpr uint16_t supportedNewAlertCategoryId = 0x2a47; static constexpr uint16_t supportedNewAlertCategoryId = 0x2a47;
static constexpr uint16_t supportedUnreadAlertCategoryId = 0x2a48; static constexpr uint16_t supportedUnreadAlertCategoryId = 0x2a48;
static constexpr uint16_t newAlertId = 0x2a46; static constexpr uint16_t newAlertId = 0x2a46;
static constexpr uint16_t unreadAlertStatusId = 0x2a45; static constexpr uint16_t unreadAlertStatusId = 0x2a45;
static constexpr uint16_t controlPointId = 0x2a44; static constexpr uint16_t controlPointId = 0x2a44;
static constexpr ble_uuid16_t ansServiceUuid { static constexpr ble_uuid16_t ansServiceUuid{
.u { .type = BLE_UUID_TYPE_16 }, .u {.type = BLE_UUID_TYPE_16},
.value = ansServiceId .value = ansServiceId
}; };
static constexpr ble_uuid16_t supportedNewAlertCategoryUuid { static constexpr ble_uuid16_t supportedNewAlertCategoryUuid{
.u { .type = BLE_UUID_TYPE_16 }, .u {.type = BLE_UUID_TYPE_16},
.value = supportedNewAlertCategoryId .value = supportedNewAlertCategoryId
}; };
static constexpr ble_uuid16_t supportedUnreadAlertCategoryUuid { static constexpr ble_uuid16_t supportedUnreadAlertCategoryUuid{
.u { .type = BLE_UUID_TYPE_16 }, .u {.type = BLE_UUID_TYPE_16},
.value = supportedUnreadAlertCategoryId .value = supportedUnreadAlertCategoryId
}; };
static constexpr ble_uuid16_t newAlertUuid { static constexpr ble_uuid16_t newAlertUuid{
.u { .type = BLE_UUID_TYPE_16 }, .u {.type = BLE_UUID_TYPE_16},
.value = newAlertId .value = newAlertId
}; };
static constexpr ble_uuid16_t unreadAlertStatusUuid { static constexpr ble_uuid16_t unreadAlertStatusUuid{
.u { .type = BLE_UUID_TYPE_16 }, .u {.type = BLE_UUID_TYPE_16},
.value = unreadAlertStatusId .value = unreadAlertStatusId
}; };
static constexpr ble_uuid16_t controlPointUuid { static constexpr ble_uuid16_t controlPointUuid{
.u { .type = BLE_UUID_TYPE_16 }, .u {.type = BLE_UUID_TYPE_16},
.value = controlPointId .value = controlPointId
}; };
uint16_t ansStartHandle;
uint16_t ansEndHandle; uint16_t ansEndHandle;
uint16_t supportedNewAlertCategoryHandle; uint16_t supportedNewAlertCategoryHandle;
uint16_t supportedUnreadAlertCategoryHandle; uint16_t supportedUnreadAlertCategoryHandle;
@ -77,12 +74,9 @@ namespace Pinetime {
uint16_t newAlertDefHandle; uint16_t newAlertDefHandle;
uint16_t unreadAlertStatusHandle; uint16_t unreadAlertStatusHandle;
uint16_t controlPointHandle; uint16_t controlPointHandle;
bool discoveryDone = false; bool isDiscovered = false;
Pinetime::System::SystemTask& systemTask; Pinetime::System::SystemTask &systemTask;
Pinetime::Controllers::NotificationManager& notificationManager; Pinetime::Controllers::NotificationManager &notificationManager;
}; };
} }
} }

51
src/Components/Ble/CurrentTimeClient.cpp
View file

@ -6,25 +6,6 @@ using namespace Pinetime::Controllers;
constexpr ble_uuid16_t CurrentTimeClient::ctsServiceUuid; constexpr ble_uuid16_t CurrentTimeClient::ctsServiceUuid;
constexpr ble_uuid16_t CurrentTimeClient::currentTimeCharacteristicUuid; constexpr ble_uuid16_t CurrentTimeClient::currentTimeCharacteristicUuid;
int Pinetime::Controllers::CurrentTimeDiscoveryEventCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_svc *service, void *arg) {
auto client = static_cast<CurrentTimeClient*>(arg);
return client->OnDiscoveryEvent(conn_handle, error, service);
}
int Pinetime::Controllers::CurrentTimeCharacteristicDiscoveredCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_chr *chr, void *arg) {
auto client = static_cast<CurrentTimeClient*>(arg);
return client->OnCharacteristicDiscoveryEvent(conn_handle, error, chr);
}
int Pinetime::Controllers::CurrentTimeReadCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
struct ble_gatt_attr *attr, void *arg) {
auto client = static_cast<CurrentTimeClient*>(arg);
return client->OnCurrentTimeReadResult(conn_handle, error, attr);
}
CurrentTimeClient::CurrentTimeClient(DateTime& dateTimeController) : dateTimeController{dateTimeController} { CurrentTimeClient::CurrentTimeClient(DateTime& dateTimeController) : dateTimeController{dateTimeController} {
} }
@ -33,10 +14,6 @@ void CurrentTimeClient::Init() {
} }
void CurrentTimeClient::StartDiscovery(uint16_t connectionHandle) {
ble_gattc_disc_svc_by_uuid(connectionHandle, ((ble_uuid_t*)&ctsServiceUuid), CurrentTimeDiscoveryEventCallback, this);
}
bool CurrentTimeClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service) { bool CurrentTimeClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error, const ble_gatt_svc *service) {
if(service == nullptr && error->status == BLE_HS_EDONE) { if(service == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("CTS Discovery complete"); NRF_LOG_INFO("CTS Discovery complete");
@ -45,20 +22,24 @@ bool CurrentTimeClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_ga
if(service != nullptr && ble_uuid_cmp(((ble_uuid_t*)&ctsServiceUuid), &service->uuid.u) == 0) { if(service != nullptr && ble_uuid_cmp(((ble_uuid_t*)&ctsServiceUuid), &service->uuid.u) == 0) {
NRF_LOG_INFO("CTS discovered : 0x%x", service->start_handle); NRF_LOG_INFO("CTS discovered : 0x%x", service->start_handle);
ble_gattc_disc_chrs_by_uuid(connectionHandle, service->start_handle, service->end_handle, ((ble_uuid_t*)&currentTimeCharacteristicUuid), CurrentTimeCharacteristicDiscoveredCallback, this); isDiscovered = true;
ctsStartHandle = service->start_handle;
ctsEndHandle = service->end_handle;
return false;
} }
return false; return false;
} }
int CurrentTimeClient::OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error, int CurrentTimeClient::OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic) { const ble_gatt_chr *characteristic) {
if(characteristic == nullptr && error->status == BLE_HS_EDONE) if(characteristic == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("CTS Characteristic discovery complete"); NRF_LOG_INFO("CTS Characteristic discovery complete");
return 0;
}
if(characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*)&currentTimeCharacteristicUuid), &characteristic->uuid.u) == 0) { if(characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*)&currentTimeCharacteristicUuid), &characteristic->uuid.u) == 0) {
NRF_LOG_INFO("CTS Characteristic discovered : 0x%x", characteristic->val_handle); NRF_LOG_INFO("CTS Characteristic discovered : 0x%x", characteristic->val_handle);
currentTimeHandle = characteristic->val_handle;
ble_gattc_read(conn_handle, characteristic->val_handle, CurrentTimeReadCallback, this);
} }
return 0; return 0;
} }
@ -78,3 +59,19 @@ int CurrentTimeClient::OnCurrentTimeReadResult(uint16_t conn_handle, const ble_g
} }
return 0; return 0;
} }
bool CurrentTimeClient::IsDiscovered() const {
return isDiscovered;
}
uint16_t CurrentTimeClient::StartHandle() const {
return ctsStartHandle;
}
uint16_t CurrentTimeClient::EndHandle() const {
return ctsEndHandle;
}
uint16_t CurrentTimeClient::CurrentTimeHandle() const {
return currentTimeHandle;
}

19
src/Components/Ble/CurrentTimeClient.h
View file

@ -6,12 +6,6 @@
namespace Pinetime { namespace Pinetime {
namespace Controllers { namespace Controllers {
int CurrentTimeDiscoveryEventCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_svc *service, void *arg);
int CurrentTimeCharacteristicDiscoveredCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_chr *chr, void *arg);
int CurrentTimeReadCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
struct ble_gatt_attr *attr, void *arg);
class CurrentTimeClient { class CurrentTimeClient {
public: public:
@ -21,9 +15,12 @@ namespace Pinetime {
int OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error, int OnCharacteristicDiscoveryEvent(uint16_t conn_handle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic); const ble_gatt_chr *characteristic);
int OnCurrentTimeReadResult(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_attr *attribute); int OnCurrentTimeReadResult(uint16_t conn_handle, const ble_gatt_error *error, const ble_gatt_attr *attribute);
bool IsDiscovered() const;
uint16_t StartHandle() const;
void StartDiscovery(uint16_t connectionHandle); uint16_t EndHandle() const;
uint16_t CurrentTimeHandle() const;
static constexpr const ble_uuid16_t* Uuid() { return &CurrentTimeClient::ctsServiceUuid; }
static constexpr const ble_uuid16_t* CurrentTimeCharacteristicUuid() { return &CurrentTimeClient::currentTimeCharacteristicUuid; }
private: private:
typedef struct __attribute__((packed)) { typedef struct __attribute__((packed)) {
uint16_t year; uint16_t year;
@ -48,7 +45,11 @@ namespace Pinetime {
.value = currentTimeCharacteristicId .value = currentTimeCharacteristicId
}; };
uint16_t currentTimeHandle;
DateTime& dateTimeController; DateTime& dateTimeController;
bool isDiscovered = false;
uint16_t ctsStartHandle;
uint16_t ctsEndHandle;
}; };
} }
} }

88
src/Components/Ble/NimbleController.cpp
View file

@ -17,8 +17,9 @@
using namespace Pinetime::Controllers; using namespace Pinetime::Controllers;
// TODO c++ify the following code // TODO I'm not satisfied by how this code looks like (AlertNotificationClient and CurrentTimeClient must
// - cts should be in it own class // expose too much data, too many callbacks -> NimbleController -> CTS/ANS client.
// Let's try to improve this code (and keep it working!)
NimbleController::NimbleController(Pinetime::System::SystemTask& systemTask, NimbleController::NimbleController(Pinetime::System::SystemTask& systemTask,
DateTime& dateTimeController, DateTime& dateTimeController,
@ -36,6 +37,33 @@ int GAPEventCallback(struct ble_gap_event *event, void *arg) {
return nimbleController->OnGAPEvent(event); return nimbleController->OnGAPEvent(event);
} }
int CurrentTimeCharacteristicDiscoveredCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_chr *chr, void *arg) {
auto client = static_cast<NimbleController*>(arg);
return client->OnCTSCharacteristicDiscoveryEvent(conn_handle, error, chr);
}
int AlertNotificationCharacteristicDiscoveredCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
const struct ble_gatt_chr *chr, void *arg) {
auto client = static_cast<NimbleController*>(arg);
return client->OnANSCharacteristicDiscoveryEvent(conn_handle, error, chr);
}
int CurrentTimeReadCallback(uint16_t conn_handle, const struct ble_gatt_error *error,
struct ble_gatt_attr *attr, void *arg) {
auto client = static_cast<NimbleController*>(arg);
return client->OnCurrentTimeReadResult(conn_handle, error, attr);
}
int AlertNotificationDescriptorDiscoveryEventCallback(uint16_t conn_handle,
const struct ble_gatt_error *error,
uint16_t chr_val_handle,
const struct ble_gatt_dsc *dsc,
void *arg) {
auto client = static_cast<NimbleController*>(arg);
return client->OnANSDescriptorDiscoveryEventCallback(conn_handle, error, chr_val_handle, dsc);
}
void NimbleController::Init() { void NimbleController::Init() {
while (!ble_hs_synced()) {} while (!ble_hs_synced()) {}
@ -203,9 +231,61 @@ int NimbleController::OnGAPEvent(ble_gap_event *event) {
} }
int NimbleController::OnDiscoveryEvent(uint16_t i, const ble_gatt_error *error, const ble_gatt_svc *service) { int NimbleController::OnDiscoveryEvent(uint16_t i, const ble_gatt_error *error, const ble_gatt_svc *service) {
alertNotificationClient.OnDiscoveryEvent(i, error, service); if(service == nullptr && error->status == BLE_HS_EDONE) {
// currentTimeClient.OnDiscoveryEvent(i, error, service); NRF_LOG_INFO("Service Discovery complete");
if(currentTimeClient.IsDiscovered()) {
ble_gattc_disc_all_chrs(connectionHandle, currentTimeClient.StartHandle(), currentTimeClient.EndHandle(),
CurrentTimeCharacteristicDiscoveredCallback, this);
} else if(alertNotificationClient.IsDiscovered()) {
ble_gattc_disc_all_chrs(connectionHandle, alertNotificationClient.StartHandle(), alertNotificationClient.EndHandle(),
AlertNotificationCharacteristicDiscoveredCallback, this);
}
return 0; return 0;
}
alertNotificationClient.OnDiscoveryEvent(i, error, service);
currentTimeClient.OnDiscoveryEvent(i, error, service);
return 0;
}
int NimbleController::OnCTSCharacteristicDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic) {
if(characteristic == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("CTS characteristic Discovery complete");
ble_gattc_read(connectionHandle, currentTimeClient.CurrentTimeHandle(), CurrentTimeReadCallback, this);
return 0;
}
return currentTimeClient.OnCharacteristicDiscoveryEvent(connectionHandle, error, characteristic);
}
int NimbleController::OnANSCharacteristicDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic) {
if(characteristic == nullptr && error->status == BLE_HS_EDONE) {
NRF_LOG_INFO("ANS characteristic Discovery complete");
ble_gattc_disc_all_dscs(connectionHandle,
alertNotificationClient.NewAlerthandle(), alertNotificationClient.EndHandle(),
AlertNotificationDescriptorDiscoveryEventCallback, this);
return 0;
}
return alertNotificationClient.OnCharacteristicsDiscoveryEvent(connectionHandle, error, characteristic);
}
int NimbleController::OnCurrentTimeReadResult(uint16_t connectionHandle, const ble_gatt_error *error, ble_gatt_attr *attribute) {
currentTimeClient.OnCurrentTimeReadResult(connectionHandle, error, attribute);
if (alertNotificationClient.IsDiscovered()) {
ble_gattc_disc_all_chrs(connectionHandle, alertNotificationClient.StartHandle(),
alertNotificationClient.EndHandle(),
AlertNotificationCharacteristicDiscoveredCallback, this);
}
return 0;
}
int NimbleController::OnANSDescriptorDiscoveryEventCallback(uint16_t connectionHandle, const ble_gatt_error *error,
uint16_t characteristicValueHandle,
const ble_gatt_dsc *descriptor) {
return alertNotificationClient.OnDescriptorDiscoveryEventCallback(connectionHandle, error, characteristicValueHandle, descriptor);
} }

8
src/Components/Ble/NimbleController.h
View file

@ -10,6 +10,7 @@ namespace Pinetime {
namespace Controllers { namespace Controllers {
class DateTime; class DateTime;
class NimbleController { class NimbleController {
public: public:
NimbleController(Pinetime::System::SystemTask& systemTask, DateTime& dateTimeController, Pinetime::Controllers::NotificationManager& notificationManager); NimbleController(Pinetime::System::SystemTask& systemTask, DateTime& dateTimeController, Pinetime::Controllers::NotificationManager& notificationManager);
void Init(); void Init();
@ -17,6 +18,13 @@ namespace Pinetime {
int OnGAPEvent(ble_gap_event *event); int OnGAPEvent(ble_gap_event *event);
int OnDiscoveryEvent(uint16_t i, const ble_gatt_error *pError, const ble_gatt_svc *pSvc); int OnDiscoveryEvent(uint16_t i, const ble_gatt_error *pError, const ble_gatt_svc *pSvc);
int OnCTSCharacteristicDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic);
int OnANSCharacteristicDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error *error,
const ble_gatt_chr *characteristic);
int OnCurrentTimeReadResult(uint16_t connectionHandle, const ble_gatt_error *error, ble_gatt_attr *attribute);
int OnANSDescriptorDiscoveryEventCallback(uint16_t connectionHandle, const ble_gatt_error *error,
uint16_t characteristicValueHandle, const ble_gatt_dsc *descriptor);
private: private:
static constexpr char* deviceName = "Pinetime-JF"; static constexpr char* deviceName = "Pinetime-JF";
Pinetime::System::SystemTask& systemTask; Pinetime::System::SystemTask& systemTask;