X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=plugins%2Fradio%2Fradio-api.c;h=ea17eb511827eb20ae63edd34e41f5e34525801e;hb=8ca3d16606a99ef91d01a623dbe5ce1331688953;hp=a3e230b1a38c737a9b71ec83554ec56ae871dceb;hpb=e2d857c5f05f84de8e2642ff9272a80ea9e5fed6;p=src%2Fapp-framework-binder.git
diff --git a/plugins/radio/radio-api.c b/plugins/radio/radio-api.c
index a3e230b1..ea17eb51 100644
--- a/plugins/radio/radio-api.c
+++ b/plugins/radio/radio-api.c
@@ -16,629 +16,317 @@
* along with this program. If not, see .
*/
+#include "radio-api.h"
-#include "local-def.h"
+/* ********************************************************
-/* -------------- RADIO DEFINITIONS ------------------ */
+ FULUP integration proposal with client session context
-#include
-#include
-#include
+ ******************************************************** */
-#define pthread_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m)
-#define pthread_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m)
-#define BUF_LEN 16*16384
+/* ------ LOCAL HELPER FUNCTIONS --------- */
-typedef enum { FM, AM } Mode;
-typedef struct dongle_ctx dongle_ctx;
-typedef struct demod_ctx demod_ctx;
-typedef struct output_ctx output_ctx;
-typedef struct dev_ctx dev_ctx_T;
+/* detect new radio devices */
+STATIC void updateRadioDevList(pluginHandleT *handle) {
-struct dongle_ctx {
- pthread_t thr;
- unsigned char thr_finished;
- uint16_t buf[BUF_LEN];
- uint32_t buf_len;
-};
+ int idx;
-struct demod_ctx {
- pthread_t thr;
- unsigned char thr_finished;
- pthread_rwlock_t lck;
- pthread_cond_t ok;
- pthread_mutex_t ok_m;
- int pre_r, pre_j, now_r, now_j, index;
- int pre_index, now_index;
- int16_t buf[BUF_LEN];
- int buf_len;
- int16_t res[BUF_LEN];
- int res_len;
-};
+ // loop on existing radio if any
+ for (idx = 0; idx < _radio_dev_count(); idx++) {
+ if (idx == MAX_RADIO) break;
+ handle->radios[idx] = calloc(1, sizeof(radioDevT)); /* use calloc to set used to FALSE */
+ handle->radios[idx]->name = (char *) _radio_dev_name(idx);
+ }
+ handle->devCount = _radio_dev_count();
+}
-struct output_ctx {
- pthread_t thr;
- unsigned char thr_finished;
- pthread_rwlock_t lck;
- pthread_cond_t ok;
- pthread_mutex_t ok_m;
- int16_t buf[BUF_LEN];
- int buf_len;
-};
+/* global plugin context creation ; at loading time [radio devices might not be visible] */
+STATIC pluginHandleT* initRadioPlugin() {
-struct dev_ctx {
- int used; // radio is free ???
- rtlsdr_dev_t* dev;
- Mode mode;
- float freq;
- unsigned char mute;
- unsigned char should_run;
- /* thread contexts */
- dongle_ctx *dongle;
- demod_ctx *demod;
- output_ctx *output;
-};
+ pluginHandleT *handle;
+ handle = calloc (1, sizeof(pluginHandleT));
+ updateRadioDevList (handle);
-STATIC void* _dongle_thread_fn (void *);
-STATIC void* _demod_thread_fn (void *);
-STATIC void* _output_thread_fn (void *);
-STATIC unsigned int _radio_dev_count (void);
-STATIC const char* _radio_dev_name (unsigned int);
-STATIC unsigned char _radio_dev_init (struct dev_ctx *, unsigned int);
-STATIC unsigned char _radio_dev_free (struct dev_ctx *);
-STATIC void _radio_apply_params (struct dev_ctx *);
-STATIC void _radio_start_threads (struct dev_ctx *);
-STATIC void _radio_stop_threads (struct dev_ctx *);
-
-static unsigned int init_dev_count;
-static struct dev_ctx **dev_ctx;
-
-/* ------------- RADIO IMPLEMENTATION ----------------- */
-
-
-// Radio initialization should be done only when user start the radio and not at plugin initialization
-// Making this call too early would impose to restart the binder to detect a radio.
-STATIC void initRadio () {
-
- init_dev_count = _radio_dev_count();
- int i;
-
- dev_ctx = (dev_ctx_T**) malloc(init_dev_count * sizeof(dev_ctx_T));
-
- for (i = 0; i < init_dev_count; i++) {
- dev_ctx[i] = (dev_ctx_T*) malloc(sizeof(dev_ctx_T));
- dev_ctx[i]->dev = NULL;
- dev_ctx[i]->mode = FM;
- dev_ctx[i]->freq = 100.0;
- dev_ctx[i]->mute = 0;
- dev_ctx[i]->should_run = 0;
- dev_ctx[i]->dongle = NULL;
- dev_ctx[i]->demod = NULL;
- dev_ctx[i]->output = NULL;
- _radio_dev_init(dev_ctx[i], i);
- }
+ return handle;
}
-STATIC void radio_off () {
- int i;
+/* private client context creation ; default values */
+STATIC radioCtxHandleT* initRadioCtx () {
- for (i = 0; i < init_dev_count; i++) {
- _radio_dev_free(dev_ctx[i]);
- free(dev_ctx[i]);
- }
- free(dev_ctx);
-}
+ radioCtxHandleT *ctx;
-STATIC void radio_set_mode (dev_ctx_T *dev_ctx, Mode mode) {
- dev_ctx->mode = mode;
- _radio_apply_params(dev_ctx);
-}
+ ctx = malloc (sizeof(radioCtxHandleT));
+ ctx->radio = NULL;
+ ctx->idx = -1;
+ ctx->mode = FM;
+ ctx->freq = 100.0;
+ ctx->mute = 0;
+ ctx->is_playing = 0;
-STATIC void radio_set_freq (dev_ctx_T *dev_ctx, float freq) {
- dev_ctx->freq = freq;
- _radio_apply_params(dev_ctx);
+ return ctx;
}
-STATIC void radio_set_mute (dev_ctx_T *dev_ctx, unsigned char mute) {
- dev_ctx->mute = mute;
- _radio_apply_params(dev_ctx);
-}
+/* reserve a radio device for requesting client, power it on */
+STATIC AFB_error reserveRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
+ int idx;
-STATIC void radio_play (dev_ctx_T *dev_ctx) {
- _radio_start_threads(dev_ctx);
-}
+ /* loop on all devices, find an unused one */
+ for (idx = 0; idx < _radio_dev_count(); idx++) {
+ if (idx == MAX_RADIO) break;
+ if (handle->radios[idx]->used == FALSE) goto found_radio; /* found one */
+ }
+ return AFB_FAIL;
-STATIC void radio_stop (dev_ctx_T *dev_ctx) {
- _radio_stop_threads(dev_ctx);
-}
+ found_radio:
+ /* try to power it on, passing client context info such as frequency... */
+ _radio_on (idx, ctx);
+ /* TODO : try to re-iterate from the next ones if it failed ! */
- /* --- HELPER FUNCTIONS --- */
+ /* globally mark it as reserved */
+ handle->radios[idx]->used = TRUE;
-STATIC unsigned int _radio_dev_count () {
- return rtlsdr_get_device_count();
-}
+ /* store relevant info to client context (direct pointer, index) */
+ ctx->radio = handle->radios[idx];
+ ctx->idx = idx;
-STATIC const char* _radio_dev_name (unsigned int num) {
- return rtlsdr_get_device_name(num);
+ return AFB_SUCCESS;
}
-STATIC unsigned char _radio_dev_init (dev_ctx_T *dev_ctx, unsigned int num) {
- rtlsdr_dev_t *dev = dev_ctx->dev;
-
- if (rtlsdr_open(&dev, num) < 0)
- return 0;
+/* free a radio device from requesting client, power it off */
+STATIC AFB_error releaseRadio (pluginHandleT *handle, radioCtxHandleT *ctx) {
- rtlsdr_set_tuner_gain_mode(dev, 0);
+ /* stop playing if it was doing this (blocks otherwise) */
+ if (ctx->is_playing) {
+ ctx->is_playing = 0;
+ _radio_stop (ctx->idx);
+ }
- if (rtlsdr_reset_buffer(dev) < 0)
- return 0;
+ /* power it off */
+ _radio_off (ctx->idx);
- dev_ctx->dev = dev;
+ /* globally mark it as free */
+ handle->radios[ctx->idx]->used = FALSE;
- _radio_apply_params(dev_ctx);
+ /* clean client context */
+ ctx->radio = NULL;
+ ctx->idx = -1;
- return 1;
+ return AFB_SUCCESS;
}
-STATIC unsigned char _radio_dev_free (dev_ctx_T *dev_ctx) {
- rtlsdr_dev_t *dev = dev_ctx->dev;
+/* called when client session dies [e.g. client quits for more than 15mns] */
+STATIC void freeRadio (void *context, void *handle) {
- if (rtlsdr_close(dev) < 0)
- return 0;
- dev = NULL;
-
- dev_ctx->dev = dev;
-
- return 1;
+ releaseRadio (handle, context);
+ free (context);
}
-STATIC void _radio_apply_params (dev_ctx_T *dev_ctx) {
- rtlsdr_dev_t *dev = dev_ctx->dev;
- Mode mode = dev_ctx->mode;
- float freq = dev_ctx->freq;
- int rate;
- freq *= 1000000;
- rate = ((1000000 / 200000) + 1) * 200000;
+/* ------ PUBLIC PLUGIN FUNCTIONS --------- */
- if (mode == FM)
- freq += 16000;
- freq += rate / 4;
+STATIC json_object* init (AFB_request *request) { /* AFB_SESSION_CHECK */
- rtlsdr_set_center_freq(dev, freq);
- rtlsdr_set_sample_rate(dev, rate);
-
- dev_ctx->dev = dev;
-}
+ json_object *jresp;
-STATIC void _radio_start_threads (dev_ctx_T *dev_ctx) {
- rtlsdr_dev_t *dev = dev_ctx->dev;
- dev_ctx->dongle = (dongle_ctx*) malloc(sizeof(dongle_ctx));
- dev_ctx->demod = (demod_ctx*) malloc(sizeof(demod_ctx));
- dev_ctx->output = (output_ctx*) malloc(sizeof(output_ctx));
-
- dongle_ctx *dongle = dev_ctx->dongle;
- demod_ctx *demod = dev_ctx->demod;
- output_ctx *output = dev_ctx->output;
-
- pthread_rwlock_init(&demod->lck, NULL);
- pthread_cond_init(&demod->ok, NULL);
- pthread_mutex_init(&demod->ok_m, NULL);
- pthread_rwlock_init(&output->lck, NULL);
- pthread_cond_init(&output->ok, NULL);
- pthread_mutex_init(&output->ok_m, NULL);
-
- dev_ctx->should_run = 1;
-
- /* dongle thread */
- dongle->thr_finished = 0;
- pthread_create(&dongle->thr, NULL, _dongle_thread_fn, (void*)dev_ctx);
-
- /* demod thread */
- demod->pre_r = demod->pre_j = 0;
- demod->now_r = demod->now_j = 0;
- demod->index = demod->pre_index = demod->now_index = 0;
- demod->thr_finished = 0;
- pthread_create(&demod->thr, NULL, _demod_thread_fn, (void*)dev_ctx);
-
- /* output thread */
- output->thr_finished = 0;
- pthread_create(&output->thr, NULL, _output_thread_fn, (void*)dev_ctx);
-}
+ /* create a private client context */
+ if (!request->context)
+ request->context = initRadioCtx();
-STATIC void _radio_stop_threads (dev_ctx_T *dev_ctx) {
- rtlsdr_dev_t *dev = dev_ctx->dev;
- dongle_ctx *dongle = dev_ctx->dongle;
- demod_ctx *demod = dev_ctx->demod;
- output_ctx *output = dev_ctx->output;
-
- if (!dongle || !demod || !output)
- return;
-
- /* stop each "while" loop in threads */
- dev_ctx->should_run = 0;
-
- rtlsdr_cancel_async(dev);
- pthread_signal(&demod->ok, &demod->ok_m);
- pthread_signal(&output->ok, &output->ok_m);
-
- while (!dongle->thr_finished ||
- !demod->thr_finished ||
- !output->thr_finished)
- usleep(100000);
-
- pthread_join(dongle->thr, NULL);
- pthread_join(demod->thr, NULL);
- pthread_join(output->thr, NULL);
- pthread_rwlock_destroy(&demod->lck);
- pthread_cond_destroy(&demod->ok);
- pthread_mutex_destroy(&demod->ok_m);
- pthread_rwlock_destroy(&output->lck);
- pthread_cond_destroy(&output->ok);
- pthread_mutex_destroy(&output->ok_m);
-
- free(dongle); dev_ctx->dongle = NULL;
- free(demod); dev_ctx->demod = NULL;
- free(output); dev_ctx->output = NULL;
+ jresp = json_object_new_object();
+ json_object_object_add(jresp, "info", json_object_new_string ("Radio initialized"));
+ return jresp;
}
- /* ---- LOCAL THREADED FUNCTIONS ---- */
-
-STATIC void _rtlsdr_callback (unsigned char *buf, uint32_t len, void *ctx) {
- dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
- dongle_ctx *dongle = dev_ctx->dongle;
- demod_ctx *demod = dev_ctx->demod;
- unsigned char tmp;
- int i;
+STATIC json_object* power (AFB_request *request) { /* AFB_SESSION_CHECK */
- if (!dev_ctx->should_run)
- return;
-
- /* rotate 90° */
- for (i = 0; i < (int)len; i += 8) {
- tmp = 255 - buf[i+3];
- buf[i+3] = buf[i+2];
- buf[i+2] = tmp;
+ pluginHandleT *handle = (pluginHandleT*)request->handle;
+ radioCtxHandleT *ctx = (radioCtxHandleT*)request->context;
+ const char *value = getQueryValue (request, "value");
+ json_object *jresp;
- buf[i+4] = 255 - buf[i+4];
- buf[i+5] = 255 - buf[i+5];
+ /* no "?value=" parameter : return current state */
+ if (!value) {
+ jresp = json_object_new_object();
+ ctx->radio ?
+ json_object_object_add (jresp, "power", json_object_new_string ("on"))
+ : json_object_object_add (jresp, "power", json_object_new_string ("off"));
+ }
- tmp = 255 - buf[i+6];
- buf[i+6] = buf[i+7];
- buf[i+7] = tmp;
+ /* "?value=" parameter is "1" or "true" */
+ else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
+ if (!ctx->radio) {
+ if (reserveRadio (handle, ctx) == AFB_FAIL) {
+ request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
+ return (jsonNewMessage (AFB_FAIL, "No more radio devices available"));
+ }
+ }
+ jresp = json_object_new_object();
+ json_object_object_add (jresp, "power", json_object_new_string ("on"));
}
- /* write data */
- for (i = 0; i < (int)len; i++)
- dongle->buf[i] = (int16_t)buf[i] - 127;
+ /* "?value=" parameter is "0" or "false" */
+ else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
+ if (ctx->radio) {
+ if (releaseRadio (handle, ctx) == AFB_FAIL) {
+ request->errcode = MHD_HTTP_SERVICE_UNAVAILABLE;
+ return (jsonNewMessage (AFB_FAIL, "Unable to release radio device"));
+ }
+ }
+ jresp = json_object_new_object();
+ json_object_object_add (jresp, "power", json_object_new_string ("off"));
+ }
+ else
+ jresp = NULL;
- /* lock demod thread, write to it, unlock */
- pthread_rwlock_wrlock(&demod->lck);
- memcpy(demod->buf, dongle->buf, 2 * len);
- demod->buf_len = len;
- pthread_rwlock_unlock(&demod->lck);
- pthread_signal(&demod->ok, &demod->ok_m);
+ return jresp;
}
- /**/
-STATIC void* _dongle_thread_fn (void *ctx) {
- dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
- dongle_ctx *dongle = dev_ctx->dongle;
- rtlsdr_read_async(dev_ctx->dev, _rtlsdr_callback, dev_ctx, 0, 0);
+STATIC json_object* mode (AFB_request *request) { /* AFB_SESSION_CHECK */
- dongle->thr_finished = 1;
- return 0;
-}
+ radioCtxHandleT *ctx = (radioCtxHandleT*)request->context;
+ const char *value = getQueryValue (request, "value");
+ json_object *jresp = json_object_new_object();
-STATIC void _lowpass_demod (void *ctx) {
- demod_ctx *demod = (demod_ctx *)ctx;
- int i=0, i2=0;
-
- while (i < demod->buf_len) {
- demod->now_r += demod->buf[i];
- demod->now_j += demod->buf[i+1];
- i += 2;
- demod->index++;
- if (demod->index < ((1000000 / 200000) + 1))
- continue;
- demod->buf[i2] = demod->now_r;
- demod->buf[i2+1] = demod->now_j;
- demod->index = 0;
- demod->now_r = demod->now_j = 0;
- i2 += 2;
- }
- demod->buf_len = i2;
-}
- /**/
-STATIC void _lowpassreal_demod (void *ctx) {
- demod_ctx *demod = (demod_ctx *)ctx;
- int i=0, i2=0;
- int fast = 200000;
- int slow = 48000;
-
- while (i < demod->res_len) {
- demod->now_index += demod->res[i];
- i++;
- demod->pre_index += slow;
- if (demod->pre_index < fast)
- continue;
- demod->res[i2] = (int16_t)(demod->now_index / (fast/slow));
- demod->pre_index -= fast;
- demod->now_index = 0;
- i2 += 1;
- }
- demod->res_len = i2;
-}
- /**/
-STATIC void _multiply (int ar, int aj, int br, int bj, int *cr, int *cj) {
- *cr = ar*br - aj*bj;
- *cj = aj*br + ar*bj;
-}
- /**/
-STATIC int _polar_discriminant (int ar, int aj, int br, int bj) {
- int cr, cj;
- double angle;
- _multiply(ar, aj, br, -bj, &cr, &cj);
- angle = atan2((double)cj, (double)cr);
- return (int)(angle / 3.14159 * (1<<14));
-}
- /**/
-STATIC void _fm_demod (void *ctx) {
- demod_ctx *demod = (demod_ctx *)ctx;
- int16_t *buf = demod->buf;
- int buf_len = demod->buf_len;
- int pcm, i;
-
- pcm = _polar_discriminant(buf[0], buf[1], demod->pre_r, demod->pre_j);
- demod->res[0] = (int16_t)pcm;
-
- for (i = 2; i < (buf_len-1); i += 2) {
- pcm = _polar_discriminant(buf[i], buf[i+1], buf[i-2], buf[i-1]);
- demod->res[i/2] = (int16_t)pcm;
- }
- demod->pre_r = buf[buf_len - 2];
- demod->pre_j = buf[buf_len - 1];
- demod->res_len = buf_len/2;
-}
- /**/
-STATIC void _am_demod (void *ctx) {
- demod_ctx *demod = (demod_ctx *)ctx;
- int16_t *buf = demod->buf;
- int buf_len = demod->buf_len;
- int pcm, i;
-
- for (i = 0; i < buf_len; i += 2) {
- pcm = buf[i] * buf[i];
- pcm += buf[i+1] * buf[i+1];
- demod->res[i/2] = (int16_t)sqrt(pcm);
- }
- demod->res_len = buf_len/2;
-}
- /**/
-STATIC void* _demod_thread_fn (void *ctx) {
- dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
- demod_ctx *demod = dev_ctx->demod;
- output_ctx *output = dev_ctx->output;
-
- while(dev_ctx->should_run) {
- pthread_wait(&demod->ok, &demod->ok_m);
- pthread_rwlock_wrlock(&demod->lck);
- _lowpass_demod(demod);
- if (dev_ctx->mode == FM)
- _fm_demod(demod);
- else
- _am_demod(demod);
- _lowpassreal_demod(demod);
- pthread_rwlock_unlock(&demod->lck);
-
- /* lock demod thread, write to it, unlock */
- pthread_rwlock_wrlock(&output->lck);
- memcpy(output->buf, demod->res, 2 * demod->res_len);
- output->buf_len = demod->res_len;
- pthread_rwlock_unlock(&output->lck);
- pthread_signal(&output->ok, &output->ok_m);
+ /* no "?value=" parameter : return current state */
+ if (!value || !ctx->radio) {
+ ctx->mode ?
+ json_object_object_add (jresp, "mode", json_object_new_string ("AM"))
+ : json_object_object_add (jresp, "mode", json_object_new_string ("FM"));
}
- demod->thr_finished = 1;
- return 0;
-}
-
-STATIC void* _output_thread_fn (void *ctx) {
- dev_ctx_T *dev_ctx = (dev_ctx_T *)ctx;
- output_ctx *output = dev_ctx->output;
-
- while (dev_ctx->should_run) {
- pthread_wait(&output->ok, &output->ok_m);
- pthread_rwlock_rdlock(&output->lck);
- //if (!dev_ctx->mute)
- // mRadio->PlayAlsa((void*)&output->buf, output->buf_len);
- pthread_rwlock_unlock(&output->lck);
+ /* "?value=" parameter is "1" or "AM" */
+ else if ( atoi(value) == 1 || !strcasecmp(value, "AM") ) {
+ ctx->mode = AM;
+ _radio_set_mode (ctx->idx, ctx->mode);
+ json_object_object_add (jresp, "mode", json_object_new_string ("AM"));
}
- output->thr_finished = 1;
- return 0;
+ /* "?value=" parameter is "0" or "FM" */
+ else if ( atoi(value) == 0 || !strcasecmp(value, "FM") ) {
+ ctx->mode = FM;
+ _radio_set_mode (ctx->idx, ctx->mode);
+ json_object_object_add (jresp, "mode", json_object_new_string ("FM"));
+ }
+
+ return jresp;
}
+STATIC json_object* freq (AFB_request *request) { /* AFB_SESSION_CHECK */
-// ********************************************************
-
-// FULUP integration proposal with client session context
-
-// ********************************************************
-
-
-#define MAX_RADIO 10
-
-// Structure holding existing radio with current usage status
-typedef struct {
- int idx;
- char *name;
- int used;
-} radioDevT;
-
-// Radio plugin handle should store everething API may need
-typedef struct {
- radioDevT *radios[MAX_RADIO]; // pointer to existing radio
- int devCount;
-} pluginHandleT;
-
-// Client Context Structure Hold any specific to client [will be destroyed when client leave]
-typedef struct {
- dev_ctx_T radio; // pointer to client radio
- int idx; // index of radio within global array
-} ctxHandleT;
+ radioCtxHandleT *ctx = (radioCtxHandleT*)request->context;
+ const char *value = getQueryValue (request, "value");
+ json_object *jresp = json_object_new_object();
+ double freq;
+ char freq_str[256];
+ /* no "?value=" parameter : return current state */
+ if (!value || !ctx->radio) {
+ snprintf (freq_str, sizeof(freq_str), "%f", ctx->freq);
+ json_object_object_add (jresp, "freq", json_object_new_string (freq_str));
+ }
-// It his was not a demo only, it should be smarter to enable hot plug/unplug
-STATIC void updateRadioDevList(pluginHandleT *handle) {
- int idx;
+ /* "?value=" parameter, set frequency */
+ else {
+ freq = strtod (value, NULL);
+ _radio_set_freq (ctx->idx, freq);
+ ctx->freq = (float)freq;
- // loop on existing radio if any
- for (idx = 0; idx < _radio_dev_count(); idx++) {
- if (idx == MAX_RADIO) break;
- handle->radios[idx] = calloc(1, sizeof(radioDevT)); // use calloc to set used to FALSE
- handle->radios[idx]->name = (char *) _radio_dev_name(idx);
- }
- handle->devCount = _radio_dev_count();
+ snprintf (freq_str, sizeof(freq_str), "%f", ctx->freq);
+ json_object_object_add (jresp, "freq", json_object_new_string (freq_str));
+ }
+
+ return jresp;
}
+STATIC json_object* mute (AFB_request *request) { /* AFB_SESSION_CHECK */
-// This is call at plugin load time [radio devices might still not be visible]
-STATIC pluginHandleT* initRadioPlugin() {
-
- // Allocate Plugin handle
- pluginHandleT *handle = calloc (1,sizeof (pluginHandleT)); // init handle with zero
+ radioCtxHandleT *ctx = (radioCtxHandleT*)request->context;
+ const char *value = getQueryValue (request, "value");
+ json_object *jresp = json_object_new_object();
+ char *mute_str;
- // Some initialization steps
- updateRadioDevList(handle);
+ /* no "?value=" parameter : return current state */
+ if (!value || !ctx->radio) {
+ ctx->mute ?
+ json_object_object_add (jresp, "mute", json_object_new_string ("on"))
+ : json_object_object_add (jresp, "mute", json_object_new_string ("off"));
+ }
- return (handle);
-}
+ /* "?value=" parameter is "1" or "true" */
+ else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
+ ctx->mute = 1;
+ _radio_set_mute (ctx->idx, ctx->mute);
+ json_object_object_add (jresp, "mute", json_object_new_string ("on"));
+ }
-// Stop a radio free related ressource and make it avaliable for other clients
-STATIC AFB_error releaseRadio (pluginHandleT* handle, ctxHandleT *ctx) {
+ /* "?value=" parameter is "0" or "false" */
+ else if ( atoi(value) == 0 || !strcasecmp(value, "off") ) {
+ ctx->mute = 0;
+ _radio_set_mute (ctx->idx, ctx->mute);
+ json_object_object_add (jresp, "mute", json_object_new_string ("off"));
+ }
- // change radio status
- (handle->radios[ctx->idx])->used = FALSE;
-
- // stop related threads and free attached resources
- radio_stop (&ctx->radio);
-
- // May be some further cleanup ????
-
- return (AFB_SUCCESS); // Could it fails ????
+ return jresp;
}
+STATIC json_object* play (AFB_request *request) { /* AFB_SESSION_CHECK */
-// Start a radio and reserve exclusive usage to requesting client
-STATIC ctxHandleT *reserveRadio (pluginHandleT* handle) {
- ctxHandleT *client;
- int idx;
+ radioCtxHandleT *ctx = (radioCtxHandleT*)request->context;
+ const char *value = getQueryValue (request, "value");
+ json_object *jresp = json_object_new_object();
- // loop on existing radio if any
- for (idx = 0; idx < _radio_dev_count(); idx++) {
- if ((handle->radios[client->idx])->used = FALSE) break;
+ /* no "?value=" parameter : return current state */
+ if (!value || !ctx->radio) {
+ ctx->is_playing ?
+ json_object_object_add (jresp, "play", json_object_new_string ("on"))
+ : json_object_object_add (jresp, "play", json_object_new_string ("off"));
}
-
- // No avaliable radio return now
- if (idx == MAX_RADIO) return (NULL);
-
- // Book radio
- (handle->radios[client->idx])->used = TRUE;
-
- // create client handle
- client = calloc (1, sizeof (ctxHandleT));
-
- // stop related threads and free attached resources
- _radio_start_threads (&client->radio);
-
- // May be some things to do ????
-
-
- return (client);
-}
-
-// This is called when client session died [ex; client quit for more than 15mn]
-STATIC json_object* freeRadio () {
-
- //releaseRadio (client->handle, client);
- //free (client);
-}
-
-STATIC json_object* powerOnOff (AFB_request *request) {
- json_object *jresp;
- AFB_clientCtx *client = request->client; // get client context from request
-
- // Make sure binder was started with client session
- if (client == NULL) {
- request->errcode=MHD_HTTP_FORBIDDEN;
- return (jsonNewMessage(AFB_FAIL, "Radio binder need session [--token=xxxx]"));
+ /* "?value=" parameter is "1" or "true" */
+ else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
+ /* radio playback */
+ ctx->is_playing = 1;
+ _radio_play (ctx->idx);
+ json_object_object_add (jresp, "play", json_object_new_string ("on"));
}
-
- // If we have a handle radio was on let power it down
- if (client->ctx != NULL) {
- dev_ctx_T *dev_ctx = (dev_ctx_T *)client->ctx;
- releaseRadio (client->plugin->handle, client->ctx); // poweroff client related radio
-
- jresp = json_object_new_object();
- json_object_object_add(jresp, "power", json_object_new_string ("off"));
- return (jresp);
- }
-
- // request a new client context token and check result
- if (AFB_UNAUTH == ctxTokenCreate (request)) {
- request->errcode=MHD_HTTP_UNAUTHORIZED;
- jresp= jsonNewMessage(AFB_FAIL, "You're not authorized to request a radio [make sure you have the right authentication token");
- return (jresp);
+ /* "?value=" parameter is "0" or "false" */
+ else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
+ /* radio stop */
+ ctx->is_playing = 0;
+ _radio_stop (ctx->idx);
+ json_object_object_add (jresp, "play", json_object_new_string ("off"));
}
-
- // Client is clean let's look it we have an avaliable radio to propose
-
- // make sure we have last hot plug dongle visible
- updateRadioDevList (client->plugin->handle);
-
- // get try to get an unused radio
- client->ctx = reserveRadio (client->plugin->handle);
- if (client->ctx == NULL) {
- return (jsonNewMessage(AFB_FAIL, "Sory No More Radio Avaliable"));
- }
-
- // At this point we should have something to retreive radio status before last poweroff [but this is only a demonstrator]
-}
-
-STATIC json_object* start (AFB_request *request) {
- return NULL;
-}
-STATIC json_object* stop (AFB_request *request) {
- return NULL;
+ return jresp;
}
-STATIC json_object* status (AFB_request *request) {
- return NULL;
+STATIC json_object* ping (AFB_request *request) { /* AFB_SESSION_NONE */
+ return jsonNewMessage(AFB_SUCCESS, "Ping Binder Daemon - Radio API");
}
-STATIC AFB_restapi pluginApis[]= {
- {"power" , AFB_SESSION_CREATE, (AFB_apiCB)powerOnOff , "Ping Application Framework"},
- {"start" , AFB_SESSION_CHECK, (AFB_apiCB)start , "Ping Application Framework"},
- {"stop" , AFB_SESSION_CHECK, (AFB_apiCB)stop , "Ping Application Framework"},
- {"status" , AFB_SESSION_RENEW, (AFB_apiCB)status , "Ping Application Framework"},
+STATIC AFB_restapi pluginApis[]= {
+ {"init" , AFB_SESSION_CHECK, (AFB_apiCB)init , "Radio API - init"},
+ {"power" , AFB_SESSION_CHECK, (AFB_apiCB)power , "Radio API - power"},
+ {"mode" , AFB_SESSION_CHECK, (AFB_apiCB)mode , "Radio API - mode"},
+ {"freq" , AFB_SESSION_CHECK, (AFB_apiCB)freq , "Radio API - freq"},
+ {"mute" , AFB_SESSION_CHECK, (AFB_apiCB)mute , "Radio API - mute"},
+ {"play" , AFB_SESSION_CHECK, (AFB_apiCB)play , "Radio API - play"},
+ {"ping" , AFB_SESSION_NONE, (AFB_apiCB)ping , "Radio API - ping"},
{NULL}
};
-PUBLIC AFB_plugin *radioRegister (AFB_session *session) {
- AFB_plugin *plugin = malloc (sizeof (AFB_plugin));
+PUBLIC AFB_plugin* pluginRegister () {
+ AFB_plugin *plugin = malloc (sizeof(AFB_plugin));
plugin->type = AFB_PLUGIN_JSON;
plugin->info = "Application Framework Binder - Radio plugin";
plugin->prefix = "radio";
plugin->apis = pluginApis;
-
+
plugin->handle = initRadioPlugin();
- plugin->freeCtxCB = freeRadio;
+ plugin->freeCtxCB = (AFB_freeCtxCB)freeRadio;
return (plugin);
};