Soporte de la política de fuentes de Google Emoji

Google ha introducido un Android: Android Emoji Policy que obliga a los desarrolladores de aplicaciones a soportar la última versión de Unicode Emoji. La política establece:

Las aplicaciones con implementaciones de emoji personalizadas, incluidas las proporcionadas por bibliotecas de terceros, deben ser totalmente compatibles con la última versión de Unicode cuando se ejecuten en Android 12+ en un plazo de 4 meses a partir del lanzamiento de nuevos Unicode Emoji.

Esta guía muestra cómo cumplir esta política mediante la inclusión de una fuente emoji o el uso de Android: Fuentes descargables de Google.

Incluir una fuente emoji VS Fuentes descargables de Google

Hay algunas ventajas y desventajas de ambos métodos para soportar los últimos emojis La mejor opción depende de cada aplicación. He aquí algunas ventajas y desventajas de los dos métodos:

Ventajas de las fuentes empaquetadas

• Carga más rápida de la fuente
• Funciona cuando el usuario no tiene internet
• Funciona en todos los sistemas operativos
• Independiente (no hay otras dependencias aparte de Qt)
• Solución más sencilla

Desventajas de agrupar fuentes:

• Aumenta el tamaño de la aplicación (NotoColorEmoji ocupa ~10 MB)
• Requiere actualizar la fuente en las nuevas versiones
• Las aplicaciones más antiguas no actualizarán los emojis automáticamente

Ventajas de las fuentes descargables de Google:

• No cambia el tamaño de la aplicación
• Se actualiza automáticamente
• Varias aplicaciones sin ninguna relación comparten la misma fuente

Desventajas de Google Downloadable Fonts:

• Depende de Google Mobile Services
• Sólo Android
• Descargará la fuente si no se ha almacenado previamente en caché
• No funciona sin Internet si no se ha almacenado previamente en caché.
• Más complejo que empaquetar la fuente

Cómo empaquetar una fuente

Es necesario obtener y empaquetar la fuente y después cargarla usando QML o C++.

Obtención de una fuente

En esta guía utilizaremos la fuente Google NotoColorEmoji. NotoColorEmoji es una fuente con licencia SIL OPEN FONT LICENSE.

Añadir la fuente

La forma correcta de empaquetar la fuente es añadirla a los archivos del sistema de recursos de Qt. Por ejemplo, puedes hacer un archivo de recursos separado para la fuente - "font.qrc" con el NotoColorEmoji_WindowsCompatible.ttf. Para incrustar el nuevo archivo de recursos utilice el siguiente código en CMakeLists.txt:

qt_add_big_resources(PROJECT_SOURCES font.qrc)

Cargar la fuente incluida en C

Para cargar la fuente utilizando C++, utilice QFontDatabase.

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

Cargar la fuente empaquetada en QML

Para cargar la fuente en QML, utilice FontLoader:

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

Uso de fuentes descargables de Google:

El uso de fuentes descargables de Google para la fuente emoji proporciona una fuente emoji actualizada automáticamente sin aumentar el tamaño de la aplicación. El proceso para descargar una fuente utilizando la función de fuentes descargables se puede ver con más detalle en Android: Proceso de descarga de fuentes

Para esta guía, el proceso será

1. Inicio del código C
2. C++ llama a una función Java
3. Java llama a GDF para obtener la fuente
4. Java abre el URI de la fuente
5. Java devuelve el descriptor de archivo a C
6. C++ carga la fuente utilizando QFontDatabase

Configuración

Google Downloadable Fonts está disponible para el nivel API 26 (Android 8.0). Pero es posible soportar APIs anteriores hasta API 14 si la aplicación utiliza AndroidX.

Personalizar la plantilla de paquetes Android

En primer lugar, es necesario personalizar las plantillas de paquetes Android. Para ello, en Qt Creator, vaya a la pestaña Projects, y luego busque en Build Settings "Build Android APK". Debe estar dentro de "Build Steps", expande los detalles y aparecerá un botón llamado "Create Templates".

Haga clic en "Crear plantillas", siga el asistente y, al final, se creará una carpeta con varios archivos de configuración para Android. Por defecto, será una carpeta llamada android dentro del directorio del proyecto.

Ver Android Package Templates para obtener información sobre cómo personalizar las plantillas android usando qmake.

En caso de que estés usando CMake y Qt 6, como en esta guía, necesitas establecer la propiedad QT_ANDROID_PACKAGE_SOURCE_DIR. Ej:

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

Añadir AndroidX

Para añadir AndroidX abra el archivo build.gradle dentro de la carpeta QT_ANDROID_PACKAGE_SOURCE_DIR añadida anteriormente y añada la dependencia allí:

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

Para utilizar Androidx tenemos que establecer la bandera correspondiente. Para ello crea un archivo llamado gradle.properties dentro de QT_ANDROID_PACKAGE_SOURCE_DIR y añade esta línea:

android.useAndroidX=true

Adding Font Provider Certificates

Como estamos usando AndroidX, hay otra configuración necesaria - añadir Android: Font Provider Certificates. Para utilizar el proveedor de fuentes GMS, descargue los certificados Android: GMS Font Provider Certificates. Si utiliza otros proveedores de fuentes, deberá obtener los certificados del propio proveedor.

Después de descargar el archivo, añádalo a Android Resources (no al sistema Qt Resource) copiándolo a la carpeta values en la carpeta android templates. La siguiente imagen muestra la carpeta correcta en (1):

Código Java

Bien, ¡ahora vamos a profundizar en el código!

Necesitamos añadir Código Java/Kotlin a nuestras plantillas Android. Colócalo bajo la carpeta src en la carpeta de plantillas android. Puede que necesites crear la carpeta src y la estructura de carpetas para tus archivos java. Puedes ver esta estructura de carpetas en la imagen de la Carpeta de Plantillas Android de la sección anterior en (2).

Para obtener la fuente en C++, es necesario que el código Java:

• Cree una Petición de Fuente
• Obtenga las fuentes de FontsContractCompat utilizando la petición de fuente
• Obtenga la información de la fuente y el URI de la fuente (archivo de esquema de contenido)
• Abrir el URI y obtener un descriptor de archivo
• Devolver el descriptor de archivo al código C

Para crear una solicitud de fuente, necesita la información del proveedor de la fuente (autoridad, paquete y certificados) y la consulta de búsqueda de la fuente. Para los certificados utiliza el archivo GMS Font Provider Certificates fonts_cert.xml añadido previamente a los recursos de 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);

Ahora, utiliza la petición que acabamos de hacer para obtener la fuente:

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

Obtenga el FontInfo y el URI:

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

Abrir un nuevo File Descriptor nativo desde el 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ódigo C

Ok todo hecho en el lado java. Vamos al lado C++.

C++ es responsable de llamar al código Java y utilizar el descriptor de archivo para cargar la fuente en Qt.

Para comprender mejor cómo funciona la comunicación entre C++ y Java en Qt 6, consulta el ejemplo de Qt for Android Notifier.

Después de obtener el descriptor de fichero desde el código Java, envuelve el descriptor de fichero en una clase QFile y carga el fichero de fuentes usando QFontDatabase:

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

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