IVI Compositor

Introduction

Cet exemple montre comment utiliser l'extension de shell IviApplication sur un serveur d'affichage Wayland (également appelé « compositeur Wayland »).

Pour une introduction aux principes de base de la création d’un Qt Wayland Compositor avec Qt, consultez l’exemple Minimal Qml.

Le protocole

IviApplication est une extension de shell spécialement conçue pour la création de systèmes d’infodivertissement embarqués.

Il s’agit d’un protocole minimaliste qui ne fournit que les fonctionnalités suivantes :

1. Le client peut s’identifier à l’aide d’un identifiant IVI-id.
2. Le serveur peut demander au client de redimensionner sa fenêtre.

Les numéros d’identification

Dans une configuration typique d’ IviApplication, vous disposerez d’un ensemble prédéfini d’applications pouvant se connecter au serveur. Comme ces applications sont déjà connues lors de la conception du système, on peut leur attribuer des numéros codés en dur qui les identifient. Étant donné que le client et le serveur s’accordent à l’avance sur ces numéros, une sémantique peut être intégrée aux numéros d’identification.

Par exemple, si un client s’identifie comme l’application de navigation, le serveur peut le reconnaître et lui allouer une grande partie centrée de l’écran pour sa fenêtre. Une application s’identifiant comme une horloge, en revanche, pourrait se voir attribuer une zone plus petite dans les marges de l’écran.

Par défaut, les applications Qt utilisent leur PID système (« identifiant de processus ») comme IVI-id. Le client peut remplacer cette valeur en définissant QT_IVI_SURFACE_ID dans son environnement avant de se connecter au serveur.

L'exemple

Un Qt Wayland Compositor peut prendre en charge plusieurs extensions de shell à la fois, mais l’exemple IVICompositor ne prend en charge que le protocole IviApplication. Cela signifie que les clients doivent également prendre en charge cette extension de shell pour pouvoir se connecter au serveur.

La fenêtre du compositeur dans l’exemple est divisée horizontalement en deux parties : une zone de gauche réservée à une application spécialisée portant l’identifiant « 1337 », et une zone de droite destinée à toutes les autres applications.

Création de la mise en page

La mise en page de la fenêtre est définie au sein d’un objet ` WaylandOutput`. Celui-ci correspond généralement à un écran physique accessible au compositeur. Si un seul ` WaylandOutput ` est créé, comme dans l’exemple IVICompositor, il correspondra généralement à l’écran principal.

WaylandOutput {
    sizeFollowsWindow: true
    window: Window {
        width: 1024
        height: 768
        visible: true
        Rectangle {
            id: leftArea
            width: parent.width / 2
            height: parent.height
            anchors.left: parent.left
            color: "cornflowerblue"
            Text {
                anchors.centerIn: parent
                text: "Ivi surface with id 1337"
            }
        }
        Rectangle {
            id: rightArea
            width: parent.width / 2
            height: parent.height
            anchors.right: parent.right
            color: "burlywood"
            Text {
                anchors.centerIn: parent
                text: "Other surfaces"
            }
        }
    }
}

Le code crée une ` WaylandOutput ` pour l’écran, puis y crée une fenêtre qui servira de conteneur de niveau supérieur pour l’ensemble du contenu du compositeur. À l’intérieur de cette fenêtre, il crée deux rectangles qui serviront de conteneurs aux applications au fur et à mesure de leur connexion.

Connexion des clients

Si aucune configuration supplémentaire n’a été effectuée, une application Qt se connectera avec un identifiant IVI égal à son ID de processus. Par exemple, si nous exécutons une autre application Qt d’exemple avec -platform wayland, elle sera placée à droite de la disposition, à condition que son identifiant soit différent de « 1337 ».

En revanche, si l’on définit la variable d’environnement ` QT_IVI_SURFACE_ID ` sur « 1337 » avant de lancer l’exemple, celui-ci sera affecté à la partie gauche de la mise en page.

Lorsqu’un client se connecte à l’interface ` IVIApplication `, celle-ci émet le signal ` iviSurfaceCreated `. C’est à ce moment-là que le positionnement de la surface de l’application est géré.

IviApplication {
    onIviSurfaceCreated: (iviSurface) =>  {
        var surfaceArea = iviSurface.iviId === 1337 ? leftArea : rightArea;
        var item = chromeComponent.createObject(surfaceArea, { "shellSurface": iviSurface } );
        item.handleResized();
    }
}

Le signal ` iviSurfaceCreated ` reçoit un argument ` IviSurface ` qui permet d’accéder à l’identifiant du client. Le compositeur crée ensuite un ` ShellSurfaceItem ` pour la surface (conformément à la définition de ` chromeComponent`). ` ShellSurfaceItem ` est la classe utilisée pour placer les surfaces shell dans la scène ` Qt Quick `, et vous retrouverez ce même schéma dans tous les exemples de ` Qt Wayland Compositor `.

Ce qui rend l’exemple IVICompositor particulier, c’est qu’il vérifie la propriété iviId de la surface shell entrante et détermine le parent de l’ ShellSurfaceItem en fonction de sa valeur. Si l’ID est égal à « 1337 », elle sera rattachée à l’ leftArea, et dans le cas contraire, elle se trouvera dans l’ rightArea.

L’implémentation de ` ShellSurfaceItem ` gère le redimensionnement en informant le client chaque fois que la taille change (ce qui peut se produire si le compositeur s’exécute au sein d’un système de fenêtrage de type bureau et que sa fenêtre est redimensionnée).

onWidthChanged: handleResized()
onHeightChanged: handleResized()
function handleResized() {
    if (width > 0 && height > 0)
        shellSurface.sendConfigure(Qt.size(width, height));
}

La méthode ` sendConfigure() ` est définie dans ` IviSurface ` et envoie un événement au client. Le client reçoit alors un événement de redimensionnement indiquant la nouvelle taille, ce qui lui permet de réorganiser son contenu.

Si plusieurs applications se connectent à la même zone de la mise en page, elles seront simplement empilées selon les règles habituelles d’ Qt Quick. Il n’existe pas de mécanismes intégrés pour fermer les applications ou gérer leur état, mais cela peut facilement être ajouté sous forme de code d’ Qt Quick classique.

Exemple de projet sur code.qt.io