Comment changer la policeFamille de TextView dans Android

Je voudrais donc changer le android:fontFamilydans Android, mais je ne vois aucune police prédéfinie dans Android. Comment sélectionner l'un des paramètres prédéfinis? Je n'ai pas vraiment besoin de définir mon propre TypeFace mais tout ce dont j'ai besoin est quelque chose de différent de ce qu'il montre en ce moment.

<TextView
    android:id="@+id/HeaderText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    android:layout_marginTop="52dp"
    android:gravity="center"
    android:text="CallerBlocker"
    android:textSize="40dp"
    android:fontFamily="Arial"
 />

Il semble que ce que j'ai fait là-haut ne fonctionnera pas vraiment! BTW android:fontFamily="Arial"était une tentative stupide!

Depuis Android 4.1 / 4.2 / 5.0, les familles de polices Roboto suivantes sont disponibles:

android:fontFamily="sans-serif"           // roboto regular
android:fontFamily="sans-serif-light"     // roboto light
android:fontFamily="sans-serif-condensed" // roboto condensed
android:fontFamily="sans-serif-black"     // roboto black
android:fontFamily="sans-serif-thin"      // roboto thin (android 4.2)
android:fontFamily="sans-serif-medium"    // roboto medium (android 5.0)

en combinaison avec

android:textStyle="normal|bold|italic"

ces 16 variantes sont possibles:

• Roboto regular
• Roboto italic
• Roboto bold
• Roboto bold italic
• Roboto-Light
• Roboto-Light italic
• Roboto-Thin
• Roboto-Thin italic
• Roboto-Condensed
• Roboto-Condensed italic
• Roboto-Condensed bold
• Roboto-Condensed bold italic
• Roboto-Black
• Roboto-Black italic
• Roboto-Medium
• Roboto-Medium italic

fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="font_family_light">sans-serif-light</string>
    <string name="font_family_medium">sans-serif-medium</string>
    <string name="font_family_regular">sans-serif</string>
    <string name="font_family_condensed">sans-serif-condensed</string>
    <string name="font_family_black">sans-serif-black</string>
    <string name="font_family_thin">sans-serif-thin</string>
</resources>

Voici la façon de définir la police par programme:

TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
            "fonts/epimodem.ttf");
tv.setTypeface(face);

placez le fichier de police dans votre dossier d'actifs. Dans mon cas, j'ai créé un sous-répertoire appelé polices.

EDIT: Si vous vous demandez où est votre dossier d'actifs, voyez cette question

À partir d' Android-Studio 3.0, il est très facile de changer la famille de polices

En utilisant la bibliothèque de support 26, il fonctionnera sur les appareils exécutant l'API Android version 16 et supérieure

Créez un dossier fontsous le resrépertoire. Téléchargez la police que vous voulez et collez-la dans le fontdossier. La structure devrait être quelque chose comme ci-dessous

Remarque: À partir de la bibliothèque de support Android 26.0, vous devez déclarer les deux ensembles d'attributs (android: et app:) pour vous assurer que vos polices se chargent sur les appareils exécutant Api 26 ou une version antérieure.

Vous pouvez maintenant changer la police de la mise en page à l' aide

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/dancing_script"
app:fontFamily="@font/dancing_script"/>

Pour changer Programatically

 Typeface typeface = getResources().getFont(R.font.myfont);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
 textView.setTypeface(typeface);  

Pour changer la police à l'aide de styles.xml, créez un style

 <style name="Regular">
        <item name="android:fontFamily">@font/dancing_script</item>
        <item name="fontFamily">@font/dancing_script</item>
        <item name="android:textStyle">normal</item>
 </style>

et appliquer ce style à TextView

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    style="@style/Regular"/>

vous pouvez également créer votre propre famille de polices

- Cliquez avec le bouton droit sur le dossier de polices et accédez à Nouveau> Fichier de ressources de polices . La fenêtre Nouveau fichier de ressources apparaît.

- Saisissez le nom du fichier , puis cliquez sur OK . La nouvelle ressource de police XML s'ouvre dans l'éditeur.

