qdeclarativeplace.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdeclarativeplace_p.h"
#include "qdeclarativecontactdetails_p.h"
#include "qdeclarativegeoserviceprovider_p.h"
#include "error_messages_p.h"
 
#include <QtCore/QCoreApplication>
#include <QtCore/QMetaObject>
#include <QtQml/QQmlEngine>
#include <QtQml/QQmlInfo>
#include <QtLocation/QGeoServiceProvider>
#include <QtLocation/QPlaceAttribute>
#include <QtLocation/QPlaceManager>
#include <QtLocation/QPlaceDetailsReply>
#include <QtLocation/QPlaceReply>
#include <QtLocation/QPlaceIdReply>
#include <QtLocation/QPlaceContactDetail>
 
QT_BEGIN_NAMESPACE
 
QDeclarativePlace::QDeclarativePlace(QObject *parent)
:   QObject(parent),
    m_extendedAttributes(new QQmlPropertyMap(this)),
    m_contactDetails(new QDeclarativeContactDetails(this))
{
    connect(m_contactDetails, &QDeclarativeContactDetails::valueChanged,
            this, &QDeclarativePlace::contactsModified);
 
    setPlace(QPlace());
}
 
QDeclarativePlace::QDeclarativePlace(const QPlace &src, QDeclarativeGeoServiceProvider *plugin, QObject *parent)
:   QObject(parent),
    m_extendedAttributes(new QQmlPropertyMap(this)),
    m_contactDetails(new QDeclarativeContactDetails(this)),
    m_plugin(plugin)
{
    Q_ASSERT(plugin);
 
    connect(m_contactDetails, &QDeclarativeContactDetails::valueChanged,
            this, &QDeclarativePlace::contactsModified);
 
    setPlace(src);
}
 
QDeclarativePlace::~QDeclarativePlace()
{
}
 
// From QQmlParserStatus
void QDeclarativePlace::componentComplete()
{
    m_complete = true;
}
 
void QDeclarativePlace::setPlugin(QDeclarativeGeoServiceProvider *plugin)
{
    if (m_plugin == plugin)
        return;
 
    m_plugin = plugin;
    if (m_complete)
        emit pluginChanged();
 
    if (m_plugin->isAttached()) {
        pluginReady();
    } else {
        connect(m_plugin, &QDeclarativeGeoServiceProvider::attached,
                this, &QDeclarativePlace::pluginReady);
    }
}
 
void QDeclarativePlace::pluginReady()
{
    QGeoServiceProvider *serviceProvider = m_plugin->sharedGeoServiceProvider();
    QPlaceManager *placeManager = serviceProvider->placeManager();
    if (!placeManager || serviceProvider->error() != QGeoServiceProvider::NoError) {
        setStatus(Error, QCoreApplication::translate(CONTEXT_NAME, PLUGIN_ERROR)
                         .arg(m_plugin->name()).arg(serviceProvider->errorString()));
        return;
    }
}
 
QDeclarativeGeoServiceProvider *QDeclarativePlace::plugin() const
{
    return m_plugin;
}
 
QDeclarativePlaceReviewModel *QDeclarativePlace::reviewModel()
{
    if (!m_reviewModel) {
        m_reviewModel = new QDeclarativePlaceReviewModel(this);
        m_reviewModel->setPlace(this);
    }
 
    return m_reviewModel;
}
 
QDeclarativePlaceImageModel *QDeclarativePlace::imageModel()
{
    if (!m_imageModel) {
        m_imageModel = new QDeclarativePlaceImageModel(this);
        m_imageModel->setPlace(this);
    }
 
    return m_imageModel;
}
 
QDeclarativePlaceEditorialModel *QDeclarativePlace::editorialModel()
{
    if (!m_editorialModel) {
        m_editorialModel = new QDeclarativePlaceEditorialModel(this);
        m_editorialModel->setPlace(this);
    }
 
    return m_editorialModel;
}
 
