Android - Benutzerdefinierte Schriftart verwenden

Ich habe eine benutzerdefinierte Schriftart auf a angewendet TextView, aber sie scheint die Schriftart nicht zu ändern.

Hier ist mein Code:

    Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
    TextView myTextView = (TextView)findViewById(R.id.myTextView);
    myTextView.setTypeface(myTypeface);

Kann mich bitte jemand aus diesem Problem herausholen?

Auf Mobiletuts + gibt es ein sehr gutes Tutorial zur Textformatierung für Android. Kurztipp: Passen Sie Android-Schriftarten an

EDIT: Habe es jetzt selbst getestet. Hier ist die Lösung. Sie können einen Unterordner namens fonts verwenden, der sich jedoch im assetsOrdner und nicht im resOrdner befinden muss. So

Assets / Schriftarten

Stellen Sie außerdem sicher, dass das Ende der Schriftart, dh das Ende der Schriftartdatei, in Kleinbuchstaben geschrieben ist. Mit anderen Worten sollte es nicht sein, myFont.TTFaber myfont.ttf dieser Weg muss in Kleinbuchstaben sein

Nachdem ich die meisten der in diesem Thread beschriebenen Lösungen ausprobiert hatte, fand ich versehentlich Calligraphy ( https://github.com/chrisjenx/Calligraphy ) - eine Bibliothek von Christopher Jenkins, mit der Sie Ihrer App ganz einfach benutzerdefinierte Schriftarten hinzufügen können. Die Vorteile seiner Bibliothek im Vergleich zu den hier vorgeschlagenen Ansätzen sind:

1. Sie müssen keine eigene überschriebene TextView-Komponente einführen, sondern verwenden die integrierte TextView
2. Sie können die Bibliothek einfach mit gradle einbinden
3. Die Bibliothek schränkt Ihre Auswahl an Schriftarten nicht ein. Sie fügen einfach Ihre bevorzugten zum Assets-Verzeichnis hinzu
4. Sie erhalten nicht nur benutzerdefinierte Textansichten - alle anderen textbasierten Android-Inhalte werden auch mit Ihrer benutzerdefinierten Schriftart angezeigt.

Ich weiß, dass es bereits gute Antworten gibt, aber hier ist eine voll funktionsfähige Implementierung.

Hier ist die benutzerdefinierte Textansicht:

package com.mycompany.myapp.widget;

/**
 * Text view with a custom font.
 * <p/>
 * In the XML, use something like {@code customAttrs:customFont="roboto-thin"}. The list of fonts
 * that are currently supported are defined in the enum {@link CustomFont}. Remember to also add
 * {@code xmlns:customAttrs="http://schemas.android.com/apk/res-auto"} in the header.
 */
public class CustomFontTextView extends TextView {

    private static final String sScheme =
            "http://schemas.android.com/apk/res-auto";
    private static final String sAttribute = "customFont";

    static enum CustomFont {
        ROBOTO_THIN("fonts/Roboto-Thin.ttf"),
        ROBOTO_LIGHT("fonts/Roboto-Light.ttf");

        private final String fileName;

        CustomFont(String fileName) {
            this.fileName = fileName;
        }

        static CustomFont fromString(String fontName) {
            return CustomFont.valueOf(fontName.toUpperCase(Locale.US));
        }

        public Typeface asTypeface(Context context) {
            return Typeface.createFromAsset(context.getAssets(), fileName);
        }
    }

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

        if (isInEditMode()) {
            return;
        } else {
            final String fontName = attrs.getAttributeValue(sScheme, sAttribute);

            if (fontName == null) {
                throw new IllegalArgumentException("You must provide \"" + sAttribute + "\" for your text view");
            } else {
                final Typeface customTypeface = CustomFont.fromString(fontName).asTypeface(context);
                setTypeface(customTypeface);
            }
        }
    }
}

Hier sind die benutzerdefinierten Attribute. Dies sollte in Ihre res/attrs.xmlDatei gehen:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="CustomFontTextView">
        <attr name="customFont" format="string"/>
    </declare-styleable>
</resources>

Und so verwenden Sie es. Ich werde ein relatives Layout verwenden, um es zu verpacken und die customAttrDeklaration anzuzeigen, aber es könnte natürlich jedes Layout sein, das Sie bereits haben.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:customAttrs="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.mycompany.myapp.widget.CustomFontTextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:text="foobar"
         customAttrs:customFont="roboto_thin" />

</RelativeLayout>

Ich habe das schon einmal erfolgreich benutzt. Der einzige Unterschied zwischen unseren Implementierungen besteht darin, dass ich keinen Unterordner in Assets verwendet habe. Ich bin mir jedoch nicht sicher, ob dies etwas ändern wird.

