QRemoteObjectHostBase Class

Documentation des fonctions membres

void QRemoteObjectHostBase::addHostSideConnection(QIODevice *ioDevice)

Pour pouvoir utiliser la fonction ` QRemoteObjectHost::enableRemoting()` sur des objets `Source ` via des périphériques QIODevices externes, ` Qt Remote Objects ` doit pouvoir accéder au canal de communication (un ` QIODevice`) entre les nœuds concernés. C’est l’appel à la fonction `addHostSideConnection()` qui permet cela du côté de la source, en recevant l’objet ` ioDevice ` en paramètre. Tout appel à ` enableRemoting()` fonctionnera toujours sans appeler `addHostSideConnection`, mais le nœud ne pourra pas partager les objets source sans disposer de la connexion au nœud réplique. Avant d’appeler cette fonction, vous devez appeler ` setHostUrl()` avec une URL unique et ` AllowExternalRegistration`.

Voir également addClientSideConnection.

[invokable] bool QRemoteObjectHostBase::disableRemoting(QObject *remoteObject)

Désactive l'accès à distance pour l'QObject remoteObject . Renvoie false si le nœud actuel est un nœud client ou si l'remoteObject n'est pas enregistré, et renvoie true si l'accès à distance a été désactivé avec succès pour l'objet Source.

Voir également enableRemoting().

template <template <typename> typename ApiDefinition, typename ObjectType> bool QRemoteObjectHostBase::enableRemoting(ObjectType *object)

Cette surcharge de fonction modélisée permet à un nœud hôte de fournir un accès à distance à une source ( QObject ) object dotée d’une interface spécifiée (et vérifiée lors de la compilation). Les nœuds clients connectés au nœud hébergeant cet objet peuvent obtenir des répliques de cette source.

Un exemple permet de mieux illustrer ce principe :

#include "rep_TimeModel_source.h"
MinuteTimer timer;
hostNode.enableRemoting<MinuteTimerSourceAPI>(&timer);

Ici, MinuteTimerSourceAPI est l’objet ApiDefinition, représentant l’ensemble des signaux, slots et propriétés définis par le fichier TimeModel.rep. Des vérifications sont effectuées lors de la compilation pour s’assurer que l’ QObject d’entrée peut exposer l’API demandée ; dans le cas contraire, la compilation échouera. Cela permet d’exposer un sous-ensemble de l’interface d’ object et de prendre en charge les types de conversions autorisés par les connexions Signal/Slot.

Renvoie ` false ` si le nœud actuel est un nœud client, ou si l’ QObject est déjà enregistrée pour être accessible à distance, et ` true ` si l’accès à distance est activé avec succès pour l’ QObject.

Voir également disableRemoting().

[invokable] bool QRemoteObjectHostBase::enableRemoting(QObject *object, const QString &name = QString())

Permet à un nœud hôte de fournir de manière dynamique un accès à distance à l'QObject object . Les nœuds clients connectés au nœud hébergeant cet objet peuvent obtenir des répliques de cette source.

La macro facultative ` name ` définit le nom de recherche sous lequel l’` QObject ` peut être obtenu à l’aide de ` QRemoteObjectNode::acquire()`. Si elle n’est pas explicitement définie, le nom indiqué dans `QCLASSINFO_REMOTEOBJECT_TYPE` sera utilisé. Si aucune macro de ce type n’a été définie pour l’` QObject `, la fonction ` QObject::objectName()` est utilisée.

Renvoie ` false ` si le nœud actuel est un nœud client, ou si l'` QObject ` est déjà enregistré pour être accessible à distance, et ` true ` si l'accès à distance est activé avec succès pour l'QObject dynamique.

Voir également disableRemoting().

bool QRemoteObjectHostBase::enableRemoting(QAbstractItemModel *model, const QString &name, const QList<int> roles, QItemSelectionModel *selectionModel = nullptr)

Cette surcharge de la méthode `enableRemoting()` est spécifique aux types ` QAbstractItemModel ` (ou à tout type dérivé de ` QAbstractItemModel`). Elle est utile si vous souhaitez que le modèle et l’IHM correspondant à ce modèle se trouvent dans des processus différents.

Les trois paramètres obligatoires sont l’ model lui-même, l’ name permettant de rechercher le modèle, et l’ roles qui doit être exposée côté réplique. Si vous souhaitez synchroniser la sélection entre la source et la réplique, vous pouvez utiliser le paramètre facultatif selectionModel. Cette option n’est recommandée que lorsque vous utilisez une seule réplique.

En arrière-plan, Qt Remote Objects regroupe les requêtes data() et précharge les données lorsque cela est possible afin de rendre l’interaction avec le modèle aussi réactive que possible.

Renvoie false si le nœud actuel est un nœud client, ou si l’ QObject est déjà enregistré pour être accessible à distance, et true si l’accès à distance est activé avec succès pour l’ QAbstractItemModel.

Voir également disableRemoting().

bool QRemoteObjectHostBase::proxy(const QUrl &registryUrl, const QUrl &hostUrl = {}, QRemoteObjectHostBase::RemoteObjectNameFilter filter = [](QStringView, QStringView) {return true; })

Transfert d'objets distants depuis un autre réseau

La fonctionnalité de proxy est utile lorsque vous souhaitez partager des objets source sur plusieurs réseaux. Par exemple, si vous disposez d'une cible embarquée utilisant des connexions réservées à la cible (comme « local ») et que vous souhaitez rendre certains de ces mêmes objets accessibles depuis l'extérieur.