void QDeclarativePlace::setPlace(const QPlace &src)
{
    QPlace previous = m_src;
    m_src = src;
 
    if (previous.categories() != m_src.categories()) {
        synchronizeCategories();
        emit categoriesChanged();
    }
 
    if (m_location && m_location->parent() == this) {
        m_location->setLocation(m_src.location());
    } else if (!m_location || m_location->parent() != this) {
        m_location = new QDeclarativeGeoLocation(m_src.location(), this);
        emit locationChanged();
    }
 
    if (previous.ratings() != m_src.ratings())
        emit ratingsChanged();
    if (previous.supplier() != m_src.supplier())
        emit supplierChanged();
    if (previous.icon() != m_src.icon())
        emit iconChanged();
    if (previous.name() != m_src.name())
        emit nameChanged();
    if (previous.placeId() != m_src.placeId())
        emit placeIdChanged();
    if (previous.attribution() != m_src.attribution())
        emit attributionChanged();
    if (previous.detailsFetched() != m_src.detailsFetched())
        emit detailsFetchedChanged();
    if (previous.primaryPhone() != m_src.primaryPhone())
        emit primaryPhoneChanged();
    if (previous.primaryFax() != m_src.primaryFax())
        emit primaryFaxChanged();
    if (previous.primaryEmail() != m_src.primaryEmail())
        emit primaryEmailChanged();
    if (previous.primaryWebsite() != m_src.primaryWebsite())
        emit primaryWebsiteChanged();
 
    if (m_reviewModel && m_src.totalContentCount(QPlaceContent::ReviewType) >= 0) {
        m_reviewModel->initializeCollection(m_src.totalContentCount(QPlaceContent::ReviewType),
                                            m_src.content(QPlaceContent::ReviewType));
    }
    if (m_imageModel && m_src.totalContentCount(QPlaceContent::ImageType) >= 0) {
        m_imageModel->initializeCollection(m_src.totalContentCount(QPlaceContent::ImageType),
                                           m_src.content(QPlaceContent::ImageType));
    }
    if (m_editorialModel && m_src.totalContentCount(QPlaceContent::EditorialType) >= 0) {
        m_editorialModel->initializeCollection(m_src.totalContentCount(QPlaceContent::EditorialType),
                                               m_src.content(QPlaceContent::EditorialType));
    }
 
    pullExtendedAttributes();
    synchronizeContacts();
}
 
QPlace QDeclarativePlace::place() const
{
    // The properties handled explicirly here are not stored in m_src, but
    // but are instead stored in QDeclarative* objects which we need to update
    // explicitly.
 
    QPlace result = m_src;
 
    // Categories
    QList<QPlaceCategory> categories;
    for (QDeclarativeCategory *value : std::as_const(m_categories))
        categories.append(value->category());
 
    result.setCategories(categories);
 
    // Location
    result.setLocation(m_location ? m_location->location() : QGeoLocation());
 
    //contact details
    QList<QPlaceContactDetail> cppDetails;
    for (const QString &key : m_contactDetails->keys()) {
        cppDetails.clear();
        if (m_contactDetails->value(key).typeId() == QMetaType::QVariantList) {
            const QVariantList detailsVarList = m_contactDetails->value(key).toList();
            for (const QVariant &detailVar : detailsVarList)
                cppDetails.append(detailVar.value<QPlaceContactDetail>());
        } else {
            cppDetails.append(m_contactDetails->value(key).value<QPlaceContactDetail>());
        }
        result.setContactDetails(key, cppDetails);
    }
 
    return result;
}
 
void QDeclarativePlace::setLocation(QDeclarativeGeoLocation *location)
{
    if (m_location == location)
        return;
 
    if (m_location && m_location->parent() == this)
        delete m_location;
 
    m_location = location;
    emit locationChanged();
}
 
QDeclarativeGeoLocation *QDeclarativePlace::location() const
{
    return m_location;
}
 
void QDeclarativePlace::setRatings(const QPlaceRatings &rating)
{
    if (m_src.ratings() != rating) {
        m_src.setRatings(rating);
        emit ratingsChanged();
    }
}
 
QPlaceRatings QDeclarativePlace::ratings() const
{
    return m_src.ratings();
}
 
void QDeclarativePlace::setSupplier(const QPlaceSupplier &supplier)
{
    if (m_src.supplier() != supplier) {
        m_src.setSupplier(supplier);
        emit supplierChanged();
    }
}
 
QPlaceSupplier QDeclarativePlace::supplier() const
{
    return m_src.supplier();
}
 
QPlaceIcon QDeclarativePlace::icon() const
{
    return m_src.icon();
}
 
void QDeclarativePlace::setIcon(const QPlaceIcon &icon)
{
    if (m_src.icon() != icon) {
        m_src.setIcon(icon);
        emit iconChanged();
    }
}
 
void QDeclarativePlace::setName(const QString &name)
{
    if (m_src.name() != name) {
        m_src.setName(name);
        emit nameChanged();
    }
}
 
QString QDeclarativePlace::name() const
{
    return m_src.name();
}
 
void QDeclarativePlace::setPlaceId(const QString &placeId)
{
    if (m_src.placeId() != placeId) {
        m_src.setPlaceId(placeId);
        emit placeIdChanged();
    }
}
 
QString QDeclarativePlace::placeId() const
{
    return m_src.placeId();
}
 
void QDeclarativePlace::setAttribution(const QString &attribution)
{
    if (m_src.attribution() != attribution) {
        m_src.setAttribution(attribution);
        emit attributionChanged();
    }
}
 
QString QDeclarativePlace::attribution() const
{
    return m_src.attribution();
}
 
bool QDeclarativePlace::detailsFetched() const
{
    return m_src.detailsFetched();
}
 
void QDeclarativePlace::setStatus(Status status, const QString &errorString)
{
    Status originalStatus = m_status;
    m_status = status;
    m_errorString = errorString;
 
    if (originalStatus != m_status)
        emit statusChanged();
}
 
QDeclarativePlace::Status QDeclarativePlace::status() const
{
    return m_status;
}
 
void QDeclarativePlace::finished()
{
    if (!m_reply)
        return;
 
    if (m_reply->error() == QPlaceReply::NoError) {
        switch (m_reply->type()) {
        case (QPlaceReply::IdReply) : {
            QPlaceIdReply *idReply = qobject_cast<QPlaceIdReply *>(m_reply);
 
            switch (idReply->operationType()) {
            case QPlaceIdReply::SavePlace:
                setPlaceId(idReply->id());
                break;
            case QPlaceIdReply::RemovePlace:
                break;
            default:
                //Other operation types shouldn't ever be received.
                break;
            }
            break;
        }
        case (QPlaceReply::DetailsReply): {
            QPlaceDetailsReply *detailsReply = qobject_cast<QPlaceDetailsReply *>(m_reply);
            setPlace(detailsReply->place());
            break;
        }
        default:
            //other types of replies shouldn't ever be received.
            break;
        }
 
        m_errorString.clear();
 
        m_reply->deleteLater();
        m_reply = nullptr;
 
        setStatus(QDeclarativePlace::Ready);
    } else {
        QString errorString = m_reply->errorString();
 
        m_reply->deleteLater();
        m_reply = nullptr;
 
        setStatus(QDeclarativePlace::Error, errorString);
    }
}
 
void QDeclarativePlace::contactsModified(const QString &key, const QVariant &)
{
    primarySignalsEmission(key);
}
 
void QDeclarativePlace::cleanupDeletedCategories()
{
    for (QDeclarativeCategory * category : m_categoriesToBeDeleted) {
        if (category->parent() == this)
            delete category;
    }
    m_categoriesToBeDeleted.clear();
}
 
void QDeclarativePlace::getDetails()
{
    QPlaceManager *placeManager = manager();
    if (!placeManager)
        return;
 
    m_reply = placeManager->getPlaceDetails(placeId());
    connect(m_reply, &QPlaceReply::finished, this, &QDeclarativePlace::finished);
    setStatus(QDeclarativePlace::Fetching);
}
 
void QDeclarativePlace::save()
{
    QPlaceManager *placeManager = manager();
    if (!placeManager)
        return;
 
    m_reply = placeManager->savePlace(place());
    connect(m_reply, &QPlaceReply::finished, this, &QDeclarativePlace::finished);
    setStatus(QDeclarativePlace::Saving);
}
 
void QDeclarativePlace::remove()
{
    QPlaceManager *placeManager = manager();
    if (!placeManager)
        return;
 
    m_reply = placeManager->removePlace(place().placeId());
    connect(m_reply, &QPlaceReply::finished, this, &QDeclarativePlace::finished);
    setStatus(QDeclarativePlace::Removing);
}
 
QString QDeclarativePlace::errorString() const
{
    return m_errorString;
}
 
QString QDeclarativePlace::primaryPhone() const
{
    return primaryValue(QPlaceContactDetail::Phone);
}
 
QString QDeclarativePlace::primaryFax() const
{
    return primaryValue(QPlaceContactDetail::Fax);
}
 
QString QDeclarativePlace::primaryEmail() const
{
    return primaryValue(QPlaceContactDetail::Email);
}
 
