Android - Verwenden von benutzerdefinierten Font

https://stackoverflow.com/questions/3651086

01-10-2019
|

Frage

I angewandt, um eine benutzerdefinierte Schriftart auf einen TextView, aber es scheint nicht die Schriftart 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 jemand bitte hol mich diese Frage aus?

Lösung

Auf Mobiletuts + gibt es sehr gutes Tutorial auf Text für Android Formatierung. Quick Tip: Anpassen Android Fonts

EDIT: es mir jetzt getestet. Hier ist die Lösung. Sie können einen Unterordner namens Fonts verwenden, aber es muss im assets Ordner nicht der res Ordner gehen. So

assets / fonts

Vergewissern Sie sich auch, dass die Schrift endet ich das Ende der Schriftdatei bedeuten selbst ist alles in Kleinbuchstaben. Mit anderen Worten es nicht myFont.TTF aber myfont.ttf diese Art und Weise muss in Kleinbuchstaben eingegeben werden

sein sollte

Andere Tipps

Nachdem die meisten der beschriebenen Lösungen in diesem Thread versucht, ich versehentlich Kalligraphie gefunden ( https://github.com/chrisjenx/Calligraphy) - eine Bibliothek von Christopher Jenkins, die Sie ganz einfach hinzufügen benutzerdefinierte Schriftarten auf Ihre App können. Die Vorteile seiner lib vorgeschlagen hier Ansätze zu vergleichen sind:

Sie haben nicht Ihre eigene überschriebene Textview-Komponente einzuführen, verwenden Sie die eingebaute in Textview
Sie können, sind leicht mit der Bibliothek gradle
Die Bibliothek schränkt Ihre Auswahl an Schriften; Sie einfach Ihre bevorzugte diejenigen auf das Vermögen dir
Sie nicht nur individuelle Textansichten bekommen -. Alle anderen textbasierten Android compontents wird auch Ihre eigene Schriftart angezeigt werden mit

Ich weiß, es gibt gute Antworten schon, 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 ist die benutzerdefinierten Attribute. Dies sollte zu Ihrer res/attrs.xml Datei gehen:

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

Und hier ist, wie Sie es verwenden. Ich werde ein relatives Layout verwenden, um sie zu wickeln und die customAttr Erklärung zeigen, aber es könnte natürlich sein, was Layout, 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 dies erfolgreich eingesetzt vor. Der einzige Unterschied zwischen unseren Implementierungen ist, dass ich nicht in Vermögenswerte einen Unterordner mit. Nicht sicher, ob das etwas ändern wird, aber.

Sofern Sie die Schrift an der richtigen Stelle platziert und es gibt keine Fehler in der Font-Datei selbst, Ihr Code sollte so funktionieren, Klapperschlange.

Allerdings wäre es viel einfacher, wenn Sie nur eine Schriftart in Layout XML definieren könnten, wie diese:

<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 dem beigefügten 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>

habe ich ein paar Tools, die speziell für diesen Zweck. Siehe dieses Projekt von GitHub, oder nehmen Sie einen Blick auf diese post Blog, die die ganze Sache erklärt

Für Custom Fonts in Android einen Ordner innerhalb Assets Ordner Namen „Schriftarten“ die gewünschten Schriftarten.ttf oder OTF-Datei in ihm setzen.

Wenn Sie sich UIBaseFragment:

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

else if erweitert Aktivität:

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

Der beste Weg, um es aus dem Android O Preview-Version zu tun ist, auf diese Weise:
Es funktioniert nur, wenn Sie Android Studio-2.4 oder höher

Rechtsklick auf das res Ordner und gehen Sie auf Neu> Android Ressourcenverzeichnis . Die neue
Resource Directory Fenster angezeigt.
In der Liste Ressourcentyp die Option Schrift und dann auf OK klicken.
Fügen Sie Ihre Schriftdateien in Font-Verzeichnis .Die Ordnerstruktur unterhalb erzeugt R.font.dancing_script, R.font.la_la und R.font.ba_ba.
Doppelklicken Sie auf eine Font-Datei der Datei Fonts im Editor in der Vorschau anzeigen.

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

Rechtsklick auf den Ordner Schriftart und gehen Sie auf Neu> Font-Ressource-Datei . Das neue Ressourcendatei-Fenster erscheint.
Geben Sie den Dateinamen, und klicken Sie dann auf OK . Die neue Schriftart-Ressource XML wird im Editor geöffnet.
Setzen Sie jede Font-Datei, Stil und Gewicht Attribut in dem font-Tag-Elemente. Die folgende XML illustriert das Hinzufügen font-bezogene Attribute in der Schriftart-Ressource XML:

Schriften in einem Textview Hinzufügen:

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

Wie aus der Dokumentation

Arbeiten mit Schriften

Alle Schritte korrekt sind.

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

importieren ihre .jar und verwenden Sie es 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 nicht mit allen vorgestellten Lösungen auf so zufrieden war, habe ich mit meiner kommen. Es basiert auf einem kleinen Trick mit Tags (das heißt Sie können keine Tags in Ihrem Code verwenden), habe ich den Font-Pfad gibt. Also, wenn Ansichten zu definieren, können Sie entweder diese:

<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 folgt aus:

<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 Zugriff / setup die Ansicht als:

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

oder Setup alles über:

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

Und was ist die magische Klasse fragen Sie? Meist aus einem anderen SO Pfosten geklebt, mit Hilfsmethoden sowohl 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 keine gute Lösung.

Ich habe viele Artikel gesehen eine benutzerdefinierte Textview zu verwenden, aber was sie vergessen, dass es nicht nur Textviews ist die Schriftarten umsetzen können und es gibt Textviews versteckt in anderen Ansichten in den Entwickler unzugänglichen; Ich werde nicht einmal auf, um loszulegen Spannable .

Sie können ein externes font Dienstprogramm wie verwenden:

Kalligraphieguß Werkzeug

ABER Diese Schleifen über jede Ansicht in der Anwendung auf seine Schöpfung und auch dieses Dienstprogramm vermisst einige Ansichten (ViewPager macht normale Schrift), dann haben Sie das Problem, dass, wenn Google aktualisiert ihre Build-Tools dieser Wille gelegentlich abstürzen, weil es veraltet Eigenschaften zum Ziel benötigt. Es ist auch ein wenig langsam, wie es verwendet Java Reflection .

Es ist wirklich an Google dies zu beheben. Wir brauchen eine bessere Schriftart-Unterstützung in Android. Wenn Sie bei der Lösung von iOS sehen sie haben buchstäblich 100 von Fonts im eingebauten zur Auswahl. Möchten Sie eine benutzerdefinierte Schriftart? Einfach eine TFF fallen in und es ist verwendbar ..

Vorerst wurden nun auf das Angebot begrenzt, dass Google bietet uns die extrem begrenzt ist, aber zum Glück mobil optimiert.

Achten Sie darauf, den obigen Code in onCreate einzufügen () nach Ihr Anruf an die Super- und der Anruf an setContentView (). Dieses kleine Detail hielt meine hung up für eine Weile.

Mit Android 8.0 in Anwendung von benutzerdefinierten Schriftarten verwendet wurde leicht mit downloadable fonts. Wir können Schriftarten hinzufügen direkt mit dem res/font/ folder im Projektordner, und dabei, die Schriftarten automatisch in Android Studio verfügbar sind.

Nun setzen fontFamily Attribut Liste der Schriftarten oder klicken Sie auf mehr und wählen Sie Schriftart Ihrer Wahl. Dies wird Add tools:fontFamily="@font/your_font_file" Zeile in den Textview.

Dies wird automatisch einige Dateien erzeugen.

1. In Werten Ordner es fonts_certs.xml schaffen wird.

2 In Manifest wird diese Zeilen hinzufügen.

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

Ich hatte das gleiche Problem hat die TTF nicht auf. Ich habe die Font-Datei, und mit dem gleichen Code, es funktioniert.

Wenn Sie die Schrift aus dem Netz geladen werden sollen oder einfach Stil es, können Sie:

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 ganze app textView ändern oder was Sie wollen einfach durch android.support Bibliotheken mit 26 ++.

Z. B:

Erstellen Sie Ihre font-Paket app / src / res / font und bewegen Sie die Schrift hinein.

Und in der App Thema fügen Sie ihn einfach als family:

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

Beispiel für die Verwendung mit textView nur:

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

Und fügen Sie in Ihr Hauptthema:

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

Zur Zeit ist es funktioniert auf 8.1 bis 4.1 API Jelly Bean Und das ist eine große Auswahl.

Update Antwort: Android 8.0 (API-Ebene 26) führt ein neues Feature, Fonts in XML. benutzen Sie einfach die Schriften in XML-Funktion auf Geräten mit Android 4.1 (API-Ebene 16) und höher, verwenden Sie die Support Library 26

finden Sie in diesem Link

Alt Antwort

Es gibt zwei Möglichkeiten, Schriftarten anpassen:

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

Way 1: Reflection Typeface.class ||| beste

Aufruf FontsOverride.setDefaultFont () in Klasse erweitert Anwendung, wird dieser Code alle Software-Schriftarten verursachen 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();
        }
    }
}

