Unterstützung der Google-Emoji-Schriftart-Richtlinie

Google hat eine Android-Richtlinie für Emojis eingeführt , die App-Entwickler dazu verpflichtet, die neueste Version der Unicode-Emojis zu unterstützen. Die Richtlinie besagt:

Apps mit benutzerdefinierten Emoji-Implementierungen, einschließlich solcher, die von Bibliotheken von Drittanbietern bereitgestellt werden, müssen die neueste Unicode-Version vollständig unterstützen, wenn sie unter Android 12+ ausgeführt werden, und zwar innerhalb von vier Monaten nach der Veröffentlichung neuer Unicode-Emojis.

Diese Anleitung zeigt, wie Sie diese Richtlinie umsetzen können, indem Sie entweder eine Emoji-Schriftart bündeln oder die „Android: Google Downloadable Fonts“ verwenden.

Einbinden einer Emoji-Schriftart vs. „Google Downloadable Fonts“

Beide Methoden zur Unterstützung der neuesten Emojis haben Vor- und Nachteile. Die beste Option hängt von der jeweiligen App ab. Hier sind einige Vor- und Nachteile der beiden Methoden:

Vorteile der Integration einer Schriftart:

• Schnelleres Laden der Schriftart
• Funktioniert auch, wenn der Nutzer keine Internetverbindung hat
• Funktioniert auf allen Betriebssystemen
• Unabhängig (keine weiteren Abhängigkeiten außer Qt)
• Einfachere Lösung

Nachteile der Schriftart-Einbindung:

• Erhöht die Anwendungsgröße (NotoColorEmoji ist ca. 10 MB groß)
• Erfordert die Aktualisierung der Schriftart bei neueren Versionen
• Ältere Apps aktualisieren Emojis nicht automatisch

Vorteile der herunterladbaren Google-Schriftarten:

• Ändert die Anwendungsgröße nicht
• Wird automatisch aktualisiert
• Mehrere Apps, die in keinem Zusammenhang zueinander stehen, nutzen dieselbe Schriftart

Nachteile von Google Downloadable Fonts:

• Abhängig von Google Mobile Services
• Nur für Android
• Die Schriftart wird heruntergeladen, wenn sie nicht zuvor zwischengespeichert wurde
• Funktioniert ohne Internetverbindung nicht, wenn die Schriftart nicht zuvor zwischengespeichert wurde
• Komplexer als das Bündeln der Schriftart

So bündeln Sie eine Schriftart

Es ist erforderlich, die Schriftart zu beschaffen und einzubinden und sie später entweder über QML oder C++ zu laden.

Eine Schriftart beschaffen

Für diese Anleitung verwenden wir die Google -Schriftart „NotoColorEmoji“. NotoColorEmoji ist eine unter der SIL OPEN FONT LICENSE lizenzierte Schriftart.

Hinzufügen der Schriftart

Die richtige Vorgehensweise zum Einbinden der Schriftart besteht darin, sie zu den Dateien des Qt-Ressourcensystems hinzuzufügen. Sie können beispielsweise eine separate Ressourcendatei für die Schriftart erstellen – „font.qrc“ mit der Datei „NotoColorEmoji_WindowsCompatible.ttf“. Um die neue Ressourcendatei einzubinden, verwenden Sie den folgenden Code in „CMakeLists.txt“:

qt_add_big_resources(PROJECT_SOURCES font.qrc)

Laden der eingebundenen Schriftart in C++

Um die Schriftart mit C++ zu laden, verwenden Sie ` QFontDatabase`.

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

Laden der mitgelieferten Schriftart in QML

Um die Schriftart in QML zu laden, verwenden Sie „ FontLoader “:

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

Verwendung von herunterladbaren Google-Schriftarten:

Die Verwendung von herunterladbaren Google-Schriftarten für die Emoji-Schriftart bietet eine automatisch aktualisierte Emoji-Schriftart, ohne die Anwendungsgröße zu erhöhen. Der Vorgang zum Herunterladen einer Schriftart mithilfe der Funktion „Downloadable Fonts“ wird ausführlicher unter „Android: Downloadable Fonts Process“ beschrieben

Für diese Anleitung sieht der Vorgang wie folgt aus:

1. C++-Code beginnt
2. C++ ruft eine Java-Funktion auf
3. Java ruft GDF auf, um die Schriftart abzurufen
4. Java öffnet die Schriftart-URI
5. Java gibt den Dateideskriptor an C++ zurück
6. C++ lädt die Schriftart mithilfe von QFontDatabase

Konfiguration

Google Downloadable Fonts ist ab API-Level 26 (Android 8.0) verfügbar. Es ist jedoch möglich, frühere API-Level bis hinunter zu API 14 zu unterstützen, wenn die App AndroidX verwendet.

Anpassen der Android-Paketvorlagen

