plugins/audio/audio-api.c

   1 /*
   2  * Copyright (C) 2015, 2016 "IoT.bzh"
   3  * Author "Manuel Bachmann"
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <stdlib.h>
  20 #include <json-c/json.h>
  21
  22 #include "audio-api.h"
  23 #include "audio-alsa.h"
  24 #ifdef HAVE_PULSE
  25 #include "audio-pulse.h"
  26 #endif
  27
  28 #include <afb/afb-plugin.h>
  29 #include <afb/afb-req-itf.h>
  30
  31 /* ------ BACKEND FUNCTIONS ------- */
  32
  33 unsigned char _backend_init (const char *name, audioCtxHandleT *ctx) {
  34
  35     char *backend_env = getenv ("AFB_AUDIO_OUTPUT");
  36     unsigned char res = 0;
  37
  38 # ifdef HAVE_PULSE
  39     if (!backend_env || (strcasecmp (backend_env, "Pulse") == 0))
  40         res = _pulse_init (name, ctx);
  41     if (!res)
  42 #endif
  43     res = _alsa_init (name, ctx);
  44
  45     if (!res)
  46         fprintf (stderr, "Could not initialize Audio backend\n");
  47
  48     return res;
  49 }
  50
  51 void _backend_free (audioCtxHandleT *ctx) {
  52
  53 # ifdef HAVE_PULSE
  54     if (ctx->audio_dev) _pulse_free (ctx); else
  55 # endif
  56     _alsa_free (ctx->name);
  57 }
  58
  59 void _backend_play (audioCtxHandleT *ctx) {
  60
  61 # ifdef HAVE_PULSE
  62     if (ctx->audio_dev) _pulse_play (ctx); else
  63 # endif
  64     _alsa_play (ctx->idx);
  65 }
  66
  67 void _backend_stop (audioCtxHandleT *ctx) {
  68
  69 # ifdef HAVE_PULSE
  70     if (ctx->audio_dev) _pulse_stop (ctx); else
  71 # endif
  72     _alsa_stop (ctx->idx);
  73 }
  74
  75 unsigned int _backend_get_volume (audioCtxHandleT *ctx, unsigned int channel) {
  76
  77 # ifdef HAVE_PULSE
  78     if (ctx->audio_dev) return _pulse_get_volume (ctx, channel); else
  79 # endif
  80     return _alsa_get_volume (ctx->idx, channel);
  81 }
  82
  83 void _backend_set_volume (audioCtxHandleT *ctx, unsigned int channel, unsigned int vol) {
  84
  85 # ifdef HAVE_PULSE
  86     if (ctx->audio_dev) _pulse_set_volume (ctx, channel, vol); else
  87 # endif
  88     _alsa_set_volume (ctx->idx, channel, vol);
  89 }
  90
  91 void _backend_set_volume_all (audioCtxHandleT *ctx, unsigned int vol) {
  92
  93 # ifdef HAVE_PULSE
  94     if (ctx->audio_dev) _pulse_set_volume_all (ctx, vol); else
  95 # endif
  96     _alsa_set_volume_all (ctx->idx, vol);
  97 }
  98
  99 unsigned char _backend_get_mute (audioCtxHandleT *ctx) {
 100
 101 # ifdef HAVE_PULSE
 102     if (ctx->audio_dev) return _pulse_get_mute (ctx); else
 103 # endif
 104     return _alsa_get_mute (ctx->idx);
 105 }
 106
 107 void _backend_set_mute (audioCtxHandleT *ctx, unsigned char mute) {
 108
 109 # ifdef HAVE_PULSE
 110     if (ctx->audio_dev) _pulse_set_mute (ctx, mute); else
 111 # endif
 112     _alsa_set_mute (ctx->idx, mute);
 113 }
 114
 115 void _backend_set_channels (audioCtxHandleT *ctx, unsigned int channels) {
 116
 117 # ifdef HAVE_PULSE
 118     if (ctx->audio_dev) return; else
 119 # endif
 120     _alsa_set_channels (ctx->idx, channels);
 121 }
 122
 123 /* ------ LOCAL HELPER FUNCTIONS --------- */
 124
 125 /* private client context constructor ; default values */
 126 static audioCtxHandleT* initAudioCtx () {
 127
 128     audioCtxHandleT *ctx;
 129     int i;
 130
 131     ctx = malloc (sizeof(audioCtxHandleT));
 132     ctx->audio_dev = NULL;
 133     ctx->name = NULL;
 134     ctx->idx = -1;
 135     for (i = 0; i < 8; i++)
 136         ctx->volume[i] = 25;
 137     ctx->channels = 2;
 138     ctx->mute = 0;
 139     ctx->is_playing = 0;
 140
 141     return ctx;
 142 }
 143
 144 static void releaseAudioCtx (void *context) {
 145
 146     audioCtxHandleT *ctx = (audioCtxHandleT*) context;
 147
 148     /* power it off */
 149     _backend_free (ctx);
 150
 151     /* clean client context */
 152     ctx->audio_dev = NULL;
 153     if (ctx->name)
 154                 free (ctx->name);
 155     ctx->idx = -1;
 156     free (ctx);
 157 }
 158
 159
 160 /* ------ PUBLIC PLUGIN FUNCTIONS --------- */
 161
 162 static void init (struct afb_req request) {        /* AFB_SESSION_CHECK */
 163
 164     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 165     json_object *jresp;
 166
 167     /* create a private client context */
 168         if (!ctx) {
 169         ctx = initAudioCtx();
 170         afb_req_context_set (request, ctx, releaseAudioCtx);
 171     }
 172
 173     if (!_backend_init ("default", ctx)) {
 174         afb_req_fail (request, "failed", "backend initialization failed");
 175     }
 176
 177     jresp = json_object_new_object();
 178     json_object_object_add (jresp, "init", json_object_new_string ("success"));
 179     afb_req_success (request, jresp, "Audio initialized");
 180 }
 181
 182 static void volume (struct afb_req request) {      /* AFB_SESSION_CHECK */
 183
 184     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 185     const char *value = afb_req_value (request, "value");
 186     json_object *jresp;
 187     unsigned int volume[8], i;
 188     char *volume_i;
 189     char volume_str[256];
 190     size_t len_str = 0;
 191
 192     /* no "?value=" parameter : return current state */
 193     if (!value) {
 194         for (i = 0; i < 8; i++) {
 195             ctx->volume[i] = _backend_get_volume (ctx, i);
 196             snprintf (volume_str+len_str, sizeof(volume_str)-len_str, "%d,", ctx->volume[i]);
 197             len_str = strlen(volume_str);
 198         }
 199         jresp = json_object_new_object();
 200         json_object_object_add (jresp, "volume", json_object_new_string(volume_str));
 201     }
 202
 203     /* "?value=" parameter, set volume */
 204     else {
 205         volume_i = strdup (value);
 206         volume_i = strtok (volume_i, ",");
 207         volume[0] = (unsigned int) atoi (volume_i);
 208
 209         if (100 < volume[0]) {
 210             free (volume_i);
 211             afb_req_fail (request, "failed", "volume must be between 0 and 100");
 212             return;
 213         }
 214         ctx->volume[0] = volume[0];
 215         _backend_set_volume (ctx, 0, ctx->volume[0]);
 216         snprintf (volume_str, sizeof(volume_str), "%d,", ctx->volume[0]);
 217
 218         for (i = 1; i < 8; i++) {
 219             volume_i = strtok (NULL, ",");
 220             /* if there is only one value, set all channels to this one */
 221             if (!volume_i && i == 1)
 222                _backend_set_volume_all (ctx, ctx->volume[0]);
 223             if (!volume_i || 100 < atoi(volume_i) || atoi(volume_i) < 0) {
 224                ctx->volume[i] = _backend_get_volume (ctx, i);
 225             } else {
 226                ctx->volume[i] = (unsigned int) atoi(volume_i);
 227                _backend_set_volume (ctx, i, ctx->volume[i]);
 228             }
 229             len_str = strlen(volume_str);
 230             snprintf (volume_str+len_str, sizeof(volume_str)-len_str, "%d,", ctx->volume[i]);
 231         }
 232         jresp = json_object_new_object();
 233         json_object_object_add (jresp, "volume", json_object_new_string(volume_str));
 234     }
 235
 236     afb_req_success (request, jresp, "Audio - Volume changed");
 237 }
 238
 239 static void channels (struct afb_req request) {    /* AFB_SESSION_CHECK */
 240
 241     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 242     const char *value = afb_req_value (request, "value");
 243     json_object *jresp = json_object_new_object();
 244     char channels_str[256];
 245
 246     /* no "?value=" parameter : return current state */
 247     if (!value) {
 248         snprintf (channels_str, sizeof(channels_str), "%d", ctx->channels);
 249         json_object_object_add (jresp, "channels", json_object_new_string (channels_str));
 250     }
 251
 252     /* "?value=" parameter, set channels */
 253     else {
 254         ctx->channels = (unsigned int) atoi (value);
 255         _backend_set_channels (ctx, ctx->channels);
 256
 257         snprintf (channels_str, sizeof(channels_str), "%d", ctx->channels);
 258         json_object_object_add (jresp, "channels", json_object_new_string (channels_str));
 259     }
 260
 261     afb_req_success (request, jresp, "Audio - Channels set");
 262 }
 263
 264 static void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
 265
 266     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 267     const char *value = afb_req_value (request, "value");
 268     json_object *jresp = json_object_new_object();
 269
 270     /* no "?value=" parameter : return current state */
 271     if (!value) {
 272         ctx->mute = _backend_get_mute (ctx);
 273         ctx->mute ?
 274             json_object_object_add (jresp, "mute", json_object_new_string ("on"))
 275           : json_object_object_add (jresp, "mute", json_object_new_string ("off"));
 276     }
 277
 278     /* "?value=" parameter is "1" or "true" */
 279     else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
 280         ctx->mute = 1;
 281         _backend_set_mute (ctx, ctx->mute);
 282
 283         json_object_object_add (jresp, "mute", json_object_new_string ("on"));
 284     }
 285
 286     /* "?value=" parameter is "0" or "false" */
 287     else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
 288         ctx->mute = 0;
 289         _backend_set_mute (ctx, ctx->mute);
 290
 291         json_object_object_add (jresp, "mute", json_object_new_string ("off"));
 292     }
 293
 294     afb_req_success (request, jresp, "Audio - Mute set");
 295 }
 296
 297 static void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
 298
 299     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 300     const char *value = afb_req_value (request, "value");
 301     json_object *jresp = json_object_new_object();
 302
 303     /* no "?value=" parameter : return current state */
 304     if (!value) {
 305         ctx->is_playing ?
 306             json_object_object_add (jresp, "play", json_object_new_string ("on"))
 307           : json_object_object_add (jresp, "play", json_object_new_string ("off"));
 308     }
 309
 310     /* "?value=" parameter is "1" or "true" */
 311     else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
 312         ctx->is_playing = 1;
 313         _backend_play (ctx);
 314
 315         json_object_object_add (jresp, "play", json_object_new_string ("on"));
 316     }
 317
 318     /* "?value=" parameter is "0" or "false" */
 319     else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
 320         ctx->is_playing = 0;
 321         _backend_stop (ctx);
 322
 323         json_object_object_add (jresp, "play", json_object_new_string ("off"));
 324     }
 325
 326     afb_req_success (request, jresp, "Audio - Play");
 327 }
 328
 329 static void ping (struct afb_req request) {         /* AFB_SESSION_NONE */
 330     afb_req_success (request, NULL, "Audio - Ping success");
 331 }
 332
 333 static const struct AFB_restapi pluginApis[]= {
 334   {"init"    , AFB_SESSION_CHECK,  init      , "Audio API - init"},
 335   {"volume"  , AFB_SESSION_CHECK,  volume    , "Audio API - volume"},
 336   {"channels", AFB_SESSION_CHECK,  channels  , "Audio API - channels"},
 337   {"mute"    , AFB_SESSION_CHECK,  mute      , "Audio API - mute"},
 338   {"play"    , AFB_SESSION_CHECK,  play      , "Audio API - play"},
 339   {"ping"    , AFB_SESSION_NONE,   ping      , "Audio API - ping"},
 340   {NULL}
 341 };
 342
 343 static const struct AFB_plugin pluginDesc = {
 344     .type   = AFB_PLUGIN_JSON,
 345     .info   = "Application Framework Binder - Audio plugin",
 346     .prefix = "audio",
 347     .apis   = pluginApis
 348 };
 349
 350 const struct AFB_plugin *pluginRegister (const struct AFB_interface *itf)
 351 {
 352         return &pluginDesc;
 353 }