Way 2: Verwendung setTypeface

für spezielle Ansicht nur Anruf setTypeface (), um Schrift ä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;
    }

}

Sie können mit einfacher und einfacher EasyFonts Dritter Bibliothek Satz Vielzahl von benutzerdefinierten Schriften in Ihrem TextView. Durch diese Bibliothek nutzen, sollten Sie sich keine Sorgen machen müssen über das Herunterladen und das Hinzufügen von Schriftarten in das Vermögen / Fonts-Ordner. Auch über Schriftbild Objekterstellung.

Anstelle von

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

Einfach gesagt:

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

Diese Bibliothek stellt auch folgende Schriftart.

Roboto
Droid Serif
Droid Roboter
Freiheit
Spaß Raiser
Android Nation
Green Avocado
Anerkennung

Der richtige Weg, dies zu tun, wie der API 26 ist in der offiziellen Dokumentation hier beschrieben:

https: // Entwickler .android.com / guide / Themen / ui / Look-and-Feel / fonts-in-xml.html

Dabei wird die ttf-Dateien in res / font Ordnern ablegen und eine font-family-Datei zu erstellen.

Die einfachste Lösung Android jetzt unterstützt!

Verwenden Sie benutzerdefinierte Schriftarten in xml:

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

siehe Details:

https: // Entwickler .android.com / guide / Themen / ui / Look-and-Feel / fonts-in-xml.html

