Partager via

Polices

Vue d’ensemble

À compter du niveau 26 de l’API, le Kit de développement logiciel (SDK) Android permet aux polices d’être traitées comme des ressources, comme des dispositions ou des dessins. La bibliothèque de support Android 26 NuGet rétroporte les nouvelles API de police à ces applications qui ciblent le niveau d’API 14 ou supérieur.

Après avoir ciblé l’API 26 ou installé la bibliothèque de support Android v26, il existe deux façons d’utiliser des polices dans une application Android :

  1. Empaqueter la police en tant que ressource Android : cela garantit que la police est toujours disponible pour l’application, mais augmente la taille de l’APK.
  2. Téléchargez les polices : Android prend également en charge le téléchargement d’une police à partir d’un fournisseur de polices. Le fournisseur de polices case activée si la police est déjà sur l’appareil. Si nécessaire, la police est téléchargée et mise en cache sur l’appareil. Cette police peut être partagée entre plusieurs applications.

Des polices similaires (ou une police qui peut avoir plusieurs styles différents) peuvent être regroupées en familles de polices. Cela permet aux développeurs de spécifier certains attributs de la police, tels que son poids, et Android sélectionne automatiquement la police appropriée dans la famille de polices.

La bibliothèque de support Android v26 prend en charge les polices au niveau de l’API 26. Lorsque vous ciblez les niveaux d’API plus anciens, il est nécessaire de déclarer l’espace app de noms XML et de nommer les différents attributs de police à l’aide de l’espace android: de noms et de l’espace app: de noms. Si seul l’espace android: de noms est utilisé, les polices ne sont pas affichées sur les appareils exécutant le niveau d’API 25 ou moins. Par exemple, cet extrait de code XML déclare une nouvelle ressource de famille de polices qui fonctionnera dans le niveau d’API 14 et versions ultérieures :

<?xml version="1.0" encoding="utf-8"?>
<font-family
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

     <font  android:font="@font/sourcesanspro_regular"
            android:fontStyle="normal"
            android:fontWeight="400"
            app:font="@font/sourcesanspro_regular"
            app:fontStyle="normal"
            app:fontWeight="400" />

</font-family>

Tant que les polices sont fournies à une application Android de manière appropriée, elles peuvent être appliquées à un widget d’interface utilisateur en définissant l’attributfontFamily. Par exemple, l’extrait de code suivant montre comment afficher une police dans un TextView :

<TextView
    android:text="The quick brown fox jumped over the lazy dog."
    android:fontFamily="@font/sourcesanspro_regular"
    app:fontFamily="@font/sourcesanspro_regular"
    android:textAppearance="?android:attr/textAppearanceLarge"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

Ce guide explique d’abord comment utiliser des polices en tant que ressource Android, puis passer à la procédure de téléchargement des polices au moment de l’exécution.

Polices en tant que ressource

L’empaquetage d’une police dans un APK Android garantit qu’elle est toujours disponible pour l’application. Un fichier de police (soit un . TTF ou a . Le fichier OTF) est ajouté à une application Xamarin.Android comme n’importe quelle autre ressource, en copiant des fichiers dans un sous-répertoire dans le dossier Ressources d’un projet Xamarin.Android. Les ressources de polices sont conservées dans un sous-répertoire de polices du dossier Ressources du projet.

Remarque

Les polices doivent avoir une action de génération d’AndroidResource ou elles ne seront pas empaquetées dans l’APK final. L’action de génération doit être automatiquement définie par l’IDE.

Lorsqu’il existe de nombreux fichiers de police similaires (par exemple, la même police avec différents poids ou styles) permet de les regrouper dans une famille de polices.

Familles de polices

Une famille de polices est un ensemble de polices qui ont différents poids et styles. Par exemple, il peut y avoir des fichiers de police distincts pour les polices gras ou italiques. La famille de polices est définie par font les éléments d’un fichier XML conservé dans le répertoire Resources/Font . Chaque famille de polices doit avoir son propre fichier XML.

Pour créer une famille de polices, ajoutez d’abord toutes les polices au dossier Resources/Font . Créez ensuite un fichier XML dans le dossier de polices pour la famille de polices. Le nom du fichier XML n’a aucune affinité ni relation avec les polices référencées ; le fichier de ressources peut être n’importe quel nom de fichier de ressource Android légal. Ce fichier XML aura un élément racine font-family qui contient un ou plusieurs font éléments. Chaque font élément déclare les attributs d’une police.