Concrètement, imaginons que vous disposiez d’un ensemble de processus communiquant entre eux sur votre matériel cible via un registre, ce registre étant accessible à l’adresse « local:registry », et que des processus distincts utilisent un nœud situé à l’adresse « local:MyHost » qui contient des objets source. Si vous souhaitez accéder à ces objets, mais via TCP, vous pouvez créer un nouveau proxyNode comme suit :

// myInternalHost is a node only visible on the device...
QRemoteObjectHost myInternalHost("local:MyHost");
myInternalHost.enableRemoting<SomeObject>(&someObject);

// Regular host node, listening on port 12123, so visible to other
// devices
QRemoteObjectHost proxyNode("tcp://localhost:12123");

// Enable proxying objects from nodes on the local machine's internal
// QtRO bus
proxyNode.proxy("local:registry");

Et depuis un autre appareil, vous créez un autre nœud :

// NB: localhost resolves to a different ip address than proxyNode
QRemoteObjectHost nodeOnRemoteDevice("tcp://localhost:23234");

// Connect to the target's proxyNode directly, or use a tcp registry...
nodeOnRemoteDevice.connectToNode("tcp://<target device>:12123");

// Because of the proxy, we can get the object over tcp/ip port 12123,
// even though we can't connect directly to "local:MyHost"
SomeObject *so = nodeOnRemoteDevice.acquire<SomeObject>();

Cela créerait (en interne) un nœud dans proxyNode, qui se connecterait (là encore en interne et automatiquement) au registre fourni (indiqué par le paramètre registryUrl, « local:registry » dans cet exemple). Chaque fois que « local:registry » émet le signal « remoteObjectAdded », l’ QRemoteObjectSourceLocation est transmise à la méthode « filter » fournie lors de l’appel au proxy. Si cette méthode renvoie « true » (le filtre par défaut renvoie simplement « true » sans effectuer de filtrage), l’objet est récupéré via « acquire() » depuis le nœud interne et la méthode « enableRemoting() » (une fois la réplique initialisée) est appelée sur « proxyNode ».

Si une adresse hostUrl est fournie (ce qui est obligatoire pour activer la fonction reverseProxy, mais facultatif dans les autres cas), le nœud interne sera un nœud QRemoteObjectHost configuré avec l’adresse fournie. Si aucune adresse hostUrl n’est fournie, le nœud interne sera un QRemoteObjectNode (et non un HostNode).

Renvoie « true » si l’objet est obtenu à partir du nœud interne.

Voir également reverseProxy().

bool QRemoteObjectHostBase::reverseProxy(QRemoteObjectHostBase::RemoteObjectNameFilter filter = [](QStringView, QStringView) {return true; })

Transmet des objets distants vers un autre réseau.

La fonction reverseProxy() permet d’étendre la fonctionnalité d’ proxy(), reproduisant ainsi la fonctionnalité de proxy dans le sens « inverse ». Ces deux fonctions sont distinctes, car la communication entre les nœuds n’est pas symétrique : d’un côté, on appelle enableRemoting() avec un objet Source, tandis que de l’autre, on appelle acquire() pour obtenir un Replica. L’utilisation de ` proxy()` vous permet d’« observer » à distance les objets d’un périphérique cible via `acquire`, mais elle ne permet pas d’acquérir des objets `Source` hors cible à partir du réseau `local:*` du périphérique. C’est là qu’intervient `reverseProxy()`. Si un `proxyNode` est créé comme suit :

// myInternalHost is a node only visible on the device...
QRemoteObjectHost myInternalHost("local:MyHost", "local:registry");

// RegistryHost node, listening on port 12123, so visible to other
// devices.  The node must be a RegistryHost, so the Sources on
// the "outside" network can be forwarded to the inner network.
QRemoteObjectRegistryHost proxyNode("tcp://0.0.0.0:12123");

// Enable proxying objects from nodes on the local machine's internal
// QtRO bus.  Note the hostUrl parameter is now needed.
proxyNode.proxy("local:registry", "local:fromProxy");
proxyNode.reverseProxy();

Et depuis un autre appareil, vous créez un autre nœud :

// Listen on a local port, and connect to "proxyNode" as the registry.
// NB: localhost resolves to a different ip address than proxyNode
QRemoteObjectHost nodeOnRemoteDevice("tcp://localhost:23234",
                                     "tcp://<target device>:12123");

// Because of the reverseProxy, we can expose objects on this device
// and they will make their way to proxyNode...
nodeOnRemoteDevice.enableRemoting<OtherObject>(&otherObject);

// Acquire() can now see the objects on other devices through proxyNode,
// due to the reverseProxy call.
OtherObject *oo = myInternalHost.acquire<OtherObject>();

Alors que la fonctionnalité ` proxy()` permet d’acquérir des objets `Source ` sur un autre réseau, `reverseProxy()` permet de « pousser » des objets `Source` vers un réseau qui serait autrement inaccessible.

Renvoie true en cas de succès, false dans le cas contraire.

Voir également proxy().

[override virtual] void QRemoteObjectHostBase::setName(const QString &name)

Réimplémente : QRemoteObjectNode::setName(const QString &name).

Similaire à ` QObject::setObjectName()` (que cette méthode appelle), mais cette version applique également l’ name aux classes internes, qui sont utilisées dans certaines sorties de débogage.