QT_BEGIN_NAMESPACE

LocalClientIo::LocalClientIo(QObject *parent)

, m_socket(new QLocalSocket(this))

{

connect(m_socket, &QLocalSocket::errorOccurred, this, &LocalClientIo::onError);

connect(m_socket, &QLocalSocket::stateChanged, this, &LocalClientIo::onStateChanged);

}

}

LocalServerIo::LocalServerIo(QLocalSocket *conn, QObject *parent)

{

m_connection->setParent(this);

}

QIODevice *LocalServerIo::connection() const

m_server.close();

}

{

if (!m_server.isListening())

return nullptr;

QT_BEGIN_NAMESPACE

{

Q_OBJECT

QLocalSocket* m_socket;

};

{

Q_OBJECT

public:

~LocalServerImpl() override;

bool hasPendingConnections() const override;

QUrl address() const override;

bool listen(const QUrl &address) override;

QAbstractSocket::SocketError serverError() const override;

QT_BEGIN_NAMESPACE

QnxClientIo::QnxClientIo(QObject *parent)

, m_socket(new QQnxNativeIo(this))

{

connect(m_socket,

static_cast<void(QQnxNativeIo::*)(QAbstractSocket::SocketError)>(&QQnxNativeIo::error),

this,

}

QnxServerIo::QnxServerIo(QSharedPointer<QIOQnxSource> conn, QObject *parent)

{

}

QIODevice *QnxServerIo::connection() const

m_server.close();

}

{

if (!m_server.isListening())

return nullptr;

QT_BEGIN_NAMESPACE

/*!

as abstract interfaces to allow different backends to be used by QtRO. The

concept behind these classes is that there needs to be a Host node, which

has an address that can be connected to. Then there is a client object,

logic for the client-side and server-side QIODevice are very different.

Thus, three additional backend classes are needed as well.

specific QQnxNativeIo QIODevice (the client-side QIODevice).

specific QIOQnxSource QIODevice (the server-side QIODevice).

QnxServerImpl implements the QtRO QConnectionAbstractServer wrapper around

QLocalServer/QLocalSocket QPA for QNX.

*/

{

Q_OBJECT

QQnxNativeIo *m_socket;

};

{

public:

explicit QnxServerIo(QSharedPointer<QIOQnxSource> conn, QObject *parent = nullptr);

~QnxServerImpl() override;

bool hasPendingConnections() const override;

QUrl address() const override;

bool listen(const QUrl &address) override;

QAbstractSocket::SocketError serverError() const override;

QT_BEGIN_NAMESPACE

TcpClientIo::TcpClientIo(QObject *parent)

, m_socket(new QTcpSocket(this))

{

connect(m_socket, &QAbstractSocket::errorOccurred, this, &TcpClientIo::onError);

connect(m_socket, &QTcpSocket::stateChanged, this, &TcpClientIo::onStateChanged);

}

TcpServerIo::TcpServerIo(QTcpSocket *conn, QObject *parent)

{

m_connection->setParent(this);

}

QIODevice *TcpServerIo::connection() const

close();

}

{

if (!m_server.isListening())

return nullptr;

QT_BEGIN_NAMESPACE

{

Q_OBJECT

QTcpSocket *m_socket;

};

{

Q_OBJECT

public:

~TcpServerImpl() override;

bool hasPendingConnections() const override;

QUrl address() const override;

bool listen(const QUrl &address) override;

QAbstractSocket::SocketError serverError() const override;

/*!

All communication between nodes happens through some form of QIODevice with

is an abstract base class that provides a consistent interface to QtRO, yet

can be extended to support different types of QIODevice.

*/

{

}

{

qCDebug(QT_REMOTEOBJECT_IO) << deviceType() << "read()" << d->m_curReadSize << bytesAvailable();

if (d->m_curReadSize == 0) {

return fromDataStream(d->m_dataStream, type, name);

}

{

if (connection()->isOpen() && !d->m_isClosing)

connection()->write(data);

}

{

if (connection()->isOpen() && !d->m_isClosing)

connection()->write(data.data(), size);

}

{

return !isClosing();

}

{

d->m_isClosing = true;

doClose();

}

{

return connection()->bytesAvailable();

}

{

d->m_dataStream.setDevice(connection());

d->m_dataStream.resetStatus();

}

{

return d->m_isClosing;

}

{

d->m_remoteObjects.insert(name);

}

{

d->m_remoteObjects.remove(name);

}

{

return d->m_remoteObjects;

}

{

}

{

if (!isClosing())

close();

}

{

doDisconnectFromServer();

emit shouldReconnect(this);

}

{

return d->m_url;

}

{

}

{

d->m_url = url;

}

problem is that they behave differently, so this class adds some

consistency.

*/

{

}

{

}

QConnectionAbstractServer::QConnectionAbstractServer(QObject *parent)

{

}

{

iodevice->initializeDataStream();

return iodevice;

}

{

initializeDataStream();

connect(device, &QIODevice::aboutToClose, this, [d]() { d->m_isClosing = true; });

auto meta = device->metaObject();

if (-1 != meta->indexOfSignal(SIGNAL(disconnected())))

connect(device, SIGNAL(disconnected()), this, SIGNAL(disconnected()));

}

{

return d->m_device;

}

{

if (!d->m_device)

return false;

}

{

if (isOpen())

d->m_device->close();

}

{

}

/*!

\sa {qRegisterRemoteObjectsServer}

*/

{

m_dataStream.setVersion(dataStreamVersion);

}

QT_BEGIN_NAMESPACE

{

Q_OBJECT

public:

bool read(QtRemoteObjects::QRemoteObjectPacketTypeEnum &, QString &);

void disconnected();

protected:

virtual QString deviceType() const = 0;

virtual void doClose() = 0;

private:

friend class QRemoteObjectNodePrivate;

friend class QConnectedReplicaImplementation;

friend class QRemoteObjectSourceIo;

};

{

Q_OBJECT

public:

protected:

QString deviceType() const override;

~QConnectionAbstractServer() override;

virtual bool hasPendingConnections() const = 0;

virtual QUrl address() const = 0;

virtual bool listen(const QUrl &address) = 0;

virtual QAbstractSocket::SocketError serverError() const = 0;

virtual void close() = 0;

protected:

Q_SIGNALS:

void newConnection();

};

{

Q_OBJECT

public:

void disconnectFromServer();

virtual void connectToServer() = 0;

QUrl url() const;

Q_SIGNALS:

protected:

virtual void doDisconnectFromServer() = 0;

void setUrl(const QUrl &url);

private:

friend class QtROClientFactory;

};

Q_REMOTEOBJECTS_EXPORT static QtROClientFactory *instance();

/// creates an object from a string

{

auto creatorFunc = m_creatorFuncs.value(url.scheme());

if (!creatorFunc)

return nullptr;

if (res)

res->setUrl(url);

return res;

template<typename T>

void registerType(const QString &id)

{

return new T(parent);

};

}

friend class QtROFactoryLoader;

QtROClientFactory();

QHash<QString, CreatorFunc> m_creatorFuncs;

};

}

{

Q_OBJECT

public:

QIODevice *connection() const override;

bool isOpen() const override;

void doClose() override;

QString deviceType() const override;

private:

};

{

public:

// TODO Remove stream()

QDataStream &stream() { return m_dataStream; }

QDataStream m_dataStream;

QSet<QString> m_remoteObjects;

QRemoteObjectPackets::CodecBase *m_codec { nullptr };

};

{

public:

QUrl m_url;

};

{

public:

QPointer<QIODevice> m_device;

};

QT_END_NAMESPACE

static QMutex s_managedTypesMutex;

static QHash<int, ManagedGadgetTypeEntry> s_managedTypes;

static void GadgetsStaticMetacallFunction(QObject *_o, QMetaObject::Call _c, int _id, void **_a)

{

return dynamicTypes.value(type);

}

{

QMutexLocker lock(&s_managedTypesMutex);

if (s_trackedConnections[typeId].contains(connection))

// Unregister the type only when the connection is destroyed

// Do not unregister types when the connections is discconected, because

// if it gets reconnected it will not register the types again

}

struct EnumPair {

return result;

}

{

const auto &gadget = gadgets.take(typeName);

// TODO Look at having registerGadgets return QMetaType index of the id of the type

return gadgetTypeId;

}

{

while (!gadgets.isEmpty())

registerGadgets(connection, gadgets, gadgets.constBegin().key());

}

}

{

quint32 qtEnums, numGadgets;

in >> qtEnums; // Qt enums - just need registration

registerAllGadgets(connection, gadgets);

}

{

QMetaObjectBuilder builder;

builder.setSuperClass(&QRemoteObjectReplica::staticMetaObject);

return true;

}

if (!connection) {

return false;

}

qROPrivDebug() << "Opening connection to" << address.toString();

qROPrivDebug() << "Replica Connection isValid" << connection->isOpen();

onShouldReconnect(connection);

});

onClientRead(connection);

});

