Fonctionnement de Qt pour Android

Si vous êtes développeur et que vous recherchez une vue d'ensemble du fonctionnement de Qt sur la plateforme Android, cette page est faite pour vous.

Lancement de l'application Qt

À l'instar des applications Android natives, la méthode onCreate() de l'activité principale Qt est appelée dès le lancement de l'application et la création de l'activité. C'est à ce moment-là que s'effectue la majeure partie de l'initialisation de l'Android Qt Platform Abstraction (QPA). Les étapes les plus importantes sont les suivantes :

• Le chargement de Qt et des bibliothèques de l'application principale.
• L'initialisation des délégués, qui se chargent d'initialiser les surfaces de rendu et la mise en page de niveau supérieur, ainsi que d'enregistrer divers écouteurs tels que les gestionnaires d'entrée, d'affichage et de touche, entre autres.

Lors du chargement des bibliothèques Qt, la machine virtuelle Java (JavaVM) est mise en cache pendant le chargement initial de QtCore. Cette opération s’effectue via la fonction JNI_OnLoad(), qui est appelée de manière synchrone lorsqu’une bibliothèque est chargée à l’aide de l’appel System.load(). Chaque module Qt peut disposer d’une implémentation de cette fonction pour effectuer certaines initialisations spécifiques au module, telles que l’enregistrement de méthodes JNI natives.

Une fois toutes les bibliothèques des modules Qt chargées, Qt charge le plugin QPA Android et la bibliothèque principale de l’application. Une fois que la mise en page de niveau supérieur de ` QtLayout ` a fini de charger son contenu, le descripteur ` main() ` de l’application Qt est localisé et invoqué. Cela lance l’application Qt en C++ et, en général, démarre la boucle d’événements principale.

Le QPA Android

Le QPA Android est chargé d’assurer la liaison entre le côté Android (Java/Kotlin) et le côté natif Qt (C++). Il gère la propagation des différents événements et signaux entre Qt et Android. Cette responsabilité couvre la gestion des signaux, les événements tactiles, les éléments de l’interface utilisateur et le rendu, etc. Cette couche est également chargée de l’initialisation au démarrage de l’application et du nettoyage à la fermeture ou à la destruction de celle-ci.

Les threads

Dans le cadre des applications Qt pour Android, Qt comporte généralement deux threads importants. Le premier est le thread « QtThread » lancé par Qt. Le second est le thread de l’interface utilisateur Android.

QtThread

Ce thread est implémenté et lancé par l’application Qt avant, par exemple, le chargement des bibliothèques. Ce thread est appelé « qtMainLoopThread ». Toutes les opérations suivantes sont exécutées sous ce thread :

• Chargement des bibliothèques Qt.
• Opérations effectuées à l’intérieur de JNI_OnLoad().
• Le lancement de l’application native.
• L'exécution de ` main()`.

Fil d'exécution de l'interface utilisateur Android

Comme pour les applications Android, les opérations qui affectent l’interface utilisateur doivent s’exécuter dans le thread de l’interface utilisateur. Qt s’en charge en arrière-plan pour tous les appels internes censés s’exécuter dans l’interface utilisateur. De plus, Qt propose une API runOnAndroidMainThread() permettant d’exécuter des opérations dans ce thread à partir de code C++. Grâce à cette API, Qt gère le moment où les appels sont directement envoyés au thread si l’application est active, ou mis en file d’attente si l’application est en pause ou en arrière-plan.

Architecture

Classes Qt

Les sections suivantes passent en revue les différentes classes de Qt pour Android, ainsi que leurs fonctionnalités et leur rôle dans les applications Qt.

Les liaisons Java publiques

Ces classes sont des classes publiques qui encapsulent les détails d’implémentation internes des classes destinées à l’utilisateur, telles que `Activity`, `Service` et `Application`. Elles sont utilisées par défaut pour les applications Qt Android et référencées dans le fichier manifeste Android. Le système de compilation et les outils de déploiement se chargent de les inclure dans la compilation.

Les utilisateurs peuvent utiliser ces classes pour modifier ou étendre le comportement par défaut. Par exemple, QtActivity étend Activity et implémente la logique nécessaire pour charger les bibliothèques Qt ou gérer les événements et les appels natifs entre Android et Qt.

L'extension de ` QtActivity ` est généralement nécessaire si vous avez besoin de l'implémentation Qt pour divers événements et appels entre Qt et Android. Sinon, l'extension de ` Activity ` devrait suffire.

Pour ajouter une logique personnalisée définie par l'utilisateur dans la méthode `onCreate()`, vous pouvez utiliser ce qui suit :

public class MyActivity extends QtActivity
{
    @Override
    protected void onCreate(Bundle bundle)
    {
        // code before Qt is initialized
        super.onCreate(bundle);
        // code after Qt is initialized
    }
}

Définition d’un thème

Lorsque vous étendez QtActivity, vous pouvez définir un thème Android spécifique à l’aide de setTheme(). Cependant, cet appel doit précéder celui de la méthode onCreate() de la classe parente pour prendre effet, car Qt définit le thème par défaut. Par exemple, vous pouvez utiliser :

@Override
protected void onCreate(Bundle bundle)
{
    setTheme(android.R.style.Theme_DeviceDefault_DayNight);
    super.onCreate(bundle);
}

Par défaut, pour Android 10 et les versions ultérieures, Qt définit le thème Theme_DeviceDefault_DayNight Style, et Theme_Holo_Light Style pour les versions antérieures.

Ajouter un paramètre d’application

Pour ajouter un paramètre d’application supplémentaire, c’est-à-dire un argument transmis à la fonction ` (main()) ` de l’application depuis Java/Kotlin, vous pouvez procéder comme suit après avoir étendu QtActivity:

@Override
protected void onCreate(Bundle bundle)
{
    appendApplicationParameters("--flag value");
    super.onCreate(bundle);
}

Cela revient à utiliser directement la variable CMake QT_ANDROID_APPLICATION_ARGUMENTS. Les paramètres transmis par l’une ou l’autre de ces méthodes acceptent les espaces ou les tabulations comme séparateurs, et la liste finale des paramètres transmis à l’application est analysée par la fonction QProcess::splitCommand.

Chargement des bibliothèques Qt avec QtLoader

Toute application Qt pour Android doit s’assurer que toutes les bibliothèques natives Qt ou tierces sont chargées avant d’appeler la moindre fonctionnalité de ces modules. Le système de compilation conserve une liste des différentes dépendances des bibliothèques Qt, du plugin QPA, de la bibliothèque principale de l’application et de toute bibliothèque tierce dans le fichier de ressources libs.xml de l’application. Une fois que toutes les étapes préalables mentionnées dans les sections ci-dessous sont effectuées, les bibliothèques sont chargées à l’aide de System.load().

Le chargeur de classes

L’objet chargeur de classes est défini dès le début par l’ QtLoader, avant le chargement des bibliothèques Qt ou l’initialisation des délégués. En effet, le chargeur de classes est utilisé par ` QJniObject ` pour rechercher les classes Java et est nécessaire pour effectuer tout appel JNI avec ` QJniObject`.

Définition des variables d’environnement et des paramètres d’application

Avant de charger les bibliothèques, Qt doit s’assurer que les variables d’environnement sont transmises sous forme de métadonnées dans le manifeste Android à configurer. Cette étape permet l’initialisation de certains modules en fonction des indicateurs de configuration définis comme métadonnées du manifeste. Certaines de ces métadonnées sont également propagées vers la liste des paramètres d’application qui est transmise à l’application lors de son lancement.

setActivity(), setContext() et setService()

Divers modules Qt peuvent avoir besoin d’effectuer certaines tâches d’initialisation côté Java, ce qui nécessite de disposer du contexte de l’Activity ou du Service. Ces modules implémentent alors une méthode statique qui prend une Activity, un Service ou un Context en paramètre :

void setActivity(Activity activity)
{
    m_activity = activity;
    // Other logic
}

Ensuite, l’ QtLoader e appelle ces méthodes avec le contexte parent du chargeur juste avant de charger les bibliothèques partagées natives.

Comment Qt pour Android gère le cycle de vie des activités Android

Qt pour Android ne fournit pas d'API permettant de gérer directement les callbacks du cycle de vie des activités Android, tels que onCreate(), onStart(), onResume(), onPause(), onStop() et onDestroy(). Il les gère plutôt en arrière-plan pour l'utilisateur. Ce comportement est décrit dans les sections suivantes.

Gestion du contexte

QAndroidApplication peut fournir le contexte Android sous la forme d’un QJniObject, indispensable pour interagir avec le système Android. Ce contexte peut être une activité ou un service. S’il y a une activité, il s’agira de l’activité lancée le plus récemment, qu’il y ait ou non des services. S’il n’y a que des services, il s’agira du service lancé le plus récemment.

Rappels

La classe QtActivityBase est conçue pour préserver la confidentialité des détails d’implémentation des différentes fonctionnalités d’une activité au sein du package Qt pour Android. Cette classe sert de médiateur entre le cycle de vie Android et le framework Qt, en traduisant les callbacks du cycle de vie Android en signaux et opérations auxquels l’application Qt peut répondre.

onCreate()

Lors de la création de l’Activity, QtActivityBase initialise l’environnement Qt. Cela inclut le chargement des bibliothèques Qt, la configuration du chargeur de classes utilisé par QJniObject, l’analyse des métadonnées de l’application et la préparation de l’application Qt en vue de son exécution. Cela garantit que toutes les initialisations nécessaires spécifiques à l’Activity sont prises en charge.

onStart()

Appelle la méthode Activity.OnStart() d’Android.

onResume()

Lorsque l’activité passe au premier plan, QtActivityBase reprend l’application Qt. Cela garantit la poursuite des processus ou opérations mis en pause et le retour de l’application à l’état prêt à interagir avec l’utilisateur. Le gestionnaire d’affichage, dont l’écouteur avait été arrêté par onPause(), est alors réenregistré.

onPause()

Si une autre activité masque partiellement l'activité, QtActivityBase met l'application Qt en pause. Elle enregistre l'état de l'application ou libère les ressources qui ne sont pas nécessaires tant que l'application n'est pas au premier plan.

onStop()

Lorsque l’activité n’est plus visible, QtActivityBase arrête l’application Qt, ce qui implique une sauvegarde plus approfondie de l’état et une libération plus poussée des ressources, préparant ainsi l’application à une destruction éventuelle.

onDestroy()

Si l’activité est terminée ou en cours de destruction par le système, QtActivityBase nettoie toutes les ressources associées à l’application Qt. Cela garantit un arrêt correct et la réalisation de toutes les opérations de nettoyage nécessaires.

Cette intégration permet aux développeurs de se concentrer sur la création de leur application Qt sans se soucier des subtilités du cycle de vie Android, car QtActivityBase gère ces complexités en arrière-plan.

Gestion de l’écran de démarrage

QAndroidApplication permet de masquer l’écran de démarrage avec un effet de fondu, qui peut être synchronisé avec la séquence de démarrage de l’application, généralement après onCreate().

En savoir plus sur Qt pour Android

La vidéo du Qt World Summit 2021 donne un aperçu de Qt pour Android.

« Image d’un ordre du jour renvoyant vers une vidéo YouTube »