accounts-qt  1.15
manager.cpp
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-2011 Nokia Corporation.
00006  * Copyright (C) 2012-2016 Canonical Ltd.
00007  *
00008  * Contact: Alberto Mardegan <alberto.mardegan@canonical.com>
00009  *
00010  * This library is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public License
00012  * version 2.1 as published by the Free Software Foundation.
00013  *
00014  * This library is distributed in the hope that it will be useful, but
00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with this library; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00022  * 02110-1301 USA
00023  */
00024 
00025 #include "application.h"
00026 #include "service.h"
00027 #include "manager.h"
00028 #include "manager_p.h"
00029 
00030 #include <libaccounts-glib/ag-account.h>
00031 
00032 
00033 namespace Accounts {
00034 
00091 } //namespace Accounts
00092 
00093 using namespace Accounts;
00094 
00095 void Manager::Private::init(Manager *q, AgManager *manager)
00096 {
00097     Q_ASSERT(q_ptr == 0);
00098     Q_ASSERT(m_manager == 0);
00099 
00100     q_ptr = q;
00101     m_manager = manager;
00102 
00103     if (manager) {
00104         g_signal_connect_swapped
00105             (manager, "account-created",
00106              G_CALLBACK(&Private::on_account_created), q);
00107         g_signal_connect_swapped
00108             (manager, "account-deleted",
00109              G_CALLBACK(&Private::on_account_deleted), q);
00110         g_signal_connect_swapped
00111             (manager, "account-updated",
00112              G_CALLBACK(&Private::on_account_updated), q);
00113         g_signal_connect_swapped
00114             (manager, "enabled-event",
00115              G_CALLBACK(&Private::on_enabled_event), q);
00116     } else {
00117         qWarning() << Q_FUNC_INFO << "Initializing with NULL AgManager!";
00118     }
00119 }
00120 
00121 void Manager::Private::on_account_created(Manager *self, AgAccountId id)
00122 {
00123     Q_EMIT self->accountCreated(id);
00124 }
00125 
00126 void Manager::Private::on_account_deleted(Manager *self, AgAccountId id)
00127 {
00128     Q_EMIT self->accountRemoved(id);
00129 }
00130 
00131 void Manager::Private::on_account_updated(Manager *self, AgAccountId id)
00132 {
00133     Q_EMIT self->accountUpdated(id);
00134 }
00135 
00136 void Manager::Private::on_enabled_event(Manager *self, AgAccountId id)
00137 {
00138     Q_EMIT self->enabledEvent(id);
00139 }
00140 
00146 Manager::Manager(QObject *parent):
00147     QObject(parent),
00148     d(new Private)
00149 {
00150     AgManager *manager = ag_manager_new();
00151 
00152     if (manager != 0) {
00153         d->init(this, manager);
00154     } else {
00155         qWarning() << "Manager could not be created. DB is locked";
00156         d->lastError = Error::DatabaseLocked;
00157     }
00158 
00159 }
00160 
00173 Manager::Manager(const QString &serviceType, QObject *parent):
00174     QObject(parent),
00175     d(new Private)
00176 {
00177     AgManager *manager =
00178         ag_manager_new_for_service_type(serviceType.toUtf8().constData());
00179 
00180     if (manager != 0) {
00181         d->init(this, manager);
00182     } else {
00183         qWarning() << "Manager could not be created, DB is locked";
00184         d->lastError = Error::DatabaseLocked;
00185     }
00186 
00187 }
00188 
00194 Manager::Manager(Options options, QObject *parent):
00195     QObject(parent),
00196     d(new Private)
00197 {
00198     bool disableNotifications = options.testFlag(DisableNotifications);
00199 
00200     GError *error = NULL;
00201     AgManager *manager =
00202         (AgManager *)g_initable_new(AG_TYPE_MANAGER, NULL, &error,
00203                                     "use-dbus", !disableNotifications,
00204                                     NULL);
00205     if (Q_LIKELY(manager)) {
00206         d->init(this, manager);
00207     } else {
00208         qWarning() << "Manager could not be created." << error->message;
00209         d->lastError = Error(error);
00210         g_error_free(error);
00211     }
00212 }
00213 
00217 Manager::~Manager()
00218 {
00219     g_signal_handlers_disconnect_by_func
00220         (d->m_manager, (void *)&Private::on_enabled_event, this);
00221     g_signal_handlers_disconnect_by_func
00222         (d->m_manager, (void *)&Private::on_account_updated, this);
00223     g_signal_handlers_disconnect_by_func
00224         (d->m_manager, (void *)&Private::on_account_deleted, this);
00225     g_signal_handlers_disconnect_by_func
00226         (d->m_manager, (void *)&Private::on_account_created, this);
00227     g_object_unref(d->m_manager);
00228 
00229     delete d;
00230     d = 0;
00231 }
00232 
00245 Account *Manager::account(const AccountId &id) const
00246 {
00247     Account *account = d->m_accounts.value(id, 0);
00248     if (account == 0) {
00249         /* Create a new account object */
00250         account = Account::fromId(const_cast<Manager*>(this), id,
00251                                   const_cast<Manager*>(this));
00252         d->m_accounts[id] = account;
00253     }
00254     return account;
00255 }
00256 
00266 AccountIdList Manager::accountList(const QString &serviceType) const
00267 {
00268     GList *list = NULL;
00269 
00270     if (serviceType.isEmpty()) {
00271         list = ag_manager_list(d->m_manager);
00272     } else {
00273         list = ag_manager_list_by_service_type(d->m_manager,
00274             serviceType.toUtf8().constData());
00275     }
00276 
00277     /* convert glist -> AccountIdList */
00278     AccountIdList idList;
00279     GList *iter;
00280 
00281     for (iter = list; iter; iter = g_list_next(iter))
00282     {
00283         idList.append((AccountId)GPOINTER_TO_INT(iter->data));
00284     }
00285 
00286     ag_manager_list_free(list);
00287 
00288     return idList;
00289 }
00290 
00301 AccountIdList Manager::accountListEnabled(const QString &serviceType) const
00302 {
00303     GList *list = NULL;
00304     if (serviceType.isEmpty()) {
00305         list = ag_manager_list_enabled(d->m_manager);
00306     } else {
00307         list = ag_manager_list_enabled_by_service_type(d->m_manager,
00308             serviceType.toUtf8().constData());
00309     }
00310 
00311     /* convert glist -> AccountIdList */
00312     AccountIdList idList;
00313     GList *iter;
00314 
00315     for (iter = list; iter; iter = g_list_next(iter))
00316     {
00317         idList.append((AccountId)GPOINTER_TO_INT(iter->data));
00318     }
00319 
00320     ag_manager_list_free(list);
00321 
00322     return idList;
00323 }
00324 
00331 Account *Manager::createAccount(const QString &providerName)
00332 {
00333     return new Account(this, providerName, this);
00334 }
00335 
00342 Service Manager::service(const QString &serviceName) const
00343 {
00344     AgService *service =
00345         ag_manager_get_service(d->m_manager,
00346                                serviceName.toUtf8().constData());
00347     return Service(service, StealReference);
00348 }
00349 
00360 ServiceList Manager::serviceList(const QString &serviceType) const
00361 {
00362     GList *list;
00363 
00364     if (serviceType.isEmpty()) {
00365         list = ag_manager_list_services(d->m_manager);
00366     } else {
00367         list = ag_manager_list_services_by_type(d->m_manager,
00368             serviceType.toUtf8().constData());
00369     }
00370 
00371     /* convert glist -> ServiceList */
00372     ServiceList servList;
00373     GList *iter;
00374 
00375     for (iter = list; iter; iter = g_list_next(iter))
00376     {
00377         AgService *service = (AgService*)iter->data;
00378         servList.append(Service(service, StealReference));
00379     }
00380 
00381     g_list_free(list);
00382 
00383     return servList;
00384 }
00385 
00393 ServiceList Manager::serviceList(const Application &application) const
00394 {
00395     GList *list;
00396 
00397     list = ag_manager_list_services_by_application(d->m_manager,
00398                                                    application.application());
00399 
00400     /* convert glist -> ServiceList */
00401     ServiceList servList;
00402     GList *iter;
00403 
00404     for (iter = list; iter; iter = g_list_next(iter))
00405     {
00406         AgService *service = (AgService*)iter->data;
00407         servList.append(Service(service, StealReference));
00408     }
00409 
00410     g_list_free(list);
00411 
00412     return servList;
00413 }
00414 
00421 Provider Manager::provider(const QString &providerName) const
00422 {
00423     AgProvider *provider;
00424 
00425     provider = ag_manager_get_provider(d->m_manager,
00426                                        providerName.toUtf8().constData());
00427     return Provider(provider, StealReference);
00428 }
00429 
00435 ProviderList Manager::providerList() const
00436 {
00437     GList *list;
00438 
00439     list = ag_manager_list_providers(d->m_manager);
00440 
00441     /* convert glist -> ProviderList */
00442     ProviderList provList;
00443     GList *iter;
00444 
00445     for (iter = list; iter; iter = g_list_next(iter))
00446     {
00447         AgProvider *provider = (AgProvider*)iter->data;
00448         provList.append(Provider(provider, StealReference));
00449     }
00450 
00451     g_list_free(list);
00452 
00453     return provList;
00454 }
00455 
00462 ServiceType Manager::serviceType(const QString &name) const
00463 {
00464     AgServiceType *type;
00465     type = ag_manager_load_service_type(d->m_manager,
00466                                         name.toUtf8().constData());
00467     return ServiceType(type, StealReference);
00468 }
00469 
00477 Application Manager::application(const QString &applicationName) const
00478 {
00479     QByteArray ba = applicationName.toUtf8();
00480     AgApplication *application =
00481         ag_manager_get_application(d->m_manager, ba.constData());
00482     return Application(application);
00483 }
00484 
00491 ApplicationList Manager::applicationList(const Service &service) const
00492 {
00493     ApplicationList ret;
00494     GList *applications, *list;
00495 
00496     applications = ag_manager_list_applications_by_service(d->m_manager,
00497                                                            service.service());
00498     for (list = applications; list != NULL; list = list->next) {
00499         AgApplication *application = (AgApplication *)list->data;
00500         ret.append(Application(application));
00501     }
00502     g_list_free (applications);
00503     return ret;
00504 }
00505 
00511 QString Manager::serviceType() const
00512 {
00513     return UTF8(ag_manager_get_service_type (d->m_manager));
00514 }
00515 
00525 void Manager::setTimeout(quint32 timeout)
00526 {
00527     ag_manager_set_db_timeout(d->m_manager, timeout);
00528 }
00529 
00534 quint32 Manager::timeout()
00535 {
00536     return ag_manager_get_db_timeout(d->m_manager);
00537 }
00538 
00543 void Manager::setAbortOnTimeout(bool abort)
00544 {
00545     ag_manager_set_abort_on_db_timeout(d->m_manager, abort);
00546 }
00547 
00552 bool Manager::abortOnTimeout() const
00553 {
00554     return ag_manager_get_abort_on_db_timeout(d->m_manager);
00555 }
00556 
00560 Manager::Options Manager::options() const
00561 {
00562     gboolean useDBus = true;
00563     g_object_get(d->m_manager,
00564                  "use-dbus", &useDBus,
00565                  NULL);
00566 
00567     Options opts;
00568     if (!useDBus) {
00569         opts |= DisableNotifications;
00570     }
00571     return opts;
00572 }
00573 
00583 Error Manager::lastError() const
00584 {
00585     return d->lastError;
00586 }
00587