QUrl QDeclarativePlace::primaryWebsite() const
{
    return QUrl(primaryValue(QPlaceContactDetail::Website));
}
 
QQmlPropertyMap *QDeclarativePlace::extendedAttributes() const
{
    return m_extendedAttributes;
}
 
QDeclarativeContactDetails *QDeclarativePlace::contactDetails() const
{
    return m_contactDetails;
}
 
QQmlListProperty<QDeclarativeCategory> QDeclarativePlace::categories()
{
    return QQmlListProperty<QDeclarativeCategory>(this,
                                                          0, // opaque data parameter
                                                          category_append,
                                                          category_count,
                                                          category_at,
                                                          category_clear);
}
 
void QDeclarativePlace::category_append(QQmlListProperty<QDeclarativeCategory> *prop,
                                                  QDeclarativeCategory *value)
{
    QDeclarativePlace *object = static_cast<QDeclarativePlace *>(prop->object);
 
    if (object->m_categoriesToBeDeleted.contains(value))
        object->m_categoriesToBeDeleted.removeAll(value);
 
    if (!object->m_categories.contains(value)) {
        object->m_categories.append(value);
        QList<QPlaceCategory> list = object->m_src.categories();
        list.append(value->category());
        object->m_src.setCategories(list);
 
        emit object->categoriesChanged();
    }
}
 
qsizetype QDeclarativePlace::category_count(QQmlListProperty<QDeclarativeCategory> *prop)
{
    return static_cast<QDeclarativePlace *>(prop->object)->m_categories.count();
}
 
QDeclarativeCategory *QDeclarativePlace::category_at(QQmlListProperty<QDeclarativeCategory> *prop,
                                                     qsizetype index)
{
    QDeclarativePlace *object = static_cast<QDeclarativePlace *>(prop->object);
    QDeclarativeCategory *res = NULL;
    if (object->m_categories.count() > index && index > -1) {
        res = object->m_categories[index];
    }
    return res;
}
 
void QDeclarativePlace::category_clear(QQmlListProperty<QDeclarativeCategory> *prop)
{
    QDeclarativePlace *object = static_cast<QDeclarativePlace *>(prop->object);
    if (object->m_categories.isEmpty())
        return;
 
    for (auto *category : std::as_const(object->m_categories)) {
        if (category->parent() == object)
            object->m_categoriesToBeDeleted.append(category);
    }
 
    object->m_categories.clear();
    object->m_src.setCategories(QList<QPlaceCategory>());
    emit object->categoriesChanged();
    QMetaObject::invokeMethod(object, "cleanupDeletedCategories", Qt::QueuedConnection);
}
 
void QDeclarativePlace::synchronizeCategories()
{
    qDeleteAll(m_categories);
    m_categories.clear();
    for (const QPlaceCategory &value : m_src.categories()) {
        QDeclarativeCategory *declarativeValue = new QDeclarativeCategory(value, m_plugin, this);
        m_categories.append(declarativeValue);
    }
}
 
QDeclarativePlace::Visibility QDeclarativePlace::visibility() const
{
    return static_cast<QDeclarativePlace::Visibility>(m_src.visibility());
}
 
void QDeclarativePlace::setVisibility(Visibility visibility)
{
    if (static_cast<QDeclarativePlace::Visibility>(m_src.visibility()) == visibility)
        return;
 
    m_src.setVisibility(static_cast<QLocation::Visibility>(visibility));
    emit visibilityChanged();
}
 
QDeclarativePlace *QDeclarativePlace::favorite() const
{
    return m_favorite;
}
 
void QDeclarativePlace::setFavorite(QDeclarativePlace *favorite)
{
 
    if (m_favorite == favorite)
        return;
 
    if (m_favorite && m_favorite->parent() == this)
        delete m_favorite;
 
    m_favorite = favorite;
    emit favoriteChanged();
}
 
void QDeclarativePlace::copyFrom(QDeclarativePlace *original)
{
    QPlaceManager *placeManager = manager();
    if (!placeManager)
        return;
 
    setPlace(placeManager->compatiblePlace(original->place()));
}
 
void QDeclarativePlace::initializeFavorite(QDeclarativeGeoServiceProvider *plugin)
{
    if (m_favorite == 0) {
        QDeclarativePlace *place = new QDeclarativePlace(this);
        place->setPlugin(plugin);
        place->copyFrom(this);
        setFavorite(place);
    }
}
 
