mirror of
https://github.com/ByteWelder/Tactility.git
synced 2026-08-18 16:05:05 +00:00
116 lines
3.6 KiB
C++
116 lines
3.6 KiB
C++
// SPDX-License-Identifier: Apache-2.0
|
|
#include <app/event.h>
|
|
|
|
#include <tactility/concurrent/mutex.h>
|
|
#include <tactility/time.h>
|
|
|
|
/**
|
|
* Intrusive singly-linked list of subscriptions, keyed by app_instance_id.
|
|
* Guarded by a single coarse-grained mutex, notifying a subscriber here never invokes caller code
|
|
* (just a struct copy and an xTaskNotifyGive), so there is no reentrancy concern requiring a snapshot-then-unlock dance.
|
|
*/
|
|
static AppEventSubscription* subscriptions = nullptr;
|
|
|
|
struct AppEventMutex {
|
|
Mutex handle {};
|
|
AppEventMutex() { mutex_construct(&handle); }
|
|
~AppEventMutex() { mutex_destruct(&handle); }
|
|
};
|
|
|
|
static AppEventMutex subscriptions_mutex;
|
|
|
|
extern "C" {
|
|
|
|
error_t app_event_subscribe(AppEventSubscription* sub) {
|
|
sub->task = xTaskGetCurrentTaskHandle();
|
|
sub->head = 0;
|
|
sub->count = 0;
|
|
|
|
mutex_lock(&subscriptions_mutex.handle);
|
|
sub->next = subscriptions;
|
|
subscriptions = sub;
|
|
mutex_unlock(&subscriptions_mutex.handle);
|
|
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
error_t app_event_unsubscribe(AppEventSubscription* sub) {
|
|
error_t result = ERROR_NOT_FOUND;
|
|
|
|
mutex_lock(&subscriptions_mutex.handle);
|
|
for (AppEventSubscription** link = &subscriptions; *link != nullptr; link = &(*link)->next) {
|
|
if (*link == sub) {
|
|
*link = sub->next;
|
|
result = ERROR_NONE;
|
|
break;
|
|
}
|
|
}
|
|
mutex_unlock(&subscriptions_mutex.handle);
|
|
|
|
return result;
|
|
}
|
|
|
|
error_t app_event_emit(uint32_t app_instance_id, const AppEvent* event) {
|
|
AppEvent stamped_event = *event;
|
|
stamped_event.timestamp = get_micros_since_boot();
|
|
|
|
error_t result = ERROR_NOT_FOUND;
|
|
|
|
mutex_lock(&subscriptions_mutex.handle);
|
|
for (AppEventSubscription* sub = subscriptions; sub != nullptr; sub = sub->next) {
|
|
if (sub->app_instance_id != app_instance_id) {
|
|
continue;
|
|
}
|
|
|
|
if (sub->count >= APP_EVENT_QUEUE_CAPACITY) {
|
|
result = ERROR_RESOURCE;
|
|
continue;
|
|
}
|
|
|
|
uint8_t tail = (sub->head + sub->count) % APP_EVENT_QUEUE_CAPACITY;
|
|
sub->queue[tail] = stamped_event;
|
|
sub->count++;
|
|
if (result != ERROR_RESOURCE) {
|
|
result = ERROR_NONE;
|
|
}
|
|
xTaskNotifyGive(sub->task);
|
|
}
|
|
mutex_unlock(&subscriptions_mutex.handle);
|
|
|
|
return result;
|
|
}
|
|
|
|
static bool try_pop(AppEventSubscription* sub, AppEvent* out_event) {
|
|
mutex_lock(&subscriptions_mutex.handle);
|
|
bool has_event = sub->count > 0;
|
|
if (has_event) {
|
|
*out_event = sub->queue[sub->head];
|
|
sub->head = (sub->head + 1) % APP_EVENT_QUEUE_CAPACITY;
|
|
sub->count--;
|
|
}
|
|
mutex_unlock(&subscriptions_mutex.handle);
|
|
return has_event;
|
|
}
|
|
|
|
error_t app_event_await(AppEventSubscription* sub, AppEvent* out_event, TickType_t timeout) {
|
|
if (try_pop(sub, out_event)) {
|
|
// Drain any notification credit this (or an earlier) push accumulated on this task's
|
|
// FreeRTOS notification value: each app_event_emit() calls xTaskNotifyGive() regardless
|
|
// of whether the consumer takes this fast path or the blocking path below, so without
|
|
// this the credit would carry over and cause a future ulTaskNotifyTake() below to
|
|
// return immediately for a notification that was already accounted for here.
|
|
ulTaskNotifyTake(pdTRUE, 0);
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
if (ulTaskNotifyTake(pdTRUE, timeout) == 0) {
|
|
return ERROR_TIMEOUT;
|
|
}
|
|
|
|
// Single-consumer by design (one task per subscription), so a wakeup implies the event
|
|
// this call was notified for is still there for us to pop.
|
|
return try_pop(sub, out_event) ? ERROR_NONE : ERROR_TIMEOUT;
|
|
}
|
|
|
|
} // extern "C"
|