FontsFonts

Vue d’ensembleOverview

À partir du niveau d’API 26, le Android SDK permet de traiter les polices comme des ressources, tout comme une disposition ou un drawables.Beginning with API level 26, the Android SDK allows fonts to be treated as resources, just like a layouts or drawables. La bibliothèque de prise en charge Android 26 NuGet rétroporter les nouvelles API de police pour les applications qui ciblent le niveau d’API 14 ou supérieur.The Android Support Library 26 NuGet will backport the new font API's to those apps that target API level 14 or higher.

Après avoir ciblé l’API 26 ou installé la bibliothèque de prise en charge Android V26, il existe deux façons d’utiliser des polices dans une application Android :After targeting API 26 or installing the Android Support Library v26, there are two ways to use fonts in an Android application:

  1. Empaqueter la police en tant que ressource Android – Cela garantit que la police est toujours disponible pour l’application, mais augmente la taille du APK.Package the font as an Android resource – this ensures that the font is always available to the application, but will increase the size of the APK.
  2. Télécharger les polices – Android prend également en charge le téléchargement d’une police à partir d’un fournisseur de polices.Download the fonts – Android also supports downloading a font from a font provider. Le fournisseur de polices vérifie si la police est déjà sur l’appareil.The font provider checks if the font is already on the device. Si nécessaire, la police est téléchargée et mise en cache sur l’appareil.If necessary, the font will be downloaded and cached on the device. Cette police peut être partagée entre plusieurs applications.This font can be shared between multiple applications.

Des polices similaires (ou une police qui peut avoir plusieurs styles différents) peuvent être regroupées dans des familles de polices.Similar fonts (or a font that may have several different styles) may be grouped into font families. 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.This allows developers to specify certain attributes of the font, such as it's weight, and Android will automatically select the appropriate font from the font family.

La bibliothèque de prise en charge Android V26 prendra en charge rétroporter pour les polices au niveau d’API 26.The Android Support Library v26 will backport support for fonts to API level 26. Lorsque vous ciblez les anciens niveaux d’API, il est nécessaire de déclarer l' app espace de noms XML et de nommer les différents attributs de police à l’aide de l' android: espace de noms et de l' app: espace de noms.When targeting the older API levels, it is necessary to declare the app XML namespace and to name the various font attributes using the android: namespace and the app: namespace. Si seul l' android: espace de noms est utilisé, les polices ne s’affichent pas pour les appareils exécutant le niveau d’API 25 ou moins.If only the android: namespace is used, then the fonts will not be displayed devices running API level 25 or less. Par exemple, cet extrait de code XML déclare une nouvelle ressource de famille de polices qui fonctionnera au niveau de l’API 14 et versions ultérieures :For example, this XML snippet declares a new font family resource that will work in API level 14 and higher:

<?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' fontFamily attribut.As long as fonts are provided to an Android application in a proper way, they can be applied to a UI widget by setting the fontFamily attribute. Par exemple, l’extrait de code suivant montre comment afficher une police dans un TextView :For example, the following snippet demonstrates how to display a font in a 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 aborde en premier le mode d’utilisation des polices comme ressource Android, puis vous explique comment télécharger des polices au moment de l’exécution.This guide will first discuss how to use fonts as an Android resource, and then move on to discuss how to download fonts at runtime.

Polices en tant que ressourceFonts as a Resource

L’empaquetage d’une police dans un APK Android garantit qu’elle est toujours disponible pour l’application.Packaging a font into an Android APK ensures that it is always available to the application. Un fichier de police (. TTF ou. OTF) est ajouté à une application Xamarin. Android comme n’importe quelle autre ressource, en copiant les fichiers dans un sous-répertoire du dossier Resources d’un projet Xamarin. Android.A font file (either a .TTF or a .OTF file) is added to a Xamarin.Android application just like any other resource, by copying files to a subdirectory in the Resources folder of a Xamarin.Android project. Les ressources de polices sont conservées dans un sous-répertoire de police du dossier ressources du projet.Fonts resources are kept in a font sub-directory of the Resources folder of the project.

Notes

Les polices doivent avoir une action de génération AndroidResource ou ne pas être empaquetées dans le apk final.The fonts should have a Build Action of AndroidResource or they will not be packaged into the final APK. L’action de génération doit être définie automatiquement par l’IDE.The build action should be automatically set by the IDE.

