Fonctionnement de Qt pour Android

Si vous êtes un développeur à la recherche d'une vue d'ensemble de la manière dont Qt prend en charge la plateforme Android, cette page est faite pour vous.

Démarrage de l'application Qt

Comme pour les applications Android natives, la fonction onCreate() de l'activité principale d'Active Qt est appelée au début du démarrage de l'application et de la création de l'activité. C'est là qu'a lieu la majeure partie de l'initialisation de la Qt Platform Abstraction (QPA) d'Android. Les parties 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 charge d'initialiser les surfaces de rendu et la disposition de haut niveau, ainsi que d'enregistrer divers récepteurs tels que les gestionnaires d'entrée, d'affichage et de toucher, entre autres.

Lors du chargement des bibliothèques Qt, la JavaVM est mise en cache pendant que QtCore est chargé pour la première fois. Cette opération est effectuée par 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 avoir une implémentation de cette fonction pour effectuer une initialisation spécifique au module, comme l'enregistrement des méthodes JNI natives.

Une fois que toutes les bibliothèques des modules Qt sont chargées, Qt charge le plugin Android QPA et la bibliothèque de l'application principale. Une fois que la présentation de haut niveau QtLayout a fini de gonfler son contenu, la poignée main() de l'application Qt est localisée et invoquée. Cela démarre l'application Qt C++ et lance généralement la boucle d'événements principale.

La QPA Android

La QPA Android est responsable du collage de la partie Android (Java/Kotlin) avec la partie native Qt (C++). Elle gère les différents événements et la propagation des signaux vers et depuis Qt vers Android. Cette responsabilité s'étend à la gestion des signaux, aux événements tactiles, aux éléments de l'interface utilisateur, au rendu, etc. Cette couche est également responsable de l'initialisation du démarrage de l'application et du nettoyage lors de la sortie ou de la destruction de l'application.

Fils

Avec Qt pour les applications Android, Qt a généralement deux fils d'intérêt. Le premier est le QtThread que Qt démarre. Le second est le thread de l'interface utilisateur d'Android.

QtThread

Ce thread est implémenté et démarré par l'application Qt avant, par exemple, de charger les bibliothèques. Ce thread est appelé qtMainLoopThread. Toutes les opérations suivantes sont exécutées dans ce thread :

• Chargement de la bibliothèque Qt.
• Opérations effectuées dans JNI_OnLoad().
• Démarrage 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 être exécutées dans le fil d'exécution de l'interface utilisateur. Qt le fait sous le capot pour tous les appels internes qui sont censés s'exécuter dans l'interface utilisateur. Qt offre également une API runOnAndroidMainThread() pour exécuter des opérations dans ce thread à partir d'un code C++. À l'aide de cette API, Qt gère le moment où les appels sont directement postés dans le 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 présentent les différentes classes de Qt pour Android, leur fonctionnalité et leur rôle dans les applications Qt.

Les liaisons Java publiques

Ces classes sont des classes publiques qui enveloppent les détails de l'implémentation interne des classes orientées vers l'utilisateur comme Activity, Service et Application. Ces classes sont utilisées par défaut pour les applications Qt Android et sont mentionnées dans le fichier manifeste Android. Le système de construction et les outils de déploiement se chargent de les inclure dans la construction.

Les utilisateurs peuvent utiliser ces classes pour modifier ou étendre le comportement par défaut. Par exemple, QtActivity étend Activity et met en œuvre 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 de Qt pour divers événements et appels entre Qt et Android. Sinon, l'extension de Activity devrait fonctionner.

Pour ajouter une logique personnalisée définie par l'utilisateur sous 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 l'appel à la fonction onCreate() de la classe mère pour qu'il prenne 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 passé à 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);
}

Ceci est similaire à l'utilisation directe de la variable CMake QT_ANDROID_APPLICATION_ARGUMENTS. Les paramètres transmis à l'aide de l'une ou l'autre méthode acceptent les espaces ou les tabulations comme séparateurs, et la liste finale des paramètres transmis à l'application est analysée à l'aide de QProcess::splitCommand.