Le code XML suivant est un exemple de famille de polices pour la police Sources Sans Pro qui définit de nombreux poids de police différents. Ce fichier est enregistré dans le dossier Resources/font nommé sourcesanspro.xml :

<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android"
             xmlns:app="http://schemas.android.com/apk/res-auto">
    <font android:font="@font/sourcesanspro_regular"
          android:fontStyle="normal"
          android:fontWeight="400"
          app:font="@font/sourcesanspro_regular"
          app:fontStyle="normal"
          app:fontWeight="400" />
    <font android:font="@font/sourcesanspro_bold"
          android:fontStyle="normal"
          android:fontWeight="800"
          app:font="@font/sourcesanspro_bold"
          app:fontStyle="normal"
          app:fontWeight="800" />
    <font android:font="@font/sourcesanspro_italic"
          android:fontStyle="italic"
          android:fontWeight="400"
          app:font="@font/sourcesanspro_italic"
          app:fontStyle="italic"
          app:fontWeight="400" />
</font-family>

L’attribut fontStyle a deux valeurs possibles :

  • normal : police normale
  • italique : police italique

L’attribut fontWeight correspond à l’attribut CSS font-weight et fait référence à l’épaisseur de la police. Il s’agit d’une valeur comprise entre 100 et 900. La liste suivante décrit les valeurs courantes de pondération de police et leur nom :

  • Fin – 100
  • Lumière supplémentaire – 200
  • Lumière – 300
  • Normal – 400
  • Moyen – 500
  • Semi-gras – 600
  • Gras – 700
  • Gras supplémentaire – 800
  • Noir – 900

Une fois qu’une famille de polices a été définie, elle peut être utilisée de manière déclarative en définissant les attributs et fontWeight les fontFamilytextStyleattributs dans le fichier de disposition. Par exemple, l’extrait de code XML suivant définit une police de 600 poids (normale) et un style de texte italique :

<TextView
    android:text="Sans Source Pro semi-bold italic, 600 weight, italic"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:fontFamily="@font/sourcesanspro"
    android:textAppearance="?android:attr/textAppearanceLarge"
    android:gravity="center_horizontal"
    android:fontWeight="600"
    android:textStyle="italic"
    />

Affectation de polices par programmation

Les polices peuvent être définies par programmation à l’aide de la Resources.GetFont méthode pour récupérer un Typeface objet. De nombreuses vues ont une TypeFace propriété qui peut être utilisée pour affecter la police au widget. Cet extrait de code montre comment définir par programmation la police sur un TextView :

Android.Graphics.Typeface typeface = this.Resources.GetFont(Resource.Font.caveat_regular);
textView1.Typeface = typeface;
textView1.Text = "Changed the font";

La GetFont méthode charge automatiquement la première police dans une famille de polices. Pour charger une police qui correspond à un style spécifique, utilisez la Typeface.Create méthode. Cette méthode tente de charger une police qui correspond au style spécifié. Par exemple, cet extrait de code tente de charger un objet en gras Typeface à partir d’une famille de polices définie dans Resources/fonts :

var typeface = Typeface.Create("<FONT FAMILY NAME>", Android.Graphics.TypefaceStyle.Bold);
textView1.Typeface = typeface;

Téléchargement des polices

Au lieu d’empaqueter des polices en tant que ressource d’application, Android peut télécharger des polices à partir d’une source distante. Cela aura l’effet souhaitable de réduire la taille de l’APK.

Les polices sont téléchargées avec l’aide d’un fournisseur de polices. Il s’agit d’un fournisseur de contenu spécialisé qui gère le téléchargement et la mise en cache de polices sur toutes les applications sur l’appareil. Android 8.0 inclut un fournisseur de polices pour télécharger des polices à partir du dépôt de polices Google. Ce fournisseur de polices par défaut est rétroporté au niveau de l’API 14 avec la bibliothèque de support Android v26.

