accounts-qt  0.31
manager.cpp
Go to the documentation of this file.
00001 /* vi: set et sw=4 ts=4 cino=t0,(0: */
00002 /*
00003  * This file is part of libaccounts-qt
00004  *
00005  * Copyright (C) 2009-2010 Nokia Corporation.
00006  *
00007  * Contact: Alberto Mardegan <alberto.mardegan@nokia.com>
00008  *
00009  * This library is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public License
00011  * version 2.1 as published by the Free Software Foundation.
00012  *
00013  * This library is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with this library; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00021  * 02110-1301 USA
00022  */
00023 
00024 #include <QtCore>
00025 
00026 #include "service.h"
00027 #include "manager.h"
00028 
00029 #include <libaccounts-glib/ag-manager.h>
00030 #include <libaccounts-glib/ag-account.h>
00031 
00032 
00033 namespace Accounts {
00034 
00035 class Manager::Private
00036 {
00037     Q_DECLARE_PUBLIC(Manager)
00038 
00039     typedef QHash<AgProvider *, Provider *> ProviderHash;
00040     typedef QHash<AgService *, Service *> ServiceHash;
00041     typedef QHash<const QString, ServiceType *> ServiceTypeHash;
00042 public:
00043     Private():
00044         q_ptr(0),
00045         m_manager(0),
00046         providers(),
00047         services(),
00048         serviceTypes()
00049     {
00050     }
00051 
00052     ~Private() {
00053         foreach (Provider *provider, providers)
00054         {
00055             delete provider;
00056         }
00057         providers.clear();
00058         foreach (Service *service, services)
00059         {
00060             delete service;
00061         }
00062         services.clear();
00063 
00064         foreach (ServiceType *serviceType, serviceTypes)
00065         {
00066             delete serviceType;
00067         }
00068         serviceTypes.clear();
00069     }
00070 
00071     void init(Manager *q, AgManager *manager);
00072 
00073     mutable Manager *q_ptr;
00074     AgManager *m_manager; //real manager
00075     ProviderHash providers;
00076     ServiceHash services;
00077     ServiceTypeHash serviceTypes;
00078 
00079     static void on_account_created(Manager *self, AgAccountId id);
00080     static void on_account_deleted(Manager *self, AgAccountId id);
00081     static void on_account_updated(Manager *self, AgAccountId id);
00082     static void on_enabled_event(Manager *self, AgAccountId id);
00083 };
00084 
00085 } //namespace Accounts
00086 
00087 using namespace Accounts;
00088 
00089 void Manager::Private::init(Manager *q, AgManager *manager)
00090 {
00091     Q_ASSERT(q_ptr == 0);
00092     Q_ASSERT(m_manager == 0);
00093 
00094     q_ptr = q;
00095     m_manager = manager;
00096 
00097     if (manager) {
00098         g_signal_connect_swapped
00099             (manager, "account-created",
00100              G_CALLBACK(&Private::on_account_created), q);
00101         g_signal_connect_swapped
00102             (manager, "account-deleted",
00103              G_CALLBACK(&Private::on_account_deleted), q);
00104         g_signal_connect_swapped
00105             (manager, "account-updated",
00106              G_CALLBACK(&Private::on_account_updated), q);
00107         g_signal_connect_swapped
00108             (manager, "enabled-event",
00109              G_CALLBACK(&Private::on_enabled_event), q);
00110     } else {
00111         qWarning() << Q_FUNC_INFO << "Initializing with NULL AgManager!";
00112     }
00113 }
00114 
00115 void Manager::Private::on_account_created(Manager *self, AgAccountId id)
00116 {
00117     TRACE() << "id =" << id;
00118 
00119     emit self->accountCreated(id);
00120 }
00121 
00122 void Manager::Private::on_account_deleted(Manager *self, AgAccountId id)
00123 {
00124     TRACE() << "id =" << id;
00125 
00126     emit self->accountRemoved(id);
00127 }
00128 
00129 void Manager::Private::on_account_updated(Manager *self, AgAccountId id)
00130 {
00131     TRACE() << "id =" << id;
00132 
00133     emit self->accountUpdated(id);
00134 }
00135 
00136 void Manager::Private::on_enabled_event(Manager *self, AgAccountId id)
00137 {
00138     TRACE() << "id =" << id;
00139 
00140     emit self->enabledEvent(id);
00141 }
00142 
00143 Manager::Manager(QObject *parent)
00144     : QObject(parent), d(new Private)
00145 {
00146     g_type_init();
00147 
00148     AgManager *manager = ag_manager_new();
00149 
00150     d->init(this, manager);
00151 }
00152 
00153 Manager::Manager(const QString &serviceType, QObject *parent)
00154     : QObject(parent), d(new Private)
00155 {
00156     g_type_init();
00157 
00158     AgManager *manager =
00159         ag_manager_new_for_service_type(serviceType.toUtf8().constData());
00160 
00161     d->init(this, manager);
00162 }
00163 
00164 Manager::~Manager()
00165 {
00166     TRACE();
00167 
00168     g_signal_handlers_disconnect_by_func
00169         (d->m_manager, (void *)&Private::on_enabled_event, this);
00170     g_signal_handlers_disconnect_by_func
00171         (d->m_manager, (void *)&Private::on_account_updated, this);
00172     g_signal_handlers_disconnect_by_func
00173         (d->m_manager, (void *)&Private::on_account_deleted, this);
00174     g_signal_handlers_disconnect_by_func
00175         (d->m_manager, (void *)&Private::on_account_created, this);
00176     g_object_unref(d->m_manager);
00177 
00178     delete d;
00179     d = 0;
00180 }
00181 
00182 Account *Manager::account(const AccountId &id) const
00183 {
00184     TRACE() << "get account id: " << id;
00185 
00186     AgAccount *account = ag_manager_get_account(d->m_manager, id);
00187 
00188     if (account != NULL) {
00189         Account *tmp = new Account(account, const_cast<Manager*>(this));
00190         g_object_unref(account);
00191         return tmp;
00192     }
00193     return NULL;
00194 }
00195 
00196 AccountIdList Manager::accountList(const QString &serviceType) const
00197 {
00198     GList *list = NULL;
00199 
00200     if (serviceType.isEmpty()) {
00201         list = ag_manager_list(d->m_manager);
00202     } else {
00203         list = ag_manager_list_by_service_type(d->m_manager,
00204             serviceType.toUtf8().constData());
00205     }
00206 
00207     /* convert glist -> AccountIdList */
00208     AccountIdList idList;
00209     GList *iter;
00210 
00211     for (iter = list; iter; iter = g_list_next(iter))
00212     {
00213         idList.append((AccountId)(iter->data));
00214     }
00215 
00216     ag_manager_list_free(list);
00217 
00218     return idList;
00219 }
00220 AccountIdList Manager::accountListEnabled(const QString &serviceType) const
00221 {
00222     GList *list = NULL;
00223     if (serviceType.isEmpty()) {
00224         list = ag_manager_list_enabled(d->m_manager);
00225     } else {
00226         list = ag_manager_list_enabled_by_service_type(d->m_manager,
00227             serviceType.toUtf8().constData());
00228     }
00229 
00230     /* convert glist -> AccountIdList */
00231     AccountIdList idList;
00232     GList *iter;
00233 
00234     for (iter = list; iter; iter = g_list_next(iter))
00235     {
00236         idList.append((AccountId)(iter->data));
00237     }
00238 
00239     ag_manager_list_free(list);
00240 
00241     return idList;
00242 }
00243 
00244 Account *Manager::createAccount(const QString &providerName)
00245 {
00246     TRACE() << providerName;
00247 
00248     AgAccount *account =
00249         ag_manager_create_account(d->m_manager,
00250                                   providerName.toUtf8().constData());
00251 
00252     if (account != NULL) {
00253         /* convert gaccount into qaccount */
00254         Account *tmp = new Account(account, this);
00255         g_object_unref(account);
00256         return tmp;
00257     }
00258 
00259     return NULL;
00260 }
00261 
00262 Service *Manager::serviceInstance(AgService *service) const
00263 {
00264     Service *ret;
00265 
00266     ret = d->services.value(service);
00267     if (!ret)
00268     {
00269         ret = new Service(service);
00270         d->services.insert(service, ret);
00271     }
00272     return ret;
00273 }
00274 
00275 Service *Manager::service(const QString &serviceName) const
00276 {
00277     TRACE() << serviceName;
00278     AgService *service =
00279         ag_manager_get_service(d->m_manager,
00280                                serviceName.toUtf8().constData());
00281     if (!service)
00282         return NULL;
00283 
00284     Service *serv= serviceInstance(service);
00285     ag_service_unref(service);
00286     return serv;
00287 }
00288 
00289 ServiceList Manager::serviceList(const QString &serviceType) const
00290 {
00291     TRACE() << serviceType;
00292     GList *list;
00293 
00294     if (serviceType.isEmpty()) {
00295         list = ag_manager_list_services(d->m_manager);
00296     } else {
00297         list = ag_manager_list_services_by_type(d->m_manager,
00298             serviceType.toUtf8().constData());
00299     }
00300     TRACE() << "found:" << g_list_length(list);
00301 
00302     /* convert glist -> ServiceList */
00303     ServiceList servList;
00304     GList *iter;
00305 
00306     for (iter = list; iter; iter = g_list_next(iter))
00307     {
00308         Service *serv = serviceInstance((AgService*)(iter->data));
00309         servList.append(serv);
00310     }
00311 
00312     ag_service_list_free(list);
00313 
00314     return servList;
00315 }
00316 
00317 Provider *Manager::providerInstance(AgProvider *provider) const
00318 {
00319     Provider *ret;
00320 
00321     ret = d->providers.value(provider);
00322     if (!ret)
00323     {
00324         ret = new Provider(provider);
00325         d->providers.insert(provider, ret);
00326     }
00327     return ret;
00328 }
00329 
00330 Provider *Manager::provider(const QString &providerName) const
00331 {
00332     TRACE() << providerName;
00333     AgProvider *provider;
00334 
00335     provider = ag_manager_get_provider(d->m_manager,
00336                                        providerName.toUtf8().constData());
00337     if (!provider)
00338         return NULL;
00339 
00340     Provider *prov = providerInstance(provider);
00341     ag_provider_unref(provider);
00342     return prov;
00343 }
00344 
00345 ProviderList Manager::providerList() const
00346 {
00347     GList *list;
00348 
00349     list = ag_manager_list_providers(d->m_manager);
00350 
00351     /* convert glist -> ProviderList */
00352     ProviderList provList;
00353     GList *iter;
00354 
00355     for (iter = list; iter; iter = g_list_next(iter))
00356     {
00357         Provider *prov = providerInstance((AgProvider*)(iter->data));
00358         provList.append(prov);
00359     }
00360 
00361     ag_provider_list_free(list);
00362 
00363     return provList;
00364 }
00365 
00366 ServiceType *Manager::serviceType(const QString &name) const
00367 {
00368     ServiceType *serviceType = d->serviceTypes.value(name, NULL);
00369     if (serviceType == 0) {
00370         AgServiceType *type;
00371         type = ag_manager_load_service_type(d->m_manager,
00372                                             name.toUtf8().constData());
00373         if (type == NULL)
00374             return NULL;
00375 
00376         serviceType = new ServiceType(type);
00377         d->serviceTypes.insert(name, serviceType);
00378         ag_service_type_unref(type);
00379     }
00380     return serviceType;
00381 }
00382 
00383 QString Manager::serviceType() const
00384 {
00385     return UTF8(ag_manager_get_service_type (d->m_manager));
00386 }
00387 
00388 void Manager::setTimeout(quint32 timeout)
00389 {
00390     ag_manager_set_db_timeout(d->m_manager, timeout);
00391 }
00392 
00393 quint32 Manager::timeout()
00394 {
00395     return ag_manager_get_db_timeout(d->m_manager);
00396 }
00397