Prise en charge de la politique de Google relative aux polices Emoji

Google a mis en place une politique relative aux emojis Android (Android: Android Emoji Policy) qui oblige les développeurs d'applications à prendre en charge la dernière version des emojis Unicode. Cette politique stipule :

Les applications disposant d’implémentations d’emoji personnalisées, y compris celles fournies par des bibliothèques tierces, doivent prendre entièrement en charge la dernière version d’Unicode lorsqu’elles s’exécutent sur Android 12 ou une version ultérieure, dans les 4 mois suivant la publication de nouveaux emoji Unicode.

Ce guide explique comment se conformer à cette politique, soit en intégrant une police d’émojis , soit en utilisant les polices téléchargeables de Google pour Android.

Intégration d’une police d’émojis VS Google Downloadable Fonts

Ces deux méthodes présentent chacune des avantages et des inconvénients pour la prise en charge des derniers emojis. Le choix de la meilleure option dépend de chaque application. Voici quelques avantages et inconvénients des deux méthodes :

Avantages de l’intégration d’une police :

• Chargement plus rapide de la police
• Fonctionne même lorsque l'utilisateur n'a pas accès à Internet
• Fonctionne sur tous les systèmes d’exploitation
• Indépendante (aucune autre dépendance que Qt)
• Solution plus simple

Inconvénients de l'intégration de la police :

• Augmente la taille de l'application (NotoColorEmoji pèse environ 10 Mo)
• Nécessite la mise à jour de la police lors des nouvelles versions
• Les anciennes applications ne mettront pas à jour les emojis automatiquement

Avantages des polices téléchargeables de Google :

• Ne modifie pas la taille de l'application
• Mise à jour automatique
• Plusieurs applications sans aucun lien entre elles partagent la même police

Inconvénients des polices téléchargeables de Google :

• Dépendent des services mobiles Google
• Android uniquement
• Télécharge la police si elle n'est pas déjà mise en cache
• Ne fonctionne pas sans connexion Internet si la police n’a pas été préalablement mise en cache
• Plus complexe que l'intégration de la police

Comment intégrer une police

Il est nécessaire d’obtenir et d’intégrer la police, puis de la charger soit via QML, soit via C++.

Obtenir une police

Pour ce guide, nous utiliserons la police Google NotoColorEmoji. NotoColorEmoji est une police sous licence SIL OPEN FONT LICENSE.

Ajout de la police

La bonne méthode pour intégrer la police consiste à l’ajouter aux fichiers du système de ressources Qt. Par exemple, vous pouvez créer un fichier de ressources distinct pour la police — « font.qrc » — contenant le fichier NotoColorEmoji_WindowsCompatible.ttf. Pour intégrer ce nouveau fichier de ressources, utilisez le code suivant dans CMakeLists.txt :

qt_add_big_resources(PROJECT_SOURCES font.qrc)

Chargement de la police intégrée en C++

Pour charger la police en C++, utilisez ` QFontDatabase`.

// Loading NotoColorEmoji bundled using C++ QFontDatabase
QFontDatabase::addApplicationFont(QStringLiteral(":/NotoColorEmoji_WindowsCompatible.ttf"));

Chargement de la police intégrée en QML

Pour charger la police en QML, utilisez ` FontLoader` :

// Loading NotoColorEmoji using QML FontLoader
FontLoader {
   source:"NotoColorEmoji_WindowsCompatible.ttf"
}

Utilisation des polices téléchargeables de Google :

L'utilisation des polices téléchargeables de Google pour la police d'émojis permet de disposer d'une police d'émojis mise à jour automatiquement sans augmenter la taille de l'application. La procédure de téléchargement d'une police à l'aide de la fonctionnalité « Polices téléchargeables » est décrite plus en détail dans Android : Procédure relative aux polices téléchargeables

Dans le cadre de ce guide, la procédure sera la suivante :

1. Début du code C++
2. Le code C++ appelle une fonction Java
3. Java appelle GDF pour récupérer la police
4. Java ouvre l'URI de la police
5. Java renvoie le descripteur de fichier à C++
6. Le C++ charge la police à l'aide de QFontDatabase

Configuration

Google Downloadable Fonts est disponible à partir du niveau d’API 26 (Android 8.0). Il est toutefois possible de prendre en charge des API antérieures, jusqu’à la version 14, si l’application utilise AndroidX.

Personnalisation du modèle de paquets Android

Il faut tout d’abord personnaliser les modèles de paquets Android. Pour cela, dans Qt Creator, accédez à l’onglet « Projets », puis recherchez « Build Android APK » dans les paramètres de compilation. Cette option se trouve dans la section « Étapes de compilation » ; développez les détails et un bouton intitulé « Créer des modèles » apparaîtra.

Cliquez sur « Créer des modèles », suivez l’assistant, et à la fin, un dossier contenant plusieurs fichiers de configuration pour Android sera créé. Par défaut, il s’agira d’un dossier nommé « android » situé dans le répertoire du projet.

Consultez la section Modèles de paquets Android pour savoir comment personnaliser les modèles Android à l’aide de qmake.

Si vous utilisez CMake et Qt 6, comme dans ce guide, vous devez définir la propriété QT_ANDROID_PACKAGE_SOURCE_DIR. Exemple :

set_property(TARGET emojiremotefont PROPERTY
         QT_ANDROID_PACKAGE_SOURCE_DIR
         ${CMAKE_CURRENT_SOURCE_DIR}/android)

Ajout d’AndroidX

Pour ajouter AndroidX, ouvrez le fichier « build.gradle » situé dans le dossier « QT_ANDROID_PACKAGE_SOURCE_DIR » créé ci-dessus et ajoutez-y la dépendance suivante :

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
    implementation 'androidx.appcompat:appcompat:1.4.1'
}

Pour utiliser AndroidX, il faut activer le drapeau correspondant. Pour cela, créez un fichier nommé gradle.properties dans le dossier QT_ANDROID_PACKAGE_SOURCE_DIR et ajoutez-y cette ligne :

android.useAndroidX=true

Ajout des certificats de fournisseur de polices

Comme nous utilisons AndroidX, une autre configuration est nécessaire : l’ajout des certificats de fournisseur de polices Android. Pour utiliser le fournisseur de polices GMS, téléchargez les certificats de fournisseur de polices Android : GMS. Si vous utilisez d’autres fournisseurs de polices, vous devez obtenir les certificats auprès du fournisseur lui-même.

Une fois le fichier téléchargé, ajoutez-le aux ressources Android (et non au système de ressources Qt) en le copiant dans le dossier ` values ` du dossier des modèles Android. L’image suivante indique le dossier correct (en position 1) :

Code Java

Bon, passons maintenant au code !

Nous devons ajouter du code Java/Kotlin à nos modèles Android. Placez-le dans le dossier « src » situé dans le dossier « android templates ». Vous devrez peut-être créer le dossier « src » ainsi que la structure de dossiers pour vos fichiers Java. Vous pouvez voir cette structure de dossiers sur l’image « Dossier des modèles Android » de la section précédente (2).

Pour récupérer la police en C++, le code Java doit :

• Créer une requête de police
• Récupérer les polices à partir de `FontsContractCompat` à l’aide de la requête de police
• Récupérer les informations sur la police et l’URI de la police (fichier de schéma de contenu)
• Ouvrir l’URI et obtenir un descripteur de fichier
• Renvoyer le descripteur de fichier au code C++

Pour créer une requête de police, vous avez besoin des informations relatives au fournisseur de polices (autorité, package et certificats) ainsi que d’une requête de recherche pour la police. Pour les certificats, utilisez le fichier « GMS Font Provider Certificates » ( fonts_cert.xml ) ajouté précédemment aux ressources Android.

// GMS fonts provider data
private static final String PROVIDER_AUTHORITY = "com.google.android.gms.fonts";
private static final String PROVIDER_PACKAGE = "com.google.android.gms";

// Emoji font search query (copied from EmojiCompat source)
private static final String EMOJI_QUERY = "emojicompat-emoji-font";

// Font Certificates resources strings (from fonts_certs.xml)
private static final String FONT_CERTIFICATE_ID = "com_google_android_gms_fonts_certs";
private static final String FONT_CERTIFICATE_TYPE = "array";

(...)

// obtain id for the font_certs.xml
int certificateId = context.getResources().getIdentifier(
                              FONT_CERTIFICATE_ID,
                              FONT_CERTIFICATE_TYPE,
                              context.getPackageName());

// creating the request
FontRequest request = new FontRequest(
                              PROVIDER_AUTHORITY,
                              PROVIDER_PACKAGE,
                              EMOJI_QUERY,
                              certificateId);

Utilisez maintenant la requête que vous venez de créer pour récupérer la police :

// fetch the font
FontsContractCompat.FontFamilyResult result =
     FontsContractCompat.fetchFonts(context, null, request);

Récupérez le fichier « FontInfo » et l’URI :

final FontsContractCompat.FontInfo[] fontInfos = result.getFonts();
final Uri emojiFontUri = fontInfos[0].getUri();

Ouvrez un nouveau descripteur de fichier natif à partir de l’URI :

final ContentResolver resolver = context.getContentResolver();
// in this case the Font URI is always a content scheme file, made
// so the app requesting it has permissions to open
final ParcelFileDescriptor fileDescriptor =
            resolver.openFileDescriptor(fontInfos[0].getUri(), "r");

// the detachFd will return a native file descriptor that we must close
// later in C++ code
int fd = fileDescriptor.detachFd();

// return fd to C++

Code C++

Bon, tout est prêt côté Java. Passons maintenant au côté C++.

Le C++ est chargé d’appeler le code Java et d’utiliser le descripteur de fichier pour charger la police dans Qt.

Pour mieux comprendre le fonctionnement de la communication entre le C++ et Java dans Qt 6, consultez l’exemple « Qt for Android Notifier ».

Après avoir obtenu le descripteur de fichier à partir du code Java, encapsulez-le dans une classe ` QFile ` et chargez le fichier de police à l’aide de ` QFontDatabase` :

QFile file;
file.open(fd, QFile::OpenModeFlag::ReadOnly, QFile::FileHandleFlag::AutoCloseHandle);

QFontDatabase::addApplicationFontFromData(file->readAll());