Écrivez votre propre famille de polices ici, par exemple

<font-family xmlns:android="http://schemas.android.com/apk/res/android">
    <font
        android:fontStyle="normal"
        android:fontWeight="400"
        android:font="@font/lobster_regular" />
    <font
        android:fontStyle="italic"
        android:fontWeight="400"
        android:font="@font/lobster_italic" />
</font-family>

il s'agit simplement d'un mappage d'un fontStyle et d'un fontWeight spécifiques à la ressource de police qui sera utilisée pour rendre cette variante spécifique. Les valeurs valides pour fontStyle sont normales ou italiques; et fontWeight est conforme à la spécification CSS de poids de police

1. Pour changer la famille de polices dans la mise en page, vous pouvez écrire

 <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:fontFamily="@font/lobster"/>

2. Pour changer par programme

 Typeface typeface = getResources().getFont(R.font.lobster);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
 textView.setTypeface(typeface);  

Pour changer la police de l'application entière Ajoutez ces deux lignes dans AppTheme

 <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
     <item name="android:fontFamily">@font/your_font</item>
     <item name="fontFamily">@font/your_font</item>
  </style>

Voir la documentation , le didacticiel sur les polices personnalisées Android pour plus d'informations

J'ai dû analyser /system/etc/fonts.xmldans un projet récent. Voici les familles de polices actuelles de Lollipop:

╔════╦════════════════════════════╦═════════════════════════════╗
║    ║ FONT FAMILY                ║ TTF FILE                    ║
╠════╬════════════════════════════╬═════════════════════════════╣
║  1 ║ casual                     ║ ComingSoon.ttf              ║
║  2 ║ cursive                    ║ DancingScript-Regular.ttf   ║
║  3 ║ monospace                  ║ DroidSansMono.ttf           ║
║  4 ║ sans-serif                 ║ Roboto-Regular.ttf          ║
║  5 ║ sans-serif-black           ║ Roboto-Black.ttf            ║
║  6 ║ sans-serif-condensed       ║ RobotoCondensed-Regular.ttf ║
║  7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf   ║
║  8 ║ sans-serif-light           ║ Roboto-Light.ttf            ║
║  9 ║ sans-serif-medium          ║ Roboto-Medium.ttf           ║
║ 10 ║ sans-serif-smallcaps       ║ CarroisGothicSC-Regular.ttf ║
║ 11 ║ sans-serif-thin            ║ Roboto-Thin.ttf             ║
║ 12 ║ serif                      ║ NotoSerif-Regular.ttf       ║
║ 13 ║ serif-monospace            ║ CutiveMono.ttf              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Voici l'analyseur (basé sur FontListParser ):

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.util.Xml;

/**
 * Helper class to get the current font families on an Android device.</p>
 * 
 * Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>
 */
public final class FontListParser {

    private static final File FONTS_XML = new File("/system/etc/fonts.xml");

    private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");

    public static List<SystemFont> getSystemFonts() throws Exception {
        String fontsXml;
        if (FONTS_XML.exists()) {
            fontsXml = FONTS_XML.getAbsolutePath();
        } else if (SYSTEM_FONTS_XML.exists()) {
            fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();
        } else {
            throw new RuntimeException("fonts.xml does not exist on this system");
        }
        Config parser = parse(new FileInputStream(fontsXml));
        List<SystemFont> fonts = new ArrayList<>();

        for (Family family : parser.families) {
            if (family.name != null) {
                Font font = null;
                for (Font f : family.fonts) {
                    font = f;
                    if (f.weight == 400) {
                        break;
                    }
                }
                SystemFont systemFont = new SystemFont(family.name, font.fontName);
                if (fonts.contains(systemFont)) {
                    continue;
                }
                fonts.add(new SystemFont(family.name, font.fontName));
            }
        }

        for (Alias alias : parser.aliases) {
            if (alias.name == null || alias.toName == null || alias.weight == 0) {
                continue;
            }
            for (Family family : parser.families) {
                if (family.name == null || !family.name.equals(alias.toName)) {
                    continue;
                }
                for (Font font : family.fonts) {
                    if (font.weight == alias.weight) {
                        fonts.add(new SystemFont(alias.name, font.fontName));
                        break;
                    }
                }
            }
        }

        if (fonts.isEmpty()) {
            throw new Exception("No system fonts found.");
        }

        Collections.sort(fonts, new Comparator<SystemFont>() {

            @Override
            public int compare(SystemFont font1, SystemFont font2) {
                return font1.name.compareToIgnoreCase(font2.name);
            }

        });

        return fonts;
    }

