summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--alsa-binding/Alsa-RegEvt.c273
1 files changed, 271 insertions, 2 deletions
diff --git a/alsa-binding/Alsa-RegEvt.c b/alsa-binding/Alsa-RegEvt.c
index c9ac5f1..28b66b1 100644
--- a/alsa-binding/Alsa-RegEvt.c
+++ b/alsa-binding/Alsa-RegEvt.c
@@ -18,14 +18,35 @@
#define _GNU_SOURCE // needed for vasprintf
+#include <sys/inotify.h>
+
+#include <afb-timer.h>
+
#include "Alsa-ApiHat.h"
+// Defines for inotify events
+#define INOTIFY_EVENT_SIZE (sizeof(struct inotify_event))
+#define INOTIFY_EVENT_BUF_LEN (1024 * (INOTIFY_EVENT_SIZE + 16))
+
+#define DIR_TO_WATCH "/dev/snd/by-path"
+
#ifndef MAX_SND_HAL
#define MAX_SND_HAL 10
#endif
-// generic sndctrl event handle hook to event callback when pooling
+typedef enum {
+ SUBSCRIPTION_CARD_ADDED_EVENTS = 0,
+ SUBSCRIPTION_CARD_REMOVED_EVENTS = 1
+} SubscriptionCardEventTypeT;
+
+typedef struct {
+ int fd;
+ int wd;
+ sd_event_source *src;
+ afb_event_t afbevt;
+} sndCardEvtHandleT;
+// generic sndctrl event handle hook to event callback when pooling
typedef struct {
struct pollfd pfds;
sd_event_source *src;
@@ -35,14 +56,23 @@ typedef struct {
} ctrlEvtHandleT;
typedef struct {
+ int available;
ctrlEvtHandleT *evtHandle;
} sndHandleT;
typedef struct {
sndHandleT sndHandles[MAX_SND_CARD];
+ sndCardEvtHandleT *cardAdded;
+ sndCardEvtHandleT *cardRemoved;
+ afb_api_t apiHandle;
} sndCardsT;
typedef struct {
+ char *createdFileName;
+ sndCardsT *sndCards;
+} sndCardCardFileEventHandleT;
+
+typedef struct {
int cardid;
char *devid;
char *apiprefix;
@@ -88,6 +118,144 @@ OnErrorExit:
return NULL;
}
+STATIC void updateSelectedAlsaCardsAvailabilityAndFireEvents(sndCardsT *sndCards, int first, int last) {
+ int idx, available;
+ char *cardId;
+
+ if (first < 0 || first >= MAX_SND_CARD)
+ return;
+
+ if (last < 0 || last >= MAX_SND_CARD)
+ return;
+
+ if (last < first)
+ return;
+
+ for (idx = first; idx < (last + 1); idx++) {
+ available = snd_card_load(idx);
+ if (available && ! sndCards->sndHandles[idx].available) {
+ sndCards->sndHandles[idx].available = 1;
+
+ if (sndCards->cardAdded)
+ afb_event_push(sndCards->cardAdded->afbevt, getCardInfo(idx));
+ }
+ else if (! available && sndCards->sndHandles[idx].available) {
+ sndCards->sndHandles[idx].available = 0;
+
+ if (sndCards->cardRemoved && (asprintf(&cardId, "hw:%i", idx) > 0))
+ afb_event_push(sndCards->cardRemoved->afbevt, json_object_new_string(cardId));
+
+ if (sndCards->sndHandles[idx].evtHandle) {
+ sd_event_source_unref(sndCards->sndHandles[idx].evtHandle->src);
+ afb_event_unref(sndCards->sndHandles[idx].evtHandle->afbevt);
+ snd_ctl_close(sndCards->sndHandles[idx].evtHandle->ctlDev);
+ free(sndCards->sndHandles[idx].evtHandle);
+ sndCards->sndHandles[idx].evtHandle = NULL;
+ }
+ }
+ }
+}
+
+STATIC void updateAllAlsaCardsAvailabilityAndFireEvents(sndCardsT *sndCards) {
+ updateSelectedAlsaCardsAvailabilityAndFireEvents(sndCards, 0, (MAX_SND_CARD - 1));
+}
+
+// This routine is called every few microseconds to verify when the newly created sound card file will be openable (using timer event firing)
+STATIC int sndCardTimerForCreatedFileCB(TimerHandleT *context) {
+ int createdFileCardNb;
+
+ sndCardCardFileEventHandleT *createdFileHandle = (sndCardCardFileEventHandleT *) context->context;
+
+ createdFileCardNb = getCardNbFromCardPath(createdFileHandle->createdFileName);
+ if(createdFileCardNb < 0) {
+ AFB_ERROR("Error %i happened when tried to get created card name file '%s' card nb",
+ createdFileCardNb,
+ createdFileHandle->createdFileName);
+ return -1;
+ }
+
+ updateSelectedAlsaCardsAvailabilityAndFireEvents(createdFileHandle->sndCards, createdFileCardNb, createdFileCardNb);
+
+ free(createdFileHandle->createdFileName);
+ free(createdFileHandle);
+
+ context->count = 1;
+
+ return 1;
+}
+
+// This routine is called when sound cards are added/removed (when inotify '/dev/snd/by-path' events are fired)
+STATIC int sndCardEventCB(sd_event_source* src, int fd, uint32_t revents, void* userData) {
+ ssize_t length, i = 0;
+ char buffer[INOTIFY_EVENT_BUF_LEN];
+ char *createdFile;
+
+ struct inotify_event *event;
+
+ sndCardCardFileEventHandleT *createdFileHandle;
+ TimerHandleT *createdFileTimerHandle;
+
+ sndCardsT *sndCards = (sndCardsT *) userData;
+
+ if (revents & EPOLLERR) {
+ AFB_ERROR("An error has been send by event loop polling, prevent new errors to be fired by deleting event src");
+
+ sd_event_source_unref(src);
+
+ afb_event_unref(sndCards->cardAdded->afbevt);
+ afb_event_unref(sndCards->cardRemoved->afbevt);
+
+ inotify_rm_watch(sndCards->cardAdded->fd, sndCards->cardAdded->wd);
+ close(sndCards->cardAdded->fd);
+
+ free(sndCards->cardAdded);
+ free(sndCards->cardRemoved);
+
+ sndCards->cardAdded = NULL;
+ sndCards->cardRemoved = NULL;
+
+ goto OnErrorExit;
+ }
+
+ if (revents & EPOLLIN) {
+ length = read(fd, buffer, INOTIFY_EVENT_BUF_LEN);
+ if (length < 0) {
+ AFB_ERROR("Nothing read using inotify");
+ goto OnErrorExit;
+ }
+
+ while (i < length) {
+ event = (struct inotify_event *) &buffer[i];
+
+ if(event->len &&
+ (event->mask & IN_CREATE) &&
+ ! (event->mask & IN_ISDIR) &&
+ (asprintf(&createdFile, "%s/%s", DIR_TO_WATCH, event->name) > 0)) {
+ createdFileHandle = calloc(1, sizeof(sndCardCardFileEventHandleT));
+ createdFileHandle->createdFileName = strdup(createdFile);
+ createdFileHandle->sndCards = sndCards;
+
+ createdFileTimerHandle = calloc(1, sizeof(TimerHandleT));
+
+ createdFileTimerHandle->uid = "sound card file creation delay";
+ createdFileTimerHandle->count = 10;
+ createdFileTimerHandle->delay = 2;
+
+ TimerEvtStart(sndCards->apiHandle, createdFileTimerHandle, sndCardTimerForCreatedFileCB, (void *) createdFileHandle);
+ }
+
+ if(event->len && (event->mask & IN_DELETE) && ! (event->mask & IN_ISDIR))
+ updateAllAlsaCardsAvailabilityAndFireEvents(sndCards);
+
+ i += INOTIFY_EVENT_SIZE + event->len;
+ }
+ }
+
+ return 0;
+
+OnErrorExit:
+ return -1;
+}
// This routine is called when ALSA control events are fired
STATIC int sndCtlEventCB(sd_event_source* src, int fd, uint32_t revents, void* userData) {
@@ -173,6 +341,101 @@ OnErrorExit:
return -1;
}
+// Subscribe to each time a sound card is added/removed (using inotify '/dev/snd/by-path' events)
+STATIC afb_event_t alsaEvtSubscribeSoundCardEvent(afb_req_t request, sndCardsT *sndCards, SubscriptionCardEventTypeT subscriptionType) {
+ int fd = -1, wd = -1, err;
+
+ // Update card list
+ updateAllAlsaCardsAvailabilityAndFireEvents(sndCards);
+
+ if (! sndCards->cardAdded && ! sndCards->cardRemoved) {
+ fd = inotify_init();
+ if (fd < 0) {
+ afb_req_fail_f(request, "inotify-init", "Error %s happened while getting file descriptor for inotify", strerror(errno));
+ goto OnErrorExit;
+ }
+
+ wd = inotify_add_watch(fd, DIR_TO_WATCH, IN_CREATE | IN_DELETE);
+ if (wd < 0) {
+ afb_req_fail_f(request,
+ "inotify-watch",
+ "Error %s happened while setting watchdog on '%s' directory using inotify",
+ strerror(errno),
+ DIR_TO_WATCH);
+ goto OnErrorExit;
+ }
+
+ sndCards->cardAdded = malloc(sizeof (sndCardEvtHandleT));
+ if (! sndCards->cardAdded) {
+ afb_req_fail(request, "card-added-event", "Error while allocating card added event handle");
+ goto OnErrorExit;
+ }
+
+ sndCards->cardRemoved = malloc(sizeof (sndCardEvtHandleT));
+ if (! sndCards->cardRemoved) {
+ afb_req_fail(request, "card-removed-event", "Error while allocating card removed event handle");
+ goto OnErrorExit;
+ }
+
+ sndCards->cardAdded->fd = fd;
+ sndCards->cardRemoved->fd = fd;
+
+ sndCards->cardAdded->wd = wd;
+ sndCards->cardRemoved->wd = wd;
+
+ sndCards->cardAdded->afbevt = afb_daemon_make_event("soundcard-added");
+ if (!afb_event_is_valid(sndCards->cardAdded->afbevt)) {
+ afb_req_fail_f(request, "register-event", "Cannot register new binder event name=%s", "soundcard-added");
+ goto OnErrorExit;
+ }
+
+ sndCards->cardRemoved->afbevt = afb_daemon_make_event("soundcard-removed");
+ if (!afb_event_is_valid(sndCards->cardRemoved->afbevt)) {
+ afb_req_fail_f(request, "register-event", "Cannot register new binder event name=%s", "soundcard-added");
+ goto OnErrorExit;
+ }
+
+ // register sound event to binder main loop
+ err = sd_event_add_io(afb_daemon_get_event_loop(),
+ &sndCards->cardAdded->src,
+ fd,
+ EPOLLIN,
+ sndCardEventCB,
+ sndCards);
+ if (err < 0) {
+ afb_req_fail_f(request, "register-mainloop", "Cannot hook sound card events to mainloop err=%d", err);
+ goto OnErrorExit;
+ }
+
+ sndCards->cardRemoved->src = sndCards->cardAdded->src;
+ }
+
+ if(subscriptionType == SUBSCRIPTION_CARD_ADDED_EVENTS)
+ return sndCards->cardAdded->afbevt;
+
+ if(subscriptionType == SUBSCRIPTION_CARD_REMOVED_EVENTS)
+ return sndCards->cardRemoved->afbevt;
+
+ return NULL;
+
+OnErrorExit:
+ if(afb_event_is_valid(sndCards->cardRemoved->afbevt))
+ afb_event_unref(sndCards->cardRemoved->afbevt);
+
+ if(afb_event_is_valid(sndCards->cardAdded->afbevt))
+ afb_event_unref(sndCards->cardAdded->afbevt);
+
+ free(sndCards->cardRemoved);
+ free(sndCards->cardAdded);
+
+ if (wd != -1)
+ inotify_rm_watch(fd, wd);
+
+ if (fd != -1)
+ close(fd);
+
+ return NULL;
+}
// Subscribe to every Alsa CtlEvent send by a given board
STATIC afb_event_t alsaEvtSubscribeAlsaControlEvent(afb_req_t request, sndCardsT *sndCards, queryValuesT *queryValues) {
@@ -263,12 +526,18 @@ PUBLIC void alsaEvtSubcribe(afb_req_t request) {
if(! sndCards) {
sndCards = calloc(1, sizeof(sndCardsT));
+ sndCards->apiHandle = afb_req_get_api(request);
}
queryJ = alsaCheckQuery(request, &queryValues);
if (!queryJ) return;
- eventToSubscribe = alsaEvtSubscribeAlsaControlEvent(request, sndCards, &queryValues);
+ if(! strcasecmp(queryValues.devid, "added"))
+ eventToSubscribe = alsaEvtSubscribeSoundCardEvent(request, sndCards, SUBSCRIPTION_CARD_ADDED_EVENTS);
+ else if(! strcasecmp(queryValues.devid, "removed"))
+ eventToSubscribe = alsaEvtSubscribeSoundCardEvent(request, sndCards, SUBSCRIPTION_CARD_REMOVED_EVENTS);
+ else
+ eventToSubscribe = alsaEvtSubscribeAlsaControlEvent(request, sndCards, &queryValues);
if(! eventToSubscribe)
return;