LCOV - code coverage report
Current view: top level - Accounts - manager.cpp (source / functions) Hit Total Coverage
Test: Code Coverage Lines: 123 128 96.1 %
Date: 2013-04-26 Functions: 26 26 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 26 34 76.5 %

           Branch data     Line data    Source code
       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-2011 Nokia Corporation.
       6                 :            :  * Copyright (C) 2012-2013 Canonical Ltd.
       7                 :            :  *
       8                 :            :  * Contact: Alberto Mardegan <alberto.mardegan@canonical.com>
       9                 :            :  *
      10                 :            :  * This library is free software; you can redistribute it and/or
      11                 :            :  * modify it under the terms of the GNU Lesser General Public License
      12                 :            :  * version 2.1 as published by the Free Software Foundation.
      13                 :            :  *
      14                 :            :  * This library is distributed in the hope that it will be useful, but
      15                 :            :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      16                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
      17                 :            :  * Lesser General Public License for more details.
      18                 :            :  *
      19                 :            :  * You should have received a copy of the GNU Lesser General Public
      20                 :            :  * License along with this library; if not, write to the Free Software
      21                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
      22                 :            :  * 02110-1301 USA
      23                 :            :  */
      24                 :            : 
      25                 :            : #include "application.h"
      26                 :            : #include "service.h"
      27                 :            : #include "manager.h"
      28                 :            : #include "manager_p.h"
      29                 :            : 
      30                 :            : #include <libaccounts-glib/ag-account.h>
      31                 :            : 
      32                 :            : 
      33                 :            : namespace Accounts {
      34                 :            : 
      35                 :            : /*!
      36                 :            :  * @class Manager
      37                 :            :  * @headerfile manager.h Accounts/Manager
      38                 :            :  *
      39                 :            :  * @brief Manager of accounts, services and providers.
      40                 :            :  *
      41                 :            :  * @details The Manager offers ways to create accounts, list accounts, services
      42                 :            :  * and providers. It also emits signals when accounts are created and removed.
      43                 :            :  */
      44                 :            : 
      45                 :            : /*!
      46                 :            :  * @fn Manager::accountCreated(Accounts::AccountId id)
      47                 :            :  *
      48                 :            :  * The signal is emitted when new account is created.
      49                 :            :  *
      50                 :            :  * @param id Identifier of the Account
      51                 :            :  */
      52                 :            : 
      53                 :            : /*!
      54                 :            :  * @fn Manager::accountRemoved(Accounts::AccountId id)
      55                 :            :  *
      56                 :            :  * The signal is emitted when existing account is removed.
      57                 :            :  *
      58                 :            :  * @param id Identifier of the Account
      59                 :            :  */
      60                 :            : 
      61                 :            : /*!
      62                 :            :  * @fn Manager::accountUpdated(Accounts::AccountId id)
      63                 :            :  *
      64                 :            :  * The signal is emitted when any account property for a particular service is
      65                 :            :  * updated.
      66                 :            :  *
      67                 :            :  * To receive this notification user has to create accounts manager using
      68                 :            :  * Manager(const QString &serviceType, QObject *parent) constructor.
      69                 :            :  * Update notification is only emitted when manager is created for particular
      70                 :            :  * type of service.
      71                 :            :  *
      72                 :            :  * @param id Identifier of the Account
      73                 :            :  */
      74                 :            : 
      75                 :            : /*!
      76                 :            :  * @fn Manager::enabledEvent(Accounts::AccountId id)
      77                 :            :  *
      78                 :            :  * If the manager has been created with serviceType, this
      79                 :            :  * signal will be emitted when an account (identified by AccountId) has been
      80                 :            :  * modified in such a way that the application might be interested to
      81                 :            :  * start/stop using it: the "enabled" flag on the account or in some service
      82                 :            :  * supported by the account and matching the AgManager::serviceType have
      83                 :            :  * changed.
      84                 :            :  * @note In practice, this signal might be emitted more often than when
      85                 :            :  * strictly needed; applications must call Account::enabledServices() to get
      86                 :            :  * the current state.
      87                 :            :  *
      88                 :            :  * @param id identifier of the Account
      89                 :            :  */
      90                 :            : 
      91                 :            : } //namespace Accounts
      92                 :            : 
      93                 :            : using namespace Accounts;
      94                 :            : 
      95                 :         35 : void Manager::Private::init(Manager *q, AgManager *manager)
      96                 :            : {
      97                 :            :     Q_ASSERT(q_ptr == 0);
      98                 :            :     Q_ASSERT(m_manager == 0);
      99                 :            : 
     100                 :         35 :     q_ptr = q;
     101                 :         35 :     m_manager = manager;
     102                 :            : 
     103         [ +  - ]:         35 :     if (manager) {
     104                 :            :         g_signal_connect_swapped
     105                 :            :             (manager, "account-created",
     106                 :         35 :              G_CALLBACK(&Private::on_account_created), q);
     107                 :            :         g_signal_connect_swapped
     108                 :            :             (manager, "account-deleted",
     109                 :         35 :              G_CALLBACK(&Private::on_account_deleted), q);
     110                 :            :         g_signal_connect_swapped
     111                 :            :             (manager, "account-updated",
     112                 :         35 :              G_CALLBACK(&Private::on_account_updated), q);
     113                 :            :         g_signal_connect_swapped
     114                 :            :             (manager, "enabled-event",
     115                 :         35 :              G_CALLBACK(&Private::on_enabled_event), q);
     116                 :            :     } else {
     117                 :          0 :         qWarning() << Q_FUNC_INFO << "Initializing with NULL AgManager!";
     118                 :            :     }
     119                 :         35 : }
     120                 :            : 
     121                 :         23 : void Manager::Private::on_account_created(Manager *self, AgAccountId id)
     122                 :            : {
     123                 :         23 :     Q_EMIT self->accountCreated(id);
     124                 :         23 : }
     125                 :            : 
     126                 :          2 : void Manager::Private::on_account_deleted(Manager *self, AgAccountId id)
     127                 :            : {
     128                 :          2 :     Q_EMIT self->accountRemoved(id);
     129                 :          2 : }
     130                 :            : 
     131                 :          2 : void Manager::Private::on_account_updated(Manager *self, AgAccountId id)
     132                 :            : {
     133                 :          2 :     Q_EMIT self->accountUpdated(id);
     134                 :          2 : }
     135                 :            : 
     136                 :          3 : void Manager::Private::on_enabled_event(Manager *self, AgAccountId id)
     137                 :            : {
     138                 :          3 :     Q_EMIT self->enabledEvent(id);
     139                 :          3 : }
     140                 :            : 
     141                 :            : /*!
     142                 :            :  * Constructor.
     143                 :            :  * Users should check for manager->lastError() to check if manager construction
     144                 :            :  * was fully succesful.
     145                 :            :  */
     146                 :         32 : Manager::Manager(QObject *parent):
     147                 :            :     QObject(parent),
     148                 :         32 :     d(new Private)
     149                 :            : {
     150                 :         32 :     g_type_init();
     151                 :            : 
     152                 :         32 :     AgManager *manager = ag_manager_new();
     153                 :            : 
     154         [ +  - ]:         32 :     if (manager != 0) {
     155                 :         32 :         d->init(this, manager);
     156                 :            :     } else {
     157                 :          0 :         qWarning() << "Manager could not be created. DB is locked";
     158                 :          0 :         d->lastError = Error::DatabaseLocked;
     159                 :            :     }
     160                 :            : 
     161                 :         32 : }
     162                 :            : 
     163                 :            : /*!
     164                 :            :  * Constructs a manager initialized with service type. This constructor
     165                 :            :  * should be used when there is an interest for just one service type.
     166                 :            :  * Such a manager has influence on some class methods. When listing the
     167                 :            :  * accounts and services only the ones supporting the given service type
     168                 :            :  * will be returned. Also the creating account with this manager will
     169                 :            :  * affect the acccount class method for listing services in same manner.
     170                 :            :  * The signal enabledEvent() will be emitted only when manager is created
     171                 :            :  * with this constructor.
     172                 :            :  * Users should check for manager->lastError() to check if manager construction
     173                 :            :  * was fully succesful.
     174                 :            :  */
     175                 :          3 : Manager::Manager(const QString &serviceType, QObject *parent):
     176                 :            :     QObject(parent),
     177                 :          3 :     d(new Private)
     178                 :            : {
     179                 :          3 :     g_type_init();
     180                 :            : 
     181                 :            :     AgManager *manager =
     182                 :          3 :         ag_manager_new_for_service_type(serviceType.toUtf8().constData());
     183                 :            : 
     184         [ +  - ]:          3 :     if (manager != 0) {
     185                 :          3 :         d->init(this, manager);
     186                 :            :     } else {
     187                 :          0 :         qWarning() << "Manager could not be created, DB is locked";
     188                 :          0 :         d->lastError = Error::DatabaseLocked;
     189                 :            :     }
     190                 :            : 
     191                 :          3 : }
     192                 :            : 
     193                 :            : /*!
     194                 :            :  * Destructor.
     195                 :            :  */
     196                 :         35 : Manager::~Manager()
     197                 :            : {
     198                 :         35 :     g_signal_handlers_disconnect_by_func
     199                 :         35 :         (d->m_manager, (void *)&Private::on_enabled_event, this);
     200                 :         35 :     g_signal_handlers_disconnect_by_func
     201                 :         35 :         (d->m_manager, (void *)&Private::on_account_updated, this);
     202                 :         35 :     g_signal_handlers_disconnect_by_func
     203                 :         35 :         (d->m_manager, (void *)&Private::on_account_deleted, this);
     204                 :         35 :     g_signal_handlers_disconnect_by_func
     205                 :         35 :         (d->m_manager, (void *)&Private::on_account_created, this);
     206                 :         35 :     g_object_unref(d->m_manager);
     207                 :            : 
     208         [ +  - ]:         35 :     delete d;
     209                 :         35 :     d = 0;
     210                 :         70 : }
     211                 :            : 
     212                 :            : /*!
     213                 :            :  * Loads an account from the database.
     214                 :            :  * @param id Id of the account to be retrieved.
     215                 :            :  *
     216                 :            :  * @return Requested account or 0 if not found. If 0 is returned,
     217                 :            :  * call lastError() to find out why.
     218                 :            :  * @attention The objects returned by this method are shared, meaning that
     219                 :            :  * calling this method twice with the same id will return the same object. It
     220                 :            :  * is recommended that clients do not destroy the objects returned by this
     221                 :            :  * method, if there's the possibility that they are still being used in other
     222                 :            :  * parts of the application.
     223                 :            :  */
     224                 :          4 : Account *Manager::account(const AccountId &id) const
     225                 :            : {
     226                 :          8 :     Account *account = d->m_accounts.value(id, 0);
     227         [ +  + ]:          4 :     if (account == 0) {
     228                 :            :         /* Create a new account object */
     229                 :            :         account = Account::fromId(const_cast<Manager*>(this), id,
     230                 :          3 :                                   const_cast<Manager*>(this));
     231                 :          3 :         d->m_accounts[id] = account;
     232                 :            :     }
     233                 :          4 :     return account;
     234                 :            : }
     235                 :            : 
     236                 :            : /*!
     237                 :            :  * Lists the accounts which support the requested service.
     238                 :            :  *
     239                 :            :  * @param serviceType Type of service that returned accounts must support.
     240                 :            :  * If not given and the manager is not constructed with service type,
     241                 :            :  * all accounts are returned.
     242                 :            :  *
     243                 :            :  * @return List of account IDs.
     244                 :            :  */
     245                 :          2 : AccountIdList Manager::accountList(const QString &serviceType) const
     246                 :            : {
     247                 :            :     GList *list = NULL;
     248                 :            : 
     249         [ +  + ]:          2 :     if (serviceType.isEmpty()) {
     250                 :          1 :         list = ag_manager_list(d->m_manager);
     251                 :            :     } else {
     252                 :            :         list = ag_manager_list_by_service_type(d->m_manager,
     253                 :          1 :             serviceType.toUtf8().constData());
     254                 :            :     }
     255                 :            : 
     256                 :            :     /* convert glist -> AccountIdList */
     257                 :            :     AccountIdList idList;
     258                 :            :     GList *iter;
     259                 :            : 
     260 [ +  - ][ +  + ]:          3 :     for (iter = list; iter; iter = g_list_next(iter))
     261                 :            :     {
     262                 :          1 :         idList.append((AccountId)GPOINTER_TO_INT(iter->data));
     263                 :            :     }
     264                 :            : 
     265                 :          2 :     ag_manager_list_free(list);
     266                 :            : 
     267                 :          2 :     return idList;
     268                 :            : }
     269                 :            : 
     270                 :            : /*!
     271                 :            :  * Lists the enabled accounts which support the requested service that also
     272                 :            :  * must be enabled.
     273                 :            :  *
     274                 :            :  * @param serviceType Type of service that returned accounts must support.
     275                 :            :  * If not given and the manager is not constructed with service type,
     276                 :            :  * all enabled accounts are returned.
     277                 :            :  *
     278                 :            :  * @return List of account IDs.
     279                 :            :  */
     280                 :          3 : AccountIdList Manager::accountListEnabled(const QString &serviceType) const
     281                 :            : {
     282                 :            :     GList *list = NULL;
     283         [ +  + ]:          3 :     if (serviceType.isEmpty()) {
     284                 :          1 :         list = ag_manager_list_enabled(d->m_manager);
     285                 :            :     } else {
     286                 :            :         list = ag_manager_list_enabled_by_service_type(d->m_manager,
     287                 :          2 :             serviceType.toUtf8().constData());
     288                 :            :     }
     289                 :            : 
     290                 :            :     /* convert glist -> AccountIdList */
     291                 :            :     AccountIdList idList;
     292                 :            :     GList *iter;
     293                 :            : 
     294 [ +  - ][ +  + ]:          5 :     for (iter = list; iter; iter = g_list_next(iter))
     295                 :            :     {
     296                 :          2 :         idList.append((AccountId)GPOINTER_TO_INT(iter->data));
     297                 :            :     }
     298                 :            : 
     299                 :          3 :     ag_manager_list_free(list);
     300                 :            : 
     301                 :          3 :     return idList;
     302                 :            : }
     303                 :            : 
     304                 :            : /*!
     305                 :            :  * Creates a new account.
     306                 :            :  * @param providerName Name of account provider.
     307                 :            :  *
     308                 :            :  * @return Created account or NULL if some error occurs.
     309                 :            :  */
     310                 :         29 : Account *Manager::createAccount(const QString &providerName)
     311                 :            : {
     312                 :         29 :     return new Account(this, providerName, this);
     313                 :            : }
     314                 :            : 
     315                 :            : /*!
     316                 :            :  * Gets an object representing a service.
     317                 :            :  * @param serviceName Name of service to get.
     318                 :            :  *
     319                 :            :  * @return The requested service or an invalid service if not found.
     320                 :            :  */
     321                 :         15 : Service Manager::service(const QString &serviceName) const
     322                 :            : {
     323                 :            :     AgService *service =
     324                 :            :         ag_manager_get_service(d->m_manager,
     325                 :         15 :                                serviceName.toUtf8().constData());
     326                 :         15 :     return Service(service, StealReference);
     327                 :            : }
     328                 :            : 
     329                 :            : /*!
     330                 :            :  * Gets the service list. If the manager is constructed with given service type
     331                 :            :  * only the services which supports the service type will be returned.
     332                 :            :  *
     333                 :            :  * @param serviceType Type of services to be listed. If not given and
     334                 :            :  * the manager is not constructed with service type, all
     335                 :            :  * services are listed.
     336                 :            :  *
     337                 :            :  * @return List of Service objects.
     338                 :            :  */
     339                 :          3 : ServiceList Manager::serviceList(const QString &serviceType) const
     340                 :            : {
     341                 :            :     GList *list;
     342                 :            : 
     343         [ +  + ]:          3 :     if (serviceType.isEmpty()) {
     344                 :          1 :         list = ag_manager_list_services(d->m_manager);
     345                 :            :     } else {
     346                 :            :         list = ag_manager_list_services_by_type(d->m_manager,
     347                 :          2 :             serviceType.toUtf8().constData());
     348                 :            :     }
     349                 :            : 
     350                 :            :     /* convert glist -> ServiceList */
     351                 :            :     ServiceList servList;
     352                 :            :     GList *iter;
     353                 :            : 
     354 [ +  - ][ +  + ]:          7 :     for (iter = list; iter; iter = g_list_next(iter))
     355                 :            :     {
     356                 :          4 :         AgService *service = (AgService*)iter->data;
     357                 :          4 :         servList.append(Service(service, StealReference));
     358                 :            :     }
     359                 :            : 
     360                 :          3 :     g_list_free(list);
     361                 :            : 
     362                 :          3 :     return servList;
     363                 :            : }
     364                 :            : 
     365                 :            : /*!
     366                 :            :  * Gets an object representing a provider.
     367                 :            :  * @param providerName Name of provider to get.
     368                 :            :  *
     369                 :            :  * @return Requested provider or NULL if not found.
     370                 :            :  */
     371                 :          2 : Provider Manager::provider(const QString &providerName) const
     372                 :            : {
     373                 :            :     AgProvider *provider;
     374                 :            : 
     375                 :            :     provider = ag_manager_get_provider(d->m_manager,
     376                 :          2 :                                        providerName.toUtf8().constData());
     377                 :          2 :     return Provider(provider, StealReference);
     378                 :            : }
     379                 :            : 
     380                 :            : /*!
     381                 :            :  * Gets a provider list.
     382                 :            :  *
     383                 :            :  * @return List of registered providers.
     384                 :            :  */
     385                 :          1 : ProviderList Manager::providerList() const
     386                 :            : {
     387                 :            :     GList *list;
     388                 :            : 
     389                 :          1 :     list = ag_manager_list_providers(d->m_manager);
     390                 :            : 
     391                 :            :     /* convert glist -> ProviderList */
     392                 :            :     ProviderList provList;
     393                 :            :     GList *iter;
     394                 :            : 
     395 [ +  - ][ +  + ]:          2 :     for (iter = list; iter; iter = g_list_next(iter))
     396                 :            :     {
     397                 :          1 :         AgProvider *provider = (AgProvider*)iter->data;
     398                 :          1 :         provList.append(Provider(provider, StealReference));
     399                 :            :     }
     400                 :            : 
     401                 :          1 :     g_list_free(list);
     402                 :            : 
     403                 :          1 :     return provList;
     404                 :            : }
     405                 :            : 
     406                 :            : /*!
     407                 :            :  * Gets an object representing a service type.
     408                 :            :  * @param name Name of service type to load.
     409                 :            :  *
     410                 :            :  * @return Requested service type or NULL if not found.
     411                 :            :  */
     412                 :          2 : ServiceType Manager::serviceType(const QString &name) const
     413                 :            : {
     414                 :            :     AgServiceType *type;
     415                 :            :     type = ag_manager_load_service_type(d->m_manager,
     416                 :          2 :                                         name.toUtf8().constData());
     417                 :          2 :     return ServiceType(type, StealReference);
     418                 :            : }
     419                 :            : 
     420                 :            : /*!
     421                 :            :  * Get an object representing an application.
     422                 :            :  * @param applicationName Name of the application to load.
     423                 :            :  *
     424                 :            :  * @return The requested Application, or an invalid Application object if not
     425                 :            :  * found.
     426                 :            :  */
     427                 :          1 : Application Manager::application(const QString &applicationName) const
     428                 :            : {
     429                 :          1 :     QByteArray ba = applicationName.toUtf8();
     430                 :            :     AgApplication *application =
     431                 :          1 :         ag_manager_get_application(d->m_manager, ba.constData());
     432                 :          1 :     return Application(application);
     433                 :            : }
     434                 :            : 
     435                 :            : /*!
     436                 :            :  * List the registered applications which support the given service.
     437                 :            :  * @param service The service to be supported.
     438                 :            :  *
     439                 :            :  * @return A list of Application objects.
     440                 :            :  */
     441                 :          2 : ApplicationList Manager::applicationList(const Service &service) const
     442                 :            : {
     443                 :            :     ApplicationList ret;
     444                 :            :     GList *applications, *list;
     445                 :            : 
     446                 :            :     applications = ag_manager_list_applications_by_service(d->m_manager,
     447                 :          2 :                                                            service.service());
     448         [ +  + ]:          4 :     for (list = applications; list != NULL; list = list->next) {
     449                 :          2 :         AgApplication *application = (AgApplication *)list->data;
     450                 :          2 :         ret.append(Application(application));
     451                 :            :     }
     452                 :          2 :     g_list_free (applications);
     453                 :          2 :     return ret;
     454                 :            : }
     455                 :            : 
     456                 :            : /*!
     457                 :            :  * Gets the service type if given in manager constructor.
     458                 :            :  *
     459                 :            :  * @return Service type or NULL if not given.
     460                 :            :  */
     461                 :          2 : QString Manager::serviceType() const
     462                 :            : {
     463                 :          2 :     return UTF8(ag_manager_get_service_type (d->m_manager));
     464                 :            : }
     465                 :            : 
     466                 :            : /*!
     467                 :            :  * Sets the timeout for database operations.
     468                 :            :  * @param timeout The new timeout in milliseconds.
     469                 :            :  *
     470                 :            :  * This tells the library how long it is allowed to block while waiting
     471                 :            :  * for a locked DB to become accessible. Higher values mean a higher
     472                 :            :  * chance of successful reads, but also mean that the execution might be
     473                 :            :  * blocked for a longer time. The default is 5 seconds.
     474                 :            :  */
     475                 :          1 : void Manager::setTimeout(quint32 timeout)
     476                 :            : {
     477                 :          1 :     ag_manager_set_db_timeout(d->m_manager, timeout);
     478                 :          1 : }
     479                 :            : 
     480                 :            : /*!
     481                 :            :  * Gets the database timeout.
     482                 :            :  * @return The timeout (in milliseconds) for database operations.
     483                 :            :  */
     484                 :          1 : quint32 Manager::timeout()
     485                 :            : {
     486                 :          1 :     return ag_manager_get_db_timeout(d->m_manager);
     487                 :            : }
     488                 :            : 
     489                 :            : /*!
     490                 :            :  * Sets whether to abort the application when a database timeout occurs.
     491                 :            :  * By default the library does not abort the application.
     492                 :            :  */
     493                 :          1 : void Manager::setAbortOnTimeout(bool abort)
     494                 :            : {
     495                 :          1 :     ag_manager_set_abort_on_db_timeout(d->m_manager, abort);
     496                 :          1 : }
     497                 :            : 
     498                 :            : /*!
     499                 :            :  * @return Whether the application will be aborted when a database timeout
     500                 :            :  * occurs.
     501                 :            :  */
     502                 :          1 : bool Manager::abortOnTimeout() const
     503                 :            : {
     504                 :          1 :     return ag_manager_get_abort_on_db_timeout(d->m_manager);
     505                 :            : }
     506                 :            : 
     507                 :            : /*!
     508                 :            :  * Gets the last error. Not all operations set/reset the error; see the
     509                 :            :  * individual methods' documentation to see if they set the last error or
     510                 :            :  * not. Call this method right after an account operation
     511                 :            :  * has failed; if no error occurred, the result of this method are
     512                 :            :  * undefined.
     513                 :            :  *
     514                 :            :  * @return The last error.
     515                 :            :  */
     516                 :          2 : Error Manager::lastError() const
     517                 :            : {
     518                 :          2 :     return d->lastError;
     519                 :        174 : }
     520                 :            : 

Generated by: LCOV version 1.9