    public static List<SystemFont> safelyGetSystemFonts() {
        try {
            return getSystemFonts();
        } catch (Exception e) {
            String[][] defaultSystemFonts = {
                    {
                            "cursive", "DancingScript-Regular.ttf"
                    }, {
                            "monospace", "DroidSansMono.ttf"
                    }, {
                            "sans-serif", "Roboto-Regular.ttf"
                    }, {
                            "sans-serif-light", "Roboto-Light.ttf"
                    }, {
                            "sans-serif-medium", "Roboto-Medium.ttf"
                    }, {
                            "sans-serif-black", "Roboto-Black.ttf"
                    }, {
                            "sans-serif-condensed", "RobotoCondensed-Regular.ttf"
                    }, {
                            "sans-serif-thin", "Roboto-Thin.ttf"
                    }, {
                            "serif", "NotoSerif-Regular.ttf"
                    }
            };
            List<SystemFont> fonts = new ArrayList<>();
            for (String[] names : defaultSystemFonts) {
                File file = new File("/system/fonts", names[1]);
                if (file.exists()) {
                    fonts.add(new SystemFont(names[0], file.getAbsolutePath()));
                }
            }
            return fonts;
        }
    }

    /* Parse fallback list (no names) */
    public static Config parse(InputStream in) throws XmlPullParserException, IOException {
        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setInput(in, null);
            parser.nextTag();
            return readFamilies(parser);
        } finally {
            in.close();
        }
    }

    private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {
        Alias alias = new Alias();
        alias.name = parser.getAttributeValue(null, "name");
        alias.toName = parser.getAttributeValue(null, "to");
        String weightStr = parser.getAttributeValue(null, "weight");
        if (weightStr == null) {
            alias.weight = 0;
        } else {
            alias.weight = Integer.parseInt(weightStr);
        }
        skip(parser); // alias tag is empty, ignore any contents and consume end tag
        return alias;
    }

    private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        Config config = new Config();
        parser.require(XmlPullParser.START_TAG, null, "familyset");
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            if (parser.getName().equals("family")) {
                config.families.add(readFamily(parser));
            } else if (parser.getName().equals("alias")) {
                config.aliases.add(readAlias(parser));
            } else {
                skip(parser);
            }
        }
        return config;
    }

    private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        String name = parser.getAttributeValue(null, "name");
        String lang = parser.getAttributeValue(null, "lang");
        String variant = parser.getAttributeValue(null, "variant");
        List<Font> fonts = new ArrayList<Font>();
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String tag = parser.getName();
            if (tag.equals("font")) {
                String weightStr = parser.getAttributeValue(null, "weight");
                int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);
                boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));
                String filename = parser.nextText();
                String fullFilename = "/system/fonts/" + filename;
                fonts.add(new Font(fullFilename, weight, isItalic));
            } else {
                skip(parser);
            }
        }
        return new Family(name, fonts, lang, variant);
    }

    private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
        int depth = 1;
        while (depth > 0) {
            switch (parser.next()) {
            case XmlPullParser.START_TAG:
                depth++;
                break;
            case XmlPullParser.END_TAG:
                depth--;
                break;
            }
        }
    }

    private FontListParser() {

    }

    public static class Alias {

        public String name;

        public String toName;

        public int weight;
    }

    public static class Config {

        public List<Alias> aliases;

        public List<Family> families;

        Config() {
            families = new ArrayList<Family>();
            aliases = new ArrayList<Alias>();
        }

    }

    public static class Family {

        public List<Font> fonts;

        public String lang;

        public String name;

        public String variant;

        public Family(String name, List<Font> fonts, String lang, String variant) {
            this.name = name;
            this.fonts = fonts;
            this.lang = lang;
            this.variant = variant;
        }

    }

    public static class Font {

        public String fontName;

        public boolean isItalic;

        public int weight;

        Font(String fontName, int weight, boolean isItalic) {
            this.fontName = fontName;
            this.weight = weight;
            this.isItalic = isItalic;
        }

    }

    public static class SystemFont {

        public String name;

        public String path;

        public SystemFont(String name, String path) {
            this.name = name;
            this.path = path;
        }

    }
}