Lorsqu’une application effectue une demande de police, le fournisseur de polices case activée d’abord pour voir si la police est déjà sur l’appareil. Si ce n’est pas le cas, il tentera de télécharger la police. Si la police ne peut pas être téléchargée, Android utilise la police système par défaut. Une fois la police téléchargée, elle est disponible pour toutes les applications sur l’appareil, et pas seulement l’application qui a effectué la requête initiale.

Lorsqu’une demande est effectuée pour télécharger une police, l’application n’interroge pas directement le fournisseur de polices. Au lieu de cela, les applications utilisent une instance de l’API FontsContract (ou si FontsContractCompat la bibliothèque de support 26 est utilisée).

Android 8.0 prend en charge le téléchargement de polices de deux façons différentes :

  1. Déclarer des polices téléchargeables en tant que ressource : une application peut déclarer des polices téléchargeables sur Android via des fichiers de ressources XML. Ces fichiers contiennent toutes les métadonnées que Android doit télécharger de manière asynchrone les polices lorsque l’application démarre et les met en cache sur l’appareil.
  2. Par programme : les API au niveau 26 de l’API Android permettent à une application de télécharger les polices par programmation, pendant l’exécution de l’application. Les applications créent un FontRequest objet pour une police donnée et passent cet objet à la FontsContract classe. Prend FontsContract la FontRequest police et récupère la police d’un fournisseur de polices. Android télécharge de manière synchrone la police. Un exemple de création d’un FontRequest fichier sera présenté plus loin dans ce guide.

Quelle que soit l’approche utilisée, les fichiers de ressources qui doivent être ajoutés à l’application Xamarin.Android avant que les polices puissent être téléchargées. Tout d’abord, la ou les polices doivent être déclarées dans un fichier XML dans le répertoire Resources/Font dans le cadre d’une famille de polices. Cet extrait de code est un exemple de téléchargement de polices à partir de la collection Google Fonts Open Source à l’aide du fournisseur de polices par défaut fourni avec Android 8.0 (ou bibliothèque de support v26) :

<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android"
             xmlns:app="http://schemas.android.com/apk/res-auto"
             android:fontProviderAuthority="com.google.android.gms.fonts"
             android:fontProviderPackage="com.google.android.gms"
             android:fontProviderQuery="VT323"
             android:fontProviderCerts="@array/com_google_android_gms_fonts_certs"
             app:fontProviderAuthority="com.google.android.gms.fonts"
             app:fontProviderPackage="com.google.android.gms"
             app:fontProviderQuery="VT323"
             app:fontProviderCerts="@array/com_google_android_gms_fonts_certs"
>
</font-family>

L’élément font-family contient les attributs suivants, déclarant les informations dont Android a besoin pour télécharger les polices :

  1. fontProviderAuthority : autorité du fournisseur de polices à utiliser pour la demande.
  2. fontPackage : package pour le fournisseur de polices à utiliser pour la demande. Il est utilisé pour vérifier l’identité du fournisseur.
  3. fontQuery : il s’agit d’une chaîne qui aidera le fournisseur de polices à localiser la police demandée. Les détails de la requête de police sont spécifiques au fournisseur de polices. La QueryBuilder classe de l’exemple d’application Fonts téléchargeables fournit des informations sur le format de requête pour les polices de la collection Open Source Google Fonts.
  4. fontProviderCerts : tableau de ressources avec la liste des jeux de hachages pour les certificats avec utilisant lequel le fournisseur doit être signé.

Une fois les polices définies, il peut être nécessaire de fournir des informations sur les certificats de police impliqués dans le téléchargement.

Certificats de police

Si le fournisseur de polices n’est pas préinstallé sur l’appareil ou si l’application utilise la Xamarin.Android.Support.Compat bibliothèque, Android requiert les certificats de sécurité du fournisseur de polices. Ces certificats sont répertoriés dans un fichier de ressources de tableau conservé dans le répertoire Ressources/valeurs .

