So ändern Sie fontFamily von TextView in Android

Ich möchte das android:fontFamilyin Android ändern, sehe aber keine vordefinierten Schriftarten in Android. Wie wähle ich eine der vordefinierten aus? Ich muss mein eigenes TypeFace nicht wirklich definieren, aber alles, was ich brauche, ist etwas anderes als das, was es gerade zeigt.

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

Es scheint, dass das, was ich dort oben getan habe, nicht wirklich funktioniert! Übrigens android:fontFamily="Arial"war ein dummer Versuch!

Ab Android 4.1 / 4.2 / 5.0 sind die folgenden Roboto- Schriftfamilien verfügbar:

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)

in Kombination mit

android:textStyle="normal|bold|italic"

Diese 16 Varianten sind möglich:

• Roboto regelmäßig
• Roboto kursiv
• Roboto mutig
• Roboto fett kursiv
• Roboto-Light
• Roboto-Light kursiv
• Roboto-Thin
• Roboto-Thin kursiv
• Roboto-kondensiert
• Roboto-Condensed kursiv
• Roboto-Condensed fett
• Roboto-Condensed fett kursiv
• Roboto-Schwarz
• Roboto-Schwarz kursiv
• Roboto-Medium
• Roboto-Medium kursiv

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>

Auf diese Weise können Sie die Schriftart programmgesteuert einstellen:

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

Legen Sie die Schriftartdatei in Ihrem Assets-Ordner ab. In meinem Fall habe ich ein Unterverzeichnis namens fonts erstellt.

BEARBEITEN: Wenn Sie sich fragen, wo sich Ihr Assets-Ordner befindet, lesen Sie diese Frage

Ab Android-Studio 3.0 sehr einfach, die Schriftfamilie zu ändern

Mit der Support-Bibliothek 26 funktioniert es auf Geräten mit Android API Version 16 und höher

Erstellen Sie einen Ordner fontunter dem resVerzeichnis. Laden Sie die gewünschte Schriftart herunter und fügen Sie sie in den fontOrdner ein. Die Struktur sollte ungefähr so ​​aussehen wie unten

Hinweis: Ab Android Support Library 26.0 müssen Sie beide Attributgruppen (android: und app :) deklarieren, um sicherzustellen, dass Ihre Schriftarten auf Geräten mit Api 26 oder niedriger geladen werden.

Jetzt können Sie die Schriftart im Layout mit ändern

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

Programmatisch ändern

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

Um die Schriftart mit styles.xml zu ändern, erstellen Sie einen Stil

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

und wende diesen Stil auf an TextView

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

Sie können auch Ihre eigene Schriftfamilie erstellen

- Klicken Sie mit der rechten Maustaste auf den Schriftartenordner und gehen Sie zu Neu> Schriftressourcendatei . Das Fenster Neue Ressourcendatei wird angezeigt.

- Geben Sie den Dateinamen ein und klicken Sie auf OK . Die neue XML-Schriftartressource wird im Editor geöffnet.

Schreiben Sie hier beispielsweise Ihre eigene Schriftfamilie

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

Dies ist einfach eine Zuordnung eines bestimmten fontStyle und fontWeight zu der Schriftartressource, die zum Rendern dieser bestimmten Variante verwendet wird. Gültige Werte für fontStyle sind normal oder kursiv. und fontWeight entspricht der CSS-Spezifikation für die Schriftgröße

1. Um die Schriftfamilie im Layout zu ändern, können Sie schreiben

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

2. Programmgesteuert ändern

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

So ändern Sie die Schriftart der gesamten App Fügen Sie diese beiden Zeilen in AppTheme hinzu

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

Sehen Sie die Dokumentation , Android benutzerdefinierten Schriftarten Tutorial Für weitere Informationen

Ich musste /system/etc/fonts.xmlkürzlich ein Projekt analysieren . Hier sind die aktuellen Schriftfamilien ab 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Hier ist der Parser (basierend auf 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;
        }

    }
}

Fühlen Sie sich frei, die oben genannte Klasse in Ihrem Projekt zu verwenden. Sie können Ihren Benutzern beispielsweise eine Auswahl von Schriftfamilien geben und die Schriftart nach ihren Wünschen festlegen.

Ein kleines unvollständiges Beispiel:

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

In Android können Sie keine benutzerdefinierten Schriftarten aus dem XML-Layout festlegen. Stattdessen müssen Sie die spezifische Schriftartdatei im Assets-Ordner Ihrer App bündeln und programmgesteuert festlegen. Etwas wie:

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

Beachten Sie, dass Sie diesen Code erst ausführen können, nachdem setContentView () aufgerufen wurde. Außerdem werden nur einige Schriftarten von Android unterstützt und sollten in einem .ttf (TrueType)oder .otf (OpenType)Format vorliegen. Selbst dann funktionieren einige Schriftarten möglicherweise nicht.

