files - change text font android app




Comment changer fontFamily de TextView dans Android (17)

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

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

Créer une font dossier sous le répertoire res Télécharger la police que vous voulez et collez-le dans le dossier de font . La structure devrait être quelque chose comme ci-dessous

maintenant vous pouvez changer la police dans la mise en page en utilisant

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

Pour changer de programme

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

Pour changer de police en utilisant styles.xml, créez un style

 <style name="Regular">
        <item name="android: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 police et accédez à Nouveau> Fichier de ressources de polices . La fenêtre Nouveau fichier de ressources apparaît.

- Entrez le nom du fichier , puis cliquez sur OK . La nouvelle ressource XML de ressource 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>

ceci est simplement un mappage d'une police de caractères spécifique et d'une police de fontWeight à 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 de police de poids CSS

1. Pour changer de fontfamily 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 modifier le programme

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

Remarque: Depuis Android Support Library 26.0, vous devez déclarer les deux ensembles d'attributs (android: et app:) pour garantir le chargement de vos polices sur les appareils exécutant Api 26 ou une version antérieure.

  <?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:fontStyle="normal" android:fontWeight="400" android:font="@font/myfont-Regular"
          app:fontStyle="normal" app:fontWeight="400" app:font="@font/myfont-Regular"/>
    <font android:fontStyle="italic" android:fontWeight="400" android:font="@font/myfont-Italic"
          app:fontStyle="italic" app:fontWeight="400" app:font="@font/myfont-Italic" />
</font-family>

Pour changer la police de l'App 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 , Didacticiel sur les polices personnalisées Android Pour plus d'informations

Donc, je voudrais changer l' android:fontFamily dans Android mais je ne vois pas de polices prédéfinies dans Android. Comment puis-je sélectionner l'un des prédéfinis? Je n'ai pas vraiment besoin de définir mon propre TypeFace mais tout ce dont j'ai besoin est différent de ce qu'il montre actuellement.

<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à-bas ne marchera pas vraiment! BTW android:fontFamily="Arial" était une tentative stupide!


Android ne vous permet pas de définir des polices personnalisées à partir de la mise en page XML. Au lieu de cela, vous devez regrouper le fichier de police spécifique dans le dossier des actifs 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 (). En outre, seules certaines polices sont prises en charge par Android et doivent être au format .otf (OpenType) .ttf (TrueType) ou .otf (OpenType) . Même alors, certaines polices peuvent ne pas fonctionner.

This une police qui fonctionne vraiment sur Android, et vous pouvez l'utiliser pour confirmer que votre code fonctionne au cas où votre fichier de police n'est pas supporté par Android.

Android O Update: Ceci est maintenant possible avec XML dans Android O , basé sur le commentaire de Roger.


C'est aussi une bonne bibliothèque RobotoTextView . Cela répond vraiment à vos besoins.


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

les polices intégrées sont:

  • Ordinaire
  • sans
  • serif
  • monospace

Voir android:typeface .


Ce que tu veux n'est pas possible. Vous devez définir TypeFace dans votre code.

En XML ce que vous pouvez faire est

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

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

Pour Arial vous devez définir le type face dans votre code.


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 régulier
  • Roboto italique
  • Roboto gras
  • Roboto gras italique
  • Roboto-Lumière
  • Roboto-Light italique
  • Roboto-Mince
  • Roboto-Thin italique
  • Roboto-Condensé
  • Roboto-Condensed italique
  • Roboto-Condensed gras
  • Roboto-condensé gras italique
  • Roboto-Noir
  • Roboto-Noir italique
  • Roboto-Medium
  • Roboto-Medium italique

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>

J'ai créé une petite bibliothèque nommée Foundry que vous pouvez utiliser pour appliquer des polices de caractères personnalisées via des mises en page et des styles XML.


J'ai dû analyser /system/etc/fonts.xml dans un projet récent. Voici les familles de polices courantes à partir 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 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();

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


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

Maintenant il y a une nouvelle ressource tapez une police et vous pouvez placer toutes vos polices d'application dans le dossier res / fonts et accéder ensuite avec R.font.my_custom_font, tout comme vous pouvez accéder aux valeurs de res res, valeurs res drawables , etc. Vous avez même chance pour créer un fichier xml font-face , qui sera défini pour vos polices personnalisées (à propos de italic, gras et underline).

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


Pour définir Roboto par programme:

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

Si vous le souhaitez par programme, vous pouvez utiliser

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

SANS_SERIF vous pouvez utiliser:

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

Et où ITALIC vous pouvez utiliser:

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

Tout est indiqué sur Android Developers


Un moyen facile 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 here et here


Voici une solution plus facile qui peut fonctionner dans certains cas. Le principe est d'ajouter une TextVview non visible dans votre layout 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).


Here vous pouvez voir toutes les valeurs de fontFamily disponibles et ses noms de 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 ci-dessous en utilisant this version, mais je pense que fonts.xml a 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>

Le nom d'attribut name="sans-serif" de la balise family défini la valeur que vous pouvez utiliser dans android: fontFamily.

La balise de font définit les fichiers de police correspondants.

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


You can do it easy way by using following library

https://github.com/sunnag7/FontStyler

<com.sunnag.fontstyler.FontStylerView
              android:textStyle="bold"
              android:text="@string/about_us"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:paddingTop="8dp"
              app:fontName="Lato-Bold"
              android:textSize="18sp"
              android:id="@+id/textView64" />

its light weight and easy to implement, just copy your fonts in asset folder and use name in xml.


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




typeface