Par exemple, le code XML suivant est nommé Resources/values/fonts_cert.xml et stocke les certificats pour le fournisseur de polices Google :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <array name="com_google_android_gms_fonts_certs">
        <item>@array/com_google_android_gms_fonts_certs_dev</item>
        <item>@array/com_google_android_gms_fonts_certs_prod</item>
    </array>
    <string-array name="com_google_android_gms_fonts_certs_dev">
        <item>
            MIIEqDCCA5CgAwIBAgIJANWFuGx90071MA0GCSqGSIb3DQEBBAUAMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNTW91bnRhaW4gVmlldzEQMA4GA1UEChMHQW5kcm9pZDEQMA4GA1UECxMHQW5kcm9pZDEQMA4GA1UEAxMHQW5kcm9pZDEiMCAGCSqGSIb3DQEJARYTYW5kcm9pZEBhbmRyb2lkLmNvbTAeFw0wODA0MTUyMzM2NTZaFw0zNTA5MDEyMzM2NTZaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNTW91bnRhaW4gVmlldzEQMA4GA1UEChMHQW5kcm9pZDEQMA4GA1UECxMHQW5kcm9pZDEQMA4GA1UEAxMHQW5kcm9pZDEiMCAGCSqGSIb3DQEJARYTYW5kcm9pZEBhbmRyb2lkLmNvbTCCASAwDQYJKoZIhvcNAQEBBQADggENADCCAQgCggEBANbOLggKv+IxTdGNs8/TGFy0PTP6DHThvbbR24kT9ixcOd9W+EaBPWW+wPPKQmsHxajtWjmQwWfna8mZuSeJS48LIgAZlKkpFeVyxW0qMBujb8X8ETrWy550NaFtI6t9+u7hZeTfHwqNvacKhp1RbE6dBRGWynwMVX8XW8N1+UjFaq6GCJukT4qmpN2afb8sCjUigq0GuMwYXrFVee74bQgLHWGJwPmvmLHC69EH6kWr22ijx4OKXlSIx2xT1AsSHee70w5iDBiK4aph27yH3TxkXy9V89TDdexAcKk/cVHYNnDBapcavl7y0RiQ4biu8ymM8Ga/nmzhRKya6G0cGw8CAQOjgfwwgfkwHQYDVR0OBBYEFI0cxb6VTEM8YYY6FbBMvAPyT+CyMIHJBgNVHSMEgcEwgb6AFI0cxb6VTEM8YYY6FbBMvAPyT+CyoYGapIGXMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNTW91bnRhaW4gVmlldzEQMA4GA1UEChMHQW5kcm9pZDEQMA4GA1UECxMHQW5kcm9pZDEQMA4GA1UEAxMHQW5kcm9pZDEiMCAGCSqGSIb3DQEJARYTYW5kcm9pZEBhbmRyb2lkLmNvbYIJANWFuGx90071MAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEEBQADggEBABnTDPEF+3iSP0wNfdIjIz1AlnrPzgAIHVvXxunW7SBrDhEglQZBbKJEk5kT0mtKoOD1JMrSu1xuTKEBahWRbqHsXclaXjoBADb0kkjVEJu/Lh5hgYZnOjvlba8Ld7HCKePCVePoTJBdI4fvugnL8TsgK05aIskyY0hKI9L8KfqfGTl1lzOv2KoWD0KWwtAWPoGChZxmQ+nBli+gwYMzM1vAkP+aayLe0a1EQimlOalO762r0GXO0ks+UeXde2Z4e+8S/pf7pITEI/tP+MxJTALw9QUWEv9lKTk+jkbqxbsh8nfBUapfKqYn0eidpwq2AzVp3juYl7//fKnaPhJD9gs=
        </item>
    </string-array>
    <string-array name="com_google_android_gms_fonts_certs_prod">
        <item>
            MIIEQzCCAyugAwIBAgIJAMLgh0ZkSjCNMA0GCSqGSIb3DQEBBAUAMHQxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1Nb3VudGFpbiBWaWV3MRQwEgYDVQQKEwtHb29nbGUgSW5jLjEQMA4GA1UECxMHQW5kcm9pZDEQMA4GA1UEAxMHQW5kcm9pZDAeFw0wODA4MjEyMzEzMzRaFw0zNjAxMDcyMzEzMzRaMHQxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1Nb3VudGFpbiBWaWV3MRQwEgYDVQQKEwtHb29nbGUgSW5jLjEQMA4GA1UECxMHQW5kcm9pZDEQMA4GA1UEAxMHQW5kcm9pZDCCASAwDQYJKoZIhvcNAQEBBQADggENADCCAQgCggEBAKtWLgDYO6IIrgqWbxJOKdoR8qtW0I9Y4sypEwPpt1TTcvZApxsdyxMJZ2JORland2qSGT2y5b+3JKkedxiLDmpHpDsz2WCbdxgxRczfey5YZnTJ4VZbH0xqWVW/8lGmPav5xVwnIiJS6HXk+BVKZF+JcWjAsb/GEuq/eFdpuzSqeYTcfi6idkyugwfYwXFU1+5fZKUaRKYCwkkFQVfcAs1fXA5V+++FGfvjJ/CxURaSxaBvGdGDhfXE28LWuT9ozCl5xw4Yq5OGazvV24mZVSoOO0yZ31j7kYvtwYK6NeADwbSxDdJEqO4k//0zOHKrUiGYXtqw/A0LFFtqoZKFjnkCAQOjgdkwgdYwHQYDVR0OBBYEFMd9jMIhF1Ylmn/Tgt9r45jk14alMIGmBgNVHSMEgZ4wgZuAFMd9jMIhF1Ylmn/Tgt9r45jk14aloXikdjB0MQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNTW91bnRhaW4gVmlldzEUMBIGA1UEChMLR29vZ2xlIEluYy4xEDAOBgNVBAsTB0FuZHJvaWQxEDAOBgNVBAMTB0FuZHJvaWSCCQDC4IdGZEowjTAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBAUAA4IBAQBt0lLO74UwLDYKqs6Tm8/yzKkEu116FmH4rkaymUIE0P9KaMftGlMexFlaYjzmB2OxZyl6euNXEsQH8gjwyxCUKRJNexBiGcCEyj6z+a1fuHHvkiaai+KL8W1EyNmgjmyy8AW7P+LLlkR+ho5zEHatRbM/YAnqGcFh5iZBqpknHf1SKMXFh4dd239FJ1jWYfbMDMy3NS5CTMQ2XFI1MvcyUTdZPErjQfTbQe3aDQsQcafEQPD+nqActifKZ0Np0IS9L9kR/wbNvyz6ENwPiTrjV2KRkEjH78ZMcUQXg0L3BYHJ3lc69Vs5Ddf9uUGGMYldX3WfMBEmh/9iFBDAaTCK
        </item>
    </string-array>
