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 pa_bool_t 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 pa_bool_t pa_routerif_domain_complete(struct userdata *u, uint16_t domain)
  88 {
  89     pa_routerif *routerif;
  90     pa_bool_t    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 pa_bool_t pa_routerif_unregister_domain(struct userdata *u, uint16_t domain)
 103 {
 104     pa_routerif *routerif;
 105     pa_bool_t    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 pa_bool_t 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     pa_bool_t        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 pa_bool_t 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     pa_bool_t    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
 156 pa_bool_t pa_routerif_acknowledge(struct userdata *u, am_method m,
 157                                   struct am_ack_data *ad)
 158 {
 159     const char     *method = method_str(m);
 160     pa_routerif    *routerif;
 161     pa_bool_t       success = TRUE;
 162
 163     pa_assert(u);
 164     pa_assert(method);
 165     pa_assert_se((routerif = u->routerif));
 166     pa_assert(routerif->sock >= 0);
 167
 168     pa_log_debug("%s: sending %s", __FILE__, method);
 169
 170     return success;
 171 }
 172
 173
 174 static const char *method_str(am_method m)
 175 {
 176     switch (m) {
 177     case audiomgr_register_domain:   return "register_domain";
 178     case audiomgr_domain_complete:   return "domain_complete";
 179     case audiomgr_deregister_domain: return "deregister_domain";
 180     case audiomgr_register_source:   return "register_source";
 181     case audiomgr_deregister_source: return "deregister_source";
 182     case audiomgr_register_sink:     return "register_sink";
 183     case audiomgr_deregister_sink:   return "deregister_sink";
 184     case audiomgr_connect:           return "connect";
 185     case audiomgr_connect_ack:       return "connect_ack";
 186     case audiomgr_disconnect:        return "disconnect";
 187     case audiomgr_disconnect_ack:    return "disconnect_ack";
 188     case audiomgr_setsinkvol_ack:    return "setsinkvol_ack";
 189     case audiomgr_setsrcvol_ack:     return "setsrcvol_ack";
 190     case audiomgr_sinkvoltick_ack:   return "sinkvoltick_ack";
 191     case audiomgr_srcvoltick_ack:    return "srcvoltick_ack";
 192     case audiomgr_setsinkprop_ack:   return "setsinkprop_ack";
 193     default:                         return "invalid_method";
 194     }
 195 }
 196
 197 /*
 198  * Local Variables:
 199  * c-basic-offset: 4
 200  * indent-tabs-mode: nil
 201  * End:
 202  *
 203  */
 204