« back to all changes in this revision
Viewing changes to src/me-service-gwibber.c
- browse files at revision 97
- compare with another revision
- download diff
- download tarball
- view history from revision 97
- Committer: David Barth
- Date: 2010-08-17 15:02:12 UTC
- mfrom: (96.1.9 indicator-me)
- Revision ID: david.barth@canonical.com-20100817150212-dsr4tuz8npp3zqx3
libgwibber port, thanks to kenvandine\!
added
removed
src/me-service-gwibber.c
24
24
25
25
#include <glib.h>
26
26
27
#include <dbus/dbus-glib.h>
28
#include <dbus/dbus-glib-bindings.h>
29
30
#define DBUS_SERVICE_ADDRESS "com.Gwibber.Service"
31
#define DBUS_SERVICE_SERVICE_OBJECT "/com/gwibber/Service"
32
#define DBUS_SERVICE_SERVICE_INTERFACE "com.Gwibber.Service"
33
34
#define DBUS_SERVICE_ACCOUNTS_OBJECT "/com/gwibber/Accounts"
35
#define DBUS_SERVICE_ACCOUNTS_INTERFACE "com.Gwibber.Accounts"
27
#include <gwibber.h>
36
28
37
29
/* gobject infrastructure */
38
30
39
typedef struct _GwibberServicePrivate GwibberServicePrivate;
40
struct _GwibberServicePrivate {
41
DBusGProxy * dbus_proxy;
42
DBusGProxy * service_proxy;
43
DBusGProxy * accounts_proxy;
31
typedef struct _MeGwibberServicePrivate MeGwibberServicePrivate;
32
struct _MeGwibberServicePrivate {
33
GwibberService * me_gwibber_service;
34
GwibberAccounts * me_gwibber_accounts;
44
35
int status;
45
36
gboolean has_configured_accounts;
46
37
};
54
45
static guint signals[LAST_SIGNAL] = { 0 };
55
46
56
47
/* Prototypes */
57
static void gwibber_service_class_init (GwibberServiceClass *klass);
58
static void gwibber_service_init (GwibberService *self);
59
static void gwibber_service_dispose (GObject *object);
60
static void gwibber_service_finalize (GObject *object);
61
62
static void dbus_namechange (DBusGProxy * proxy, const gchar * name, const gchar * prev, const gchar * new, GwibberService * self);
63
static void gwibber_exists_cb (DBusGProxy * proxy, gboolean exists, GError * error, gpointer userdata);
64
static void setup_service_proxies (GwibberService *self);
65
static void query_account_manager (GwibberService *self);
66
67
G_DEFINE_TYPE (GwibberService, gwibber_service, G_TYPE_OBJECT);
68
69
#define GWIBBER_SERVICE_GET_PRIVATE(o) \
70
(G_TYPE_INSTANCE_GET_PRIVATE ((o), GWIBBER_SERVICE_TYPE, GwibberServicePrivate))
48
static void me_gwibber_service_class_init (MeGwibberServiceClass *klass);
49
static void me_gwibber_service_init (MeGwibberService *self);
50
static void me_gwibber_service_dispose (GObject *object);
51
static void me_gwibber_service_finalize (GObject *object);
52
53
static void me_gwibber_service_exists_cb (GwibberService * me_gwibber_service, gboolean exists, gpointer userdata);
54
static void me_gwibber_accounts_exists_cb (GwibberAccounts * me_gwibber_accounts, gboolean exists, gpointer userdata);
55
static void setup_service_proxies (MeGwibberService *self);
56
static void query_account_manager (MeGwibberService *self);
57
58
G_DEFINE_TYPE (MeGwibberService, me_gwibber_service, G_TYPE_OBJECT);
59
60
#define ME_GWIBBER_SERVICE_GET_PRIVATE(o) \
61
(G_TYPE_INSTANCE_GET_PRIVATE ((o), ME_GWIBBER_SERVICE_TYPE, MeGwibberServicePrivate))
71
62
72
63
static void
73
gwibber_service_class_init (GwibberServiceClass *klass)
64
me_gwibber_service_class_init (MeGwibberServiceClass *klass)
74
65
{
75
66
GObjectClass *object_class = G_OBJECT_CLASS (klass);
76
67
77
g_type_class_add_private (klass, sizeof (GwibberServicePrivate));
78
79
object_class->dispose = gwibber_service_dispose;
80
object_class->finalize = gwibber_service_finalize;
81
82
signals[STATUS_CHANGED] = g_signal_new(GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED,
68
g_type_class_add_private (klass, sizeof (MeGwibberServicePrivate));
69
70
object_class->dispose = me_gwibber_service_dispose;
71
object_class->finalize = me_gwibber_service_finalize;
72
73
signals[STATUS_CHANGED] = g_signal_new(ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED,
83
74
G_TYPE_FROM_CLASS(klass),
84
75
G_SIGNAL_RUN_LAST,
85
G_STRUCT_OFFSET(GwibberServiceClass, status_changed),
76
G_STRUCT_OFFSET(MeGwibberServiceClass, status_changed),
86
77
NULL, NULL,
87
78
g_cclosure_marshal_VOID__UINT,
88
79
G_TYPE_NONE, 1, G_TYPE_UINT);
90
81
}
91
82
92
83
static void
93
gwibber_service_init (GwibberService *self)
94
{
95
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
96
97
priv->dbus_proxy = NULL;
98
priv->service_proxy = NULL;
99
priv->accounts_proxy = NULL;
100
priv->status = GWIBBER_SERVICE_STATUS_NOT_RUNNING;
101
priv->has_configured_accounts = FALSE;
102
103
DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
104
g_return_if_fail(bus != NULL); /* Can't do anymore DBus stuff without this,
105
all non-DBus stuff should be done */
106
107
GError * error = NULL;
108
109
/* Set up the dbus Proxy */
110
priv->dbus_proxy = dbus_g_proxy_new_for_name_owner (bus,
111
DBUS_SERVICE_DBUS,
112
DBUS_PATH_DBUS,
113
DBUS_INTERFACE_DBUS,
114
&error);
115
if (error != NULL) {
116
g_warning("Unable to connect to DBus events: %s", error->message);
117
g_error_free(error);
118
return;
119
}
120
121
/* Configure the name owner changing */
122
dbus_g_proxy_add_signal(priv->dbus_proxy, "NameOwnerChanged",
123
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
124
G_TYPE_INVALID);
125
dbus_g_proxy_connect_signal(priv->dbus_proxy, "NameOwnerChanged",
126
G_CALLBACK(dbus_namechange),
127
self, NULL);
128
129
org_freedesktop_DBus_name_has_owner_async(priv->dbus_proxy, DBUS_SERVICE_ADDRESS, gwibber_exists_cb, self);
130
131
return;
132
}
133
134
static void
135
gwibber_service_dispose (GObject *object)
136
{
137
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(object);
138
139
if (priv->dbus_proxy != NULL) {
140
g_object_unref(priv->dbus_proxy);
141
priv->dbus_proxy = NULL;
142
}
143
144
if (priv->service_proxy != NULL) {
145
g_object_unref(priv->service_proxy);
146
priv->service_proxy = NULL;
147
}
148
149
if (priv->accounts_proxy != NULL) {
150
g_object_unref(priv->accounts_proxy);
151
priv->accounts_proxy = NULL;
152
}
153
154
G_OBJECT_CLASS (gwibber_service_parent_class)->dispose (object);
155
return;
156
}
157
158
static void
159
gwibber_service_finalize (GObject *object)
160
{
161
G_OBJECT_CLASS (gwibber_service_parent_class)->finalize (object);
162
return;
163
}
164
165
166
/* Watch for Gwibber coming on and off the bus. */
167
static void
168
dbus_namechange (DBusGProxy * proxy, const gchar * name, const gchar * prev, const gchar * new, GwibberService * self)
169
{
170
g_return_if_fail (IS_GWIBBER_SERVICE (self));
171
172
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
173
174
if (prev[0] == '\0' && g_strcmp0(name, DBUS_SERVICE_ADDRESS) == 0) {
175
g_debug("Gwibber Service coming online");
176
priv->status = GWIBBER_SERVICE_STATUS_RUNNING;
177
if (priv->service_proxy == NULL ||
178
priv->accounts_proxy == NULL)
179
setup_service_proxies (self);
180
query_account_manager (self);
181
}
182
183
if (new[0] == '\0' && g_strcmp0(name, DBUS_SERVICE_ADDRESS) == 0) {
184
g_debug("Gwibber Service going offline");
185
priv->status = GWIBBER_SERVICE_STATUS_NOT_RUNNING;
186
g_signal_emit (G_OBJECT (self), GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
187
if (priv->service_proxy != NULL) {
188
g_object_unref(priv->service_proxy);
189
priv->service_proxy = NULL;
190
}
191
if (priv->accounts_proxy != NULL) {
192
g_object_unref(priv->accounts_proxy);
193
priv->accounts_proxy = NULL;
194
}
195
}
196
197
return;
198
}
199
200
static void
201
get_accounts_response (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
202
{
203
GError *error = NULL;
204
gchar *accounts_string = NULL;
205
206
dbus_g_proxy_end_call (proxy, call, &error,
207
G_TYPE_STRING, &accounts_string,
208
G_TYPE_INVALID);
209
210
if (error != NULL) {
211
g_warning ("GetAccounts: %s", error->message);
212
g_error_free (error);
213
g_free (accounts_string);
214
return;
215
}
216
217
/* don't print the accounts string, it contains passwords */
218
/* g_debug ("GetAccounts: %s", accounts_string); */
219
220
g_return_if_fail (IS_GWIBBER_SERVICE (data));
221
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(data);
222
g_return_if_fail (priv != NULL);
223
/* Note: not free'ing accounts_string here, but g_return_if_fail are
224
meant to catch design errors, not runtime ones */
225
226
priv->status = GWIBBER_SERVICE_STATUS_RUNNING;
227
priv->has_configured_accounts = g_strrstr (accounts_string, " \"send_enabled\": true,") ? TRUE : FALSE;
228
229
/* trigger a status update */
230
g_signal_emit (G_OBJECT (data),
231
GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID,
84
me_gwibber_service_init (MeGwibberService *self)
85
{
86
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
87
88
priv->me_gwibber_service = NULL;
89
priv->me_gwibber_accounts = NULL;
90
priv->status = ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING;
91
priv->has_configured_accounts = FALSE;
92
93
setup_service_proxies(self);
94
return;
95
}
96
97
static void
98
me_gwibber_service_dispose (GObject *object)
99
{
100
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(object);
101
102
if (priv->me_gwibber_service != NULL) {
103
g_object_unref(priv->me_gwibber_service);
104
priv->me_gwibber_service = NULL;
105
}
106
107
if (priv->me_gwibber_accounts != NULL) {
108
g_object_unref(priv->me_gwibber_accounts);
109
priv->me_gwibber_accounts = NULL;
110
}
111
112
G_OBJECT_CLASS (me_gwibber_service_parent_class)->dispose (object);
113
return;
114
}
115
116
static void
117
me_gwibber_service_finalize (GObject *object)
118
{
119
G_OBJECT_CLASS (me_gwibber_service_parent_class)->finalize (object);
120
return;
121
}
122
123
static gboolean
124
check_account_send_enabled (GHashTable * account_table) {
125
return g_value_get_boolean(g_hash_table_lookup(account_table, "send_enabled"));
126
}
127
128
static void
129
query_account_manager (MeGwibberService *self)
130
{
131
g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
132
133
gpointer accounts_table;
134
gpointer account_table;
135
GHashTableIter accounts_iter;
136
gpointer account;
137
gboolean send_enabled;
138
139
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
140
141
if (priv->me_gwibber_accounts == NULL) {
142
g_warning ("no accounts, can't query for accounts");
143
return;
144
}
145
146
accounts_table = gwibber_accounts_list (priv->me_gwibber_accounts);
147
if (accounts_table == NULL) {
148
g_warning ("failed to get accounts list");
149
return;
150
}
151
152
g_hash_table_iter_init (&accounts_iter, accounts_table);
153
154
priv->has_configured_accounts = FALSE;
155
156
while (g_hash_table_iter_next (&accounts_iter, &account, &account_table)) {
157
send_enabled = check_account_send_enabled (account_table);
158
if (send_enabled) {
159
priv->has_configured_accounts = TRUE;
160
}
161
}
162
163
g_signal_emit (G_OBJECT (self),
164
ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID,
232
165
0, priv->status, TRUE);
233
166
234
g_free (accounts_string);
235
167
g_hash_table_destroy(accounts_table);
236
168
return;
237
169
}
238
170
239
171
static void
240
query_account_manager (GwibberService *self)
241
{
242
g_return_if_fail (IS_GWIBBER_SERVICE (self));
243
244
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
245
246
if (priv->service_proxy == NULL) {
247
g_warning ("no service_proxy, can't query for accounts");
248
return;
249
}
250
251
dbus_g_proxy_begin_call(priv->service_proxy,
252
"GetAccounts",
253
get_accounts_response,
254
self,
255
NULL,
256
G_TYPE_INVALID);
257
}
258
259
static void
260
accounts_changed (DBusGProxy *proxy, const gchar *id, GwibberService *self)
261
{
262
g_return_if_fail (IS_GWIBBER_SERVICE (self));
263
264
g_debug ("accounts_changed");
172
accounts_changed (GwibberAccounts *me_gwibber_accounts, GHashTable *account_table, MeGwibberService *self)
173
{
174
g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
265
175
266
176
query_account_manager (self);
267
177
268
178
return;
269
179
}
270
180
271
static void
272
setup_service_proxies (GwibberService *self)
273
{
274
g_return_if_fail (IS_GWIBBER_SERVICE (self));
275
276
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
277
278
DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
279
g_return_if_fail(bus != NULL); /* Can't do anymore DBus stuff without this,
280
all non-DBus stuff should be done */
281
282
if (priv->service_proxy == NULL) {
283
priv->service_proxy = dbus_g_proxy_new_for_name(
284
bus,
285
DBUS_SERVICE_ADDRESS,
286
DBUS_SERVICE_SERVICE_OBJECT,
287
DBUS_SERVICE_SERVICE_INTERFACE);
288
if (priv->service_proxy == NULL) {
289
g_warning ("can't setup service_proxy");
290
return;
291
}
292
}
293
294
if (priv->accounts_proxy == NULL) {
295
priv->accounts_proxy =
296
dbus_g_proxy_new_for_name(bus,
297
DBUS_SERVICE_ADDRESS,
298
DBUS_SERVICE_ACCOUNTS_OBJECT,
299
DBUS_SERVICE_ACCOUNTS_INTERFACE);
300
if (priv->accounts_proxy == NULL) {
301
g_warning ("can't setup accounts_proxy");
302
return;
303
}
304
}
305
306
/* Monitor signals about account changes */
307
dbus_g_proxy_add_signal(priv->accounts_proxy, "AccountChanged",
308
G_TYPE_STRING,
309
G_TYPE_INVALID);
310
dbus_g_proxy_connect_signal(priv->accounts_proxy, "AccountChanged",
311
G_CALLBACK(accounts_changed),
312
self, NULL);
313
dbus_g_proxy_add_signal(priv->accounts_proxy, "AccountDeleted",
314
G_TYPE_STRING,
315
G_TYPE_INVALID);
316
dbus_g_proxy_connect_signal(priv->accounts_proxy, "AccountDeleted",
317
G_CALLBACK(accounts_changed),
318
self, NULL);
319
320
}
321
322
static void
323
gwibber_exists_cb (DBusGProxy * proxy, gboolean exists, GError * error, gpointer userdata)
324
{
325
if (error) {
326
g_warning ("Unable to check if Gwibber is running: %s", error->message);
327
return;
328
}
329
330
if (exists) {
331
setup_service_proxies (GWIBBER_SERVICE (userdata));
332
query_account_manager (GWIBBER_SERVICE (userdata));
333
}
334
335
return;
336
}
337
338
GwibberService * gwibber_service_new (void){
339
return GWIBBER_SERVICE (g_object_new (GWIBBER_SERVICE_TYPE, NULL));
340
}
341
342
static void
343
send_message_response (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
344
{
345
g_debug ("send_message_response");
346
347
return;
181
182
static void
183
setup_service_proxies (MeGwibberService *self)
184
{
185
g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
186
187
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
188
189
if (priv->me_gwibber_service == NULL) {
190
priv->me_gwibber_service = gwibber_service_new ();
191
if (priv->me_gwibber_service == NULL) {
192
g_warning ("can't setup me_gwibber_service");
193
return;
194
}
195
}
196
197
g_signal_connect (priv->me_gwibber_service, "is-available",
198
G_CALLBACK(me_gwibber_service_exists_cb), ME_GWIBBER_SERVICE (self));
199
200
if (priv->me_gwibber_accounts == NULL) {
201
priv->me_gwibber_accounts = gwibber_accounts_new ();;
202
if (priv->me_gwibber_accounts == NULL) {
203
g_warning ("can't setup me_gwibber_accounts");
204
return;
205
}
206
}
207
208
g_signal_connect (priv->me_gwibber_accounts, "is-available",
209
G_CALLBACK(me_gwibber_accounts_exists_cb), ME_GWIBBER_SERVICE (self));
210
}
211
212
static void
213
me_gwibber_service_exists_cb (GwibberService * me_gwibber_service, gboolean exists, gpointer userdata)
214
{
215
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(ME_GWIBBER_SERVICE (userdata));
216
217
if (exists) {
218
priv->status = ME_GWIBBER_SERVICE_STATUS_RUNNING;
219
}
220
221
222
if (!exists) {
223
priv->status = ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING;
224
g_signal_emit (G_OBJECT (ME_GWIBBER_SERVICE (userdata)), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
225
}
226
return;
227
}
228
229
static void
230
me_gwibber_accounts_exists_cb (GwibberAccounts * me_gwibber_accounts, gboolean exists, gpointer userdata)
231
{
232
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(ME_GWIBBER_SERVICE (userdata));
233
234
if (exists) {
235
if (priv->me_gwibber_accounts == NULL) {
236
priv->me_gwibber_accounts = gwibber_accounts_new ();;
237
if (priv->me_gwibber_accounts == NULL) {
238
g_warning ("can't setup me_gwibber_accounts");
239
return;
240
}
241
}
242
243
query_account_manager (ME_GWIBBER_SERVICE (userdata));
244
g_signal_emit (G_OBJECT (ME_GWIBBER_SERVICE (userdata)), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
245
g_signal_connect (priv->me_gwibber_accounts, "account-updated",
246
G_CALLBACK(accounts_changed), ME_GWIBBER_SERVICE (userdata));
247
}
248
return;
249
}
250
251
252
MeGwibberService * me_gwibber_service_new (void){
253
return ME_GWIBBER_SERVICE (g_object_new (ME_GWIBBER_SERVICE_TYPE, NULL));
348
254
}
349
255
350
256
void
351
gwibber_service_send (GwibberService *self, const gchar *msg)
257
me_gwibber_service_send (MeGwibberService *self, const gchar *msg)
352
258
{
353
g_return_if_fail (IS_GWIBBER_SERVICE (self));
259
g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
354
260
355
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
261
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
356
262
357
263
GValue value = {0};
358
264
g_value_init(&value, G_TYPE_STRING);
359
265
g_value_set_string(&value, msg);
360
266
361
g_debug ("gwibber_send: %s\n", msg);
362
363
if (priv->service_proxy == NULL) {
267
if (priv->me_gwibber_service == NULL) {
364
268
setup_service_proxies (self);
365
if (priv->service_proxy == NULL) {
366
g_warning ("can't setup service_proxy");
269
if (priv->me_gwibber_service == NULL) {
270
g_warning ("can't setup me_gwibber_service");
367
271
return;
368
272
}
369
273
}
370
274
371
dbus_g_proxy_begin_call(priv->service_proxy,
372
"SendMessage",
373
send_message_response,
374
NULL,
375
NULL,
376
G_TYPE_VALUE,
377
&value,
378
G_TYPE_INVALID);
275
gwibber_service_send_message (priv->me_gwibber_service, g_value_get_string (&value));
379
276
380
277
g_value_unset(&value);
381
278
382
279
return;
383
280
}
384
281
385
GwibberService *
386
gwibber_service_get (void)
282
MeGwibberService *
283
me_gwibber_service_get (void)
387
284
{
388
static GwibberService *singleton = NULL;
285
static MeGwibberService *singleton = NULL;
389
286
390
287
if (! singleton) {
391
singleton = gwibber_service_new ();
288
singleton = me_gwibber_service_new ();
392
289
}
393
290
394
291
return singleton;
395
292
}
396
293
397
294
gboolean
398
gwibber_service_has_configured_accounts (GwibberService *self)
295
me_gwibber_service_has_configured_accounts (MeGwibberService *self)
399
296
{
400
g_return_val_if_fail (IS_GWIBBER_SERVICE (self), FALSE);
297
g_return_val_if_fail (IS_ME_GWIBBER_SERVICE (self), FALSE);
401
298
402
GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
299
MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
403
300
404
301
return priv->has_configured_accounts;
405
302
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1