Lorsqu’il existe de nombreux fichiers de polices similaires (par exemple, la même police avec des pondérations ou des styles différents), il est possible de les regrouper dans une famille de polices.When there are many similar font files (for example, the same font with different weights or styles) it is possible to group them into a font family.

Familles de policesFont Families

Une famille de polices est un ensemble de polices qui ont des pondérations et des styles différents.A font family is a set of fonts that have different weights and styles. Par exemple, il peut y avoir des fichiers de polices distincts pour les polices en gras ou en italique.For example, there might be separate font files for bold or italic fonts. La famille de polices est définie par les font éléments d’un fichier XML qui est conservé dans le répertoire Resources/font .The font family is defined by font elements in an XML file that is kept in the Resources/font directory. Chaque famille de polices doit avoir son propre fichier XML.Each font family should have it's own XML file.

Pour créer une famille de polices, commencez par ajouter toutes les polices au dossier Resources/font .To create a font family, first add all the fonts to the Resources/font folder. Créez ensuite un nouveau fichier XML dans le dossier de polices pour la famille de polices.Then create a new XML file in the font folder for the font family. Le nom du fichier XML n’a aucune affinité ou relation avec les polices référencées ; le fichier de ressources peut être n’importe quel nom de fichier de ressources Android légal.The name of the XML file has no affinity or relationship to the fonts being referenced; the resource file can be any legal Android resource file name. Ce fichier XML aura un élément racine font-family qui contient un ou plusieurs font éléments.This XML file will have a root font-family element that contains one or more font elements. Chaque font élément déclare les attributs d’une police.Each font element declares the attributes of a font.

Le code XML suivant est un exemple de famille de polices pour la police San Pro qui définit de nombreux poids de police différents.The following XML is an example of a font family for the Sources Sans Pro font that defines many different font weights. Celui-ci est enregistré en tant que fichier dans le dossier Resources/font nommé sourcesanspro. xml:This is saved as file in the Resources/font folder named 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' fontStyle attribut a deux valeurs possibles :The fontStyle attribute has two possible values:

  • normal – une police normalenormal – a normal font
  • italique – une police en italiqueitalic – an italic font

L' fontWeight attribut correspond à l' font-weight attribut CSS et fait référence à l’épaisseur de la police.The fontWeight attribute corresponds to the CSS font-weight attribute and refers to the thickness of the font. Il s’agit d’une valeur comprise dans la plage 100-900.This is a value in the range of 100 - 900. La liste suivante décrit les valeurs de poids de police courantes et leur nom :The following list describes the common font weight values and their name:

  • Fin – 100Thin – 100
  • Très clair – 200Extra Light – 200
  • Clair – 300Light – 300
  • Normal – 400Normal – 400
  • Moyenne – 500Medium – 500
  • Semi-gras – 600Semi Bold – 600
  • Gras – 700Bold – 700
  • Extra-gras – 800Extra Bold – 800
  • Noir – 900Black – 900

Une fois qu’une famille de polices a été définie, elle peut être utilisée de façon déclarative en définissant les fontFamily textStyle attributs, et fontWeight dans le fichier de disposition.Once a font family has been defined, it can be used declaratively by setting the fontFamily, textStyle, and fontWeight attributes in the layout file. Par exemple, l’extrait de code XML suivant définit une police de pondération 600 (normale) et un style de texte en italique :For example the following XML snippet sets a 600 weight font (normal) and an italic text style:

<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"
    />

Affecter des polices par programmationProgrammatically Assigning Fonts

Les polices peuvent être définies par programmation à l’aide de la Resources.GetFont méthode pour récupérer un Typeface objet.Fonts can be programmatically set by using the Resources.GetFont method to retrieve a Typeface object. De nombreux affichages ont une TypeFace propriété qui peut être utilisée pour assigner la police au widget.Many views have a TypeFace property that can be used to assign the font to the widget. Cet extrait de code montre comment définir par programmation la police sur un TextView :This code snippet shows how to programmatically set the font on a 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.The GetFont method will automatically load the first font within a font family. Pour charger une police qui correspond à un style spécifique, utilisez la Typeface.Create méthode.To load a font that matches a specific style, use the Typeface.Create method. Cette méthode essaiera de charger une police qui correspond au style spécifié.This method will try to load a font that matches the specified style. Par exemple, cet extrait de code essaiera de charger un Typeface objet en gras à partir d’une famille de polices définie dans ressources/polices:As an example, this snippet will try to load a bold Typeface object from a font family that is defined in Resources/fonts:

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

