Prise en charge de la politique de police Google Emoji

Google a introduit une politique Android : Android Emoji Policy qui oblige les développeurs d'applications à prendre en charge la dernière version d'Unicode Emoji. Cette politique stipule ce qui suit :

Les applications avec des implémentations d'emoji personnalisées, y compris celles fournies par des bibliothèques tierces, doivent entièrement prendre en charge la dernière version d'Unicode lorsqu'elles fonctionnent sur Android 12+ dans les 4 mois suivant la publication de nouveaux Emoji Unicode.

Ce guide montre comment prendre en charge cette politique en intégrant une police d'emoji ou en utilisant les polices téléchargeables d'Android : Polices téléchargeables de Google.

Intégration d'une police Emoji VS polices téléchargeables Google

Les deux méthodes présentent des avantages et des inconvénients en ce qui concerne la prise en charge des derniers emojis. Voici quelques avantages et inconvénients des deux méthodes :

Avantages des polices groupées :

• Chargement plus rapide de la police
• Fonctionne lorsque l'utilisateur ne dispose pas d'internet
• Fonctionne avec tous les systèmes d'exploitation
• Indépendant (pas d'autres dépendances que Qt)
• Solution plus simple

Inconvénients du regroupement des polices :

• Augmente la taille de l'application (NotoColorEmoji est ~10 MB)
• Nécessite la mise à jour de la police sur les versions les plus récentes
• 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 aucune relation partagent la même police.

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

• dépend des services mobiles de Google
• Android uniquement
• Télécharge la police si elle n'a pas été mise en cache auparavant
• Ne fonctionne pas sans internet si elle n'a pas été mise en cache auparavant
• Plus complexe que le regroupement de polices

Comment regrouper une police

Il est nécessaire d'obtenir et de regrouper la police, puis de la charger à l'aide de QML ou de C++.

Obtention d'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 façon d'intégrer la police est de l'ajouter aux fichiers du système de ressources Qt. Par exemple, vous pouvez créer un fichier de ressources séparé pour la police - "font.qrc" avec la police NotoColorEmoji_WindowsCompatible.ttf. Pour intégrer le 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 groupé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 emoji permet d'obtenir une police emoji automatiquement mise à jour sans augmenter la taille de l'application. La procédure de téléchargement d'une police à l'aide de la fonction Polices téléchargeables est décrite plus en détail dans Android : Processus de téléchargement des polices

Pour ce guide, le processus sera le suivant :

1. Le code C++ démarre
2. 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. C++ charge la police à l'aide de la fonction QFontDatabase

Configuration

Les polices téléchargeables de Google sont disponibles pour le niveau API 26 (Android 8.0). Mais il est possible de prendre en charge les API antérieures jusqu'à l'API 14 si l'application utilise AndroidX.

Personnalisation du modèle de paquets Android

Tout d'abord, il est nécessaire de personnaliser les modèles de paquets Android. Pour cela, dans Qt Creator, allez dans l'onglet Projets, et cherchez dans les paramètres de construction "Build Android APK". Il devrait se trouver dans "Build Steps", développez les détails et un bouton appelé "Create Templates" apparaîtra.

Cliquez sur "Create templates", suivez l'assistant, et à la fin, un dossier avec plusieurs fichiers de configuration pour Android sera créé. Par défaut, il s'agit d'un dossier appelé android dans le répertoire du projet.

Voir Modèles de paquets Android pour savoir comment personnaliser les modèles android à l'aide de qmake.

Dans le cas où vous utilisez CMake et Qt 6, comme dans ce guide, vous devez définir la propriété QT_ANDROID_PACKAGE_SOURCE_DIR. Ex :

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 dans le dossier QT_ANDROID_PACKAGE_SOURCE_DIR ajouté ci-dessus et ajoutez-y la dépendance :

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

Pour utiliser Androidx, nous devons activer le drapeau correspondant. Pour cela, créez un fichier nommé gradle.properties dans le dossier QT_ANDROID_PACKAGE_SOURCE_DIR et ajoutez cette ligne :

android.useAndroidX=true

Ajouter les certificats du fournisseur de polices

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

Après avoir téléchargé le fichier, ajoutez-le aux ressources Android (et non au système de ressources Qt XML) en le copiant dans le dossier values du dossier android templates. L'image suivante montre le dossier correct sur (1) :

Code Java

D'accord, entrons dans le code maintenant !

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

Pour obtenir la police en C++, il faut que le code Java.. :

• créer une demande de police
• Récupérer les polices de FontsContractCompat à l'aide de la demande de police.
• Obtenir les informations sur les polices et l'URI des polices (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 demande de police, vous avez besoin des informations sur le fournisseur de la police (autorité, paquet et certificats) et de la requête de recherche de 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);

Maintenant, utilisez la requête que vous venez de faire pour récupérer la police :

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

Obtenir le FontInfo et l'URI :

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

Ouvrir 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++

Ok, tout est fait du côté Java. Passons au côté C++.

Le C++ est responsable de l'appel au code Java et de l'utilisation du descripteur de fichier pour charger la police dans Qt.

Pour mieux comprendre comment fonctionne la communication entre 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, intégrez le descripteur de fichier 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());