Dies ist eine Schriftart, die definitiv unter Android funktioniert. Mit dieser Schriftart können Sie bestätigen, dass Ihr Code funktioniert, falls Ihre Schriftartdatei von Android nicht unterstützt wird.

Android O Update: Dies ist jetzt mit XML in Android O möglich , basierend auf Rogers Kommentar.

So programmieren Sie Roboto programmgesteuert:

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

Es ist das gleiche wie android:typeface.

Integrierte Schriftarten sind:

• normal
• ohne
• Serife
• Monospace

Siehe Android: Schrift .

Wenn Sie es programmgesteuert möchten, können Sie es verwenden

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

Wo SANS_SERIFSie verwenden können:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Und wo können ITALICSie verwenden:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Alles ist auf Android-Entwicklern angegeben

Ich verwende eine ausgezeichnete Bibliothek Kalligraphie von Chris Jenx, mit der Sie benutzerdefinierte Schriftarten in Ihrer Android-Anwendung verwenden können. Versuche es!

Was Sie wollen, ist nicht möglich. Sie müssen TypeFaceIhren Code festlegen .

In XMLwas Sie tun können , ist

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

Ansonsten kann man mit den Fonts in XML nicht viel spielen. :) :)

Denn ArialSie müssen in Ihrem Code die Schriftart eingeben.

Eine einfache Möglichkeit, die Schriftarten zu verwalten, besteht darin, sie über Ressourcen als solche zu deklarieren:

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

Dies basiert hier und hier auf dem Quellcode

Dynamisch können Sie die Schriftfamilie ähnlich wie android: fontFamily in XML festlegen, indem Sie Folgendes verwenden:

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

Dies ist die Liste der verwendeten Standardschriftfamilien . Verwenden Sie eine dieser Schriftarten , indem Sie die doppelte Anführungszeichenfolge "serifenlos-mittel" ersetzen.

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" ist die ttf-Datei. Der Pfad befindet sich in src / assets / fonts / mycustomfont.ttf. Weitere Informationen zur Standardschrift finden Sie in dieser Standardschriftfamilie

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

Stellen Sie die Schriftart einfach programmgesteuert auf eine beliebige Textansicht aus dem Verzeichnis res> font ein

Ich denke, ich bin zu spät, aber vielleicht ist diese Lösung für andere hilfreich. Wenn Sie eine benutzerdefinierte Schriftart verwenden möchten, legen Sie Ihre Schriftartdatei in Ihrem Schriftartenverzeichnis ab.

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

Mit einigem Ausprobieren habe ich Folgendes gelernt.

Innerhalb der * .xml können Sie die Standardschriftarten mit den folgenden Funktionen kombinieren, nicht nur mit der Schrift:

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

Bei diesen beiden Stilen war es in keinem anderen Fall erforderlich, eine Schriftart zu verwenden. Die Auswahl an Kombinationen ist mit fontfamily & textStyle viel größer.

Der gültige Wert von android: fontFamily ist in /system/etc/system_fonts.xml (4.x) oder /system/etc/fonts.xml (5.x) definiert. Der Gerätehersteller kann dies jedoch ändern, sodass die tatsächliche Schriftart, die beim Festlegen des fontFamily-Werts verwendet wird, von der oben genannten Datei des angegebenen Geräts abhängt.

In AOSP ist die Arial-Schriftart gültig, muss jedoch mit "arial" und nicht mit "Arial" definiert werden, z. B. android: fontFamily = "arial" . Schauen Sie sich Kitkats system_fonts.xml an

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

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

Es gibt drei relevante XML-Attribute zur Definition einer "font" in layout-- android: family , android: Schrift und android: Textart . Die Kombination von "fontFamily" und "textStyle" oder "typeface" und "textStyle" kann verwendet werden, um das Erscheinungsbild von Schriftarten im Text zu ändern. Code-Snippet in TextView.java wie folgt :

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

Aus dem Code können wir sehen:

1. Wenn "fontFamily" eingestellt ist, wird die "Schrift" ignoriert.
2. "Schrift" hat Standardwerte und begrenzte gültige Werte. Tatsächlich sind die Werte "normal", "ohne", "Serife" und "Monospace". Sie finden sie in system_fonts.xml (4.x) oder fonts.xml (5.x). Tatsächlich sind sowohl "normal" als auch "sans" die Standardschriftart des Systems.
3. "fontFamily" kann verwendet werden, um alle Schriftarten von integrierten Schriftarten festzulegen, während "Schrift" nur die typischen Schriftarten "serifenlos", "serif" und "monospace" (die drei Hauptkategorien von Schriftarten in der Welt) enthält. .
4. Wenn nur "textStyle" festgelegt wird, legen wir tatsächlich die Standardschriftart und den angegebenen Stil fest. Der effektive Wert ist "normal", "fett", "kursiv" und "fett | kursiv".

Hier ist eine einfachere Möglichkeit , die in einigen Fällen funktionieren kann. Das Prinzip besteht darin, eine nicht sichtbare TextVview in Ihr XML-Layout einzufügen und deren typeFace im Java-Code abzurufen .

