LCOV - Code Coverage - Accounts/account-service.cpp

LCOV - code coverage report
Current view: | top level - Accounts - account-service.cpp (source / functions) |  |  | Hit | Total | Coverage
Test: | Code Coverage |  | Lines: | 122 | 126 | 96.8 %
Date: | 2013-04-26 |  | Functions: | 28 | 28 | 100.0 %
Legend: | Lines: hit not hit | Branches: + taken - not taken # not executed |  | Branches: | 34 | 49 | 69.4 %

               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-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 "account-service.h"
          25                 :            : #include "manager.h"
          26                 :            : #include "utils.h"
          27                 :            : #include <QPointer>
          28                 :            : #include <libaccounts-glib/ag-account.h>
          29                 :            : #include <libaccounts-glib/ag-account-service.h>
          30                 :            : #include <libaccounts-glib/ag-auth-data.h>
          31                 :            :
          32                 :            : namespace Accounts
          33                 :            : {
          34                 :            :
          35                 :            : /*!
          36                 :            :  * @class AccountService
          37                 :            :  * @headerfile account-service.h Accounts/AccountService
          38                 :            :  *
          39                 :            :  * @brief Account settings for a specific service
          40                 :            :  *
          41                 :            :  * @details The AccountService class provides access to the account settings
          42                 :            :  * for a specific service type. It is meant to be easier to use than the
          43                 :            :  * Account class because it hides the complexity of the account structure and
          44                 :            :  * gives access to only the limited subset of account settings which are
          45                 :            :  * relevant to a service.
          46                 :            :  *
          47                 :            :  * To get an AccountService one can use the Manager methods accountServices()
          48                 :            :  * or enabledAccountServices(), which both return a QList of account services.
          49                 :            :  * Note that if the Manager was instantiated for a specific service type, these
          50                 :            :  * lists will contain only those account services matching that service type.
          51                 :            :  * The AccountService can also be instantiated with its AccountService(Account
          52                 :            :  * *account, Service *service) constructor: this is useful if one already has
          53                 :            :  * an Account instance.
          54                 :            :  *
          55                 :            :  * This is intended to be a convenient wrapper over the accounts settings
          56                 :            :  * specific for a service; as such, it doesn't offer all the editing
          57                 :            :  * possibilities offered by the Account class, such as enabling the service
          58                 :            :  * itself: these operations should ideally not be performed by consumer
          59                 :            :  * applications, but by the account editing UI only.
          60                 :            :  *
          61                 :            :  * Example code:
          62                 :            :  * @code
          63                 :            :  * // Instantiate an account manager interested in e-mail services only.
          64                 :            :  * Accounts::Manager *manager = new Accounts::Manager("e-mail");
          65                 :            :  *
          66                 :            :  * // Get the list of enabled AccountService objects of type e-mail.
          67                 :            :  * Accounts::AccountServiceList services = manager->enabledAccountServices();
          68                 :            :  *
          69                 :            :  * // Loop through the account services and do something useful with them.
          70                 :            :  * foreach (Accounts::AccountService service, services) {
          71                 :            :  *     QString server = service.value("pop3/hostname").toString();
          72                 :            :  *     int port = service.value("pop3/port").toInt();
          73                 :            :  *
          74                 :            :  *     // Suppose that the e-mail address is stored in the global account
          75                 :            :  *     // settings; let's get it from there:
          76                 :            :  *     QString fromAddress = service.account()->valueAsString("username");
          77                 :            :  *
          78                 :            :  *     ...
          79                 :            :  * }
          80                 :            :  * @endcode
          81                 :            :  *
          82                 :            :  * @note User applications (with the notable exception of the accounts editing
          83                 :            :  * application) should never use account services which are not enabled, and
          84                 :            :  * should stop using an account when the account service becomes disabled. The
          85                 :            :  * latter can be done by connecting to the changed() signal and checking if
          86                 :            :  * enabled() still returns true.
          87                 :            :  * @note Note that if the account gets deleted, it will always get disabled
          88                 :            :  * first; so, there is no need to connect to the Account::removed() signal; one
          89                 :            :  * can just monitor the changed() signal from the AccountService objects.
          90                 :            :  */
          91                 :            :
          92                 :            : /*!
          93                 :            :  * @fn AccountService::enabled(bool isEnabled)
          94                 :            :  *
          95                 :            :  * Emitted when the enabledness state of the account service has changed.
          96                 :            :  */
          97                 :            :
          98                 :            :
          99                 :            : /*!
         100                 :            :  * @fn AccountService::changed()
         101                 :            :  * Emitted when some setting has changed on the account service.
         102                 :            :  * You can use the changedFields() method to retrieve the list of the
         103                 :            :  * settings which have changed.
         104                 :            :  */
         105                 :            :
         106                 :            : class AccountServicePrivate
         107                 :            : {
         108                 :            :     Q_DECLARE_PUBLIC(AccountService)
         109                 :            :
         110                 :            : public:
         111                 :            :     AccountServicePrivate(Account *account,
         112                 :            :                           const Service &service,
         113                 :            :                           AccountService *accountService);
         114                 :            :     ~AccountServicePrivate();
         115                 :            :
         116                 :            : private:
         117                 :            :     static void onEnabled(AccountService *accountService, gboolean isEnabled);
         118                 :            :     static void onChanged(AccountService *accountService);
         119                 :            :
         120                 :            :     ServiceList m_serviceList;
         121                 :            :     AgAccountService *m_accountService;
         122                 :            :     QPointer<Account> m_account;
         123                 :            :     QString prefix;
         124                 :            :     mutable AccountService *q_ptr;
         125                 :            : };
         126                 :            :
         127                 :            : } // namespace
         128                 :            :
         129                 :            : using namespace Accounts;
         130                 :            :
         131                 :          1 : static QChar slash = QChar::fromLatin1('/');
         132                 :            :
         133                 :          4 : AccountServicePrivate::AccountServicePrivate(Account *account,
         134                 :            :                                              const Service &service,
         135                 :            :                                              AccountService *accountService):
         136                 :            :     m_account(account),
         137                 :          4 :     q_ptr(accountService)
         138                 :            : {
         139                 :            :     m_accountService = ag_account_service_new(account->account(),
         140                 :          4 :                                               service.service());
         141                 :            :     g_signal_connect_swapped(m_accountService, "enabled",
         142                 :          4 :                              G_CALLBACK(&onEnabled), accountService);
         143                 :          4 :     g_signal_connect_swapped(m_accountService, "changed",
         144                 :          4 :                              G_CALLBACK(&onChanged), accountService);
         145                 :          4 : }
         146                 :            :
         147                 :          4 : AccountServicePrivate::~AccountServicePrivate()
         148                 :            : {
         149                 :            :     Q_Q(AccountService);
         150                 :          4 :     g_signal_handlers_disconnect_by_func(m_accountService,
         151                 :          4 :                                          (void *)&onEnabled, q);
         152                 :          4 :     g_signal_handlers_disconnect_by_func(m_accountService,
         153                 :          4 :                                          (void *)&onChanged, q);
         154                 :          4 :     g_object_unref(m_accountService);
         155                 :          4 :     m_accountService = 0;
         156                 :          4 : }
         157                 :            :
         158                 :          4 : void AccountServicePrivate::onEnabled(AccountService *accountService,
         159                 :            :                                       gboolean isEnabled)
         160                 :            : {
         161                 :          4 :     TRACE();
         162                 :            :
         163                 :          4 :     Q_EMIT accountService->enabled(isEnabled);
         164                 :          4 : }
         165                 :            :
         166                 :          5 : void AccountServicePrivate::onChanged(AccountService *accountService)
         167                 :            : {
         168                 :          5 :     TRACE();
         169                 :            :
         170                 :          5 :     Q_EMIT accountService->changed();
         171                 :          5 : }
         172                 :            :
         173                 :            : /*!
         174                 :            :  * Constructor.
         175                 :            :  * @param account An Account.
         176                 :            :  * @param service A Service supported by the account.
         177                 :            :  */
         178                 :          3 : AccountService::AccountService(Account *account, const Service &service):
         179                 :            :     QObject(0),
         180                 :          3 :     d_ptr(new AccountServicePrivate(account, service, this))
         181                 :            : {
         182                 :          3 : }
         183                 :            :
         184                 :            : /*!
         185                 :            :  * Constructor.
         186                 :            :  * @param account An Account.
         187                 :            :  * @param service A Service supported by the account.
         188                 :            :  * @param parent The parent object.
         189                 :            :  */
         190                 :          1 : AccountService::AccountService(Account *account, const Service &service,
         191                 :            :                                QObject *parent):
         192                 :            :     QObject(parent),
         193                 :          1 :     d_ptr(new AccountServicePrivate(account, service, this))
         194                 :            : {
         195                 :          1 : }
         196                 :            :
         197                 :            : /*!
         198                 :            :  * Destructor.
         199                 :            :  */
         200                 :          4 : AccountService::~AccountService()
         201                 :            : {
         202         [ +  - ]:          4 :     delete d_ptr;
         203                 :          8 : }
         204                 :            :
         205                 :            : /*!
         206                 :            :  * Return the Account.
         207                 :            :  */
         208                 :          2 : Account *AccountService::account() const
         209                 :            : {
         210                 :            :     Q_D(const AccountService);
         211                 :          2 :     return d->m_account;
         212                 :            : }
         213                 :            :
         214                 :            : /*!
         215                 :            :  * Return the Service. Do not delete this object explicitly.
         216                 :            :  */
         217                 :          1 : Service AccountService::service() const
         218                 :            : {
         219                 :            :     Q_D(const AccountService);
         220                 :          1 :     AgService *service = ag_account_service_get_service(d->m_accountService);
         221                 :          1 :     return Service(service);
         222                 :            : }
         223                 :            :
         224                 :            : /*!
         225                 :            :  * Check whether the account service is enabled.
         226                 :            :  */
         227                 :          6 : bool AccountService::enabled() const
         228                 :            : {
         229                 :            :     Q_D(const AccountService);
         230                 :          6 :     return ag_account_service_get_enabled(d->m_accountService);
         231                 :            : }
         232                 :            :
         233                 :            : /*!
         234                 :            :  * Return all the keys in the current group.
         235                 :            :  */
         236                 :          5 : QStringList AccountService::allKeys() const
         237                 :            : {
         238                 :            :     Q_D(const AccountService);
         239                 :            :     QStringList allKeys;
         240                 :            :     AgAccountSettingIter iter;
         241                 :            :     const gchar *key;
         242                 :            :     GVariant *val;
         243                 :            :
         244                 :            :     /* iterate the settings */
         245                 :          5 :     QByteArray tmp = d->prefix.toLatin1();
         246                 :            :     ag_account_service_settings_iter_init(d->m_accountService,
         247                 :          5 :                                           &iter, tmp.constData());
         248         [ +  + ]:         27 :     while (ag_account_settings_iter_get_next(&iter, &key, &val))
         249                 :            :     {
         250                 :         22 :         allKeys.append(ASCII(key));
         251                 :            :     }
         252                 :          5 :     return allKeys;
         253                 :            : }
         254                 :            :
         255                 :            : /*!
         256                 :            :  * Enter a group. This method never fails.
         257                 :            :  * @param prefix
         258                 :            :  */
         259                 :          1 : void AccountService::beginGroup(const QString &prefix)
         260                 :            : {
         261                 :            :     Q_D(AccountService);
         262                 :          1 :     d->prefix += prefix + slash;
         263                 :          1 : }
         264                 :            :
         265                 :            : /*!
         266                 :            :  * Return all the groups which are direct children of the current group.
         267                 :            :  */
         268                 :          2 : QStringList AccountService::childGroups() const
         269                 :            : {
         270                 :            :     QStringList groups, all_keys;
         271                 :            :
         272                 :          2 :     all_keys = allKeys();
         273 [ +  - ][ +  + ]:         11 :     Q_FOREACH (QString key, all_keys)
                     [ +  + ]
         274                 :            :     {
         275         [ +  + ]:          9 :         if (key.contains(slash)) {
         276                 :          4 :             QString group = key.section(slash, 0, 0);
         277         [ +  + ]:          4 :             if (!groups.contains(group))
         278                 :          4 :                 groups.append(group);
         279                 :            :         }
         280                 :         11 :     }
         281                 :          2 :     return groups;
         282                 :            : }
         283                 :            :
         284                 :            : /*!
         285                 :            :  * Return all the keys which are direct children of the current group.
         286                 :            :  */
         287                 :          2 : QStringList AccountService::childKeys() const
         288                 :            : {
         289                 :            :     QStringList keys, all_keys;
         290                 :            :
         291                 :          2 :     all_keys = allKeys();
         292 [ +  - ][ +  + ]:         10 :     Q_FOREACH (QString key, all_keys)
                     [ +  + ]
         293                 :            :     {
         294         [ +  - ]:          8 :         if (!key.contains(slash))
         295                 :          8 :             keys.append(key);
         296                 :         10 :     }
         297                 :          2 :     return keys;
         298                 :            : }
         299                 :            :
         300                 :            : /*!
         301                 :            :  * Remove all the keys.
         302                 :            :  * @see remove(const QString &key)
         303                 :            :  */
         304                 :          1 : void AccountService::clear()
         305                 :            : {
         306                 :            :     Q_D(AccountService);
         307                 :            :     /* clear() must ignore the group: so, temporarily reset it and call
         308                 :            :      * remove("") */
         309                 :            :     QString saved_prefix = d->prefix;
         310                 :          1 :     d->prefix = QString();
         311                 :          1 :     remove(QString());
         312                 :          1 :     d->prefix = saved_prefix;
         313                 :          1 : }
         314                 :            :
         315                 :            : /*!
         316                 :            :  * Check whether the given key is in the current group.
         317                 :            :  * @param key The key name of the setting.
         318                 :            :  */
         319                 :          1 : bool AccountService::contains(const QString &key) const
         320                 :            : {
         321                 :          2 :     return childKeys().contains(key);
         322                 :            : }
         323                 :            :
         324                 :            : /*!
         325                 :            :  * Exit a group.
         326                 :            :  */
         327                 :          1 : void AccountService::endGroup()
         328                 :            : {
         329                 :            :     Q_D(AccountService);
         330                 :            :     d->prefix = d->prefix.section(slash, 0, -3,
         331                 :          1 :                                   QString::SectionIncludeTrailingSep);
         332         [ +  - ]:          1 :     if (d->prefix[0] == slash) d->prefix.remove(0, 1);
         333                 :          1 : }
         334                 :            :
         335                 :            : /*!
         336                 :            :  * Return the name of the current group.
         337                 :            :  */
         338                 :          1 : QString AccountService::group() const
         339                 :            : {
         340                 :            :     Q_D(const AccountService);
         341         [ +  - ]:          1 :     if (d->prefix.endsWith(slash))
         342                 :          1 :         return d->prefix.left(d->prefix.size() - 1);
         343                 :            :     return d->prefix;
         344                 :            : }
         345                 :            :
         346                 :            : /*!
         347                 :            :  * Remove the given key. If the key is the empty string, all keys in the
         348                 :            :  * current group are removed.
         349                 :            :  * @param key The key name of the setting.
         350                 :            :  */
         351                 :          7 : void AccountService::remove(const QString &key)
         352                 :            : {
         353                 :            :     Q_D(AccountService);
         354         [ +  + ]:          7 :     if (key.isEmpty())
         355                 :            :     {
         356                 :            :         /* delete all keys in the group */
         357                 :          1 :         QStringList keys = allKeys();
         358 [ +  - ][ +  + ]:          6 :         Q_FOREACH (QString key, keys)
                     [ +  + ]
         359                 :            :         {
         360         [ +  - ]:          5 :             if (!key.isEmpty())
         361                 :          5 :                 remove(key);
         362                 :          6 :         }
         363                 :            :     }
         364                 :            :     else
         365                 :            :     {
         366                 :          6 :         QString full_key = d->prefix + key;
         367                 :          6 :         QByteArray tmpkey = full_key.toLatin1();
         368                 :            :         ag_account_service_set_variant(d->m_accountService,
         369                 :            :                                        tmpkey.constData(),
         370                 :          6 :                                        NULL);
         371                 :            :     }
         372                 :          7 : }
         373                 :            :
         374                 :            : /*!
         375                 :            :  * Change the value of an account setting.
         376                 :            :  * @param key The name of the setting.
         377                 :            :  * @param value The new value of the setting.
         378                 :            :  */
         379                 :          1 : void AccountService::setValue(const QString &key, const QVariant &value)
         380                 :            : {
         381                 :            :     Q_D(AccountService);
         382                 :            :
         383                 :          1 :     GVariant *variant = qVariantToGVariant(value);
         384         [ +  - ]:          1 :     if (variant == 0) {
         385                 :          1 :         return;
         386                 :            :     }
         387                 :            :
         388                 :          1 :     QString full_key = d->prefix + key;
         389                 :          1 :     QByteArray tmpkey = full_key.toLatin1();
         390                 :            :     ag_account_service_set_variant(d->m_accountService,
         391                 :            :                                    tmpkey.constData(),
         392                 :          1 :                                    variant);
         393                 :            : }
         394                 :            :
         395                 :          1 : void AccountService::setValue(const char *key, const QVariant &value)
         396                 :            : {
         397                 :          1 :     setValue(ASCII(key), value);
         398                 :          1 : }
         399                 :            :
         400                 :            : /*!
         401                 :            :  * Retrieves the value of an account setting, as a QVariant.
         402                 :            :  * @param key The key whose value must be retrieved.
         403                 :            :  * @param defaultValue Value returned if the key is unset.
         404                 :            :  * @param source Indicates whether the value comes from the account, the
         405                 :            :  * service template or was unset.
         406                 :            :  *
         407                 :            :  * @return The value associated to \a key.
         408                 :            :  *
         409                 :            :  * This method operates on the currently selected service.
         410                 :            :  */
         411                 :          4 : QVariant AccountService::value(const QString &key,
         412                 :            :                                const QVariant &defaultValue,
         413                 :            :                                SettingSource *source) const
         414                 :            : {
         415                 :            :     Q_D(const AccountService);
         416                 :          4 :     QString full_key = d->prefix + key;
         417                 :          4 :     QByteArray ba = full_key.toLatin1();
         418                 :            :     AgSettingSource settingSource;
         419                 :            :     GVariant *variant =
         420                 :            :         ag_account_service_get_variant(d->m_accountService,
         421                 :            :                                        ba.constData(),
         422                 :          4 :                                        &settingSource);
         423         [ -  + ]:          4 :     if (source != 0) {
         424      [ #  #  # ]:          0 :         switch (settingSource) {
         425                 :          0 :         case AG_SETTING_SOURCE_ACCOUNT: *source = ACCOUNT; break;
         426                 :          0 :         case AG_SETTING_SOURCE_PROFILE: *source = TEMPLATE; break;
         427                 :          0 :         default: *source = NONE; break;
         428                 :            :         }
         429                 :            :     }
         430                 :            :
         431         [ +  - ]:          4 :     return (variant != 0) ? gVariantToQVariant(variant) : defaultValue;
         432                 :            : }
         433                 :            :
         434                 :            : /*!
         435                 :            :  * Retrieves the value of an account setting.
         436                 :            :  * @param key The key whose value must be retrieved
         437                 :            :  * @param source Indicates whether the value comes from the account, the
         438                 :            :  * service template or was unset.
         439                 :            :  *
         440                 :            :  * Returns the value of the setting, or an invalid QVariant if unset.
         441                 :            :  */
         442                 :          4 : QVariant AccountService::value(const QString &key, SettingSource *source) const
         443                 :            : {
         444                 :          4 :     return value(key, QVariant(), source);
         445                 :            : }
         446                 :            :
         447                 :          4 : QVariant AccountService::value(const char *key, SettingSource *source) const
         448                 :            : {
         449                 :          4 :     return value(ASCII(key), source);
         450                 :            : }
         451                 :            :
         452                 :            : /*!
         453                 :            :  * This method should be called only in the context of a handler of the
         454                 :            :  * AccountService::changed() signal, and can be used to retrieve the set of
         455                 :            :  * changes.
         456                 :            :  *
         457                 :            :  * @return a QStringList of the keys which have changed.
         458                 :            :  */
         459                 :          5 : QStringList AccountService::changedFields() const
         460                 :            : {
         461                 :            :     Q_D(const AccountService);
         462                 :            :
         463                 :            :     gchar **changedFields =
         464                 :          5 :         ag_account_service_get_changed_fields(d->m_accountService);
         465                 :            :
         466                 :            :     QStringList keyList;
         467         [ +  - ]:          5 :     if (changedFields == 0)
         468                 :            :         return keyList;
         469                 :            :
         470                 :            :     gchar **keys = changedFields;
         471         [ +  + ]:         15 :     while (*keys != 0) {
         472                 :         10 :         keyList.append(QString(ASCII(*keys)));
         473                 :         10 :         keys++;
         474                 :            :     }
         475                 :            :
         476                 :          5 :     g_strfreev(changedFields);
         477                 :          5 :     return keyList;
         478                 :            : }
         479                 :            :
         480                 :            : /*!
         481                 :            :  * Read the authentication data stored in the account (merging the
         482                 :            :  * service-specific settings with the global account settings).
         483                 :            :  * The method and mechanism are read from the "auth/method" and
         484                 :            :  * "auth/mechanism" keys, respectively. The authentication parameters are
         485                 :            :  * found under the "auth/<method>/<mechanism>/" group.
         486                 :            :  *
         487                 :            :  * @return an AuthData object, describing the authentication settings.
         488                 :            :  */
         489                 :          2 : AuthData AccountService::authData() const
         490                 :            : {
         491                 :            :     Q_D(const AccountService);
         492                 :            :
         493                 :            :     AgAuthData *agAuthData =
         494                 :          2 :         ag_account_service_get_auth_data(d->m_accountService);
         495                 :          2 :     return AuthData(agAuthData);
         496                 :          1 : }

Generated by: LCOV version 1.9