Téléchargement des policesDownloading Fonts

Au lieu d’empaqueter des polices en tant que ressource d’application, Android peut télécharger des polices à partir d’une source distante.Instead of packaging fonts as an application resource, Android can download fonts from a remote source. Cela aura l’effet souhaitable de réduire la taille du APK.This will have the desirable effect of reducing the size of the APK.

Les polices sont téléchargées avec l’assistance d’un fournisseur de polices.Fonts are downloaded with the assistance of a font provider. Il s’agit d’un fournisseur de contenu spécialisé qui gère le téléchargement et la mise en cache des polices dans toutes les applications sur l’appareil.This is a specialized content provider that manages the downloading and caching of fonts to all applications on the device. Android 8,0 comprend un fournisseur de polices pour télécharger des polices à partir du référentiel de polices Google.Android 8.0 includes a font provider to download fonts from the Google Font Repository. Ce fournisseur de polices par défaut est reporté au niveau d’API 14 avec la bibliothèque de prise en charge Android V26.This default font provider is backported to API level 14 with the Android Support Library v26.

Quand une application effectue une requête pour une police, le fournisseur de polices vérifie d’abord si la police est déjà sur l’appareil.When an app makes a request for a font, the font provider will first check to see if the font is already on the device. Si ce n’est pas le cas, il tentera de télécharger la police.If not, it will then attempt to download the font. Si la police ne peut pas être téléchargée, Android utilise la police système par défaut.If the font cannot be downloaded, then Android will use the default system font. Une fois la police téléchargée, elle est disponible pour toutes les applications sur l’appareil, et pas seulement pour l’application qui a effectué la demande initiale.Once the font has been downloaded, it is available to all applications on the device, not just the app that made the initial request.

Lorsqu’une demande est effectuée pour télécharger une police, l’application n’interroge pas directement le fournisseur de polices.When a request is made to download a font, the app does not directly query the font provider. Au lieu de cela, les applications utiliseront une instance de l' FontsContract API (ou FontsContractCompat si la bibliothèque de prise en charge 26 est utilisée).Instead, apps will use an instance of the FontsContract API (or the FontsContractCompat if the Support Library 26 is being used).

Android 8,0 prend en charge le téléchargement des polices de deux manières différentes :Android 8.0 supports downloading fonts in two different ways:

  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.Declare Downloadable Fonts as a Resource – An app may declare downloadable fonts to Android via XML resource files. Ces fichiers contiennent toutes les métadonnées dont Android a besoin pour télécharger de manière asynchrone les polices lorsque l’application démarre et les met en cache sur l’appareil.These files will contain all of the meta-data that Android needs to asynchronously download the fonts when the app starts and cache them on the device.
  2. Par programmation – Les API dans le niveau d’API Android 26 permettent à une application de télécharger les polices par programme, pendant que l’application est en cours d’exécution.Programmatically – APIs in Android API level 26 allow an application to download the fonts programmatically, while the application is running. Les applications créent un FontRequest objet pour une police donnée et passent cet objet à la FontsContract classe.Apps will create a FontRequest object for a given font, and pass this object to the FontsContract class. FontsContractPrend le FontRequest et récupère la police d’un fournisseur de polices.The FontsContract takes the FontRequest and retrieves the font from a font provider. Android télécharge la police en mode synchrone.Android will synchronously download the font. Un exemple de création d’un FontRequest sera présenté plus loin dans ce guide.An example of creating a FontRequest will be shown later in this guide.

