← Back to branch summary

~ubuntu-branches/ubuntu/trusty/modem-manager-gui/trusty-backports

« back to all changes in this revision

Viewing changes to src/addressbooks.c

  • Committer: Package Import Robot
  • Author(s): Graham Inggs
  • Date: 2013-07-30 12:51:59 UTC
  • Revision ID: package-import@ubuntu.com-20130730125159-flzv882fhuzhmfmi
Tags: upstream-0.0.16
Import upstream version 0.0.16

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addressbooks.c
 
1
/*
 
2
 *      addressbooks.c
 
3
 *      
 
4
 *      Copyright 2013 Alex <alex@linuxonly.ru>
 
5
 *      
 
6
 *      This program is free software: you can redistribute it and/or modify
 
7
 *      it under the terms of the GNU General Public License as published by
 
8
 *      the Free Software Foundation; either version 3 of the License, or
 
9
 *      (at your option) any later version.
 
10
 *      
 
11
 *      This program is distributed in the hope that it will be useful,
 
12
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *      GNU General Public License for more details.
 
15
 *      
 
16
 *      You should have received a copy of the GNU General Public License
 
17
 *      along with this program. If not, see <http://www.gnu.org/licenses/>.
 
18
 */
 
19
 
 
20
#include <stdlib.h>
 
21
#include <stdio.h>
 
22
#include <glib.h>
 
23
#include <gmodule.h>
 
24
 
 
25
#include "addressbooks.h"
 
26
 
 
27
 
 
28
static void mmgui_addressbooks_get_gnome_contacts_foreach(gpointer data, gpointer user_data)
 
29
{
 
30
        mmgui_addressbooks_t addressbooks;
 
31
        EContact *econtact;
 
32
        mmgui_contact_t contact;
 
33
        const gchar *fullname, *nickname, *primaryphone, *mobilephone, *email, *group;
 
34
        GList *emails;
 
35
        
 
36
        addressbooks = (mmgui_addressbooks_t)user_data;
 
37
        econtact = (EContact *)data;
 
38
        
 
39
        if ((addressbooks == NULL) || (econtact == NULL)) return;
 
40
        
 
41
        fullname = (addressbooks->e_contact_get_const)(econtact, E_CONTACT_FULL_NAME);
 
42
        nickname = (addressbooks->e_contact_get_const)(econtact, E_CONTACT_NICKNAME);
 
43
        primaryphone = (addressbooks->e_contact_get_const)(econtact, E_CONTACT_PHONE_HOME);
 
44
        mobilephone = (addressbooks->e_contact_get_const)(econtact, E_CONTACT_PHONE_MOBILE);
 
45
        group = (addressbooks->e_contact_get_const)(econtact, E_CONTACT_CATEGORIES);
 
46
        emails = (addressbooks->e_contact_get)(econtact, E_CONTACT_EMAIL);
 
47
        email = g_list_nth_data(emails, 0);
 
48
        
 
49
        contact = g_new0(struct _mmgui_contact, 1);
 
50
        
 
51
        contact->name = g_strdup(fullname);
 
52
        contact->number = g_strdup(primaryphone);
 
53
        contact->email = g_strdup(email);
 
54
        contact->group = g_strdup(group);
 
55
        contact->name2 = g_strdup(nickname);
 
56
        contact->number2 = g_strdup(mobilephone);
 
57
        contact->id = addressbooks->counter;
 
58
        contact->hidden = FALSE;
 
59
        contact->storage = MMGUI_CONTACTS_STORAGE_UNKNOWN;
 
60
        
 
61
        addressbooks->gnomecontacts = g_slist_prepend(addressbooks->gnomecontacts, contact);
 
62
        
 
63
        addressbooks->counter++;
 
64
        
 
65
        g_list_foreach(emails, (GFunc)g_free, NULL);
 
66
        g_list_free(emails);
 
67
}
 
68
 
 
69
static gboolean mmgui_addressbooks_get_gnome_contacts(mmgui_addressbooks_t addressbooks)
 