Öffnen Sie Ihr Projekt und wählen Sie Projekt links oben
App -> src -> Haupt
Recht auf Haupt klicken und Verzeichnisnamen als Vermögen
Rechtsklick auf assest und neuen Verzeichnisnamen es Schriftarten
benötigen Sie den kostenlosen Schriftarten wie kostenlose Fonts und Schriftarten
geben Sie es zu Ihrem Textview und nennen Sie es in Ihrer Aktivitätsklasse
Kopieren Sie Ihre Schriften in der Schriftarten Ordner
TextView txt = (TextView) findViewById(R.id.txt_act_spalsh_welcome); Typeface font = Typeface.createFromAsset(getAssets(), "fonts/Aramis Italic.ttf"); txt.setTypeface(font);

Name der Schriftart muss korrekt sein und Spaß haben

Ja, herunterladbare Schriften sind so einfach, wie Dipali s , sagte.

Dies ist, wie Sie es tun ...

Legen Sie eine TextView.
Sie im Eigenschaftenbereich die fontFamily Dropdown-Menü. Wenn es nicht vorhanden ist, findet das caret Dingen (die> und klicken Sie darauf textAppearance zu erweitern) unter dem.
Erweitern Sie das font-family Dropdown.
In der kleinen Liste scrollen ganz nach unten, bis Sie sehen more fonts
Das wird ein Dialogfeld geöffnet, in dem Sie von Google Fonts suchen
Suchen Sie die Schriftart, die Sie wie mit der Suchleiste am oberen
Wählen Sie Ihre Schriftart.
Wählen Sie den Stil der Schriftart, die Sie mögen (das heißt fett, normal, kursiv, etc.)
im rechten Fensterbereich, wählen Sie das Optionsfeld, das sagt Add font to project
Klicken Sie auf OK. Jetzt ist Ihre Textview hat die Schriftart, die Sie mögen!

BONUS: Wenn Sie mit gewählten Schriftart Stil ALLES mit Text in Ihrer Anwendung haben mögen, fügen Sie einfach <item name="android:fontfamily">@font/fontnamehere</item> in Ihre styles.xml

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow