QtJenny : Générer des classes proxy C++ pour accéder aux API Android

Démonstration de l'utilisation de QtJenny.

Vue d'ensemble

Cette démo présente l'utilisation de QtJenny et l'utilise pour générer des classes proxy C++ afin d'accéder aux API Android à partir d'un code C++. Les classes C++ générées sont utilisées dans la démo pour effectuer des actions telles que le réglage du volume et de la luminosité, l'activation et la désactivation des verrous de réveil, l'envoi de notifications et le déclenchement de vibrations. Ces actions font partie des API Android que Qt n'implémente pas.

La génération de classes C++ à l'aide de QtJenny élimine la nécessité d'écrire manuellement du code JNI.

Comment fonctionne QtJenny ?

La démo contient deux parties, un projet Qt XML appelé qtjenny_consumer et un projet Android Studio appelé qtjenny_generator. Le projet qtjenny_consumer contient l'interface utilisateur de l'application et le code utilisant les en-têtes C++ générés. Le projet qtjenny_generator contient les annotations de classe et les configurations Gradle pour QtJenny.

Pour lancer la démo, vous devez exécuter le projet qtjenny_consumer. Pendant la configuration CMake de qtjenny_consumer, la génération du code est déclenchée automatiquement par un appel à l'exécution d'une tâche gradlew dans le répertoire du projet qtjenny_generator.

if (ANDROID)
    if (CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
        set (gradlew_cmd "gradlew.bat")
    else()
         set (gradlew_cmd "./gradlew")
    endif()
    set (gradlew_arg "--rerun-tasks")
    set (gradlew_task "kaptReleaseKotlin")
    execute_process(COMMAND ${gradlew_cmd} ${gradlew_arg} ${gradlew_task}
    WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/qtjenny_generator")
else()
    message(FATAL_ERROR "Example only works on Android")
endif()
Génération des en-têtes C

La génération des en-têtes C++ commence lorsque qtjenny_generator est construit, ce qui déclenche un processeur d'annotation qui traite les annotations dans GenerateCppCode.kt.

@NativeClass
@NativeProxy(allMethods = false, allFields = false)
@NativeProxyForClasses(namespace = "android::os", classes = [BatteryManager::class, VibratorManager::class, Vibrator::class, VibrationEffect::class, Context::class, PowerManager::class, PowerManager.WakeLock::class])
@NativeProxyForClasses(namespace = "android::view", classes = [Window::class, WindowManager.LayoutParams::class])
@NativeProxyForClasses(namespace = "android::media", classes = [AudioManager::class])
@NativeProxyForClasses(namespace = "android::drawable", classes = [android.R.drawable::class])
@NativeProxyForClasses(namespace = "android::app", classes = [Activity::class, Notification::class, Notification.Builder::class, NotificationChannel::class, NotificationManager::class])
@NativeProxyForClasses(namespace = "android::provider", classes = [Settings.Global::class, Settings.System::class, Settings::class])
@NativeProxyForClasses(namespace = "android::content", classes = [Intent::class])

Le processeur d'annotation génère alors les en-têtes C++ dans le répertoire qtjenny_output. Ces en-têtes C++ contiennent le code JNI boilerplate nécessaire pour accéder aux API Android utilisées dans cette démo.

Le script build.gradle au niveau de l'application dans qtjenny_generator spécifie les arguments pour kapt que QtJenny implémente. Ces arguments sont analysés par le compilateur QtJenny et utilisés dans le processus de génération.

kapt {
    arguments {
        // pass arguments to jenny
        arg("jenny.outputDirectory", project.file("../../qtjenny_output"))
        arg("jenny.templateDirectory", project.file("../templates"))
        arg("jenny.headerOnlyProxy", "true")
        arg("jenny.useJniHelper", "false")
        arg("jenny.useTemplates", "true")
    }
}
Utilisation des en-têtes C++ générés dans l'application Qt Quick

L'application qtjenny_consumer est l'application Qt Quick qui utilise les en-têtes C++ générés par l'application qtjenny_generator. Nous incluons les en-têtes générés dans le fichier backend.h et les utilisons dans backend.cpp pour accéder à diverses API Android.

L'interface utilisateur de l'application consiste en un fichier Main.qml, qui contient les contrôles et actions suivants.

Réveiller les serrures

Vous pouvez activer et désactiver les verrous de réveil complets ou partiels à l'aide de Switches. Lorsqu'ils sont cochés, ils invoquent une fonction dans backend.cpp qui active le verrou de réveil et définit le texte d'état du verrou de réveil.

if (checked) {
    myBackEnd.setFullWakeLock()
    if (partialWakeLock.checked)
        partialWakeLock.click()
    mainWindow.wakeLockStatus = "Full WakeLock active"

Le réglage du verrouillage partiel du réveil utilise la classe WakeLockProxy qui se connecte à l'API Android PowerManager.WakeLock. Le verrouillage complet se fait à l'aide de la classe WindowProxy qui se connecte à l'API Android Window.

Vibreur

Vous pouvez déclencher une vibration à l'aide de la fonction vibrate dans backend.cpp, qui utilise les classes VibrationEffectProxy, VibratorManagerProxy et VibratorProxy pour effectuer la vibration.

Notifications

L'envoi d'une notification est géré par la fonction notify de backend.cpp, qui utilise la classe NotificationManagerProxy.

La notification est déjà créée lors de l'initialisation de la classe Backend dans la fonction createNotification.

Réglage de la luminosité

Le réglage de la luminosité est géré par la fonction adjustBrightness dans backend.cpp, à l'aide des classes IntentProxy, SettingsProxy, SystemProxy, ContextProxy, LayoutParamsProxy et WindowProxy.

Réglage du volume

Le réglage du volume est géré par la fonction adjustVolume dans backend.cpp, avec l'utilisation des classes GlobalProxy et AudioManagerProxy.

Exemple de projet @ code.qt.io

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.