70
{
 
71
        EBookQuery *queryelements[2];
 
72
        EBookQuery *query;
 
73
        GError *error;
 
74
        gchar *s;
 
75
        /*New API*/
 
76
        ESourceRegistry *registry;
 
77
        ESource *source, *addressbook;
 
78
        EBookClient *client;
 
79
        GSList *scontacts;
 
80
        /*Old API*/
 
81
        EBook *book;
 
82
        GList *dcontacts;
 
83
        
 
84
        if (addressbooks == NULL) return FALSE;
 
85
        if (!addressbooks->gnomesupported) return FALSE;
 
86
        if (addressbooks->ebookmodule == NULL) return FALSE;
 
87
        
 
88
        error = NULL;
 
89
        
 
90
        queryelements[0] = (addressbooks->e_book_query_field_exists)(E_CONTACT_PHONE_HOME);
 
91
        queryelements[1] = (addressbooks->e_book_query_field_exists)(E_CONTACT_PHONE_MOBILE);
 
92
        
 
93
        query = (addressbooks->e_book_query_or)(2, queryelements, TRUE);
 
94
        if (query == NULL) {
 
95
                g_debug("Failed to form GNOME contacts query\n");
 
96
                return FALSE;
 
97
        }
 
98
        
 
99
        if (addressbooks->e_book_new_system_addressbook != NULL) {
 
100
                g_debug("Using old GNOME contacts API\n");
 
101
                book = (addressbooks->e_book_new_system_addressbook)(&error);
 
102
                if (book == NULL) {
 
103
                        (addressbooks->e_book_query_unref)(query);
 
104
                        g_debug("Failed to load GNOME system addressbook: %s\n", error->message);
 
105
                        g_error_free(error);
 
106
                        return FALSE;
 
107
                }
 
108
                
 
109
                if (!(addressbooks->e_book_open)(book, TRUE, &error)) {
 
110
                        (addressbooks->e_book_query_unref)(query);
 
111
                        g_debug("Failed to load GNOME system addressbook: %s\n", error->message);
 
112
                        g_error_free(error);
 
113
                        return FALSE;
 
114
                }
 
115
                
 
116
                if (!(addressbooks->e_book_get_contacts)(book, query, &dcontacts, &error)) {
 
117
                        (addressbooks->e_book_query_unref)(query);
 
118
                        g_debug("Failed to get query GNOME addressbook results: %s\n", error->message);
 
119
                        g_error_free(error);
 
120
                        return FALSE;
 
121
                }
 
122
        } else {
 
123
                g_debug("Using new GNOME contacts API\n");
 
124
                registry = (addressbooks->e_source_registry_new_sync)(NULL, &error);
 
125
                if (registry == NULL) {
 
126
                        (addressbooks->e_book_query_unref)(query);
 
127
                        g_debug("Failed to get ESourceRegistry: %s\n", error->message);
 
128
                        g_error_free(error);
 
129
                        return FALSE;
 
130
                }
 
131
                
 
132
                source = (addressbooks->e_source_registry_ref_builtin_address_book)(registry);
 
133
                if (source == NULL) {
 
134
                        (addressbooks->e_book_query_unref)(query);
 
135
                        g_debug("Failed to get ESource\n");
 
136
                        return FALSE;
 
137
                }
 
138
                
 
139
                if (addressbooks->e_book_client_connect_sync != NULL) {
 
140
                        /*Version 3.8*/
 
141
                        client = (EBookClient *)(addressbooks->e_book_client_connect_sync)(source, NULL, &error);
 
142
                        if (client == NULL) {
 
143
                                (addressbooks->e_book_query_unref)(query);
 
144
                                g_debug("Failed to get EBookClient: %s\n", error->message);
 
145
                                g_error_free(error);
 
146
                                return FALSE;
 
147
                        }
 
148
                } else {
 
149
                        /*Versions 3.2 ... 3.6*/
 
150
                        client = (addressbooks->e_book_client_new)(source, &error);
 
151
                        if (client == NULL) {
 
152
                                (addressbooks->e_book_query_unref)(query);
 
153
                                g_debug("Failed to get EBookClient: %s\n", error->message);
 
154
                                g_error_free(error);
 
155
                                return FALSE;
 
156
                        }
 
157
                        
 
158
                        if (!(addressbooks->e_client_open_sync)((EClient *)client, TRUE, NULL, &error)) {
 
159
                                (addressbooks->e_book_query_unref)(query);
 
160
                                g_debug("Failed to open EBookClient: %s\n", error->message);
 
161
                                g_error_free(error);
 
162
                                return FALSE;
 
163
                        }
 
164
                }
 
165
                
 
166
                s = (addressbooks->e_book_query_to_string)(query);
 
167
                if (s == NULL) {
 
168
                        (addressbooks->e_book_query_unref)(query);
 
169
                        g_debug("Failed to get GNOME addressbook request in string format\n");
 
170
                        return FALSE;
 
171
                }
 
172
                
 
173
                g_debug("GNOME addressbook request: %s\n", s);
 
174
                
 
175
                if (!(addressbooks->e_book_client_get_contacts_sync)(client, s, &scontacts, NULL, &error)) {
 
176
                        (addressbooks->e_book_query_unref)(query);
 
177
                        g_debug("Failed to get GNOME addressbook query results: %s\n", error->message);
 
178
                        g_error_free(error);
 
179
                        return FALSE;
 
180
                }
 
181
        }
 
182
        
 
183
        (addressbooks->e_book_query_unref)(query);
 
184
        
 
185
        if (addressbooks->e_book_new_system_addressbook != NULL) {
 
186
                if (dcontacts != NULL) {
 
187
                        addressbooks->counter = 0;
 
188
                        g_list_foreach(dcontacts, (GFunc)mmgui_addressbooks_get_gnome_contacts_foreach, addressbooks);
 
189
                } else {
 
190
                        g_debug("No suitable contacts found\n");
 
191
                }
 
192
        } else {
 
193
                if (scontacts != NULL) {
 
194
                        addressbooks->counter = 0;
 
195
                        g_slist_foreach(scontacts, (GFunc)mmgui_addressbooks_get_gnome_contacts_foreach, addressbooks);
 
196
                } else {
 
197
                        g_debug("No suitable contacts found\n");
 
198
                }
 
199
        }
 
200
        
 
201
        addressbooks->counter = 0;
 
202
        
 
203
        return TRUE;
 
204
}
 