</resources>

Avec ces fichiers de ressources en place, l’application est capable de télécharger les polices.

Déclaration des polices téléchargeables en tant que ressources

En répertoriant les polices téléchargeables dans le AndroidManifest.XML, Android télécharge de manière asynchrone les polices au démarrage de l’application. Les polices elles-mêmes sont répertoriées dans un fichier de ressources de tableau, semblable à celle-ci :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <array name="downloadable_fonts" translatable="false">
        <item>@font/vt323</item>
    </array>
</resources>

Pour télécharger ces polices, elles doivent être déclarées dans AndroidManifest.XML en ajoutant meta-data en tant qu’enfant de l’élémentapplication. Par exemple, si les polices téléchargeables sont déclarées dans un fichier de ressources sur Resources/values/downloadable_fonts.xml, cet extrait de code doit être ajouté au manifeste :

<meta-data android:name="downloadable_fonts" android:resource="@array/downloadable_fonts" />

Téléchargement d’une police avec les API Police

Il est possible de télécharger par programmation une police en instanciant un FontRequest objet et en le transmettant à la FontContractCompat.RequestFont méthode. La FontContractCompat.RequestFont méthode case activée d’abord pour voir si la police existe sur l’appareil, puis, si nécessaire, interrogera de manière asynchrone le fournisseur de polices et tentera de télécharger la police pour l’application. S’il FontRequest n’est pas en mesure de télécharger la police, Android utilise la police système par défaut.

Un FontRequest objet contient des informations qui seront utilisées par le fournisseur de polices pour localiser et télécharger une police. Un FontRequest besoin de quatre informations :

  1. Autorité du fournisseur de polices : autorité du fournisseur de polices à utiliser pour la demande.
  2. Package de police : package pour le fournisseur de polices à utiliser pour la demande. Il est utilisé pour vérifier l’identité du fournisseur.
  3. Requête de police : il s’agit d’une chaîne qui aidera le fournisseur de polices à localiser la police demandée. Les détails de la requête de police sont spécifiques au fournisseur de polices. Les détails de la chaîne sont spécifiques au fournisseur de polices. La QueryBuilder classe de l’exemple d’application Fonts téléchargeables fournit des informations sur le format de requête pour les polices de la collection Open Source Google Fonts.
  4. Certificats du fournisseur de polices : tableau de ressources avec la liste des jeux de hachages pour les certificats avec utilisant lequel le fournisseur doit être signé.