N'hésitez pas à utiliser la classe ci-dessus dans votre projet. Par exemple, vous pouvez donner à vos utilisateurs une sélection de familles de polices et définir la police de caractères en fonction de leurs préférences.

Un petit exemple incomplet:

final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();
String[] items = new String[fonts.size()];
for (int i = 0; i < fonts.size(); i++) {
    items[i] = fonts.get(i).name;
}

new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        FontListParser.SystemFont selectedFont = fonts.get(which);
        // TODO: do something with the font
        Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();
    }
}).show();

Android ne vous permet pas de définir des polices personnalisées à partir de la disposition XML. Au lieu de cela, vous devez regrouper le fichier de police spécifique dans le dossier des ressources de votre application et le définir par programme. Quelque chose comme:

TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);

Notez que vous ne pouvez exécuter ce code qu'après l'appel de setContentView (). De plus, seules certaines polices sont prises en charge par Android et doivent être au format .ttf (TrueType)ou .otf (OpenType). Même dans ce cas, certaines polices peuvent ne pas fonctionner.

Il s'agit d'une police qui fonctionne définitivement sur Android, et vous pouvez l'utiliser pour confirmer que votre code fonctionne au cas où votre fichier de police ne serait pas pris en charge par Android.

Mise à jour Android O: Ceci est désormais possible avec XML dans Android O , sur la base des commentaires de Roger.

Pour définir Roboto par programme:

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));

C'est la même chose que android:typeface.

les polices intégrées sont:

• Ordinaire
• sans
• empattement
• monospace

Voir android: police de caractères .

Si vous le souhaitez par programme, vous pouvez utiliser

label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);

Où SANS_SERIFvous pouvez utiliser:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Et où ITALICvous pouvez utiliser:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Tout est indiqué sur les développeurs Android

J'utilise une excellente bibliothèque Calligraphy de Chris Jenx conçue pour vous permettre d'utiliser des polices personnalisées dans votre application Android. Essaie!

Ce que vous voulez n'est pas possible. Vous devez définir TypeFacevotre code.

Dans XMLce que vous pouvez faire,

android:typeface="sans" | "serif" | "monospace"

à part cela, vous ne pouvez pas jouer beaucoup avec les polices en XML. :)

Car Arialvous devez définir le type de visage dans votre code.

Un moyen simple de gérer les polices serait de les déclarer via des ressources, en tant que telles:

<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>

<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>

<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

Ceci est basé sur le code source ici et ici

Dynamiquement, vous pouvez définir la famille de polices similaire à android: fontFamily en xml en utilisant ceci,

For Custom font:

 TextView tv = ((TextView) v.findViewById(R.id.select_item_title));
 Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf"); 
 tv.setTypeface(face);

For Default font:

 tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));

Il s'agit de la liste des familles de polices par défaut utilisées, utilisez tout cela en remplaçant la chaîne de guillemets doubles "sans-serif-medium"

FONT FAMILY                    TTF FILE                    