205
 
 
206
mmgui_addressbooks_t mmgui_addressbooks_new(mmgui_libpaths_cache_t libcache)
 
207
{
 
208
        mmgui_addressbooks_t addressbooks;
 
209
        gboolean libopened;
 
210
        
 
211
        addressbooks = g_new0(struct _mmgui_addressbooks, 1);
 
212
        
 
213
        /*libebook*/
 
214
        addressbooks->ebookmodule = NULL;
 
215
        addressbooks->gnomesupported = FALSE;
 
216
        addressbooks->gnomecontacts = NULL;
 
217
        
 
218
        /*Open module*/
 
219
        addressbooks->ebookmodule = g_module_open(mmgui_libpaths_cache_get_library_name(libcache, "libebook-1.2"), G_MODULE_BIND_LAZY);
 
220
        
 
221
        if (addressbooks->ebookmodule != NULL) {
 
222
                libopened = TRUE;
 
223
                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_query_field_exists", (gpointer *)&(addressbooks->e_book_query_field_exists));
 
224
                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_query_or", (gpointer *)&(addressbooks->e_book_query_or));
 
225
                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_query_unref", (gpointer *)&(addressbooks->e_book_query_unref));
 
226
                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_contact_get_const", (gpointer *)&(addressbooks->e_contact_get_const));
 
227
                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_contact_get", (gpointer *)&(addressbooks->e_contact_get));
 
228
                if (g_module_symbol(addressbooks->ebookmodule, "e_book_new_system_addressbook", (gpointer *)&(addressbooks->e_book_new_system_addressbook))) {
 
229
                        libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_open", (gpointer *)&(addressbooks->e_book_open));
 
230
                        libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_get_contacts", (gpointer *)&(addressbooks->e_book_get_contacts));
 
231
                        /*Unused functions*/
 
232
                        addressbooks->e_source_registry_new_sync = NULL;
 
233
                        addressbooks->e_source_registry_ref_builtin_address_book = NULL;
 
234
                        addressbooks->e_book_client_new = NULL;
 
235
                        addressbooks->e_client_open_sync = NULL;
 
236
                        addressbooks->e_book_client_connect_sync = NULL;
 
237
                        addressbooks->e_book_query_to_string = NULL;
 
238
                        addressbooks->e_book_client_get_contacts_sync = NULL;
 
239
                } else {
 
240
                        if (!g_module_symbol(addressbooks->ebookmodule, "e_book_client_connect_sync", (gpointer *)&(addressbooks->e_book_client_connect_sync))) {
 
241
                                /*Since version 3.2 used these functions, but in 3.8 they are deprecated*/
 
242
                                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_client_new", (gpointer *)&(addressbooks->e_book_client_new));
 
243
                                libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_client_open_sync", (gpointer *)&(addressbooks->e_client_open_sync));
 
244
                                addressbooks->e_book_client_connect_sync = NULL;
 
245
                        }
 
246
                        libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_source_registry_new_sync", (gpointer *)&(addressbooks->e_source_registry_new_sync));
 
247
                        libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_source_registry_ref_builtin_address_book", (gpointer *)&(addressbooks->e_source_registry_ref_builtin_address_book));
 
248
                        libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_query_to_string", (gpointer *)&(addressbooks->e_book_query_to_string));
 
249
                        libopened = libopened && g_module_symbol(addressbooks->ebookmodule, "e_book_client_get_contacts_sync", (gpointer *)&(addressbooks->e_book_client_get_contacts_sync));
 
250
                        
 
251
                        /*Unused functions*/
 
252
                        addressbooks->e_book_get_contacts = NULL;
 
253
                        addressbooks->e_book_open = NULL;
 
254
                        addressbooks->e_book_get_contacts = NULL;
 
255
                }
 
256
                /*If some functions not exported, close library*/
 
257
                if (!libopened) {
 
258
                        addressbooks->e_book_query_field_exists = NULL;
 
259
                        addressbooks->e_book_query_or = NULL;
 
260
                        addressbooks->e_source_registry_new_sync = NULL;
 
261
                        addressbooks->e_source_registry_ref_builtin_address_book = NULL;
 
262
                        addressbooks->e_book_client_new = NULL;
 
263
                        addressbooks->e_client_open_sync = NULL;
 
264
                        addressbooks->e_book_query_to_string = NULL;
 
265
                        addressbooks->e_book_client_get_contacts_sync = NULL;
 
266
                        addressbooks->e_book_new_system_addressbook = NULL;
 
267
                        addressbooks->e_book_open = NULL;
 
268
                        addressbooks->e_book_get_contacts = NULL;
 
269
                        addressbooks->e_book_query_unref = NULL;
 
270
                        addressbooks->e_contact_get_const = NULL;
 
271
                        addressbooks->e_contact_get = NULL;
 
272
                        /*Close module*/
 
273
                        g_module_close(addressbooks->ebookmodule);
 
274
                        addressbooks->ebookmodule = NULL;
 
275
                        addressbooks->gnomesupported = FALSE;
 
276
                } else {
 
277
                        /*Get contacts*/
 
278
                        addressbooks->gnomesupported = TRUE;
 
279
                        mmgui_addressbooks_get_gnome_contacts(addressbooks);
 
280
                }
 
281
        }
 
282
        
 
283
        /*KDE addressbook is not supported now*/
 
284
        addressbooks->kdecontacts = NULL;
 
285
        addressbooks->kdesupported = FALSE;
 
286
        
 
287
        return addressbooks;
 
288
}
 
