QQmlIncubator Class

Description détaillée

La création d'objets QML — tels que des délégués dans une vue ou une nouvelle page dans une application — peut prendre un temps considérable, en particulier sur les appareils mobiles aux ressources limitées. Lorsqu'une application utilise directement la fonction ` QQmlComponent::create()`, l'instance de l'objet QML est créée de manière synchrone, ce qui, selon la complexité de l'objet, peut entraîner des pauses ou des saccades perceptibles dans l'application.

L'utilisation de `QQmlIncubator` offre un meilleur contrôle sur la création d'un objet QML, notamment en permettant de le créer de manière asynchrone en exploitant les temps d'inactivité de l'application. L'exemple suivant illustre une utilisation simple de `QQmlIncubator`.

// Initialize the incubator
QQmlIncubator incubator;
component->create(incubator);

Laissez l’incubateur s’exécuter pendant un certain temps (généralement en rendant le contrôle à la boucle d’événements), puis interrogez-le. Il existe plusieurs façons de revenir à l’incubateur ultérieurement. Vous pouvez vous connecter à l’un des signaux émis par ` QQuickWindow`, ou exécuter une fonction ` QTimer ` spécialement prévue à cet effet. Il se peut également que vous ayez besoin de l’objet à des fins spécifiques et que vous interrogiez l’incubateur lorsque ces besoins se présentent.

// Poll the incubator
if (incubator.isReady()) {
    QObject *object = incubator.object();
    // Use created object
}

Les incubateurs asynchrones sont contrôlés par un signal « QQmlIncubationController » défini sur l’ QQmlEngine, qui indique au moteur quand l’application est inactive et que les objets en incubation doivent être traités. Si aucun contrôleur d’incubation n’est défini sur le paramètre « QQmlEngine », « QQmlIncubator » crée les objets de manière synchrone, quel que soit le paramètre « IncubationMode » spécifié. Par défaut, aucun contrôleur d’incubation n’est défini. Cependant, « QQuickView », « QQuickWindow » et « QQuickWidget » définissent tous des contrôleurs d’incubation sur leurs paramètres « QQmlEngine» respectifs. Ces contrôleurs d’incubation répartissent les incubations sur plusieurs images pendant le rendu de la vue.

QQmlIncubator prend en charge trois modes d’incubation :

• Synchrone : la création s’effectue de manière synchrone. Autrement dit, dès que l’appel à ` QQmlComponent::create()` renvoie une valeur, l’incubateur se trouve déjà dans l’état « Error » (Erreur) ou « Ready » (Prêt). Un incubateur synchrone ne présente aucun avantage réel par rapport à l’utilisation directe des méthodes de création synchrones sur ` QQmlComponent `, mais l’utilisation d’une même API pour les créations synchrones et asynchrones peut simplifier l’implémentation d’une application.
• Asynchrone (par défaut) La création s’effectue de manière asynchrone, à condition qu’un `QQmlIncubatorController` soit défini sur ` QQmlEngine`.

  L’incubateur restera à l’état « Loading » jusqu’à ce que la création soit terminée ou qu’une erreur se produise. La fonction de rappel statusChanged() peut être utilisée pour être averti des changements d’état.

  Les applications doivent utiliser le mode d’incubation asynchrone pour créer des objets qui ne sont pas nécessaires immédiatement. Par exemple, le type ` ListView ` utilise l’incubation asynchrone pour créer des objets qui se trouvent légèrement hors de l’écran pendant le défilement de la liste. Si, au cours de la création asynchrone, l’objet est nécessaire immédiatement, la méthode ` QQmlIncubator::forceCompletion()` peut être appelée pour terminer le processus de création de manière synchrone.

• AsynchronousIfNested La création se fera de manière asynchrone si elle s'inscrit dans le cadre d'une création asynchrone imbriquée, ou de manière synchrone dans le cas contraire.

  Dans la plupart des cas où un composant QML souhaite donner l’impression d’une instanciation synchrone, il doit utiliser ce mode.

  Un exemple permet de mieux comprendre ce mode. Lorsque le type ` ListView ` est créé pour la première fois, il doit se remplir d’un ensemble initial de délégués à afficher. Si l’ ListView avait une hauteur de 400 pixels et que chaque délégué mesurait 100 pixels de haut, il faudrait créer quatre instances initiales de délégués. Si l’ ListView utilisait le mode d’incubation asynchrone, l’ ListView serait toujours créé vide, puis, un peu plus tard, les quatre éléments initiaux apparaîtraient.

  À l’inverse, si l’ ListView utilisait le mode d’incubation synchrone, elle se comporterait correctement, mais cela pourrait entraîner des saccades dans l’application. Comme QML devrait s’arrêter pour instancier de manière synchrone les délégués de l’ ListView, si l’ ListView faisait partie d’un composant QML instancié de manière asynchrone, cela annulerait une grande partie des avantages de l’instanciation asynchrone.

  Le mode « AsynchronousIfNested » résout ce problème. En utilisant ` AsynchronousIfNested`, les délégués de l’ ListView sont instanciés de manière asynchrone si l’ ListView e lui-même fait déjà partie d’une instanciation asynchrone, et de manière synchrone dans le cas contraire. Dans le cas d’une instanciation asynchrone imbriquée, l’instanciation asynchrone externe ne s’achèvera qu’une fois que toutes les instanciations imbriquées auront également été menées à bien. Cela garantit qu’au moment où l’instanciation asynchrone externe s’achève, les éléments internes tels que ListView ont déjà terminé le chargement de leurs délégués initiaux.

  Il est presque toujours inapproprié d’utiliser le mode d’incubation « Synchronous » : les éléments ou composants qui souhaitent donner l’impression d’une instanciation synchrone, sans pour autant présenter les inconvénients liés à l’apparition de blocages ou de saccades dans l’application, doivent utiliser le mode d’incubation « AsynchronousIfNested ».