So ändern Sie die Schriftfamilie von TextView in Android

So können Sie die Schrift 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 mit dem Namen fonts erstellt.

EDIT: Wenn Sie sich fragen, wo sich Ihr Assets-Ordner befindet, sehen Sie diese Frage

Ich musste /system/etc/fonts.xml in einem aktuellen 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 Vorlieben 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();

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

Mit der Support-Bibliothek 26 funktioniert sie auf Geräten, auf denen Android API Version 16 und höher ausgeführt wird 

Erstellen Sie einen Ordner font im Verzeichnis res. Laden Sie die gewünschte Schriftart herunter und fügen Sie sie in den Ordner font ein. Die Struktur sollte wie folgt aussehen

Hinweis: Ab der Android Support Library 26.0 müssen Sie beide Attributsätze (Android: und app:) deklarieren, um sicherzustellen, dass die Schriftarten auf Geräten geladen werden, auf denen .__ ausgeführt wird. Api 26 oder niedriger.

Nun können Sie die Schriftart in layout mit ändern

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

Programmgesteuert ä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 TextView an

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

sie können auch ein eigenes Schriftfamilie erstellen.

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

- Geben Sie das Dateiname 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>

hierbei handelt es sich lediglich um die Zuordnung eines bestimmten fontStyle und fontWeight zu der Fontressource, die zum Rendern dieser bestimmten Variante verwendet wird. Gültige Werte für fontStyle sind normal oder kursiv. und fontWeight entspricht der CSS-Schriftgewichtsspezifikation

1. An ändern Schriftfamilie in Layout können Sie schreiben

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

2. Ändern programmgesteuert

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

An Schriftart der gesamten App ändern 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>

Weitere Informationen finden Sie im Documentation , Android Custom Fonts Tutorial

In Android können Sie keine benutzerdefinierten Schriftarten im XML-Layout festlegen. Sie müssen stattdessen die bestimmte Schriftartdatei im Asset-Ordner Ihrer App bündeln und programmgesteuert festlegen. So 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 nur ausführen können, nachdem setContentView () aufgerufen wurde. Außerdem werden nur einige Schriftarten von Android unterstützt und sollten das Format .ttf (TrueType) oder .otf (OpenType) haben. Selbst dann funktionieren manche Schriftarten möglicherweise nicht.

Dies ist eine Schriftart, die definitiv unter Android funktioniert, und Sie können dies verwenden, um zu bestätigen, dass Ihr Code funktioniert, falls Ihre Fontdatei nicht von Android unterstützt wird.

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

Roboto programmgesteuert einstellen:

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

Es ist dasselbe wie Android:typeface.

integrierte Schriftarten sind:

• normal
• sans
• serif
• monospace

Siehe Android: Schrift .

Wenn Sie es programmgesteuert wünschen, können Sie es verwenden 

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

Wo SANS_SERIF Sie verwenden können:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Und wo ITALIC Sie verwenden können:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Alles ist angegeben auf Android-Entwicklern

Ich verwende eine ausgezeichnete Bibliothek Kalligraphie von Chris Jenx, die Ihnen die Verwendung benutzerdefinierter Schriftarten in Ihrer Android-Anwendung ermöglicht. Versuche es!

Was Sie wollen, ist nicht möglich. Sie müssen in Ihrem Code TypeFace einstellen.

In XML können Sie Folgendes tun 

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

andernfalls kann man mit den Schriftarten in XML nicht viel spielen. :)

Für Arial müssen Sie in Ihrem Code den Typ face eingeben.

Eine einfache Möglichkeit zum Verwalten der Zeichensätze 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 auf dem Quellcode hier und hier