Cet extrait de code est un exemple d’instanciation d’un nouvel FontRequest objet :

FontRequest request = new FontRequest("com.google.android.gms.fonts", "com.google.android.gms", <FontToDownload>, Resource.Array.com_google_android_gms_fonts_certs);

Dans l’extrait de code FontToDownload précédent, il s’agit d’une requête qui aidera la police de la collection Open Source Google Fonts.

Avant de passer la FontRequestFontContractCompat.RequestFont méthode, il existe deux objets qui doivent être créés :

  • FontsContractCompat.FontRequestCallback : il s’agit d’une classe abstraite qui doit être étendue. Il s’agit d’un rappel qui sera appelé une fois RequestFont terminé. Une application Xamarin.Android doit sous-classe FontsContractCompat.FontRequestCallback et remplacer les OnTypefaceRequestFailed actions OnTypefaceRetrievedet, en fournissant les actions à entreprendre lorsque le téléchargement échoue ou réussit respectivement.
  • Handler : il s’agit d’un Handler élément qui sera utilisé pour RequestFont télécharger la police sur un thread, si nécessaire. Les polices ne doivent pas être téléchargées sur le thread d’interface utilisateur.

Cet extrait de code est un exemple de classe C# qui télécharge de façon asynchrone une police à partir de la collection Open Source Google Fonts. Il implémente l’interface FontRequestCallback et déclenche un événement C# une fois FontRequest terminé.

public class FontDownloadHelper : FontsContractCompat.FontRequestCallback
{
    // A very simple font query; replace as necessary
    public static readonly String FontToDownload = "Courgette";

    Android.OS.Handler Handler = null;

    public event EventHandler<FontDownloadEventArg> FontDownloaded = delegate
    {
        // just an empty delegate to avoid null reference exceptions.  
    };

    public void DownloadFonts(Context context)
    {
        FontRequest request = new FontRequest("com.google.android.gms.fonts", "com.google.android.gms",FontToDownload , Resource.Array.com_google_android_gms_fonts_certs);
        FontsContractCompat.RequestFont(context, request, this, GetHandlerThreadHandler());
    }

    public override void OnTypefaceRequestFailed(int reason)
    {
        base.OnTypefaceRequestFailed(reason);
        FontDownloaded(this, new FontDownloadEventArg(null));
    }

    public override void OnTypefaceRetrieved(Android.Graphics.Typeface typeface)
    {
        base.OnTypefaceRetrieved(typeface);
        FontDownloaded(this, new FontDownloadEventArg(typeface));
    }

    Handler GetHandlerThreadHandler()
    {
        if (Handler == null)
        {
            HandlerThread handlerThread = new HandlerThread("fonts");
            handlerThread.Start();
            Handler = new Handler(handlerThread.Looper);
        }
        return Handler;
    }
}

public class FontDownloadEventArg : EventArgs
{
    public FontDownloadEventArg(Android.Graphics.Typeface typeface)
    {
        Typeface = typeface;
    }
    public Android.Graphics.Typeface Typeface { get; private set; }
    public bool RequestFailed
    {
        get
        {
            return Typeface != null;
        }
    }
}

Pour utiliser cet assistance, un nouveau FontDownloadHelper est créé et un gestionnaire d’événements est affecté :

var fontHelper = new FontDownloadHelper();

fontHelper.FontDownloaded += (object sender, FontDownloadEventArg e) =>
{
    //React to the request
};
fontHelper.DownloadFonts(this); // this is an Android Context instance.

Résumé

Ce guide a abordé les nouvelles API dans Android 8.0 pour prendre en charge les polices et polices téléchargeables en tant que ressources. Il a expliqué comment incorporer des polices existantes dans un APK et les utiliser dans une disposition. Il a également abordé la façon dont Android 8.0 prend en charge le téléchargement de polices à partir d’un fournisseur de polices, par programme ou en déclarant les métadonnées de police dans les fichiers de ressources.