murphy/socketif.c

   1 /*
   2  * module-murphy-ivi -- PulseAudio module for providing audio routing support
   3  * Copyright (c) 2012, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU Lesser General Public License,
   7  * version 2.1, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.
  12  * See the GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St - Fifth Floor, Boston,
  17  * MA 02110-1301 USA.
  18  *
  19  */
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25
  26 #include <pulsecore/pulsecore-config.h>
  27
  28 #include "userdata.h"
  29 #include "socketif.h"
  30 #include "audiomgr.h"
  31
  32
  33 struct pa_routerif {
  34     int  sock;
  35 };
  36
  37
  38
  39 static const char *method_str(am_method);
  40
  41 pa_routerif *pa_routerif_init(struct userdata *u,
  42                               const char      *socktyp,
  43                               const char      *addr,
  44                               const char      *port)
  45 {
  46     pa_module      *m = u->module;
  47     pa_routerif    *routerif = NULL;
  48
  49     routerif = pa_xnew0(pa_routerif, 1);
  50     routerif->sock = -1;
  51
  52     return routerif;
  53 }
  54
  55
  56 void pa_routerif_done(struct userdata *u)
  57 {
  58     pa_routerif *routerif;
  59
  60     if (u && (routerif = u->routerif)) {
  61         if (routerif->sock >= 0)
  62             close(routerif->sock);
  63
  64         pa_xfree(routerif);
  65
  66         u->routerif = NULL;
  67     }
  68 }
  69
  70
  71 bool pa_routerif_register_domain(struct userdata   *u,
  72                                            am_domainreg_data *dr)
  73 {
  74     pa_routerif *routerif;
  75     int          success = true;
  76
  77     pa_assert(u);
  78     pa_assert(dr);
  79     pa_assert_se((routerif = u->routerif));
  80     pa_assert(routerif->sock >= 0);
  81
  82     pa_log_info("%s: registering to AudioManager", __FILE__);
  83
  84     return success;
  85 }
  86
  87 bool pa_routerif_domain_complete(struct userdata *u, uint16_t domain)
  88 {
  89     pa_routerif *routerif;
  90     bool    success = true;
  91
  92     pa_assert(u);
  93     pa_assert_se((routerif = u->routerif));
  94     pa_assert(routerif->sock >= 0);
  95
  96     pa_log_debug("%s: domain %u AudioManager %s", __FUNCTION__,
  97                  domain, method_str(audiomgr_domain_complete));
  98
  99     return success;
 100 }
 101
 102 bool pa_routerif_unregister_domain(struct userdata *u, uint16_t domain)
 103 {
 104     pa_routerif *routerif;
 105     bool    success = true;
 106
 107     pa_assert(u);
 108     pa_assert_se((routerif = u->routerif));
 109     pa_assert(routerif->sock >= 0);
 110
 111     pa_log_info("%s: deregistreing domain %u from AudioManager",
 112                 __FILE__, domain);
 113
 114     return success;
 115 }
 116
 117
 118 bool pa_routerif_register_node(struct userdata *u,
 119                                     am_method m,
 120                                     am_nodereg_data *rd)
 121 {
 122     const char      *method = method_str(m);
 123     pa_routerif     *routerif;
 124     bool        success = true;
 125
 126     pa_assert(u);
 127     pa_assert(rd);
 128     pa_assert_se((routerif = u->routerif));
 129     pa_assert(routerif->sock >= 0);
 130
 131     pa_log_debug("%s: %s '%s' to AudioManager", __FUNCTION__, method,rd->name);
 132
 133     return success;
 134 }
 135
 136
 137 bool pa_routerif_unregister_node(struct userdata *u,
 138                                       am_method m,
 139                                       am_nodeunreg_data *ud)
 140 {
 141     const char  *method = method_str(m);
 142     pa_routerif *routerif;
 143     bool    success = true;
 144
 145     pa_assert(u);
 146     pa_assert(ud);
 147     pa_assert_se((routerif = u->routerif));
 148     pa_assert(routerif->sock >= 0);
 149
 150     pa_log_debug("%s: %s '%s' to AudioManager", __FUNCTION__, method,ud->name);
 151
 152     return success;
 153 }
 154
 155 bool pa_routerif_register_implicit_connection(struct userdata *u,
 156                                                    am_connect_data *conn) {
 157     return false;
 158 }
 159
 160 bool pa_routerif_register_implicit_connections(struct userdata *u,
 161                                                     int              nconn,
 162                                                     am_connect_data *conns)
 163 {
 164     return false;
 165 }
 166
 167 bool pa_routerif_acknowledge(struct userdata *u, am_method m,
 168                                   struct am_ack_data *ad)
 169 {
 170     const char     *method = method_str(m);
 171     pa_routerif    *routerif;
 172     bool       success = true;
 173
 174     pa_assert(u);
 175     pa_assert(method);
 176     pa_assert_se((routerif = u->routerif));
 177     pa_assert(routerif->sock >= 0);
 178
 179     pa_log_debug("%s: sending %s", __FILE__, method);
 180
 181     return success;
 182 }
 183
 184
 185 static const char *method_str(am_method m)
 186 {
 187     switch (m) {
 188     case audiomgr_register_domain:      return "register_domain";
 189     case audiomgr_domain_complete:      return "domain_complete";
 190     case audiomgr_deregister_domain:    return "deregister_domain";
 191     case audiomgr_register_source:      return "register_source";
 192     case audiomgr_deregister_source:    return "deregister_source";
 193     case audiomgr_register_sink:        return "register_sink";
 194     case audiomgr_deregister_sink:      return "deregister_sink";
 195     case audiomgr_implicit_connection:  return "register_implicit_connection";
 196     case audiomgr_implicit_connections: return "replace_implicit_connections";
 197     case audiomgr_connect:              return "connect";
 198     case audiomgr_connect_ack:          return "connect_ack";
 199     case audiomgr_disconnect:           return "disconnect";
 200     case audiomgr_disconnect_ack:       return "disconnect_ack";
 201     case audiomgr_setsinkvol_ack:       return "setsinkvol_ack";
 202     case audiomgr_setsrcvol_ack:        return "setsrcvol_ack";
 203     case audiomgr_sinkvoltick_ack:      return "sinkvoltick_ack";
 204     case audiomgr_srcvoltick_ack:       return "srcvoltick_ack";
 205     case audiomgr_setsinkprop_ack:      return "setsinkprop_ack";
 206     default:                            return "invalid_method";
 207     }
 208 }
 209
 210 /*
 211  * Local Variables:
 212  * c-basic-offset: 4
 213  * indent-tabs-mode: nil
 214  * End:
 215  *
 216  */
 217