Dynamisch können Sie die Schriftfamilie ähnlich wie Android einstellen: fontFamily in xml, indem Sie dies 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 Standardschriftart -Familie. Verwenden Sie eine beliebige davon, indem Sie die doppelte Anführungszeichenfolge "sans-serif-medium" 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. Pfad wird in src/assets/fonts/mycustomfont.ttf angezeigt. Sie können mehr über die Standardschriftart in dieser Standardschriftfamilie verweisen.

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, die Schrift zu verwenden. Die Auswahl an Kombinationen ist mit der Schriftfamilie & 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 es jedoch ändern, sodass die tatsächliche Schriftart, die zum Festlegen des fontFamily-Werts verwendet wird, von der oben genannten Datei des angegebenen Geräts abhängt.

In AOSP ist die Schriftart Arial gültig, muss aber mit "arial" definiert werden, nicht mit "arial", zum Beispiel Android: fontFamily = "arial" . Werfen Sie einen Blick auf KitKats system_fonts.xml

    <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 zum Definieren einer "Schrift" in Layout - Android: fontFamily , Android: Schrift und Android: textStyle . Die Kombination aus "fontFamily" und "textStyle" oder "Schriftbild" und "TextStyle" kann verwendet werden, um das Erscheinungsbild der Schrift 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" "sans" "serif" und "Monospace". Sie können in system_fonts.xml (4.x) oder fonts.xml (5.x) gefunden werden. Eigentlich sind sowohl "Normal" als auch "Sans" die Standardschrift des Systems.
3. "fontFamily" kann verwendet werden, um alle Schriftarten von eingebauten Schriftarten festzulegen, während "Schrift" nur die typischen Schriftarten von "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. Die effektiven Werte sind "normal" "fett" "kursiv" und "fett | kursiv".

<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 TextView an so vielen Stellen mit derselben Schriftfamilie verwenden möchten, erweitern Sie die TextView-Klasse und stellen Sie Ihre Schriftart folgendermaßen ein:

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

Und dann verwenden Sie 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"
        />

Ich möchte nur erwähnen, dass die Hölle mit den Schriftarten in Android bald enden wird, denn in diesem Jahr haben wir bei Google IO endlich diese -> https://developer.Android.com/preview/features/ arbeiten-mit-fonts.html

Nun gibt es einen neuen Ressourcentyp, einen font, und Sie können alle Ihre Anwendungszeichensätze im res/fonts-Ordner ablegen und dann mit R.font.my_custom_font auf den Zugriff zugreifen, genau wie auf string. res-Werte, drawable res-Werte usw. Sie haben sogar die Möglichkeit, eine font-face xml-Datei zu erstellen, in der Ihre benutzerdefinierten Schriftarten (kursiv, fett und unterstrichen) gesetzt werden. . 

Lesen Sie den Link oben für weitere Informationen. Lassen Sie uns die Unterstützung sehen.

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

Hier ist eine einfachere Wa y, die in einigen Fällen funktionieren kann. Das Prinzip ist, ein nicht sichtbares TextVview in Ihr XML-Layout einzufügen und dessen TypFace 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 für mich funktioniert (zB innerhalb eines TextSwitcher).

Sie setzen den Stil in res/layout/value/style.xml so:

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

und diesen Stil in der main.xml-Datei verwenden:

style="@style/boldText"

Sie können Standardschriften auch mit setTextAppearance ändern (API 16 erforderlich), siehe https://stackoverflow.com/a/36301508/2914140 :

<style name="styleA">
    <item name="Android:fontFamily">sans-serif</item>
    <item name="Android:textStyle">bold</item>
    <item name="Android:textColor">?android:attr/textColorPrimary</item>
</style>
<style name="styleB">
    <item name="Android:fontFamily">sans-serif-light</item>
    <item name="Android:textStyle">normal</item>
    <item name="Android:textColor">?android:attr/textColorTertiary</item>
</style>


if(condition){
    TextViewCompat.setTextAppearance(textView, R.style.styleA);
} else {
    TextViewCompat.setTextAppearance(textView,R.style.styleB);
}

Sie können dies auf einfache Weise tun, indem Sie folgende Bibliothek verwenden

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

