accounts-qt  0.31
manager.cpp
Go to the documentation of this file.
1 /* vi: set et sw=4 ts=4 cino=t0,(0: */
2 /*
3  * This file is part of libaccounts-qt
4  *
5  * Copyright (C) 2009-2010 Nokia Corporation.
6  *
7  * Contact: Alberto Mardegan <alberto.mardegan@nokia.com>
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public License
11  * version 2.1 as published by the Free Software Foundation.
12  *
13  * This library is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21  * 02110-1301 USA
22  */
23 
24 #include <QtCore>
25 
26 #include "service.h"
27 #include "manager.h"
28 
29 #include <libaccounts-glib/ag-manager.h>
30 #include <libaccounts-glib/ag-account.h>
31 
32 
33 namespace Accounts {
34 
35 class Manager::Private
36 {
37  Q_DECLARE_PUBLIC(Manager)
38 
39  typedef QHash<AgProvider *, Provider *> ProviderHash;
40  typedef QHash<AgService *, Service *> ServiceHash;
41  typedef QHash<const QString, ServiceType *> ServiceTypeHash;
42 public:
43  Private():
44  q_ptr(0),
45  m_manager(0),
46  providers(),
47  services(),
48  serviceTypes()
49  {
50  }
51 
52  ~Private() {
53  foreach (Provider *provider, providers)
54  {
55  delete provider;
56  }
57  providers.clear();
58  foreach (Service *service, services)
59  {
60  delete service;
61  }
62  services.clear();
63 
64  foreach (ServiceType *serviceType, serviceTypes)
65  {
66  delete serviceType;
67  }
68  serviceTypes.clear();
69  }
70 
71  void init(Manager *q, AgManager *manager);
72 
73  mutable Manager *q_ptr;
74  AgManager *m_manager; //real manager
75  ProviderHash providers;
76  ServiceHash services;
77  ServiceTypeHash serviceTypes;
78 
79  static void on_account_created(Manager *self, AgAccountId id);
80  static void on_account_deleted(Manager *self, AgAccountId id);
81  static void on_account_updated(Manager *self, AgAccountId id);
82  static void on_enabled_event(Manager *self, AgAccountId id);
83 };
84 
85 } //namespace Accounts
86 
87 using namespace Accounts;
88 
89 void Manager::Private::init(Manager *q, AgManager *manager)
90 {
91  Q_ASSERT(q_ptr == 0);
92  Q_ASSERT(m_manager == 0);
93 
94  q_ptr = q;
95  m_manager = manager;
96 
97  if (manager) {
98  g_signal_connect_swapped
99  (manager, "account-created",
100  G_CALLBACK(&Private::on_account_created), q);
101  g_signal_connect_swapped
102  (manager, "account-deleted",
103  G_CALLBACK(&Private::on_account_deleted), q);
104  g_signal_connect_swapped
105  (manager, "account-updated",
106  G_CALLBACK(&Private::on_account_updated), q);
107  g_signal_connect_swapped
108  (manager, "enabled-event",
109  G_CALLBACK(&Private::on_enabled_event), q);
110  } else {
111  qWarning() << Q_FUNC_INFO << "Initializing with NULL AgManager!";
112  }
113 }
114 
115 void Manager::Private::on_account_created(Manager *self, AgAccountId id)
116 {
117  TRACE() << "id =" << id;
118 
119  emit self->accountCreated(id);
120 }
121 
122 void Manager::Private::on_account_deleted(Manager *self, AgAccountId id)
123 {
124  TRACE() << "id =" << id;
125 
126  emit self->accountRemoved(id);
127 }
128 
129 void Manager::Private::on_account_updated(Manager *self, AgAccountId id)
130 {
131  TRACE() << "id =" << id;
132 
133  emit self->accountUpdated(id);
134 }
135 
136 void Manager::Private::on_enabled_event(Manager *self, AgAccountId id)
137 {
138  TRACE() << "id =" << id;
139 
140  emit self->enabledEvent(id);
141 }
142 
143 Manager::Manager(QObject *parent)
144  : QObject(parent), d(new Private)
145 {
146  g_type_init();
147 
148  AgManager *manager = ag_manager_new();
149 
150  d->init(this, manager);
151 }
152 
153 Manager::Manager(const QString &serviceType, QObject *parent)
154  : QObject(parent), d(new Private)
155 {
156  g_type_init();
157 
158  AgManager *manager =
159  ag_manager_new_for_service_type(serviceType.toUtf8().constData());
160 
161  d->init(this, manager);
162 }
163 
165 {
166  TRACE();
167 
168  g_signal_handlers_disconnect_by_func
169  (d->m_manager, (void *)&Private::on_enabled_event, this);
170  g_signal_handlers_disconnect_by_func
171  (d->m_manager, (void *)&Private::on_account_updated, this);
172  g_signal_handlers_disconnect_by_func
173  (d->m_manager, (void *)&Private::on_account_deleted, this);
174  g_signal_handlers_disconnect_by_func
175  (d->m_manager, (void *)&Private::on_account_created, this);
176  g_object_unref(d->m_manager);
177 
178  delete d;
179  d = 0;
180 }
181 
183 {
184  TRACE() << "get account id: " << id;
185 
186  AgAccount *account = ag_manager_get_account(d->m_manager, id);
187 
188  if (account != NULL) {
189  Account *tmp = new Account(account, const_cast<Manager*>(this));
190  g_object_unref(account);
191  return tmp;
192  }
193  return NULL;
194 }
195 
196 AccountIdList Manager::accountList(const QString &serviceType) const
197 {
198  GList *list = NULL;
199 
200  if (serviceType.isEmpty()) {
201  list = ag_manager_list(d->m_manager);
202  } else {
203  list = ag_manager_list_by_service_type(d->m_manager,
204  serviceType.toUtf8().constData());
205  }
206 
207  /* convert glist -> AccountIdList */
208  AccountIdList idList;
209  GList *iter;
210 
211  for (iter = list; iter; iter = g_list_next(iter))
212  {
213  idList.append((AccountId)(iter->data));
214  }
215 
216  ag_manager_list_free(list);
217 
218  return idList;
219 }
220 AccountIdList Manager::accountListEnabled(const QString &serviceType) const
221 {
222  GList *list = NULL;
223  if (serviceType.isEmpty()) {
224  list = ag_manager_list_enabled(d->m_manager);
225  } else {
226  list = ag_manager_list_enabled_by_service_type(d->m_manager,
227  serviceType.toUtf8().constData());
228  }
229 
230  /* convert glist -> AccountIdList */
231  AccountIdList idList;
232  GList *iter;
233 
234  for (iter = list; iter; iter = g_list_next(iter))
235  {
236  idList.append((AccountId)(iter->data));
237  }
238 
239  ag_manager_list_free(list);
240 
241  return idList;
242 }
243 
244 Account *Manager::createAccount(const QString &providerName)
245 {
246  TRACE() << providerName;
247 
248  AgAccount *account =
249  ag_manager_create_account(d->m_manager,
250  providerName.toUtf8().constData());
251 
252  if (account != NULL) {
253  /* convert gaccount into qaccount */
254  Account *tmp = new Account(account, this);
255  g_object_unref(account);
256  return tmp;
257  }
258 
259  return NULL;
260 }
261 
262 Service *Manager::serviceInstance(AgService *service) const
263 {
264  Service *ret;
265 
266  ret = d->services.value(service);
267  if (!ret)
268  {
269  ret = new Service(service);
270  d->services.insert(service, ret);
271  }
272  return ret;
273 }
274 
275 Service *Manager::service(const QString &serviceName) const
276 {
277  TRACE() << serviceName;
278  AgService *service =
279  ag_manager_get_service(d->m_manager,
280  serviceName.toUtf8().constData());
281  if (!service)
282  return NULL;
283 
284  Service *serv= serviceInstance(service);
285  ag_service_unref(service);
286  return serv;
287 }
288 
289 ServiceList Manager::serviceList(const QString &serviceType) const
290 {
291  TRACE() << serviceType;
292  GList *list;
293 
294  if (serviceType.isEmpty()) {
295  list = ag_manager_list_services(d->m_manager);
296  } else {
297  list = ag_manager_list_services_by_type(d->m_manager,
298  serviceType.toUtf8().constData());
299  }
300  TRACE() << "found:" << g_list_length(list);
301 
302  /* convert glist -> ServiceList */
303  ServiceList servList;
304  GList *iter;
305 
306  for (iter = list; iter; iter = g_list_next(iter))
307  {
308  Service *serv = serviceInstance((AgService*)(iter->data));
309  servList.append(serv);
310  }
311 
312  ag_service_list_free(list);
313 
314  return servList;
315 }
316 
317 Provider *Manager::providerInstance(AgProvider *provider) const
318 {
319  Provider *ret;
320 
321  ret = d->providers.value(provider);
322  if (!ret)
323  {
324  ret = new Provider(provider);
325  d->providers.insert(provider, ret);
326  }
327  return ret;
328 }
329 
330 Provider *Manager::provider(const QString &providerName) const
331 {
332  TRACE() << providerName;
334 
335  provider = ag_manager_get_provider(d->m_manager,
336  providerName.toUtf8().constData());
337  if (!provider)
338  return NULL;
339 
340  Provider *prov = providerInstance(provider);
341  ag_provider_unref(provider);
342  return prov;
343 }
344 
346 {
347  GList *list;
348 
349  list = ag_manager_list_providers(d->m_manager);
350 
351  /* convert glist -> ProviderList */
352  ProviderList provList;
353  GList *iter;
354 
355  for (iter = list; iter; iter = g_list_next(iter))
356  {
357  Provider *prov = providerInstance((AgProvider*)(iter->data));
358  provList.append(prov);
359  }
360 
361  ag_provider_list_free(list);
362 
363  return provList;
364 }
365 
366 ServiceType *Manager::serviceType(const QString &name) const
367 {
368  ServiceType *serviceType = d->serviceTypes.value(name, NULL);
369  if (serviceType == 0) {
370  AgServiceType *type;
371  type = ag_manager_load_service_type(d->m_manager,
372  name.toUtf8().constData());
373  if (type == NULL)
374  return NULL;
375 
376  serviceType = new ServiceType(type);
377  d->serviceTypes.insert(name, serviceType);
378  ag_service_type_unref(type);
379  }
380  return serviceType;
381 }
382 
383 QString Manager::serviceType() const
384 {
385  return UTF8(ag_manager_get_service_type (d->m_manager));
386 }
387 
388 void Manager::setTimeout(quint32 timeout)
389 {
390  ag_manager_set_db_timeout(d->m_manager, timeout);
391 }
392 
394 {
395  return ag_manager_get_db_timeout(d->m_manager);
396 }
397