Quelle que soit l’approche utilisée, les fichiers de ressources qui doivent être ajoutés à l’application Xamarin. Android avant le téléchargement des polices.Regardless of which approach is used, resources files that must be added to the Xamarin.Android application before fonts can be downloaded. 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.First, the font(s) must be declared in an XML file in the Resources/font directory as part of a font family. Cet extrait de code est un exemple de téléchargement de polices à partir du regroupement Open source Google polices à l’aide du fournisseur de polices par défaut fourni avec Android 8,0 (ou la bibliothèque de prise en charge V26) :This snippet is an example of how to download fonts from the Google Fonts Open Source collection using the default font provider that comes with Android 8.0 (or Support Library 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' font-family élément contient les attributs suivants, qui déclarent les informations requises par Android pour télécharger les polices :The font-family element contains the following attributes, declaring the information that Android requires to download the fonts:

  1. fontProviderAuthority – Autorité du fournisseur de polices à utiliser pour la requête.fontProviderAuthority – The authority of the Font Provider to be used for the request.
  2. fontPackage – Package pour le fournisseur de polices à utiliser pour la requête.fontPackage – The package for the Font Provider to be used for the request. Cela permet de vérifier l’identité du fournisseur.This is used to verify the identity of the provider.
  3. fontQuery – Il s’agit d’une chaîne qui aide le fournisseur de polices à localiser la police demandée.fontQuery – This is a string that will help the font provider locate the requested font. Les détails sur la requête de police sont spécifiques au fournisseur de polices.Details on the font query are specific to the font provider. La QueryBuilder classe de l’exemple d’application de polices téléchargeables fournit des informations sur le format de requête pour les polices de la collection Open source Google Fonts.The QueryBuilder class in the Downloadable Fonts sample app provides some information on the query format for fonts from the Google Fonts Open Source Collection.
  4. fontProviderCerts – Tableau de ressources avec la liste des jeux de hachages pour les certificats avec lesquels le fournisseur doit être signé.fontProviderCerts – A resource array with the list of sets of hashes for the certificates that the provider should be signed with.

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.Once the fonts are defined, it may be necessary to provide information about the font certificates involved with the download.

Certificats de policeFont Certificates

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.If the font provider is not preinstalled on the device, or if the app is using the Xamarin.Android.Support.Compat library, Android requires the security certificates of the font provider. Ces certificats sont listés dans un fichier de ressources de tableau qui est conservé dans le répertoire des ressources/valeurs .These certificates will be listed in an array resource file that is kept in Resources/values directory.

Par exemple, le code XML suivant est nommé Resources/values/fonts_cert. xml et stocke les certificats pour le fournisseur de polices Google :For example, the following XML is named Resources/values/fonts_cert.xml and stores the certificates for the Google font provider:

<?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>

Lorsque ces fichiers de ressources sont en place, l’application peut télécharger les polices.With these resource files in place, the app is capable of downloading the fonts.

Déclaration des polices téléchargeables en tant que ressourcesDeclaring Downloadable Fonts as Resources

En répertoriant les polices téléchargeables dans fichier AndroidManifest. xml, Android télécharge les polices de manière asynchrone lors du premier démarrage de l’application.By listing the downloadable fonts in the AndroidManifest.XML, Android will asynchronously download the fonts when the app first starts. Les polices elles-mêmes sont répertoriées dans un fichier de ressources de tableau, comme celle-ci :The font's themselves are listed in an array resource file, similar to this one:

<?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 fichier AndroidManifest. xml en ajoutant meta-data en tant qu’enfant de l' application élément.To download these fonts, they have to be declared in AndroidManifest.XML by adding meta-data as a child of the application element. Par exemple, si les polices téléchargeables sont déclarées dans un fichier de ressources au niveau des ressources/valeurs/downloadable_fonts. xml, cet extrait de code doit être ajouté au manifeste :For example, if the downloadable fonts are declared in a resource file at Resources/values/downloadable_fonts.xml, then this snippet would have to be added to the manifest:

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

Téléchargement d’une police avec les API de policeDownloading a Font with the Font APIs

Il est possible de télécharger une police par programmation en instanciant un FontRequest objet et en le passant à la FontContractCompat.RequestFont méthode.It is possible to programmatically download a font by instantiating a FontRequest object and passing that to the FontContractCompat.RequestFont method. La FontContractCompat.RequestFont méthode vérifie d’abord si la police existe sur l’appareil, puis, si nécessaire, interroge de manière asynchrone le fournisseur de polices et tente de télécharger la police de l’application.The FontContractCompat.RequestFont method will first check to see if the font exists on the device, and then if necessary will asynchronously query the font provider and try to download the font for the app. Si FontRequest le n’est pas en mesure de télécharger la police, Android utilise la police système par défaut.If FontRequest is unable to download the font, then Android will use the default system font.

Un FontRequest objet contient des informations qui seront utilisées par le fournisseur de polices pour rechercher et télécharger une police.A FontRequest object contains information that will be used by the font provider to locate and download a font. Un FontRequest requiert quatre éléments d’information :A FontRequest requires four pieces of information:

  1. Autorité du fournisseur de polices – Autorité du fournisseur de polices à utiliser pour la requête.Font Provider Authority – The authority of the Font Provider to be used for the request.
  2. Package – de polices Package pour le fournisseur de polices à utiliser pour la requête.Font Package – The package for the Font Provider to be used for the request. Cela permet de vérifier l’identité du fournisseur.This is used to verify the identity of the provider.
  3. Requête – de police Il s’agit d’une chaîne qui aide le fournisseur de polices à localiser la police demandée.Font Query – This is a string that will help the font provider locate the requested font. Les détails sur la requête de police sont spécifiques au fournisseur de polices.Details on the font query are specific to the font provider. Les détails de la chaîne sont spécifiques au fournisseur de polices.The details of the string are specific to the font provider. La QueryBuilder classe de l’exemple d’application de polices téléchargeables fournit des informations sur le format de requête pour les polices de la collection Open source Google Fonts.The QueryBuilder class in the Downloadable Fonts sample app provides some information on the query format for fonts from the Google Fonts Open Source Collection.
  4. Certificats du fournisseur de polices – Tableau de ressources avec la liste des jeux de hachages pour les certificats avec lesquels le fournisseur doit être signé.Font Provider Certificates – A resource array with the list of sets of hashes for the certificates the provider should be signed with.

Cet extrait de code est un exemple d’instanciation d’un nouvel FontRequest objet :This snippet is an example of instantiating a new FontRequest object:

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 FontToDownload code précédent se trouve une requête qui permet d’obtenir la police de la collection Open source Google polices.In the previous snippet FontToDownload is a query that will help the font from the Google Fonts Open Source collection.

Avant de passer FontRequest à la FontContractCompat.RequestFont méthode, il existe deux objets qui doivent être créés :Before passing the FontRequest to the FontContractCompat.RequestFont method, there are two objects that must be created:

  • FontsContractCompat.FontRequestCallback–Il s’agit d’une classe abstraite qui doit être étendue.FontsContractCompat.FontRequestCallback – This is an abstract class which must be extended. Il s’agit d’un rappel qui sera appelé lorsque RequestFont est terminé.It is a callback that will be invoked when RequestFont is finished. Une application Xamarin. Android doit effectuer une sous-classe FontsContractCompat.FontRequestCallback et remplacer la OnTypefaceRequestFailed et OnTypefaceRetrieved , en fournissant les actions à entreprendre lorsque le téléchargement échoue ou réussit respectivement.A Xamarin.Android app must subclass FontsContractCompat.FontRequestCallback and override the OnTypefaceRequestFailed and OnTypefaceRetrieved, providing the actions to be taken when the download fails or succeeds respectively.
  • Handler–Il s’agit d’un Handler qui sera utilisé par RequestFont pour télécharger la police sur un thread, si nécessaire.Handler – This is a Handler which will be used by RequestFont to download the font on a thread, if necessary. Les polices ne doivent pas être téléchargées sur le thread d’interface utilisateur.Fonts should not be downloaded on the UI thread.

Cet extrait de code est un exemple de classe C# qui télécharge de manière asynchrone une police de la collection Open source Google polices.This snippet is an example of a C# class that will asynchronously download a font from Google Fonts Open Source collection. Il implémente l' FontRequestCallback interface et déclenche un événement C# lorsque FontRequest est terminé.It implements the FontRequestCallback interface, and raises a C# event when FontRequest has finished.

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 cette application d’assistance, une nouvelle FontDownloadHelper est créée et un gestionnaire d’événements est affecté :To use this helper, a new FontDownloadHelper is created, and an event handler is assigned:

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éSummary

Ce guide a présenté les nouvelles API d’Android 8,0 pour prendre en charge les polices et les polices téléchargeables en tant que ressources.This guide discussed the new APIs in Android 8.0 to support downloadable fonts and fonts as resources. Il a expliqué comment incorporer des polices existantes dans un APK et comment les utiliser dans une disposition.It discussed how to embed existing fonts in an APK and to use them in a layout. Elle a également expliqué comment Android 8,0 prend en charge le téléchargement des polices d’un fournisseur de polices, par programmation ou en déclarant les métadonnées de police dans les fichiers de ressources.It also discussed how Android 8.0 supports downloading fonts from a font provider, either programmatically or by declaring the font meta-data in resource files.