Vorausgesetzt, Sie haben die Schriftart an der richtigen Stelle platziert und es liegt kein Fehler in der Schriftartdatei selbst vor, sollte Ihr Code so funktionieren, RATTLESNAKE.

Es wäre jedoch viel einfacher, wenn Sie einfach eine Schriftart in Ihrer Layout-XML definieren könnten, wie folgt:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <!-- This text view is styled with the app theme -->
    <com.innovattic.font.FontTextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This uses my font in bold italic style" />

    <!-- This text view is styled here and overrides the app theme -->
    <com.innovattic.font.FontTextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:flFont="anotherFont"
        android:textStyle="normal"
        android:text="This uses another font in normal style" />

    <!-- This text view is styled with a style and overrides the app theme -->
    <com.innovattic.font.FontTextView
        style="@style/StylishFont"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This also uses another font in normal style" />

</LinearLayout>

Mit der Begleitung res/values/styles.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">

    <!-- Application theme -->
    <!-- Use a different parent if you don't want Holo Light -->
    <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
        <item name="android:textViewStyle">@style/MyTextViewStyle</item>
    </style>

    <!-- Style to use for ALL text views (including FontTextView) -->
    <!-- Use a different parent if you don't want Holo Light -->
    <style name="MyTextViewStyle" parent="@android:style/Widget.Holo.Light.TextView">
        <item name="android:textAppearance">@style/MyTextAppearance</item>
    </style>

    <!-- Text appearance to use for ALL text views (including FontTextView) -->
    <!-- Use a different parent if you don't want Holo Light -->
    <style name="MyTextAppearance" parent="@android:style/TextAppearance.Holo">
        <!-- Alternatively, reference this font with the name "aspergit" -->
        <!-- Note that only our own TextView's will use the font attribute -->
        <item name="flFont">someFont</item>
        <item name="android:textStyle">bold|italic</item>
    </style>

    <!-- Alternative style, maybe for some other widget -->
    <style name="StylishFont">
        <item name="flFont">anotherFont</item>
        <item name="android:textStyle">normal</item>
    </style>

</resources>

Ich habe einige Tools speziell für diesen Zweck erstellt. Beziehen Sie sich auf dieses Projekt von GitHub oder werfen Sie einen Blick auf diesen Blog-Beitrag, der das Ganze erklärt.

Der beste Weg, dies zu tun Ab Android O Preview Release ist folgender:

Es funktioniert nur, wenn Sie Android Studio-2.4 oder höher haben

1. Klicken Sie mit der rechten Maustaste auf den Ordner res und gehen Sie zu Neu> Android-Ressourcenverzeichnis . Das
   Fenster Neues Ressourcenverzeichnis wird angezeigt.
   
2. Wählen Sie in der Liste Ressourcentyp die Schriftart aus und klicken Sie auf OK.
   
3. Fügen Sie Ihre Schriftart - Dateien in Font - Verzeichnis .Der Ordnerstruktur unten erzeugt R.font.dancing_script, R.font.la_laund R.font.ba_ba.
   
4. Doppelklicken Sie auf eine Schriftartdatei, um eine Vorschau der Schriftarten der Datei im Editor anzuzeigen.

Als nächstes müssen wir eine Schriftfamilie erstellen:

1. Klicken Sie mit der rechten Maustaste auf den Schriftartenordner und gehen Sie zu Neu> Schriftartressourcendatei . Das Fenster Neue Ressourcendatei wird angezeigt.
   
2. Geben Sie den Dateinamen ein und klicken Sie auf OK . Die neue XML-Schriftartressource wird im Editor geöffnet.
   

3. Fügen Sie jede Schriftartdatei, jeden Stil und jedes Gewichtsattribut in das Schriftart-Tag-Element ein. Das folgende XML veranschaulicht das Hinzufügen von font-bezogenen Attributen in der XML-Schriftartressource:

Hinzufügen von Schriftarten zu einer Textansicht:

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

Wie aus der Dokumentation

Arbeiten mit Schriftarten

Alle Schritte sind korrekt.

Für benutzerdefinierte Schriftarten in Android erstellen Sie einen Ordner innerhalb des Assets-Ordnernamens. "Schriftarten" platzieren Sie die gewünschte fonts.ttf- oder .otf-Datei darin.

Wenn Sie UIBaseFragment erweitern:

Typeface font = Typeface.createFromAsset(getActivity().getAssets(), "fonts/Arial.ttf");
        tv.setTypeface(font);

