Revision control
Copy as Markdown
// Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author
// Milian Wolff <milian.wolff@kdab.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qqmlwebchannel.h"
#include <QtWebChannel/qwebchannelabstracttransport.h>
#include <QtWebChannel/private/qwebchannel_p.h>
#include <QtWebChannel/private/qmetaobjectpublisher_p.h>
#include <QtQml/QQmlContext>
#include "qqmlwebchannelattached_p.h"
QT_BEGIN_NAMESPACE
/*!
\qmltype WebChannel
\nativetype QQmlWebChannel
\inqmlmodule QtWebChannel
\ingroup webchannel-qml
\brief QML interface to QWebChannel.
\since 5.4
The WebChannel provides a mechanism to transparently access QObject or QML objects from HTML
clients. All properties, signals and public slots can be used from the HTML clients.
\sa QWebChannel, {Qt WebChannel JavaScript API}{JavaScript API}
*/
class QQmlWebChannelPrivate : public QWebChannelPrivate
{
Q_DECLARE_PUBLIC(QQmlWebChannel)
public:
QList<QObject *> registeredObjects;
void _q_objectIdChanged(const QString &newId);
};
/*!
\internal
Update the name of the sender object, when its attached WebChannel.id property changed.
This is required, since during startup the property is empty and only gets set later on.
*/
void QQmlWebChannelPrivate::_q_objectIdChanged(const QString &newId)
{
Q_Q(QQmlWebChannel);
const QQmlWebChannelAttached *const attached =
qobject_cast<QQmlWebChannelAttached *>(q->sender());
Q_ASSERT(attached);
Q_ASSERT(attached->parent());
Q_ASSERT(registeredObjects.contains(attached->parent()));
QObject *const object = attached->parent();
const QString &oldId = publisher->registeredObjectIds.value(object);
if (!oldId.isEmpty()) {
q->deregisterObject(object);
}
q->registerObject(newId, object);
}
QQmlWebChannel::QQmlWebChannel(QObject *parent) : QWebChannel(*(new QQmlWebChannelPrivate), parent)
{
}
QQmlWebChannel::~QQmlWebChannel() { }
/*!
\qmlmethod void WebChannel::registerObjects(object objects)
Registers the specified \a objects to make them accessible to HTML clients.
\a objects should be a JavaScript Map object.
The key of the map is used as an identifier for the object on the client side.
Once registered, all signals and property changes are automatically propagated to the clients.
Public invokable methods, including slots, are also accessible to the clients.
This imperative API can be used to register objects on the fly. For static objects, the
declarative registeredObjects property should be preferred.
\sa registeredObjects
*/
void QQmlWebChannel::registerObjects(const QVariantMap &objects)
{
Q_D(QQmlWebChannel);
QMap<QString, QVariant>::const_iterator it = objects.constBegin();
for (; it != objects.constEnd(); ++it) {
QObject *object = it.value().value<QObject *>();
if (!object) {
qWarning("Invalid QObject given to register under name %s", qPrintable(it.key()));
continue;
}
d->publisher->registerObject(it.key(), object);
}
}
QQmlWebChannelAttached *QQmlWebChannel::qmlAttachedProperties(QObject *obj)
{
return new QQmlWebChannelAttached(obj);
}
/*!
\qmlmethod void WebChannel::connectTo(QtObject transport)
\brief Connects to the \a transport, which represents a communication
channel to a single client.
The transport object must be an implementation of \l QWebChannelAbstractTransport.
\sa transports, disconnectFrom()
*/
void QQmlWebChannel::connectTo(QObject *transport)
{
if (QWebChannelAbstractTransport *realTransport =
qobject_cast<QWebChannelAbstractTransport *>(transport)) {
QWebChannel::connectTo(realTransport);
} else {
qWarning() << "Cannot connect to transport" << transport
<< " - it is not a QWebChannelAbstractTransport.";
}
}
/*!
\qmlmethod void WebChannel::disconnectFrom(QtObject transport)
\brief Disconnects the \a transport from this WebChannel.
The client will not be able to communicate with the WebChannel anymore, nor will it receive any
signals or property updates.
\sa connectTo()
*/
void QQmlWebChannel::disconnectFrom(QObject *transport)
{
if (QWebChannelAbstractTransport *realTransport =
qobject_cast<QWebChannelAbstractTransport *>(transport)) {
QWebChannel::disconnectFrom(realTransport);
} else {
qWarning() << "Cannot disconnect from transport" << transport
<< " - it is not a QWebChannelAbstractTransport.";
}
}
/*!
\qmlproperty list<QtObject> WebChannel::registeredObjects
\brief A list of objects that should be accessible to remote clients.
The objects must have the attached \l id property set to an identifier, under which the
object is then known on the HTML side.
Once registered, all signals and property changes are automatically propagated to the clients.
Public invokable methods, including slots, are also accessible to the clients.
If you need to register objects that are not available when the component is created, use the
imperative registerObjects method.
\sa registerObjects(), id
*/
QQmlListProperty<QObject> QQmlWebChannel::registeredObjects()
{
return QQmlListProperty<QObject>(this, nullptr, registeredObjects_append,
registeredObjects_count, registeredObjects_at,
registeredObjects_clear);
}
void QQmlWebChannel::registeredObjects_append(QQmlListProperty<QObject> *prop, QObject *object)
{
if (!object) {
qWarning() << "Cannot register null object to WebChannel";
return;
}
const QQmlWebChannelAttached *const attached = qobject_cast<QQmlWebChannelAttached *>(
qmlAttachedPropertiesObject<QQmlWebChannel>(object, false /* don't create */));
if (!attached) {
const QQmlContext *const context = qmlContext(object);
if (context) {
qWarning() << "Cannot register object" << context->nameForObject(object) << '(' << object
<< ") without attached WebChannel.id property. Did you forget to set it?";
} else {
qWarning() << "Cannot register an object without WebChannel attached property.";
}
return;
}
QQmlWebChannel *channel = static_cast<QQmlWebChannel *>(prop->object);
if (!attached->id().isEmpty()) {
// TODO: warning in such cases?
channel->registerObject(attached->id(), object);
}
channel->d_func()->registeredObjects.append(object);
connect(attached, SIGNAL(idChanged(QString)), channel, SLOT(_q_objectIdChanged(QString)));
}
qsizetype QQmlWebChannel::registeredObjects_count(QQmlListProperty<QObject> *prop)
{
return static_cast<QQmlWebChannel *>(prop->object)->d_func()->registeredObjects.size();
}
QObject *QQmlWebChannel::registeredObjects_at(QQmlListProperty<QObject> *prop, qsizetype index)
{
return static_cast<QQmlWebChannel *>(prop->object)->d_func()->registeredObjects.at(index);
}
void QQmlWebChannel::registeredObjects_clear(QQmlListProperty<QObject> *prop)
{
QQmlWebChannel *channel = static_cast<QQmlWebChannel *>(prop->object);
const auto moved = std::exchange(channel->d_func()->registeredObjects, {}); // precautionary
for (QObject *object : moved)
channel->deregisterObject(object);
}
/*!
\qmlproperty list<QtObject> WebChannel::transports
A list of transport objects that implement QWebChannelAbstractTransport. The transports
are used to talk to the remote clients.
\sa connectTo(), disconnectFrom()
*/
QQmlListProperty<QObject> QQmlWebChannel::transports()
{
return QQmlListProperty<QObject>(this, nullptr, transports_append, transports_count,
transports_at, transports_clear);
}
void QQmlWebChannel::transports_append(QQmlListProperty<QObject> *prop, QObject *transport)
{
QQmlWebChannel *channel = static_cast<QQmlWebChannel *>(prop->object);
channel->connectTo(transport);
}
qsizetype QQmlWebChannel::transports_count(QQmlListProperty<QObject> *prop)
{
return static_cast<QQmlWebChannel *>(prop->object)->d_func()->transports.size();
}
QObject *QQmlWebChannel::transports_at(QQmlListProperty<QObject> *prop, qsizetype index)
{
QQmlWebChannel *channel = static_cast<QQmlWebChannel *>(prop->object);
return channel->d_func()->transports.at(index);
}
void QQmlWebChannel::transports_clear(QQmlListProperty<QObject> *prop)
{
QWebChannel *channel = static_cast<QWebChannel *>(prop->object);
// Need to take a copy (incl. forced detach :():
// - disconnectFrom() modifies `transport`, and
// - if we were to use a consume loop, disconnectFrom() wouldn't actually disconnect
const auto copy = channel->d_func()->transports;
for (QWebChannelAbstractTransport *transport : copy)
channel->disconnectFrom(transport);
Q_ASSERT(channel->d_func()->transports.isEmpty());
}
QT_END_NAMESPACE
#include "moc_qqmlwebchannel.cpp"