Comment changer la policeFamille de TextView dans Android


740

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!


Réponses:


1661

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)

entrez la description de l'image ici

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>

17
N'oubliez pas ceci: android: fontFamily = "sans-serif-thin" // roboto thin
Sam Lu

6
J'ai vu une variante appelée "black small caps" dans le livre de spécimens de roboto , mais je n'arrive pas à l'utiliser. L'utilisation ne android:fontFamily="sans-serif-black-small-caps"fonctionne pas. Est-ce que quelqu'un sait?
tbruyelle

3
je ne suis pas en mesure de trouver une de ces famille de polices ce que vous avez tapé ici. je ne peux pas trouver "sans-serif" ensemble.
Monty

9
Ceci est une belle liste. Quelqu'un a-t-il un lien vers la provenance de ces informations? Ce serait bien si Google avait cela dans sa documentation dans un endroit facile à trouver, par exemple pour la documentation de android:fontFamilyTextView.
Christopher Perry

8
La liste définitive des polices peut être trouvée dans system_fonts.xml comme expliqué ici
Newtonx

207

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


34
Bien que cela fonctionne, veuillez noter que cela peut créer une fuite de mémoire . Il peut être corrigé en utilisant cette réponse .
Charles Madere

@ScootrNova j'obtiens cette erreur lorsque j'utilise votre solution. Erreur: élément de police introuvable gothic.ttf
Sagar Devanga

Comment l'appliquer à toute l'application? En ce moment dans l'exemple, vous l'appliquez uniquement sur textview
Pritish Joshi

178

À 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

Ici

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


7
NB: Cela ne fonctionne actuellement que dans Android Studio 3.0 Preview. Cela n'a pas fonctionné pour moi sur Android Studio 2.3.3. J'espère que cela fait gagner du temps à quelqu'un!
Tash Pemhiwa

2
Comment pourriez-vous obtenir la police à partir d'un fragment puisque vous ne pouvez pas simplement le faire getResources()? EDIT : Cette ligne à la fin de votre réponse a fonctionné pour moi: Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
Paradox

D'une manière ou d'une autre, la police semblait corrompue dans mon cas, par rapport à la caligtraphie. FontWeight ne fait rien non plus
Leo Droidcoder

@LeoDroidcoder ça marche, assurez-vous d'avoir utilisé les deux android:fontWeightetapp:fontWeight
Manohar Reddy

J'ai vérifié plusieurs fois. Il n'y a aucun effet.
Leo Droidcoder

100

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

Savez-vous peut-être quelle version d'Android a ajouté quelle police?
développeur Android

@androiddeveloper non. Vous pouvez probablement le découvrir en consultant les modifications ici: github.com/android/platform_frameworks_base/blob/…
Jared Rummler

@JaredRummler, pardonne mon ignorance. Pourquoi / Quel est le poids == 400?
Samuel

1
@Samuel Je n'ai pas regardé ce code depuis un moment, mais le poids de 400 polices est utilisé pour les polices "normales" ou "normales". Exemple, Roboto-Regular a un poids de 400.
Jared Rummler

Est-ce que cela nécessite une racine ou quelque chose? J'ai exécuté ce code sur l'émulateur Android (version 8.1), et quand j'ai appelé getSystemFonts(), j'ai eu une exceptionorg.xmlpull.v1.XmlPullParserException: END_TAG expected (position:START_TAG (empty) <axis tag='wdth' stylevalue='100.0'>@219:51 in java.io.InputStreamReader@f001fb3)
Damn Vegetables

49

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.


"Android ne vous permet pas de définir des polices personnalisées à partir de la disposition XML." Cela a été changé dans Android O, ce qui vous permet de créer une famille de polices personnalisée et de les appliquer en XML: developer.android.com/preview/features/working-with-fonts.html
Roger Huang

27

Pour définir Roboto par programme:

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

25

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 .


4
Je ne pense pas que ce soit la même chose, mais il semble que nous ne pouvons pas utiliser les deux. Il semble qu'il y ait désormais pas moins de trois attributs différents mappés setTypeface(). À savoir fontFamily, typefaceet textStyle. Mais je ne peux pas pour la vie de moi comprendre comment ceux-ci sont précisément combinés pour résoudre une instance concrète de Typeface. Quelqu'un a-t-il compris cela? La documentation de Google est loin d'être utile ...
Rad Haring

23

Si vous le souhaitez par programme, vous pouvez utiliser

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

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


15

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!


oui, mais par exemple, je veux l’utiliser functionanl, mais je ne voulais pas implémenter toutes les bibliothèques;)
Morozov

12

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.


11

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


Où les déclarer?
AZ_

@AZ_ Tout comme de nombreux fichiers de ressources, vous pouvez les placer dans n'importe quel fichier XML de votre choix, dans le dossier "res / values ​​/". Par exemple, mettez-le dans "res / values ​​/ fonts.xml". Et, pour l'utiliser, faites simplement comme ceci par exemple: android: fontFamily = "string / fontFamily__roboto_regular"
développeur android

Merci, j'utilise ce github.com/norbsoft/android-typeface-helper et c'est vraiment utile
AZ_

ok, la bibliothèque est probablement pour le faire par programme. ici c'est pour XML
développeur android

9

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


9
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


8

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

6

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.


5

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

4

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).


4

Essaye ça:

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

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

4

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

entrez la description de l'image ici

Sélectionnez ensuite Police comme type de ressource. entrez la description de l'image ici

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

entrez la description de l'image ici

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

entrez la description de l'image ici


très sympa, merci pour ça. idk pourquoi d'autres ont plus d'étoiles mais la vôtre est confirmée pour fonctionner avec la vue de texte de conception matérielle, vous devez utiliser app:fontFamily=cependant, tout le reste est le même.
EvOlaNdLuPiZ

Vous m'avez sauvé la vie, je venais de créer un dossier nommé font et cela n'a pas fonctionné. Quoi qu'il en soit, j'ai utilisé votre chemin et cela a fonctionné.Merci
Hilal

4

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

9
Meilleure ResourcesCompat.getFontméthode d' utilisation
Vadim Kotov

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

3

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

3

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 Fenêtre d'attribut

Google Fonts Google Fonts


2

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.


Malheureusement, cela ne fonctionne toujours pas avec IntelliJ (bien que fonctionnant comme un charme sur Android Studio 3.0+).
Dominikus K.

Oui, mais Redmanla réponse de l'utilisateur ci-dessus est toujours une partie nécessaire de la solution.
jungledev

2

Il y a une belle bibliothèque disponible pour cela

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

Cette bibliothèque est utilisée pour changer la police de toutes les vues dans l'application entière. Cela ne s'applique pas aux vues d'adaptateur telles que la vue de liste. Pour cela, nous devons ajouter du code dans chaque adaptateur spécifiquement
Senthilvel S

2

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

android:fontFamily="@font/my_font_in_font_folder"

1

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"

1

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>

1

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

0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.