es ist leicht und einfach zu implementieren. Kopieren Sie einfach Ihre Schriften in den Asset-Ordner und verwenden Sie den Namen in XML.

Hierfür steht eine Nice-Bibliothek zur Verfügung

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

Der einfachste Weg die Schriftart programmatisch zu einer TextView hinzuzufügen ist, zunächst die Schriftartdatei im Ordner Assets des Projekts hinzuzufügen. Zum Beispiel sieht Ihr Schriftpfad so aus: assets/fonts/my_font.otf

Und fügen Sie es einer TextView 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);

Für Android-Studio 3 und höher können Sie diesen Stil verwenden und anschließend alle 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>

Dann verwenden Sie es 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>

Versuche dies:

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

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

Ich benutze Letter Press lib für meine NonTextView-Sachen wie Buttons und kianoni fontloader lib für meine TextViews. Die Verwendung von Stil in dieser Lib ist für mich einfacher als Letter Press und ich habe damit ein ideales Feedback. Dies ist großartig für diejenigen, die eine benutzerdefinierte Schriftart verwenden möchten, mit Ausnahme von Roboto Font . Ich hatte also Erfahrung mit Font-Libs . Für diejenigen, die eine benutzerdefinierte Klasse für die Änderung der Schriftart verwenden möchten, empfahl ich dringend, diese zu erstellen klasse mit diesem schnipsel

    public class TypefaceSpan extends MetricAffectingSpan {
    /** An <code>LruCache</code> for previously loaded typefaces. */
    private static LruCache<String, Typeface> sTypefaceCache =
            new LruCache<String, Typeface>(12);

    private Typeface mTypeface;

    /**
     * Load the {@link Android.graphics.Typeface} and apply to a {@link Android.text.Spannable}.
     */
    public TypefaceSpan(Context context, String typefaceName) {
        mTypeface = sTypefaceCache.get(typefaceName);

        if (mTypeface == null) {
            mTypeface = Typeface.createFromAsset(context.getApplicationContext()
                    .getAssets(), String.format("fonts/%s", typefaceName));

            // Cache the loaded Typeface
            sTypefaceCache.put(typefaceName, mTypeface);
        }
    }

    @Override
    public void updateMeasureState(TextPaint p) {
        p.setTypeface(mTypeface);

        // Note: This flag is required for proper typeface rendering
        p.setFlags(p.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
    }

    @Override
    public void updateDrawState(TextPaint tp) {
        tp.setTypeface(mTypeface);

        // Note: This flag is required for proper typeface rendering
        tp.setFlags(tp.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
    }
}

Und benutze Klasse wie folgt:

AppData = PreferenceManager.getDefaultSharedPreferences(this);
TextView bannertv= (TextView) findViewById(R.id.txtBanner);
    SpannableString s = new SpannableString(getResources().getString(R.string.enterkey));
    s.setSpan(new TypefaceSpan(this, AppData.getString("font-Bold",null)), 0, s.length(),
            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    bannertv.setText(s);

vielleicht diese hilfe.

Hier können Sie alle verfügbaren fontFamily-Werte und deren Namen sehen (Diese Datei wird in Android 5.0 und höher verwendet). In mobilen Geräten finden Sie es in:

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

(Für Android 4.4 und darunter wird this verwendet, aber ich denke, dass fonts.xml ein klareres Format hat und leicht verständlich ist.)

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 Namensattribut name="sans-serif" des family-Tags hat den Wert definiert, den Sie in Android verwenden können: fontFamily.

Das font-Tag definiert die entsprechenden Zeichensatzdateien.

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

probieren Sie diese einfachen Schritte aus ... 1. Erstellen Sie den Zeichensatzordner im Ordner res .. 2. Kopieren Sie die .ttf-Datei und fügen Sie sie in den Schriftartenordner ein. 3. Nun geben Sie den Pfad in xml wie folgt an.

 Android:fontFamily="@font/frutiger"

oder was auch immer dein Dateiname ist . Das ist es glücklich Code