plugins/audio/audio-api.c

   1 /*
   2  * Copyright (C) 2015 "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-plugin.h"
  29 #include "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     struct afb_arg arg = afb_req_get (request, "value");
 186     const char *value = arg.value;
 187     json_object *jresp;
 188     unsigned int volume[8], i;
 189     char *volume_i;
 190     char volume_str[256];
 191     size_t len_str = 0;
 192
 193     /* no "?value=" parameter : return current state */
 194     if (!value) {
 195         for (i = 0; i < 8; i++) {
 196             ctx->volume[i] = _backend_get_volume (ctx, i);
 197             snprintf (volume_str+len_str, sizeof(volume_str)-len_str, "%d,", ctx->volume[i]);
 198             len_str = strlen(volume_str);
 199         }
 200         jresp = json_object_new_object();
 201         json_object_object_add (jresp, "volume", json_object_new_string(volume_str));
 202     }
 203
 204     /* "?value=" parameter, set volume */
 205     else {
 206         volume_i = strdup (value);
 207         volume_i = strtok (volume_i, ",");
 208         volume[0] = (unsigned int) atoi (volume_i);
 209
 210         if (100 < volume[0]) {
 211             free (volume_i);
 212             afb_req_fail (request, "failed", "volume must be between 0 and 100");
 213             return;
 214         }
 215         ctx->volume[0] = volume[0];
 216         _backend_set_volume (ctx, 0, ctx->volume[0]);
 217         snprintf (volume_str, sizeof(volume_str), "%d,", ctx->volume[0]);
 218
 219         for (i = 1; i < 8; i++) {
 220             volume_i = strtok (NULL, ",");
 221             /* if there is only one value, set all channels to this one */
 222             if (!volume_i && i == 1)
 223                _backend_set_volume_all (ctx, ctx->volume[0]);
 224             if (!volume_i || 100 < atoi(volume_i) || atoi(volume_i) < 0) {
 225                ctx->volume[i] = _backend_get_volume (ctx, i);
 226             } else {
 227                ctx->volume[i] = (unsigned int) atoi(volume_i);
 228                _backend_set_volume (ctx, i, ctx->volume[i]);
 229             }
 230             len_str = strlen(volume_str);
 231             snprintf (volume_str+len_str, sizeof(volume_str)-len_str, "%d,", ctx->volume[i]);
 232         }
 233         jresp = json_object_new_object();
 234         json_object_object_add (jresp, "volume", json_object_new_string(volume_str));
 235     }
 236
 237     afb_req_success (request, jresp, "Audio - Volume changed");
 238 }
 239
 240 static void channels (struct afb_req request) {    /* AFB_SESSION_CHECK */
 241
 242     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 243     struct afb_arg arg = afb_req_get (request, "value");
 244     const char *value = arg.value;
 245     json_object *jresp = json_object_new_object();
 246     char channels_str[256];
 247
 248     /* no "?value=" parameter : return current state */
 249     if (!value) {
 250         snprintf (channels_str, sizeof(channels_str), "%d", ctx->channels);
 251         json_object_object_add (jresp, "channels", json_object_new_string (channels_str));
 252     }
 253
 254     /* "?value=" parameter, set channels */
 255     else {
 256         ctx->channels = (unsigned int) atoi (value);
 257         _backend_set_channels (ctx, ctx->channels);
 258
 259         snprintf (channels_str, sizeof(channels_str), "%d", ctx->channels);
 260         json_object_object_add (jresp, "channels", json_object_new_string (channels_str));
 261     }
 262
 263     afb_req_success (request, jresp, "Audio - Channels set");
 264 }
 265
 266 static void mute (struct afb_req request) {        /* AFB_SESSION_CHECK */
 267
 268     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 269     struct afb_arg arg = afb_req_get (request, "value");
 270     const char *value = arg.value;
 271     json_object *jresp = json_object_new_object();
 272
 273     /* no "?value=" parameter : return current state */
 274     if (!value) {
 275         ctx->mute = _backend_get_mute (ctx);
 276         ctx->mute ?
 277             json_object_object_add (jresp, "mute", json_object_new_string ("on"))
 278           : json_object_object_add (jresp, "mute", json_object_new_string ("off"));
 279     }
 280
 281     /* "?value=" parameter is "1" or "true" */
 282     else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
 283         ctx->mute = 1;
 284         _backend_set_mute (ctx, ctx->mute);
 285
 286         json_object_object_add (jresp, "mute", json_object_new_string ("on"));
 287     }
 288
 289     /* "?value=" parameter is "0" or "false" */
 290     else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
 291         ctx->mute = 0;
 292         _backend_set_mute (ctx, ctx->mute);
 293
 294         json_object_object_add (jresp, "mute", json_object_new_string ("off"));
 295     }
 296
 297     afb_req_success (request, jresp, "Audio - Mute set");
 298 }
 299
 300 static void play (struct afb_req request) {        /* AFB_SESSION_CHECK */
 301
 302     audioCtxHandleT *ctx = (audioCtxHandleT*) afb_req_context_get(request);
 303     struct afb_arg arg = afb_req_get (request, "value");
 304     const char *value = arg.value;
 305     json_object *jresp = json_object_new_object();
 306
 307     /* no "?value=" parameter : return current state */
 308     if (!value) {
 309         ctx->is_playing ?
 310             json_object_object_add (jresp, "play", json_object_new_string ("on"))
 311           : json_object_object_add (jresp, "play", json_object_new_string ("off"));
 312     }
 313
 314     /* "?value=" parameter is "1" or "true" */
 315     else if ( atoi(value) == 1 || !strcasecmp(value, "true") ) {
 316         ctx->is_playing = 1;
 317         _backend_play (ctx);
 318
 319         json_object_object_add (jresp, "play", json_object_new_string ("on"));
 320     }
 321
 322     /* "?value=" parameter is "0" or "false" */
 323     else if ( atoi(value) == 0 || !strcasecmp(value, "false") ) {
 324         ctx->is_playing = 0;
 325         _backend_stop (ctx);
 326
 327         json_object_object_add (jresp, "play", json_object_new_string ("off"));
 328     }
 329
 330     afb_req_success (request, jresp, "Audio - Play");
 331 }
 332
 333 static void ping (struct afb_req request) {         /* AFB_SESSION_NONE */
 334     afb_req_success (request, NULL, "Audio - Ping success");
 335 }
 336
 337 static const struct AFB_restapi pluginApis[]= {
 338   {"init"    , AFB_SESSION_CHECK,  init      , "Audio API - init"},
 339   {"volume"  , AFB_SESSION_CHECK,  volume    , "Audio API - volume"},
 340   {"channels", AFB_SESSION_CHECK,  channels  , "Audio API - channels"},
 341   {"mute"    , AFB_SESSION_CHECK,  mute      , "Audio API - mute"},
 342   {"play"    , AFB_SESSION_CHECK,  play      , "Audio API - play"},
 343   {"ping"    , AFB_SESSION_NONE,   ping      , "Audio API - ping"},
 344   {NULL}
 345 };
 346
 347 static const struct AFB_plugin pluginDesc = {
 348     .type   = AFB_PLUGIN_JSON,
 349     .info   = "Application Framework Binder - Audio plugin",
 350     .prefix = "audio",
 351     .apis   = pluginApis
 352 };
 353
 354 const struct AFB_plugin *pluginRegister (const struct AFB_interface *itf)
 355 {
 356         return &pluginDesc;
 357 }