socketif: dummy implementation of pa_routerif_register_implicit_connection()
[profile/ivi/pulseaudio-module-murphy-ivi.git] / 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