289
 
 
290
gboolean mmgui_addressbooks_get_gnome_contacts_available(mmgui_addressbooks_t addressbooks)
 
291
{
 
292
        if (addressbooks == NULL) return FALSE;
 
293
        
 
294
        return addressbooks->gnomesupported;
 
295
}
 
296
 
 
297
gboolean mmgui_addressbooks_get_kde_contacts_available(mmgui_addressbooks_t addressbooks)
 
298
{
 
299
        if (addressbooks == NULL) return FALSE;
 
300
        
 
301
        return addressbooks->kdesupported;
 
302
}
 
303
 
 
304
GSList *mmgui_addressbooks_get_gnome_contacts_list(mmgui_addressbooks_t addressbooks)
 
305
{
 
306
        if (addressbooks == NULL) return NULL;
 
307
        if (!addressbooks->gnomesupported) return NULL;
 
308
        
 
309
        return addressbooks->gnomecontacts;
 
310
}
 
311
 
 
312
GSList *mmgui_addressbooks_get_kde_contacts_list(mmgui_addressbooks_t addressbooks)
 
313
{
 
314
        if (addressbooks == NULL) return NULL;
 
315
        if (!addressbooks->kdesupported) return NULL;
 
316
        
 
317
        return addressbooks->kdecontacts;
 
318
}
 
319
 
 
320
 
 
321
static gint mmgui_addressbooks_get_contact_compare(gconstpointer a, gconstpointer b)
 
322
{
 
323
        mmgui_contact_t contact;
 
324
        guint id;
 
325
        
 
326
        contact = (mmgui_contact_t)a;
 
327
        id = GPOINTER_TO_UINT(b);
 
328
        
 
329
        if (contact->id < id) {
 
330
                return 1;
 
331
        } else if (contact->id > id) {
 
332
                return -1;
 
333
        } else {
 
334
                return 0;
 
335
        }
 
336
}
 