Chargement des bibliothèques Qt avec QtLoader

Chaque application Qt pour Android doit s'assurer que chaque bibliothèque native Qt ou tierce partie est d'abord chargée avant d'invoquer toute fonctionnalité de ces modules. Le système de construction conserve une liste des diverses 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 class loader est défini par QtLoader avant de charger les bibliothèques Qt ou d'initialiser les délégués. En effet, le chargeur de classe est utilisé par QJniObject pour trouver 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 passées comme métadonnées dans le manifeste Android à définir. Cette étape permet l'initialisation de certains modules en fonction des drapeaux de configuration définis en tant que méta-données du manifeste. Certaines de ces méta-données sont également propagées dans la liste des paramètres de l'application qui est transmise à l'application lorsqu'elle est lancée.

setActivity(), setContext() et setService()

Différents modules Active Qt peuvent avoir besoin d'effectuer un travail d'initialisation du côté Java qui nécessite d'avoir le contexte de l'activité ou du service. Ces modules implémentent alors une méthode statique qui prend en paramètre une activité, un service ou un contexte :

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

Ensuite, le site QtLoader invoque 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 pour gérer directement les rappels du cycle de vie de l'activité Android tels que onCreate(), onStart(), onResume(), onPause(), onStop() et onDestroy(). Au lieu de cela, il les gère sous le capot pour l'utilisateur. Le comportement est décrit dans les sections suivantes.

Gestion du contexte

QAndroidApplication peut fournir le contexte Android en tant que QJniObject, essentiel 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é la plus récemment démarrée, qu'il y ait ou non des services. S'il n'y a que des services, il s'agira du service le plus récemment démarré.

Rappels

La classe QtActivityBase est conçue pour que les détails de la mise en œuvre des diverses fonctionnalités d'une activité restent privés au sein du paquetage Qt pour Android. Cette classe est un médiateur entre le cycle de vie d'Android et le cadre Qt, traduisant les rappels du cycle de vie d'Android en signaux et opérations auxquels l'application Qt peut répondre.

onCreate()

Lorsque l'activité est créée, QtActivityBase initialise l'environnement Qt. Cela comprend 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 à l'exécution. Il s'assure que toutes les initialisations nécessaires spécifiques à l'activité sont prises en charge.

onStart()

Appelle la fonction Activity.OnStart() d'Android.

onResume()

Lorsque l'Active Qt passe au premier plan, QtActivityBase reprend l'application Qt. Elle s'assure que les processus ou opérations mis en pause se poursuivent et que l'application est à nouveau prête pour l'interaction avec l'utilisateur. Elle réenregistre l'auditeur du gestionnaire d'affichage arrêté par onPause().

onPause()

Si une autre activité obscurcit partiellement l'Active Qt, QtActivityBase met l'application Qt en pause. Il sauvegardera l'état de l'application ou libérera les ressources qui ne sont pas nécessaires tant que l'application n'est pas au premier plan.

onStop()

Lorsque l'Active Qt n'est plus visible, QtActivityBase arrête l'application Qt, ce qui implique une sauvegarde de l'état et une libération des ressources plus importantes, préparant l'application à une destruction potentielle.

onDestroy()

Si l'Active Qt est terminée ou en cours de destruction par le système, QtActivityBase nettoie toutes les ressources associées à l'application Qt. Il garantit un arrêt correct et l'exécution de toutes les opérations de nettoyage nécessaires.

Cette intégration permet aux développeurs de se concentrer sur la construction de leur application Qt sans se soucier des subtilités du cycle de vie d'Android, car QtActivityBase gère ces complexités sous le capot.

Gestion de l'écran d'accueil

QAndroidApplication QtActivityBase permet de masquer l'écran d'accueil 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 sommet mondial Qt 2021 donne un aperçu de Qt pour Android.

"Une image d'un agenda qui renvoie à une vidéo YouTube"