connection->connectToServer();

}

}

{

Q_Q(QRemoteObjectNode);

}

}

{

if (!checkSignatures(rep->m_objectSignature, sourceSignature)) {

qROPrivWarning() << "Signature mismatch for" << rep->m_metaObject->className() << (rep->m_objectName.isEmpty() ? QLatin1String("(unnamed)") : rep->m_objectName);

void QRemoteObjectNodePrivate::onClientRead(QObject *obj)

{

using namespace QRemoteObjectPackets;

QRemoteObjectPacketTypeEnum packetType;

Q_ASSERT(connection);

auto &codec = connection->d_func()->m_codec;

qWarning() << "A null or closed QIODevice was passed to addClientSideConnection(). Ignoring.";

return;

}

d->onClientRead(device);

});

if (device->bytesAvailable())

}

if (!d->remoteObjectIo)

d->remoteObjectIo = new QRemoteObjectSourceIo(this);

return d->remoteObjectIo->newConnection(device);

}

~QRemoteObjectMetaObjectManager();

const QMetaObject *metaObjectForType(const QString &type);

void addFromMetaObject(const QMetaObject *);

private:

void onRemoteObjectSourceAdded(const QRemoteObjectSourceLocation &entry);

void onRemoteObjectSourceRemoved(const QRemoteObjectSourceLocation &entry);