337
 
 
338
mmgui_contact_t mmgui_addressbooks_get_gnome_contact(mmgui_addressbooks_t addressbooks, guint index)
 
339
{
 
340
        GSList *contactptr;
 
341
        mmgui_contact_t contact;
 
342
        
 
343
        if (addressbooks == NULL) return NULL;
 
344
        if (!addressbooks->gnomesupported) return NULL;
 
345
        if (addressbooks->gnomecontacts == NULL) return NULL;
 
346
        
 
347
        contactptr = g_slist_find_custom(addressbooks->gnomecontacts, GUINT_TO_POINTER(index), mmgui_addressbooks_get_contact_compare);
 
348
        
 
349
        if (contactptr != NULL) {
 
350
                contact = (mmgui_contact_t)contactptr->data;
 
351
                return contact;
 
352
        } else {
 
353
                return NULL;
 
354
        }
 
355
}
 
356
 
 
357
mmgui_contact_t mmgui_addressbooks_get_kde_contact(mmgui_addressbooks_t addressbooks, guint index)
 
358
{
 
359
        GSList *contactptr;
 
360
        mmgui_contact_t contact;
 
361
        
 
362
        if (addressbooks == NULL) return NULL;
 
363
        if (!addressbooks->kdesupported) return NULL;
 
364
        if (addressbooks->kdecontacts == NULL) return NULL;
 
365
        
 
366
        contactptr = g_slist_find_custom(addressbooks->kdecontacts, GUINT_TO_POINTER(index), mmgui_addressbooks_get_contact_compare);
 
367
        
 
368
        if (contactptr != NULL) {
 
369
                contact = (mmgui_contact_t)contactptr->data;
 
370
                return contact;
 
371
        } else {
 
372
                return NULL;
 
373
        }
 
374
}
 
375
 
 
376
static void mmgui_addressbooks_free_contacts_list_foreach(gpointer data, gpointer user_data)
 
377
{
 
378
        mmgui_contact_t contact;
 
379
        
 
380
        if (data == NULL) return;
 
381
        
 
382
        contact = (mmgui_contact_t)data;
 
383
        
 
384
        if (contact->name != NULL) {
 
385
                g_free(contact->name);
 
386
        }
 
387
        if (contact->number != NULL) {
 
388
                g_free(contact->number);
 
389
        }
 
390
        if (contact->email != NULL) {
 
391
                g_free(contact->email);
 
392
        }
 
393
        if (contact->group != NULL) {
 
394
                g_free(contact->group);
 
395
        }
 
396
        if (contact->name2 != NULL) {
 
397
                g_free(contact->name2);
 
398
        }
 
399
        if (contact->number2 != NULL) {
 
400
                g_free(contact->number2);
 
401
        }
 
402
}
 
403
 
 
404
void mmgui_addressbooks_close(mmgui_addressbooks_t addressbooks)
 
405
{
 
406
        if (addressbooks == NULL) return;
 
407
        
 
408
        /*GNOME addressbook*/
 
409
        addressbooks->gnomesupported = FALSE;
 
410
        if (addressbooks->ebookmodule != NULL) {
 
411
                /*First free contacts list*/
 
412
                if (addressbooks->gnomecontacts != NULL) {
 
413
                        g_slist_foreach(addressbooks->gnomecontacts, mmgui_addressbooks_free_contacts_list_foreach, NULL);
 
414
                        g_slist_free(addressbooks->gnomecontacts);
 
415
                        addressbooks->gnomecontacts = NULL;
 
416
                }
 
417
                /*Then unload module*/
 
418
                g_module_close(addressbooks->ebookmodule);
 
419
                addressbooks->ebookmodule = NULL;
 
420
        }
 
421
        
 
422
        /*KDE addressbook*/
 
423
        addressbooks->kdesupported = FALSE;
 
424
        if (addressbooks->kdecontacts != NULL) {
 
425
                /*Only free contacts list*/
 
426
                g_slist_foreach(addressbooks->kdecontacts, mmgui_addressbooks_free_contacts_list_foreach, NULL);
 
427
                g_slist_free(addressbooks->kdecontacts);
 
428
                addressbooks->kdecontacts = NULL;
 
429
        }
 
430
        
 
431
        g_free(addressbooks);
 
432
}