← Back to branch summary

~binli/ubuntu/vivid/pulseaudio/load-extcon-module

« back to all changes in this revision

Viewing changes to src/modules/dbus/iface-card-profile.c

  • Committer: Bin Li
  • Date: 2016-01-23 15:04:48 UTC
  • Revision ID: bin.li@canonical.com-20160123150448-5ockvw4p5xxntda4
init the 1:6.0-0ubuntu9.15 from silo 12

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/modules/dbus/iface-card-profile.c
 
1
/***
 
2
  This file is part of PulseAudio.
 
3
 
 
4
  Copyright 2009 Tanu Kaskinen
 
5
 
 
6
  PulseAudio is free software; you can redistribute it and/or modify
 
7
  it under the terms of the GNU Lesser General Public License as published
 
8
  by the Free Software Foundation; either version 2.1 of the License,
 
9
  or (at your option) any later version.
 
10
 
 
11
  PulseAudio is distributed in the hope that it will be useful, but
 
12
  WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
14
  General Public License for more details.
 
15
 
 
16
  You should have received a copy of the GNU Lesser General Public License
 
17
  along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
 
18
***/
 
19
 
 
20
#ifdef HAVE_CONFIG_H
 
21
#include <config.h>
 
22
#endif
 
23
 
 
24
#include <dbus/dbus.h>
 
25
 
 
26
#include <pulsecore/core-util.h>
 
27
#include <pulsecore/dbus-util.h>
 
28
 
 
29
#include "iface-card-profile.h"
 
30
 
 
31
#define OBJECT_NAME "profile"
 
32
 
 
33
static void handle_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
34
static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
35
static void handle_get_description(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
36
static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
37
static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
38
static void handle_get_priority(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
39
 
 
40
static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata);
 
41
 
 
42
struct pa_dbusiface_card_profile {
 
43
    uint32_t index;
 
44
    pa_card_profile *profile;
 
45
    char *path;
 
46
    pa_dbus_protocol *dbus_protocol;
 
47
};
 
48
 
 
49
enum property_handler_index {
 
50
    PROPERTY_HANDLER_INDEX,
 
51
    PROPERTY_HANDLER_NAME,
 
52
    PROPERTY_HANDLER_DESCRIPTION,
 
53
    PROPERTY_HANDLER_SINKS,
 
54
    PROPERTY_HANDLER_SOURCES,
 
55
    PROPERTY_HANDLER_PRIORITY,
 
56
    PROPERTY_HANDLER_MAX
 
57
};
 
58
 
 
59
static pa_dbus_property_handler property_handlers[PROPERTY_HANDLER_MAX] = {
 
60
    [PROPERTY_HANDLER_INDEX]       = { .property_name = "Index",       .type = "u", .get_cb = handle_get_index,       .set_cb = NULL },
 
61
    [PROPERTY_HANDLER_NAME]        = { .property_name = "Name",        .type = "s", .get_cb = handle_get_name,        .set_cb = NULL },
 
62
    [PROPERTY_HANDLER_DESCRIPTION] = { .property_name = "Description", .type = "s", .get_cb = handle_get_description, .set_cb = NULL },
 
63
    [PROPERTY_HANDLER_SINKS]       = { .property_name = "Sinks",       .type = "u", .get_cb = handle_get_sinks,       .set_cb = NULL },
 
64
    [PROPERTY_HANDLER_SOURCES]     = { .property_name = "Sources",     .type = "u", .get_cb = handle_get_sources,     .set_cb = NULL },
 
65
    [PROPERTY_HANDLER_PRIORITY]    = { .property_name = "Priority",    .type = "u", .get_cb = handle_get_priority,    .set_cb = NULL },
 
66
};
 
67
 
 
68
static pa_dbus_interface_info profile_interface_info = {
 
69
    .name = PA_DBUSIFACE_CARD_PROFILE_INTERFACE,
 
70
    .method_handlers = NULL,
 
71
    .n_method_handlers = 0,
 
72
    .property_handlers = property_handlers,
 
73
    .n_property_handlers = PROPERTY_HANDLER_MAX,
 
74
    .get_all_properties_cb = handle_get_all,
 
75
    .signals = NULL,
 
76
    .n_signals = 0
 
77
};
 
78
 
 
79
static void handle_get_index(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
80
    pa_dbusiface_card_profile *p = userdata;
 
81
 
 
82
    pa_assert(conn);
 
83
    pa_assert(msg);
 
84
    pa_assert(p);
 
85
 
 
86
    pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &p->index);
 
87
}
 
88
 
 
89
static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
90
    pa_dbusiface_card_profile *p = userdata;
 
91
 
 
92
    pa_assert(conn);
 
93
    pa_assert(msg);
 
94
    pa_assert(p);
 
95
 
 
96
    pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &p->profile->name);
 
97
}
 
98
 
 
99
static void handle_get_description(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
100
    pa_dbusiface_card_profile *p = userdata;
 
101
 
 
102
    pa_assert(conn);
 
103
    pa_assert(msg);
 
104
    pa_assert(p);
 
105
 
 
106
    pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &p->profile->description);
 
107
}
 
108
 
 
109
static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
110
    pa_dbusiface_card_profile *p = userdata;
 
111
    dbus_uint32_t sinks = 0;
 
112
 
 
113
    pa_assert(conn);
 
114
    pa_assert(msg);
 
115
    pa_assert(p);
 
116
 
 
117
    sinks = p->profile->n_sinks;
 
118
 
 
119
    pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &sinks);
 
120
}
 
121
 
 
122
static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
123
    pa_dbusiface_card_profile *p = userdata;
 
124
    dbus_uint32_t sources = 0;
 
125
 
 
126
    pa_assert(conn);
 
127
    pa_assert(msg);
 
128
    pa_assert(p);
 
129
 
 
130
    sources = p->profile->n_sources;
 
131
 
 
132
    pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &sources);
 
133
}
 
134
 
 
135
static void handle_get_priority(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
136
    pa_dbusiface_card_profile *p = userdata;
 
137
    dbus_uint32_t priority = 0;
 
138
 
 
139
    pa_assert(conn);
 
140
    pa_assert(msg);
 
141
    pa_assert(p);
 
142
 
 
143
    priority = p->profile->priority;
 
144
 
 
145
    pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &priority);
 
146
}
 
147
 
 
148
static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 
149
    pa_dbusiface_card_profile *p = userdata;
 
150
    DBusMessage *reply = NULL;
 
151
    DBusMessageIter msg_iter;
 
152
    DBusMessageIter dict_iter;
 
153
    dbus_uint32_t sinks = 0;
 
154
    dbus_uint32_t sources = 0;
 
155
    dbus_uint32_t priority = 0;
 
156
 
 
157
    pa_assert(conn);
 
158
    pa_assert(msg);
 
159
    pa_assert(p);
 
160
 
 
161
    sinks = p->profile->n_sinks;
 
162
    sources = p->profile->n_sources;
 
163
    priority = p->profile->priority;
 
164
 
 
165
    pa_assert_se((reply = dbus_message_new_method_return(msg)));
 
166
 
 
167
    dbus_message_iter_init_append(reply, &msg_iter);
 
168
    pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
 
169
 
 
170
    pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_INDEX].property_name, DBUS_TYPE_UINT32, &p->index);
 
171
    pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_NAME].property_name, DBUS_TYPE_STRING, &p->profile->name);
 
172
    pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DESCRIPTION].property_name, DBUS_TYPE_STRING, &p->profile->description);
 
173
    pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SINKS].property_name, DBUS_TYPE_UINT32, &sinks);
 
174
    pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SOURCES].property_name, DBUS_TYPE_UINT32, &sources);
 
175
    pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_PRIORITY].property_name, DBUS_TYPE_UINT32, &priority);
 
176
 
 
177
    pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
 
178
 
 
179
    pa_assert_se(dbus_connection_send(conn, reply, NULL));
 
180
    dbus_message_unref(reply);
 
181
}
 
182
 
 
183
pa_dbusiface_card_profile *pa_dbusiface_card_profile_new(
 
184
        pa_dbusiface_card *card,
 
185
        pa_core *core,
 
186
        pa_card_profile *profile,
 
187
        uint32_t idx) {
 
188
    pa_dbusiface_card_profile *p = NULL;
 
189
 
 
190
    pa_assert(card);
 
191
    pa_assert(core);
 
192
    pa_assert(profile);
 
193
 
 
194
    p = pa_xnew(pa_dbusiface_card_profile, 1);
 
195
    p->index = idx;
 
196
    p->profile = profile;
 
197
    p->path = pa_sprintf_malloc("%s/%s%u", pa_dbusiface_card_get_path(card), OBJECT_NAME, idx);
 
198
    p->dbus_protocol = pa_dbus_protocol_get(core);
 
199
 
 
200
    pa_assert_se(pa_dbus_protocol_add_interface(p->dbus_protocol, p->path, &profile_interface_info, p) >= 0);
 
201
 
 
202
    return p;
 
203
}
 
204
 
 
205
void pa_dbusiface_card_profile_free(pa_dbusiface_card_profile *p) {
 
206
    pa_assert(p);
 
207
 
 
208
    pa_assert_se(pa_dbus_protocol_remove_interface(p->dbus_protocol, p->path, profile_interface_info.name) >= 0);
 
209
 
 
210
    pa_dbus_protocol_unref(p->dbus_protocol);
 
211
 
 
212
    pa_xfree(p->path);
 
213
    pa_xfree(p);
 
214
}
 
215
 
 
216
const char *pa_dbusiface_card_profile_get_path(pa_dbusiface_card_profile *p) {
 
217
    pa_assert(p);
 
218
 
 
219
    return p->path;
 
220
}
 
221
 
 
222
const char *pa_dbusiface_card_profile_get_name(pa_dbusiface_card_profile *p) {
 
223
    pa_assert(p);
 
224
 
 
225
    return p->profile->name;
 
226
}
 
227
 
 
228
pa_card_profile *pa_dbusiface_card_profile_get_profile(pa_dbusiface_card_profile *p) {
 
229
    pa_assert(p);
 
230
 
 
231
    return p->profile;
 
232
}