31#include <libaccounts-glib/ag-account.h> 
   78    Private(
Manager *manager, 
const QString &providerName, Account *account);
 
   79    Private(
Manager *manager, AgAccount *agAccount);
 
   83        g_cancellable_cancel(m_cancellable);
 
   84        g_object_unref(m_cancellable);
 
   88    void init(Account *account);
 
   90    QPointer<Manager> m_manager;
 
   92    GCancellable *m_cancellable;
 
   95    static void on_display_name_changed(Account *self);
 
   96    static void on_enabled(Account *self, 
const gchar *service_name,
 
   98    static void account_store_cb(AgAccount *account,
 
  101    static void on_deleted(Account *self);
 
  107    static void account_notify_cb(AgAccount *account, 
const gchar *key,
 
  113using namespace Accounts;
 
  115static QChar slash = QChar::fromLatin1(
'/');
 
  126Watch::Watch(QObject *parent):
 
  133    Account *account = qobject_cast<Account *>(QObject::parent());
 
  136    Q_ASSERT(account != NULL);
 
  137    ag_account_remove_watch(account->d->m_account, watch);
 
  140Account::Private::Private(
Manager *manager, 
const QString &providerName,
 
  143    m_cancellable(g_cancellable_new())
 
  145    m_account = ag_manager_create_account(manager->d->m_manager,
 
  146                                          providerName.toUtf8().constData());
 
  150Account::Private::Private(
Manager *manager, AgAccount *agAccount):
 
  152    m_account(agAccount),
 
  153    m_cancellable(g_cancellable_new())
 
  157void Account::Private::init(Account *account)
 
  159    if (m_account == 
nullptr) 
return;
 
  160    g_signal_connect_swapped(m_account, 
"display-name-changed",
 
  161                             G_CALLBACK(&Private::on_display_name_changed),
 
  163    g_signal_connect_swapped(m_account, 
"enabled",
 
  164                             G_CALLBACK(&Private::on_enabled), account);
 
  165    g_signal_connect_swapped(m_account, 
"deleted",
 
  166                             G_CALLBACK(&Private::on_deleted), account);
 
  169void Account::Private::on_display_name_changed(Account *self)
 
  171    const gchar *name = ag_account_get_display_name(self->d->m_account);
 
  173    Q_EMIT self->displayNameChanged(UTF8(name));
 
  176void Account::Private::on_enabled(Account *self, 
const gchar *service_name,
 
  179    Q_EMIT self->enabledChanged(UTF8(service_name), enabled);
 
  182void Account::Private::on_deleted(Account *self)
 
  184    Q_EMIT self->removed();
 
  202Account::Account(
Manager *manager, 
const QString &providerName,
 
  205    d(new Private(manager, providerName, this))
 
  209Account::Account(Private *d, QObject *parent):
 
  225Account *Account::fromId(
Manager *manager, AccountId 
id, QObject *parent)
 
  227    GError *error = 
nullptr;
 
  228    AgAccount *account = ag_manager_load_account(manager->d->m_manager, 
id,
 
  230    if (account == 
nullptr) {
 
  231        Q_ASSERT(error != 
nullptr);
 
  236    Q_ASSERT(error == 
nullptr);
 
  237    return new Account(
new Private(manager, account), parent);
 
  245    QObjectList list = children();
 
  246    for (
int i = 0; i < list.count(); i++)
 
  248        QObject *o = list.at(i);
 
  249        if (qobject_cast<Watch *>(o))
 
  253    g_signal_handlers_disconnect_by_func
 
  254        (d->m_account, (
void *)&Private::on_display_name_changed, 
this);
 
  255    g_signal_handlers_disconnect_by_func
 
  256        (d->m_account, (
void *)&Private::on_enabled, 
this);
 
  257    g_signal_handlers_disconnect_by_func
 
  258        (d->m_account, (
void *)&Private::on_deleted, 
this);
 
  259    g_object_unref(d->m_account);
 
  268AccountId Account::id()
 const 
  270    return d->m_account ? d->m_account->id : 0;
 
  276Manager *Account::manager()
 const 
  284bool Account::supportsService(
const QString &serviceType)
 const 
  286    return ag_account_supports_service(d->m_account,
 
  287                                       serviceType.toUtf8().constData());
 
  298ServiceList Account::services(
const QString &serviceType)
 const 
  301    if (serviceType.isEmpty()) {
 
  302        list = ag_account_list_services(d->m_account);
 
  304        list = ag_account_list_services_by_type(d->m_account,
 
  305            serviceType.toUtf8().constData());
 
  309    ServiceList servList;
 
  311    for (iter = list; iter; iter = iter->next)
 
  313        AgService *service = (AgService*)iter->data;
 
  314        servList.append(
Service(service, StealReference));
 
  327ServiceList Account::enabledServices()
 const 
  330    list = ag_account_list_enabled_services(d->m_account);
 
  333    ServiceList servList;
 
  335    for (iter = list; iter; iter = g_list_next(iter))
 
  337        AgService *service = (AgService*)iter->data;
 
  338        servList.append(
Service(service, StealReference));
 
  356bool Account::enabled()
 const 
  367bool Account::isEnabled()
 const 
  369    return ag_account_get_enabled(d->m_account);
 
  379void Account::setEnabled(
bool enabled)
 
  381    ag_account_set_enabled(d->m_account, enabled);
 
  389QString Account::displayName()
 const 
  391    return UTF8(ag_account_get_display_name(d->m_account));
 
  398void Account::setDisplayName(
const QString &displayName)
 
  400    ag_account_set_display_name(d->m_account,
 
  401                                displayName.toUtf8().constData());
 
  407QString Account::providerName()
 const 
  409    return UTF8(ag_account_get_provider_name(d->m_account));
 
  417    return manager()->
provider(providerName());
 
  425void Account::selectService(
const Service &service)
 
  427    AgService *agService = NULL;
 
  430        agService = service.service();
 
  432    ag_account_select_service(d->m_account, agService);
 
  433    d->prefix = QString();
 
  439Service Account::selectedService()
 const 
  441    AgService *agService = ag_account_get_selected_service(d->m_account);
 
  450QStringList Account::allKeys()
 const 
  453    AgAccountSettingIter iter;
 
  458    QByteArray tmp = d->prefix.toLatin1();
 
  459    ag_account_settings_iter_init(d->m_account, &iter, tmp.constData());
 
  460    while (ag_account_settings_iter_get_next(&iter, &key, &val))
 
  462        allKeys.append(QString(ASCII(key)));
 
  473void Account::beginGroup(
const QString &prefix)
 
  475    d->prefix += prefix + slash;
 
  483QStringList Account::childGroups()
 const 
  485    QStringList groups, all_keys;
 
  487    all_keys = allKeys();
 
  488    Q_FOREACH (
const QString &key, all_keys)
 
  490        if (key.contains(slash)) {
 
  491            QString group = key.section(slash, 0, 0);
 
  492            if (!groups.contains(group))
 
  493                groups.append(group);
 
  504QStringList Account::childKeys()
 const 
  506    QStringList keys, all_keys;
 
  508    all_keys = allKeys();
 
  509    Q_FOREACH (
const QString &key, all_keys)
 
  511        if (!key.contains(slash))
 
  525    QString saved_prefix = d->prefix;
 
  526    d->prefix = QString();
 
  528    d->prefix = saved_prefix;
 
  537bool Account::contains(
const QString &key)
 const 
  539    return childKeys().contains(key);
 
  547void Account::endGroup()
 
  549    d->prefix = d->prefix.section(slash, 0, -3,
 
  550                                  QString::SectionIncludeTrailingSep);
 
  551    if (d->prefix[0] == slash) d->prefix.remove(0, 1);
 
  559QString Account::group()
 const 
  561    if (d->prefix.endsWith(slash))
 
  562        return d->prefix.left(d->prefix.size() - 1);
 
  569bool Account::isWritable()
 const 
  581void Account::remove(
const QString &key)
 
  586        QStringList keys = allKeys();
 
  587        Q_FOREACH (
const QString &key, keys)
 
  595        QString full_key = d->prefix + key;
 
  596        QByteArray tmpkey = full_key.toLatin1();
 
  597        ag_account_set_variant(d->m_account, tmpkey.constData(), NULL);
 
  608void Account::setValue(
const QString &key, 
const QVariant &value)
 
  610    GVariant *variant = qVariantToGVariant(value);
 
  611    if (variant == 
nullptr) {
 
  615    QString full_key = d->prefix + key;
 
  616    QByteArray tmpkey = full_key.toLatin1();
 
  617    ag_account_set_variant(d->m_account, tmpkey.constData(), variant);
 
  620void Account::Private::account_store_cb(AgAccount *account,
 
  624    GError *error = NULL;
 
  625    ag_account_store_finish(account, res, &error);
 
  627        if (error->domain == G_IO_ERROR &&
 
  628            error->code == G_IO_ERROR_CANCELLED) {
 
  630            Q_EMIT self->error(
Error(error));
 
  634        Q_EMIT self->synced();
 
  652QVariant Account::value(
const QString &key, 
const QVariant &defaultValue,
 
  653                        SettingSource *source)
 const 
  655    QString full_key = d->prefix + key;
 
  656    QByteArray ba = full_key.toLatin1();
 
  657    AgSettingSource settingSource;
 
  659        ag_account_get_variant(d->m_account, ba.constData(), &settingSource);
 
  660    if (source != 
nullptr) {
 
  661        switch (settingSource) {
 
  662        case AG_SETTING_SOURCE_ACCOUNT: *source = ACCOUNT; 
break;
 
  663        case AG_SETTING_SOURCE_PROFILE: *source = TEMPLATE; 
break;
 
  664        default: *source = NONE; 
break;
 
  668    return (variant != 
nullptr) ? gVariantToQVariant(variant) : defaultValue;
 
  686SettingSource Account::value(
const QString &key, QVariant &value)
 const 
  688    SettingSource source;
 
  689    QVariant variant = this->value(key, QVariant(), &source);
 
  690    if (variant.isValid()) {
 
  691        if (value.type() != variant.type()) {
 
  692            if (!variant.convert(value.type())) source = NONE;
 
  709QString Account::valueAsString(
const QString &key,
 
  710                               QString default_value,
 
  711                               SettingSource *source)
 const 
  713    QVariant var = default_value;
 
  714    SettingSource src = value(key, var);
 
  717    return var.toString();
 
  729int Account::valueAsInt(
const QString &key,
 
  731                        SettingSource *source)
 const 
  733    QVariant var = default_value;
 
  734    SettingSource src = value(key, var);
 
  749quint64 Account::valueAsUInt64(
const QString &key,
 
  750                        quint64 default_value,
 
  751                        SettingSource *source)
 const 
  753    QVariant var = default_value;
 
  754    SettingSource src = value(key, var);
 
  757    return var.toULongLong();
 
  769bool Account::valueAsBool(
const QString &key,
 
  771                          SettingSource *source)
 const 
  773    QVariant var = default_value;
 
  774    SettingSource src = value(key, var);
 
  780void Watch::Private::account_notify_cb(AgAccount *account, 
const gchar *key,
 
  783    Q_EMIT watch->notify(key);
 
  798Watch *Account::watchKey(
const QString &key)
 
  800    AgAccountWatch ag_watch;
 
  801    Watch *watch = 
new Watch(
this);
 
  805        QString full_key = d->prefix + key;
 
  806        ag_watch = ag_account_watch_key
 
  807            (d->m_account, full_key.toLatin1().constData(),
 
  808             (AgAccountNotifyCb)&Watch::Private::account_notify_cb, watch);
 
  812        ag_watch = ag_account_watch_dir
 
  813            (d->m_account, d->prefix.toLatin1().constData(),
 
  814             (AgAccountNotifyCb)&Watch::Private::account_notify_cb, watch);
 
  823    watch->setWatch(ag_watch);
 
  841    ag_account_store_async(d->m_account,
 
  843                           (GAsyncReadyCallback)&Private::account_store_cb,
 
  854bool Account::syncAndBlock()
 
  856    GError *error = NULL;
 
  859    ret = ag_account_store_blocking(d->m_account, &error);
 
  862        qWarning() << 
"Store operation failed: " << error->message;
 
  873void Account::remove()
 
  875    ag_account_delete(d->m_account);
 
  887void Account::sign(
const QString &key, 
const char *token)
 
  889    ag_account_sign (d->m_account, key.toUtf8().constData(), token);
 
  903bool Account::verify(
const QString &key, 
const char **token)
 
  905    return ag_account_verify(d->m_account, key.toUtf8().constData(), token);
 
  920bool Account::verifyWithTokens(
const QString &key, QList<const char*> tokens)
 
  922    int tokensCount = tokens.count();
 
  924    const char *tmp[tokensCount + 1];
 
  926    for (
int i = 0; i < tokensCount; ++i)
 
  928        tmp[i] = tokens.at(i);
 
  930    tmp[tokensCount] = NULL;
 
  932    return ag_account_verify_with_tokens(d->m_account, key.toUtf8().constData(), tmp);
 
  935uint Account::credentialsId()
 
  937    QString key = ACCOUNTS_KEY_CREDENTIALS_ID;
 
  938    QVariant val(QVariant::Int);
 
  940    if (value(key, val) != NONE)
 
  944    Service service = selectedService();
 
  947        if (value(key, val) != NONE)
 
  949        selectService(service);
 
  954AgAccount *Account::account()
 
Base object definition for accounts error handling.
Manager of accounts, services and providers.
Provider provider(const QString &providerName) const
Gets an object representing a provider.
Error lastError() const
Gets the last error.
Representation of an account provider.
Representation of an account service.
bool isValid() const
Check whether this object represents a Service.