sonst wenn erweitert Aktivität:

Typeface font = Typeface.createFromAsset(getContext().getAssets(), "fonts/Arial.ttf");
        tv.setTypeface(font);

Sie können PixlUI unter https://github.com/neopixl/PixlUI verwenden

Importieren Sie ihre .jar und verwenden Sie sie in XML

 <com.neopixl.pixlui.components.textview.TextView
    android:id="@+id/textView1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world"
    pixlui:typeface="GearedSlab.ttf" />

Da ich mit allen auf SO vorgestellten Lösungen nicht zufrieden war, habe ich mir meine ausgedacht. Es basiert auf einem kleinen Trick mit Tags (dh Sie können keine Tags in Ihrem Code verwenden). Ich habe den Schriftpfad dort eingefügt. Wenn Sie Ansichten definieren, können Sie Folgendes tun:

<TextView
        android:id="@+id/textViewHello1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World 1"
        android:tag="fonts/Oswald-Regular.ttf"/>

oder dieses:

<TextView
        android:id="@+id/textViewHello2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World 2"
        style="@style/OswaldTextAppearance"/>

<style name="OswaldTextAppearance">
        <item name="android:tag">fonts/Oswald-Regular.ttf</item>
        <item name="android:textColor">#000000</item>
</style>

Jetzt können Sie entweder explizit auf die Ansicht zugreifen oder sie einrichten als:

TextView textView = TextViewHelper.setupTextView(this, R.id.textViewHello1).setText("blah");

oder einfach alles einrichten über:

TextViewHelper.setupTextViews(this, (ViewGroup) findViewById(R.id.parentLayout)); // parentLayout is the root view group (relative layout in my case)

Und was ist der Zauberkurs, den du fragst? Meistens von anderen SO-Posts geklebt, mit Hilfsmethoden für Aktivität und Fragmente:

import android.app.Activity;
import android.content.Context;
import android.graphics.Typeface;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import java.util.HashMap;
import java.util.Map;

public class TextViewHelper {
    private static final Map<String, Typeface> mFontCache = new HashMap<>();

    private static Typeface getTypeface(Context context, String fontPath) {
        Typeface typeface;
        if (mFontCache.containsKey(fontPath)) {
            typeface = mFontCache.get(fontPath);
        } else {
            typeface = Typeface.createFromAsset(context.getAssets(), fontPath);
            mFontCache.put(fontPath, typeface);
        }
        return typeface;
    }

    public static void setupTextViews(Context context, ViewGroup parent) {
        for (int i = parent.getChildCount() - 1; i >= 0; i--) {
            final View child = parent.getChildAt(i);
            if (child instanceof ViewGroup) {
                setupTextViews(context, (ViewGroup) child);
            } else {
                if (child != null) {
                    TextViewHelper.setupTextView(context, child);
                }
            }
        }
    }

    public static void setupTextView(Context context, View view) {
        if (view instanceof TextView) {
            if (view.getTag() != null) // also inherited from TextView's style
            {
                TextView textView = (TextView) view;
                String fontPath = (String) textView.getTag();
                Typeface typeface = getTypeface(context, fontPath);
                if (typeface != null) {
                    textView.setTypeface(typeface);
                }
            }
        }
    }

    public static TextView setupTextView(View rootView, int id) {
        TextView textView = (TextView) rootView.findViewById(id);
        setupTextView(rootView.getContext().getApplicationContext(), textView);
        return textView;
    }

    public static TextView setupTextView(Activity activity, int id) {
        TextView textView = (TextView) activity.findViewById(id);
        setupTextView(activity.getApplicationContext(), textView);
        return textView;
    }
}

Leider gibt es dafür keine gute Lösung.

Ich habe die vielen Artikel über die Verwendung einer benutzerdefinierten Textansicht gesehen, aber was sie vergessen, ist, dass nicht nur Textansichten Schriftarten implementieren können und dass Textansichten in anderen Ansichten versteckt sind, auf die der Entwickler nicht zugreifen kann. Ich werde nicht einmal mit Spannable anfangen .

Sie können ein externes Schriftart-Dienstprogramm wie das folgende verwenden:

Kalligraphie-Schriftwerkzeug

ABER dies durchläuft jede Ansicht in der Anwendung bei ihrer Erstellung und selbst dieses Dienstprogramm vermisst einige Ansichten (ViewPager rendert normale Schriftarten). Wenn Google seine Build-Tools aktualisiert, stürzt dies gelegentlich ab, da veraltete Eigenschaften als Ziel ausgewählt werden müssen. Es ist auch etwas langsam, da es Javas Reflection verwendet .