Zunächst müssen die Android-Paketvorlagen angepasst werden. Gehen Sie dazu in „ Qt Creator “ auf die Registerkarte „Projekte“ und suchen Sie in den „Build-Einstellungen“ nach „Build Android APK“. Der Eintrag sollte sich unter „Build-Schritte“ befinden. Erweitern Sie die Details, woraufhin eine Schaltfläche namens „Vorlagen erstellen“ erscheint.

Klicken Sie auf „Vorlagen erstellen“, folgen Sie den Anweisungen des Assistenten, und am Ende wird ein Ordner mit mehreren Konfigurationsdateien für Android erstellt. Standardmäßig handelt es sich dabei um einen Ordner namens „ android “ im Projektverzeichnis.

Informationen dazu, wie Sie die Android-Vorlagen mit qmake anpassen können, finden Sie unter „Android-Paketvorlagen “.

Falls Sie wie in dieser Anleitung CMake und Qt 6 verwenden, müssen Sie die Eigenschaft „QT_ANDROID_PACKAGE_SOURCE_DIR“ setzen. Beispiel:

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

AndroidX hinzufügen

Um AndroidX hinzuzufügen, öffnen Sie die Datei „ build.gradle “ im oben hinzugefügten Ordner „QT_ANDROID_PACKAGE_SOURCE_DIR“ und fügen Sie dort die Abhängigkeit hinzu:

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

Um AndroidX zu verwenden, müssen wir das entsprechende Flag setzen. Erstellen Sie dazu eine Datei namens „ gradle.properties “ im Ordner „QT_ANDROID_PACKAGE_SOURCE_DIR“ und fügen Sie folgende Zeile hinzu:

android.useAndroidX=true

Hinzufügen von Font-Provider-Zertifikaten

Da wir AndroidX verwenden, ist eine weitere Konfiguration erforderlich – das Hinzufügen von „Android: Font Provider Certificates“. Um den GMS-Schriftartenanbieter zu verwenden, laden Sie die „Android: GMS Font Provider Certificates“ herunter. Wenn Sie andere Schriftartenanbieter verwenden, müssen Sie die Zertifikate vom Anbieter selbst beziehen.

Fügen Sie die Datei nach dem Herunterladen zu den Android-Ressourcen hinzu (nicht zum Qt-Ressourcensystem), indem Sie sie in den Ordner „ values “ im Ordner „android templates“ kopieren. Die folgende Abbildung zeigt den richtigen Ordner an Position (1):

Java-Code

Okay, lassen Sie uns nun in den Code einsteigen!

Wir müssen Java-/Kotlin-Code zu unseren Android-Vorlagen hinzufügen. Speichere ihn im Ordner „ src “ im Ordner „android templates“. Möglicherweise musst du den Ordner „ src “ sowie die Ordnerstruktur für deine Java-Dateien erstellen. Diese Ordnerstruktur siehst du in der Abbildung „Android-Vorlagenordner“ im vorherigen Abschnitt unter (2).

Um die Schriftart in C++ abzurufen, muss der Java-Code Folgendes tun:

• Erstellen einer Schriftartanforderung
• die Schriftarten mithilfe der Schriftart-Anfrage von „FontsContractCompat“ abrufen
• Schriftart-Informationen und die Schriftart-URI (Content-Schema-Datei) abrufen
• Öffnen der URI und Abrufen eines Dateideskriptors
• Den Dateideskriptor an den C++-Code zurückgeben

Um eine Schriftartenanforderung zu erstellen, benötigen Sie die Informationen zum Schriftartenanbieter (Autorität, Paket und Zertifikate) sowie die Suchanfrage für die Schriftart. Verwenden Sie für die Zertifikate die Datei „GMS Font Provider Certificates“ ( fonts_cert.xml ), die zuvor zu den Android-Ressourcen hinzugefügt wurde.

// 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);

Verwenden Sie nun die soeben erstellte Anfrage, um die Schriftart abzurufen:

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

Rufen Sie die Datei „ FontInfo “ und die URI ab:

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

Öffnen Sie einen neuen nativen Dateideskriptor anhand der 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++

C++-Code

Ok, auf der Java-Seite ist alles erledigt. Kommen wir nun zur C++-Seite.

C++ ist dafür zuständig, den Java-Code aufzurufen und mithilfe des Dateideskriptors die Schriftart in Qt zu laden.

Um ein tieferes Verständnis dafür zu erhalten, wie die Kommunikation zwischen C++ und Java in Qt 6 funktioniert, sehen Sie sich das Beispiel „Qt for Android Notifier“ an.

Nachdem Sie den Dateideskriptor aus dem Java-Code erhalten haben, verpacken Sie den Dateideskriptor in eine „ QFile “-Klasse und laden Sie die Schriftartdatei mithilfe von „ QFontDatabase “:

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

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