void onRegistryInitialized();

virtual QReplicaImplementationInterface *handleNewAcquire(const QMetaObject *meta, QRemoteObjectReplica *instance, const QString &name);

void handleReplicaConnection(const QString &name);

void initialize();

private:

bool checkSignatures(const QByteArray &a, const QByteArray &b);

public:

struct SourceInfo

{

QString typeName;

QByteArray objectSignature;

};

QHash<QString, QWeakPointer<QReplicaImplementationInterface> > replicas;

QMap<QString, SourceInfo> connectedSources;

QMap<QString, QRemoteObjectNode::RemoteObjectSchemaHandler> schemaHandlers;

QSet<QUrl> requestedUrls;

QRemoteObjectRegistry *registry;

int retryInterval;

*this << id;

}

{

const auto bytearray = getPayload();

for (auto conn : connections)

reset();

}

{

const auto bytearray = getPayload();

for (auto conn : connections)

reset();

}

{

const auto bytearray = getPayload();

connection->write(bytearray);

virtual void deserializeInitPacket(QDataStream &, QVariantList &) = 0;

virtual void deserializeInvokeReplyPacket(QDataStream &in, int &ackedSerialId,

QVariant &value) = 0;

protected:

// A payload can consist of one or more packets

connect(&m_heartbeatTimer, &QTimer::timeout, this, [this] {

// TODO: Revisit if a baseclass method can be used to avoid specialized cast

// conditional logic.

if (m_pendingCalls.contains(0)) {

m_pendingCalls.take(0);

// The source didn't respond in time, disconnect the connection

m_propertyStorage[i] = prop;

}

{

if (connectionToSource.isNull()) {

connectionToSource = conn;

class QRemoteObjectReplica;

class QRemoteObjectSource;

class QReplicaImplementationInterface

{

QRemoteObjectPendingCall sendCommandWithReply(int serialId);

bool waitForFinished(const QRemoteObjectPendingCall &call, int timeout) override;

void notifyAboutReply(int ackedSerialId, const QVariant &value) override;

void setDisconnected();

void _q_send(QMetaObject::Call call, int index, const QVariantList &args) override;

QList<QRemoteObjectReplica *> m_parentsNeedingConnect;

QVariantList m_propertyStorage;

QList<int> m_childIndices;

// pending call data

int m_curSerialId = 1; // 0 is reserved for heartbeat signals

// removeListener tries to modify d->m_listeners, this is O(N²),

// so clear d->m_listeners prior to calling unregister (consume loop).

// We can do this, because we don't care about the return value of removeListener() here.

removeListener(io, true);

}

delete d;

d->codec->send(d->m_listeners);

}

{

d->m_listeners.append(io);

d->isDynamic = d->isDynamic || dynamic;

}

}

{

d->m_listeners.removeAll(io);

if (shouldSendRemove)

QT_BEGIN_NAMESPACE

class QRemoteObjectSourceIo;

class QRemoteObjectSourceBase : public QObject

{

struct Private {

Private(QRemoteObjectSourceIo *io, QRemoteObjectRootSource *root);

QRemoteObjectSourceIo *m_sourceIo;

// Pointer to codec, not owned by Private. We can assume it is valid.

QRemoteObjectPackets::CodecBase *codec;

bool isRoot() const override { return true; }

QString name() const override { return m_name; }

QString m_name;

};

void QRemoteObjectSourceIo::onServerDisconnect(QObject *conn)

{

m_connections.remove(connection);

qRODebug(this) << "OnServerDisconnect";

void QRemoteObjectSourceIo::onServerRead(QObject *conn)

{

// Assert the invariant here conn is of type QIODevice

QRemoteObjectPacketTypeEnum packetType;

do {

{

qRODebug(this) << "handleConnection" << m_connections;

newConnection(conn);

}

{

m_connections.insert(conn);

onServerRead(conn);

});

onServerDisconnect(conn);

});

const QString &typeName);

bool enableRemoting(QObject *object, const SourceApiMap *api, QObject *adapter = nullptr);

bool disableRemoting(QObject *object);

QUrl serverAddress() const;

void unregisterSource(QRemoteObjectSourceBase *source);

QHash<QIODevice*, quint32> m_readSize;

QHash<QObject *, QRemoteObjectRootSource*> m_objectToSourceMap;

QMap<QString, QRemoteObjectSourceBase*> m_sourceObjects;

QMap<QString, QRemoteObjectRootSource*> m_sourceRoots;

QScopedPointer<QConnectionAbstractServer> m_server;

// TODO should have some sort of manager for the codec

QScopedPointer<QRemoteObjectPackets::CodecBase> m_codec{new QRemoteObjectPackets::QDataStreamCodec};