Es liegt wirklich an Google, dies zu beheben. Wir brauchen eine bessere Unterstützung für Schriftarten in Android. Wenn Sie sich die Lösung von iOS ansehen, sind buchstäblich Hunderte von Schriftarten zur Auswahl. Möchten Sie eine benutzerdefinierte Schriftart? Geben Sie einfach einen TFF ein und es ist verwendbar.

Im Moment beschränkten wir uns nun auf das Angebot, das Google uns anbietet, das extrem begrenzt, aber glücklicherweise für Mobilgeräte optimiert ist.

Stellen Sie sicher, dass Sie den obigen Code nach Ihrem Aufruf von super und dem Aufruf von setContentView () in onCreate () einfügen. Dieses kleine Detail hielt mich eine Weile auf.

Mit Android 8.0 wurde die Verwendung von benutzerdefinierten Schriftarten in der Anwendung einfach downloadable fonts. Wir können Schriftarten direkt res/font/ folderim Projektordner hinzufügen. Auf diese Weise werden die Schriftarten automatisch in Android Studio verfügbar.

Setzen Sie nun das fontFamilyAttribut auf die Liste der Schriftarten oder klicken Sie auf mehr und wählen Sie die Schriftart Ihrer Wahl aus. Dadurch wird Ihrer Textansicht eine tools:fontFamily="@font/your_font_file"Zeile hinzugefügt.

Dadurch werden automatisch einige Dateien generiert.

1. Im Werteordner wird erstellt fonts_certs.xml.

2. In Manifest werden folgende Zeilen hinzugefügt:

  <meta-data
            android:name="preloaded_fonts"
            android:resource="@array/preloaded_fonts" /> 

3. preloaded_fonts.xml

<resources>
    <array name="preloaded_fonts" translatable="false">
        <item>@font/open_sans_regular</item>
        <item>@font/open_sans_semibold</item>
    </array>
</resources>

Sie können die einfache EasyFonts- Bibliothek von Drittanbietern verwenden, um verschiedene benutzerdefinierte Schriftarten für Ihre Bibliothek festzulegenTextView . Wenn Sie diese Bibliothek verwenden, müssen Sie sich nicht um das Herunterladen und Hinzufügen von Schriftarten zum Ordner "Assets / Fonts" kümmern. Auch über die Erstellung von Schriftobjekten.

Anstatt

Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(myTypeface);

Einfach:

TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(EasyFonts.robotoThin(this));

Diese Bibliothek bietet auch die folgende Schriftart.

• Roboto
• Droid Serif
• Droidenroboter
• Freiheit
• Fun Raiser
• Android Nation
• Grüne Avocado
• Anerkennung

Ich hatte das gleiche Problem, der TTF wurde nicht angezeigt. Ich habe die Schriftartdatei geändert und mit demselben Code funktioniert es.

Wenn Sie die Schriftart aus dem Netzwerk laden oder einfach formatieren möchten, können Sie Folgendes verwenden:

https://github.com/shellum/fontView

Beispiel:

<!--Layout-->
<com.finalhack.fontview.FontView
        android:id="@+id/someFontIcon"
        android:layout_width="80dp"
        android:layout_height="80dp" />

//Java:
fontView.setupFont("http://blah.com/myfont.ttf", true, character, FontView.ImageType.CIRCLE);
fontView.addForegroundColor(Color.RED);
fontView.addBackgroundColor(Color.WHITE);

Nun, nach sieben Jahren können Sie die gesamte App textViewoder das, was Sie wollen, einfach mit den android.supportBibliotheken 26 ++ ändern .

Z.B:

Erstellen Sie Ihre Schriftpaket- App / src / res / font und verschieben Sie Ihre Schriftart hinein.

Und in Ihrem App-Thema fügen Sie es einfach als fontFamily hinzu:

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

Beispiel zur Verwendung textViewnur mit:

<style name="fontTextView" parent="@android:style/Widget.TextView">
    <item name="android:fontFamily">monospace</item>
</style>

Und fügen Sie Ihrem Hauptthema hinzu:

<item name="android:textViewStyle">@style/fontTextView</item>

Derzeit wird an 8.1 bis 4.1 API Jelly Bean gearbeitet. Und das ist eine breite Palette.

Antwort aktualisieren: Android 8.0 (API-Level 26) führt eine neue Funktion ein, Schriftarten in XML. Verwenden Sie einfach die Funktion "Schriftarten in XML" auf Geräten mit Android 4.1 (API-Stufe 16) und höher. Verwenden Sie die Support-Bibliothek 26.

siehe diesen Link

Alte Antwort