Das Layout in der XML-Datei:

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

Und der Java-Code:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Es hat bei mir funktioniert (zum Beispiel in einem TextSwitcher).

Versuche dies:

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

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

Sie können dies auch tun, indem Sie einen Schriftartenordner unter dem Verzeichnis res wie unten hinzufügen.

Wählen Sie dann Schriftart als Ressourcentyp aus.

Sie finden verfügbare Schriftarten unter https://www.1001fonts.com/ und extrahieren dann die TTF-Dateien in dieses Schriftartenverzeichnis.

Zum Schluss ändern Sie einfach die XML-Datei, die Ihre Textansicht enthält, indem Sie android: fontFamily: "@ font / urfontfilename" hinzufügen.

Eine einfache Möglichkeit besteht darin, die gewünschte Schriftart in das Projekt einzufügen.

Gehen Sie zu Datei-> Neu-> Neues Ressourcenverzeichnis. Wählen Sie die Schriftart aus

Dadurch wird ein neues Verzeichnis ( Schriftart ) in Ihren Ressourcen erstellt.

Laden Sie Ihre Schriftart (.ttf) herunter . Ich benutze https://fonts.google.com für das gleiche

Fügen Sie dies Ihrem Schriftartenordner hinzu und verwenden Sie sie dann im XML oder programmgesteuert.

XML -

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

Programmatisch -

 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>

Wenn Sie eine TextView an so vielen Stellen mit derselben Schriftfamilie verwenden möchten, erweitern Sie die TextView-Klasse und legen Sie Ihre Schriftart wie folgt fest: -

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

Verwenden Sie dann diese benutzerdefinierte Klasse in XML für die Textansicht wie folgt: -

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

Wenn Sie Android Studio 3.5+ verwenden, ist das Ändern der Schriftart sehr einfach. Wählen Sie das Text-Widget in der Entwurfsansicht aus und aktivieren Sie fontFamily im Attributfenster. Die Wert-Dropdown-Liste enthält alle verfügbaren Schriftarten, aus denen Sie eine auswählen können. Wenn Sie nach Google Fonts suchen, klicken Sie auf die Option Weitere Schriftarten.

Attributfenster

Google Fonts

Ich möchte nur erwähnen, dass die Hölle mit den Schriftarten in Android bald zu Ende geht, denn dieses Jahr haben wir auf Google IO endlich diese -> https://developer.android.com/preview/features/working-with-fonts. html

Jetzt gibt es einen neuen Ressourcentyp, eine Schriftart, und Sie können alle Ihre Anwendungsschriftarten im Ordner res / fonts ablegen und dann mit R.font.my_custom_font darauf zugreifen, genau wie Sie auf Zeichenfolgen- Res-Werte, zeichnbare Res-Werte usw. zugreifen können. Sie haben sogar eine Chance um eine XML-Datei für Schriftarten zu erstellen , die aus Ihren benutzerdefinierten Schriftarten besteht (über Kursiv, Fett und Unterstrich).

Lesen Sie den obigen Link für weitere Informationen. Mal sehen, die Unterstützung.

Dafür steht eine schöne Bibliothek zur Verfügung

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

Die neue Schriftartressource ermöglicht die direkte Einstellung fontmit

android:fontFamily="@font/my_font_in_font_folder"

Sie setzen den Stil res/layout/value/style.xmlso ein:

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

und um diesen Stil bei der main.xmlVerwendung von Dateien zu verwenden:

style="@style/boldText"

Für Android-Studio 3 und höher können Sie diesen Stil und dann alle verwenden textView Schriftarten in der App ändern.

Erstellen Sie diesen Stil in Ihrem style.xml:

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

Verwenden Sie es dann in Ihrem Thema:

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

Der einfachste Weg , die Schriftart programmgesteuert zu einer Textansicht hinzuzufügen, besteht darin, zunächst die Schriftartdatei in Ihrem Assets-Ordner im Projekt hinzuzufügen. Ihr Schriftpfad sieht beispielsweise folgendermaßen aus:assets/fonts/my_font.otf

Und fügen Sie es einer Textansicht hinzu als:

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

Hier sehen Sie alle verfügbaren fontFamily-Werte und die Namen der entsprechenden Schriftdateien (diese Datei wird in Android 5.0+ verwendet). Auf Mobilgeräten finden Sie es in:

/system/etc/fonts.xml (für 5.0+)

(Für Android 4.4 und niedriger mit dieser Version, aber ich denke, das fonts.xmlhat ein klareres Format und ist leicht zu verstehen.)

Zum Beispiel,

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

Das Attribut name name="sans-serif"des familyTags definiert den Wert, den Sie in android verwenden können: fontFamily.

Das fontTag definiert die entsprechenden Schriftdateien.

In diesem Fall können Sie die Quelle ignorieren <!-- fallback fonts -->, die für die Fallback-Logik von Schriftarten verwendet wird.