Android - Benutzerdefinierte Schriftart verwenden

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

1. sie müssen keine eigene überschreibbare TextView-Komponente einführen, Sie verwenden die integrierte TextView-Komponente 
2. sie können die Bibliothek problemlos in Gradle einbinden 
3. Die Bibliothek schränkt die Auswahl der Schriftarten nicht ein. Sie fügen einfach Ihre bevorzugten zu den Vermögenswerten hinzu
4. sie erhalten nicht nur benutzerdefinierte Textansichten - alle anderen textbasierten Android-Komponenten werden auch mit Ihrer benutzerdefinierten Schriftart angezeigt.

Ich weiß, es gibt bereits gute Antworten, 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.xml-Datei 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 verwende ein relatives Layout, um es einzuwickeln und die customAttr-Deklaration anzuzeigen, aber es könnte natürlich auch das 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 früher erfolgreich eingesetzt. Der einzige Unterschied zwischen unseren Implementierungen ist, dass ich keinen Unterordner in Assets verwendet habe. Nicht sicher, ob sich dadurch etwas ändert.

Vorausgesetzt, Sie haben die Schriftart an der richtigen Stelle platziert und es ist kein Fehler in der Schriftartdatei selbst vorhanden, sollte Ihr Code wie folgt funktionieren: RATTLESNAKE.

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

<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 beiliegenden 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 ein paar Tools speziell für diesen Zweck erstellt. Siehe dieses Projekt von GitHub, oder werfen Sie einen Blick auf diesen Blogbeitrag , der das Ganze erklärt.

Erstellen Sie für Benutzerdefinierte Schriftarten in Android einen Ordner innerhalb des Assets-Ordnernamens, in dem die gewünschten Schriftarten "fonts.ttf" oder.

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

Der beste Weg, dies zu tun Ab der Vorschau für Android O ist dies folgendermaßen: 

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 wechseln Sie zu New> Android-Ressourcenverzeichnis. Das neue
   Das Ressourcenverzeichnis-Fenster wird angezeigt.
   
2. Wählen Sie in der Liste Ressourcentyp font aus und klicken Sie dann auf OK.
   
3. Fügen Sie Ihre Schriftartendateien im Schriftartenordner hinzu. Die folgende Ordnerstruktur generiert R.font.dancing_script, R.font.la_la und 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> Ressourcendatei für Schriftarten. 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. Schließen Sie alle Schriftdatei-, Stil- und Gewichtsattribute in das Schriftarten-Tag-Element ein. Das folgende XML veranschaulicht das Hinzufügen von fontbezogenen Attributen in der Fontressourcen-XML:

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 

Mit Schriften arbeiten

Alle Schritte sind korrekt.

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

importieren Sie die .jar-Datei 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 all den vorgestellten Lösungen für SO nicht zufrieden war, habe ich mir meine ausgedacht. Es basiert auf einem kleinen Trick mit Tags (d. H. Sie können Tags nicht in Ihrem Code verwenden). Ich gebe den Pfad für die Schrift dort an. Wenn Sie also 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 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 die Zauberklasse, die du fragst? Meistens von anderen SO -Stellen 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. Was sie jedoch vergessen, ist, dass nicht nur Textansichten Schriftarten implementieren können und Textansichten in anderen Ansichten versteckt sind, die für den Entwickler nicht zugänglich sind. Ich werde noch nicht einmal mit Spannable anfangen.

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

Kalligraphie-Schriftart-Werkzeug

BUT Hierdurch werden alle Ansichten in der Anwendung bei ihrer Erstellung durchlaufen, und selbst dieses Dienstprogramm vermisst einige Ansichten (ViewPager stellt die normale Schriftart dar). Dann besteht das Problem, dass Google seine Build-Tools aktualisiert, da dies gelegentlich zum Absturz führt muss veraltete Eigenschaften als Ziel haben. Es ist auch etwas langsam, da es Javas Reflection verwendet.

Es liegt wirklich an Google, dies zu beheben. Wir brauchen eine bessere Schriftunterstützung in Android. Wenn Sie sich die Lösung von iOS ansehen, haben sie buchstäblich Hunderte von Schriftarten zur Auswahl. Wünschen Sie eine benutzerdefinierte Schriftart? Geben Sie einfach eine TFF ein und sie ist verwendbar.

Denn jetzt beschränken wir uns jetzt auf das Angebot, das Google uns anbietet, das zwar extrem begrenzt, aber zum Glück mobil optimiert ist.

Mit Android 8.0 wurde die Verwendung von benutzerdefinierten Zeichensätzen in der Anwendung mit downloadable fonts..__ einfach. Wir können dem res/font/ folder im Projektordner Zeichensätze direkt hinzufügen. Dadurch sind die Zeichensätze in Android Studio automatisch verfügbar .

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

Dies erzeugt automatisch wenige Dateien.

1. Im Werteordner wird fonts_certs.xml erstellt.

2. In Manifest wird folgende Zeile 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>

Stellen Sie sicher, dass Sie den obigen Code in onCreate () after Ihren Aufruf an den Super und den Aufruf von setContentView () einfügen. Dieses kleine Detail hielt mich für eine Weile auf.

Wenn Sie die Schrift aus dem Netzwerk laden oder einfach gestalten 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 Anwendung textView ändern oder ganz einfach, indem Sie Android.support-Bibliotheken 26 ++ verwenden.

Z.B:

Erstellen Sie Ihr Schriftartenpaket app/src/res/font und verschieben Sie Ihre Schrift darin.

Und in Ihrem App-Theme 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 für die Verwendung nur mit textView:

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

Und fügen Sie in Ihr Hauptthema hinzu:

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

Derzeit wird an 8.1 bis 4.1 API Jelly Bean gearbeitet. Das ist eine große Auswahl.

Ich hatte das gleiche Problem, die TTF erschien nicht. Ich habe die Schriftartdatei geändert und mit demselben Code funktioniert sie. 

Sie können die einfache und einfache EasyFonts Drittanbieter-Bibliothek verwenden, um verschiedene benutzerdefinierte Schriftarten für Ihre TextView festzulegen. Wenn Sie diese Bibliothek verwenden, müssen Sie sich keine Sorgen darüber machen, dass Sie Zeichensätze herunterladen und in den Ordner assets/fonts einfügen. Auch zur 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 folgenden Schriftarten.

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

Update-Antwort: Android 8.0 (API Level 26) führt eine neue Funktion ein, Fonts in XML . Verwenden Sie einfach das Feature Fonts in XML auf Geräten mit Android 4.1 (API Level 16) und höher die Unterstützungsbibliothek 26. 

siehe diesen link

Alte Antwort

Es gibt zwei Möglichkeiten, die 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 Application auf. Dieser Code bewirkt, dass alle Softwareschriftarten geändert werden, selbst 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: setTypeface verwenden

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

}

• Öffnen Sie Ihr Projekt und wählen Sie oben links Project
• app -> src -> main 
• klicken Sie mit der rechten Maustaste auf "main" und erstellen Sie ein Verzeichnis mit assets.
• klicken Sie mit der rechten Maustaste, um den neuen Verzeichnisnamen fonts zu prüfen und zu erstellen.
• sie müssen kostenlose Schriftarten finden wie Kostenlose Schriftarten
• geben Sie es Ihrer Textansicht und rufen Sie es in Ihrer Activity-Klasse auf
• kopieren Sie Ihre Schriftarten in den Ordner fonts
• 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

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

Benutzerdefinierte Schriftart in XML verwenden:

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

details ansehen:

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

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

Das ist wie man es macht...

1. Platziere eine TextView.
2. Wählen Sie im Eigenschaftenbereich die Dropdown-Liste fontFamily aus. Ist dies nicht der Fall, finden Sie das Caret-Ding (das> und klicken Sie darauf, um textAppearance zu erweitern) unter.
3. Erweitern Sie die Dropdown-Liste font-family.
4. Scrollen Sie in der kleinen Liste ganz nach unten, bis Sie more fonts sehen.
5. Daraufhin wird ein Dialogfeld geöffnet, in dem Sie über Google Fonts suchen können.
6. Suchen Sie nach der Schriftart, die Sie mögen, mit der Suchleiste oben
7. Wähle deine Schrift aus.
8. Wählen Sie den Stil der Schriftart aus (d. H. Fett, normal, kursiv usw.).
9. Wählen Sie im rechten Bereich das Optionsfeld mit der Aufschrift Add font to project
10. Klicken Sie auf OK. Jetzt hat Ihr TextView die Schriftart, die Sie mögen!

BONUS: Wenn Sie ALLES mit Text in Ihrer Anwendung mit der gewählten Schriftart gestalten möchten, fügen Sie einfach <item name="Android:fontfamily">@font/fontnamehere</item> in Ihren styles.xml ein.

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

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

Dazu müssen Sie die TTF-Dateien im Ordner res/font ablegen und eine Schriftfamilien-Datei erstellen.