1  casual                      ComingSoon.ttf              
2  cursive                     DancingScript-Regular.ttf   
3  monospace                   DroidSansMono.ttf           
4  sans-serif                  Roboto-Regular.ttf          
5  sans-serif-black            Roboto-Black.ttf            
6  sans-serif-condensed        RobotoCondensed-Regular.ttf 
7  sans-serif-condensed-light  RobotoCondensed-Light.ttf   
8  sans-serif-light            Roboto-Light.ttf            
9  sans-serif-medium           Roboto-Medium.ttf           
10  sans-serif-smallcaps       CarroisGothicSC-Regular.ttf 
11  sans-serif-thin            Roboto-Thin.ttf             
12  serif                      NotoSerif-Regular.ttf       
13  serif-monospace            CutiveMono.ttf              

"mycustomfont.ttf" est le fichier ttf. Le chemin sera dans src / assets / fonts / mycustomfont.ttf , vous pouvez en savoir plus sur la police par défaut dans cette famille de polices par défaut

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

définissez facilement la police sur n'importe quelle vue de texte à partir du répertoire res> font par programmation

Je pense que je suis trop tard, mais cette solution peut-être utile pour les autres. Pour utiliser une police personnalisée, placez votre fichier de police dans votre répertoire de polices.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));

Avec quelques essais et erreurs, j'ai appris ce qui suit.

Dans le * .xml, vous pouvez combiner les polices de base avec les fonctions suivantes, pas seulement avec la police de caractères:

 android:fontFamily="serif" 
 android:textStyle="italic"

Avec ces deux styles, il n'était pas nécessaire d'utiliser la police de caractères dans les autres cas. La gamme de combinaisons est beaucoup plus large avec fontfamily & textStyle.

La valeur valide d'android: fontFamily est définie dans /system/etc/system_fonts.xml(4.x) ou /system/etc/fonts.xml(5.x). Mais le fabricant du périphérique peut le modifier, de sorte que la police réelle utilisée en définissant la valeur fontFamily dépend du fichier mentionné ci-dessus du périphérique spécifié.

Dans AOSP, la police Arial est valide mais doit être définie en utilisant "arial" et non "Arial", par exemple android: fontFamily = "arial" . Jetez un coup d'œil sur le fichier system_fonts.xml de Kitkat

    <family>
    <nameset>
        <name>sans-serif</name>
        <name>arial</name>
        <name>helvetica</name>
        <name>tahoma</name>
        <name>verdana</name>
    </nameset>
    <fileset>
        <file>Roboto-Regular.ttf</file>
        <file>Roboto-Bold.ttf</file>
        <file>Roboto-Italic.ttf</file>
        <file>Roboto-BoldItalic.ttf</file>
    </fileset>
</family>

//////////////////////////////////////////////////// //////////////////////////

Il y a trois xml-attributs pertinents pour la définition d' une "police" dans layout-- android: fontFamily , android: caractères et Android: TEXTSTYLE . La combinaison de "fontFamily" et "textStyle" ou "typeface" et "textStyle" peut être utilisée pour changer l'apparence de la police dans le texte, donc elle est utilisée seule. Extrait de code dans TextView.java comme ceci:

    private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {
    Typeface tf = null;
    if (familyName != null) {
        tf = Typeface.create(familyName, styleIndex);
        if (tf != null) {
            setTypeface(tf);
            return;
        }
    }
    switch (typefaceIndex) {
        case SANS:
            tf = Typeface.SANS_SERIF;
            break;

        case SERIF:
            tf = Typeface.SERIF;
            break;

        case MONOSPACE:
            tf = Typeface.MONOSPACE;
            break;
    }
    setTypeface(tf, styleIndex);
}


    public void setTypeface(Typeface tf, int style) {
    if (style > 0) {
        if (tf == null) {
            tf = Typeface.defaultFromStyle(style);
        } else {
            tf = Typeface.create(tf, style);
        }

        setTypeface(tf);
        // now compute what (if any) algorithmic styling is needed
        int typefaceStyle = tf != null ? tf.getStyle() : 0;
        int need = style & ~typefaceStyle;
        mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);
        mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);
    } else {
        mTextPaint.setFakeBoldText(false);
        mTextPaint.setTextSkewX(0);
        setTypeface(tf);
    }
}

D'après le code, nous pouvons voir:

1. si "fontFamily" est défini, alors la "police" sera ignorée.
2. "typeface" a des valeurs valides standard et limitées. En fait, les valeurs sont "normales" "sans" "serif" et "monospace", elles peuvent être trouvées dans system_fonts.xml (4.x) ou fonts.xml (5.x). En fait, "normal" et "sans" sont la police par défaut du système.
3. "fontFamily" peut être utilisé pour définir toutes les polices de polices intégrées, tandis que "fonteface" ne fournit que les polices typiques de "sans-serif" "serif" et "monospace" (les trois principales catégories de types de polices dans le monde) .
4. Lorsque nous définissons uniquement "textStyle", nous définissons en fait la police par défaut et le style spécifié. Les valeurs effectives sont "normal" "gras" "italique" et "gras | italique".

Voici une méthode plus simple qui peut fonctionner dans certains cas. Le principe est d'ajouter un TextVview non visible dans votre mise en page XML et d' obtenir son typeFace dans le code java.

La disposition dans le fichier xml:

 <TextView
        android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:fontFamily="sans-serif-thin"
        android:id="@+id/textViewDescription"/>

Et le code java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Cela a fonctionné pour moi (dans un TextSwitcher par exemple).

Essaye ça:

TextView textview = (TextView) findViewById(R.id.textview);

Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);

Vous pouvez également le faire en ajoutant un dossier de polices sous le répertoire res comme ci-dessous.

Sélectionnez ensuite Police comme type de ressource.

Vous pouvez trouver des polices disponibles sur https://www.1001fonts.com/ , puis extraire les fichiers TTF dans ce répertoire de polices.

Enfin, modifiez simplement le fichier XML qui contient votre affichage de texte en ajoutant android: fontFamily: "@ font / urfontfilename"

Une façon simple consiste à ajouter la police souhaitée dans le projet.

Allez dans Fichier-> Nouveau-> Nouveau répertoire de ressources Sélectionnez la police

Cela créera un nouveau répertoire, une police , dans vos ressources.

Téléchargez votre police (.ttf) . J'utilise https://fonts.google.com pour les mêmes

Ajoutez cela à votre dossier de polices puis utilisez-les dans le XML ou par programme.

XML -

<TextView 
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/your_font"/>

Par programmation -

 Typeface typeface = getResources().getFont(R.font.your_font);
 textView.setTypeface(typeface); 

<string name="font_family_display_4_material">sans-serif-light</string>
<string name="font_family_display_3_material">sans-serif</string>
<string name="font_family_display_2_material">sans-serif</string>
<string name="font_family_display_1_material">sans-serif</string>
<string name="font_family_headline_material">sans-serif</string>
<string name="font_family_title_material">sans-serif-medium</string>
<string name="font_family_subhead_material">sans-serif</string>
<string name="font_family_menu_material">sans-serif</string>
<string name="font_family_body_2_material">sans-serif-medium</string>
<string name="font_family_body_1_material">sans-serif</string>
<string name="font_family_caption_material">sans-serif</string>
<string name="font_family_button_material">sans-serif-medium</string>

Si vous souhaitez utiliser un TextView dans de nombreux endroits avec la même famille de polices, étendez la classe TextView et définissez votre police comme ceci: -

public class ProximaNovaTextView extends TextView {

    public ProximaNovaTextView(Context context) {
        super(context);

        applyCustomFont(context);
    }

    public ProximaNovaTextView(Context context, AttributeSet attrs) {
        super(context, attrs);

        applyCustomFont(context);
    }

    public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {
       super(context, attrs, defStyle);

       applyCustomFont(context);
    } 

    private void applyCustomFont(Context context) {
        Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);
        setTypeface(customFont);
    }
}

Et puis utilisez cette classe personnalisée en xml pour le TextView comme ceci: -

   <com.myapp.customview.ProximaNovaTextView
        android:id="@+id/feed_list_item_name_tv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="14sp"
        />

Si vous utilisez Android Studio 3.5+, le changement de police est super simple. Sélectionnez le widget de texte en mode Création et cochez fontFamily dans la fenêtre d'attributs. La liste déroulante des valeurs contient toutes les polices disponibles à partir desquelles vous pouvez en sélectionner une. Si vous recherchez des polices Google, cliquez sur l'option Plus de polices.

Fenêtre d'attribut

Google Fonts

Je veux juste mentionner que l'enfer avec les polices dans Android est sur le point de se terminer, car cette année sur Google IO, nous avons finalement obtenu ceci -> https://developer.android.com/preview/features/working-with-fonts. html

Maintenant, il y a un nouveau type de ressource une police et vous pouvez placer toutes vos polices d'application dans le dossier res / fonts et y accéder ensuite avec R.font.my_custom_font, tout comme vous pouvez accéder aux valeurs de chaîne res, aux valeurs res dessinables , etc. Vous avez même la chance pour créer un fichier xml font-face , qui va être défini avec vos polices personnalisées (à propos de l'italique, du gras et du soulignement attr).

Lisez le lien ci-dessus pour plus d'informations. Voyons voir le soutien.

Il y a une belle bibliothèque disponible pour cela

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'

La nouvelle ressource de police permet de définir directement en fontutilisant

android:fontFamily="@font/my_font_in_font_folder"

Vous définissez le style res/layout/value/style.xml comme ça:

<style name="boldText">
    <item name="android:textStyle">bold|italic</item>
    <item name="android:textColor">#FFFFFF</item>
</style>

et pour utiliser ce style dans l' main.xmlutilisation des fichiers:

style="@style/boldText"

Pour android-studio 3 et supérieur, vous pouvez utiliser ce style, puis tout textView les changements de police dans l'application.

créez ce style dans votre style.xml:

<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="android:Widget.TextView">
        <item name="android:fontFamily">@font/your_custom_font</item>
</style>

Ensuite, utilisez-le dans votre thème:

<!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <item name="android:textViewStyle">@style/defaultTextViewStyle</item>
    </style>

La façon la plus simple d'ajouter la police par programme à un TextView est, tout d'abord, d'ajouter le fichier de police dans votre dossier Assets dans le projet. Par exemple, votre chemin de police ressemble à ceci:assets/fonts/my_font.otf

Et ajoutez-le à une TextView en tant que:

Kotlin

val font_path = "fonts/my_font.otf"  

myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)

textView.typeface = myTypeface

Java

String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);

Ici, vous pouvez voir toutes les valeurs disponibles de fontFamily et les noms des fichiers de polices correspondants (ce fichier est utilisé dans Android 5.0+). Dans un appareil mobile, vous pouvez le trouver dans:

/system/etc/fonts.xml (pour 5.0+)

(Pour Android 4.4 et inférieur utilisant cette version, mais je pense que cela fonts.xmla un format plus clair et facile à comprendre.)

Par exemple,

    <!-- first font is default -->
20    <family name="sans-serif">
21        <font weight="100" style="normal">Roboto-Thin.ttf</font>
22        <font weight="100" style="italic">Roboto-ThinItalic.ttf</font>
23        <font weight="300" style="normal">Roboto-Light.ttf</font>
24        <font weight="300" style="italic">Roboto-LightItalic.ttf</font>
25        <font weight="400" style="normal">Roboto-Regular.ttf</font>
26        <font weight="400" style="italic">Roboto-Italic.ttf</font>
27        <font weight="500" style="normal">Roboto-Medium.ttf</font>
28        <font weight="500" style="italic">Roboto-MediumItalic.ttf</font>
29        <font weight="900" style="normal">Roboto-Black.ttf</font>
30        <font weight="900" style="italic">Roboto-BlackItalic.ttf</font>
31        <font weight="700" style="normal">Roboto-Bold.ttf</font>
32        <font weight="700" style="italic">Roboto-BoldItalic.ttf</font>
33    </family>

L'attribut name name="sans-serif"de familytag a défini la valeur que vous pouvez utiliser dans android: fontFamily.

La fontbalise définit les fichiers de police correspondants.

Dans ce cas, vous pouvez ignorer la source sous <!-- fallback fonts -->, elle utilise pour la logique de secours des polices.