Es gibt zwei Möglichkeiten, Schriftarten anzupassen:

!!! meine benutzerdefinierte Schriftart in assets / fonts / iran_sans.ttf

Weg 1: Refrection Typeface.class ||| bester Weg

Rufen Sie FontsOverride.setDefaultFont () in der Klasse Extend Application auf. Dieser Code bewirkt, dass alle Software-Schriftarten geändert werden, auch Toasts-Schriftarten

AppController.java

public class AppController extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        //Initial Font
        FontsOverride.setDefaultFont(getApplicationContext(), "MONOSPACE", "fonts/iran_sans.ttf");

    }
}

FontsOverride.java

public class FontsOverride {

    public static void setDefaultFont(Context context, String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(), fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    }

    private static void replaceFont(String staticTypefaceFieldName, final Typeface newTypeface) {
        try {
            final Field staticField = Typeface.class.getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Weg 2: Verwenden Sie setTypeface

Für eine spezielle Ansicht rufen Sie einfach setTypeface () auf, um die Schriftart zu ändern.

CTextView.java

public class CTextView extends TextView {

    public CTextView(Context context) {
        super(context);
        init(context,null);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context,attrs);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context,attrs);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init(context,attrs);
    }

    public void init(Context context, @Nullable AttributeSet attrs) {

        if (isInEditMode())
            return;

        // use setTypeface for change font this view
        setTypeface(FontUtils.getTypeface("fonts/iran_sans.ttf"));

    }
}

FontUtils.java

public class FontUtils {

    private static Hashtable<String, Typeface> fontCache = new Hashtable<>();

    public static Typeface getTypeface(String fontName) {
        Typeface tf = fontCache.get(fontName);
        if (tf == null) {
            try {
                tf = Typeface.createFromAsset(AppController.getInstance().getApplicationContext().getAssets(), fontName);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            fontCache.put(fontName, tf);
        }
        return tf;
    }

}

Die korrekte Vorgehensweise ab API 26 ist in der offiziellen Dokumentation hier beschrieben:

https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html

Dazu müssen die ttf-Dateien im Ordner res / font abgelegt und eine Schriftfamiliendatei erstellt werden.

Die einfachste Lösung, die Android jetzt unterstützt!

Verwenden Sie eine benutzerdefinierte Schriftart in XML:

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:fontFamily="@font/[your font resource]"/>

Details sehen:

https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html

• Öffnen Sie Ihr Projekt und wählen Sie oben links Projekt
• app -> src -> main
• Klicken Sie mit der rechten Maustaste auf main und erstellen Sie den Verzeichnisnamen als Assets
• Rechtsklick auf assest und neue Verzeichnisnamen es Schriftarten
• Sie müssen freie Schriftarten wie freie Schriftarten finden
• Geben Sie es Ihrer Textansicht und rufen Sie es in Ihrer Aktivitätsklasse auf
• Kopieren Sie Ihre Schriftarten in den Schriftarten - Ordner
• TextView txt = (TextView) findViewById(R.id.txt_act_spalsh_welcome); Typeface font = Typeface.createFromAsset(getAssets(), "fonts/Aramis Italic.ttf"); txt.setTypeface(font);

Der Name der Schriftart muss korrekt sein und Spaß haben

Ja, herunterladbare Schriftarten sind so einfach, wie Dipali sagte.

Das ist wie man es macht...

1. Platziere a TextView.
2. fontFamilyWählen Sie im Eigenschaftenbereich die Dropdown-Liste aus. Wenn es nicht vorhanden ist, suchen Sie das Caret-Ding (das> und klicken Sie darauf, um es zu erweitern textAppearance) unter.
3. Erweitern Sie die font-familyDropdown-Liste.
4. Scrollen Sie in der kleinen Liste ganz nach unten, bis Sie sehen more fonts
5. Dies öffnet ein Dialogfeld, in dem Sie suchen können Google Fonts
6. Suchen Sie mit der Suchleiste oben nach der gewünschten Schriftart
7. Wählen Sie Ihre Schriftart.
8. Wählen Sie den Stil der gewünschten Schriftart aus (z. B. fett, normal, kursiv usw.).
9. Wählen Sie im rechten Bereich das Optionsfeld aus Add font to project
10. Klicken Sie auf OK. Jetzt hat Ihre TextView die Schriftart, die Sie mögen!

BONUS: Wenn Sie ALLES mit Text in Ihrer Anwendung mit der ausgewählten Schriftart formatieren möchten, fügen <item name="android:fontfamily">@font/fontnamehere</item>Sie einfach Ihre hinzustyles.xml