void QDeclarativePlace::pullExtendedAttributes()
{
    const QStringList keys = m_extendedAttributes->keys();
    for (const QString &key : keys)
        m_extendedAttributes->clear(key);
 
    const QStringList attributeTypes = m_src.extendedAttributeTypes();
    for (const QString &attributeType : attributeTypes) {
        m_extendedAttributes->insert(attributeType,
            QVariant::fromValue(m_src.extendedAttribute(attributeType)));
    }
 
    emit extendedAttributesChanged();
}
 
void QDeclarativePlace::synchronizeContacts()
{
    //clear out contact data
    for (const QString &contactType : m_contactDetails->keys()) {
        const QList<QVariant> contacts = m_contactDetails->value(contactType).toList();
        for (const QVariant &var : contacts) {
            QObject *obj = var.value<QObject *>();
            if (obj->parent() == this)
                delete obj;
        }
        m_contactDetails->insert(contactType, QVariantList());
    }
 
    //insert new contact data from source place
    for (const QString &contactType : m_src.contactTypes()) {
        const QList<QPlaceContactDetail> sourceContacts = m_src.contactDetails(contactType);
        QVariantList declContacts;
        for (const QPlaceContactDetail &sourceContact : sourceContacts)
            declContacts.append(QVariant::fromValue(sourceContact));
        m_contactDetails->insert(contactType, declContacts);
    }
    primarySignalsEmission();
}
 
void QDeclarativePlace::primarySignalsEmission(const QString &type)
{
    if (type.isEmpty() || type == QPlaceContactDetail::Phone) {
        if (m_prevPrimaryPhone != primaryPhone()) {
            m_prevPrimaryPhone = primaryPhone();
            emit primaryPhoneChanged();
        }
        if (!type.isEmpty())
            return;
    }
 
    if (type.isEmpty() || type == QPlaceContactDetail::Email) {
        if (m_prevPrimaryEmail != primaryEmail()) {
            m_prevPrimaryEmail = primaryEmail();
            emit primaryEmailChanged();
        }
        if (!type.isEmpty())
            return;
    }
 
    if (type.isEmpty() || type == QPlaceContactDetail::Website) {
        if (m_prevPrimaryWebsite != primaryWebsite()) {
            m_prevPrimaryWebsite = primaryWebsite();
            emit primaryWebsiteChanged();
        }
        if (!type.isEmpty())
            return;
    }
 
    if (type.isEmpty() || type == QPlaceContactDetail::Fax) {
        if (m_prevPrimaryFax != primaryFax()) {
            m_prevPrimaryFax = primaryFax();
            emit primaryFaxChanged();
        }
    }
}
 
QPlaceManager *QDeclarativePlace::manager()
{
    if (m_status != QDeclarativePlace::Ready && m_status != QDeclarativePlace::Error)
        return nullptr;
 
    if (m_reply) {
        m_reply->abort();
        m_reply->deleteLater();
        m_reply = nullptr;
    }
 
    if (!m_plugin) {
           qmlWarning(this) << QStringLiteral("Plugin is not assigned to place.");
           return nullptr;
    }
 
    QGeoServiceProvider *serviceProvider = m_plugin->sharedGeoServiceProvider();
    if (!serviceProvider)
        return nullptr;
 
    QPlaceManager *placeManager = serviceProvider->placeManager();
 
    if (!placeManager) {
        setStatus(Error, QCoreApplication::translate(CONTEXT_NAME, PLUGIN_ERROR)
                         .arg(m_plugin->name()).arg(serviceProvider->errorString()));
        return nullptr;
    }
 
    return placeManager;
}
 
QString QDeclarativePlace::primaryValue(const QString &contactType) const
{
    QVariant value = m_contactDetails->value(contactType);
    if (value.userType() == qMetaTypeId<QJSValue>())
        value = value.value<QJSValue>().toVariant();
 
    if (value.userType() == QMetaType::QVariantList) {
        QVariantList detailList = m_contactDetails->value(contactType).toList();
        if (!detailList.isEmpty())
            return detailList.at(0).value<QPlaceContactDetail>().value();
    } else if (value.metaType() == QMetaType::fromType<QPlaceContactDetail>()) {
        return value.value<QPlaceContactDetail>().value();
    }
 
    return QString();
}
 
QT_END_NAMESPACE