Ich versuche, ein GUI-Layout mithilfe von XML-Dateien in Android zu definieren. Soweit ich herausfinden kann, kann nicht angegeben werden, dass Ihre Widgets eine benutzerdefinierte Schriftart (z. B. eine, die Sie in Assets / font / platziert haben) in XML-Dateien verwenden sollen, und Sie können nur die vom System installierten Schriftarten verwenden.

Ich weiß, dass ich im Java-Code die Schriftart jedes Widgets manuell mithilfe eindeutiger IDs ändern kann. Alternativ könnte ich alle Widgets in Java durchlaufen, um diese Änderung vorzunehmen, aber dies wäre wahrscheinlich sehr langsam.

Welche anderen Optionen habe ich? Gibt es bessere Möglichkeiten, Widgets mit einem benutzerdefinierten Erscheinungsbild zu erstellen? Ich möchte nicht besonders die Schriftart für jedes neue Widget, das ich hinzufüge, manuell ändern müssen.

Sie können TextView erweitern, um benutzerdefinierte Schriftarten festzulegen, wie ich hier erfahren habe .

TextViewPlus.java:

package com.example;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.TextView;

public class TextViewPlus extends TextView {
    private static final String TAG = "TextView";

    public TextViewPlus(Context context) {
        super(context);
    }

    public TextViewPlus(Context context, AttributeSet attrs) {
        super(context, attrs);
        setCustomFont(context, attrs);
    }

    public TextViewPlus(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setCustomFont(context, attrs);
    }

    private void setCustomFont(Context ctx, AttributeSet attrs) {
        TypedArray a = ctx.obtainStyledAttributes(attrs, R.styleable.TextViewPlus);
        String customFont = a.getString(R.styleable.TextViewPlus_customFont);
        setCustomFont(ctx, customFont);
        a.recycle();
    }

    public boolean setCustomFont(Context ctx, String asset) {
        Typeface tf = null;
        try {
        tf = Typeface.createFromAsset(ctx.getAssets(), asset);  
        } catch (Exception e) {
            Log.e(TAG, "Could not get typeface: "+e.getMessage());
            return false;
        }

        setTypeface(tf);  
        return true;
    }

}

attrs.xml: (in res / values)

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

main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:foo="http://schemas.android.com/apk/res/com.example"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <com.example.TextViewPlus
        android:id="@+id/textViewPlus1"
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        android:text="@string/showingOffTheNewTypeface"
        foo:customFont="saxmono.ttf">
    </com.example.TextViewPlus>
</LinearLayout>

Sie würden "saxmono.ttf" in den Assets- Ordner legen .

UPDATE 8/1/13

Bei dieser Methode gibt es ernsthafte Speicherprobleme. Siehe den Kommentar von chedabob unten.

Ich bin 3 Jahre zu spät für die Party :( Dies könnte jedoch für jemanden nützlich sein, der über diesen Beitrag stolpern könnte.

Ich habe eine Bibliothek geschrieben, die Schriften zwischenspeichert und es Ihnen ermöglicht, benutzerdefinierte Schriften direkt aus XML anzugeben. Die Bibliothek finden Sie hier .

So würde Ihr XML-Layout aussehen, wenn Sie es verwenden.

<com.mobsandgeeks.ui.TypefaceTextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world"
    geekui:customTypeface="fonts/custom_font.ttf" />

Dies kann etwas spät sein, aber Sie müssen eine Singleton-Klasse erstellen, die die benutzerdefinierte Schriftart zurückgibt, um Speicherverluste zu vermeiden.

TypeFace-Klasse:

public class OpenSans {

private static OpenSans instance;
private static Typeface typeface;

public static OpenSans getInstance(Context context) {
    synchronized (OpenSans.class) {
        if (instance == null) {
            instance = new OpenSans();
            typeface = Typeface.createFromAsset(context.getResources().getAssets(), "open_sans.ttf");
        }
        return instance;
    }
}

public Typeface getTypeFace() {
    return typeface;
}
}

Benutzerdefinierte Textansicht:

public class NativelyCustomTextView extends TextView {

    public NativelyCustomTextView(Context context) {
        super(context);
        setTypeface(OpenSans.getInstance(context).getTypeFace());
    }

    public NativelyCustomTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setTypeface(OpenSans.getInstance(context).getTypeFace());
    }

    public NativelyCustomTextView(Context context, AttributeSet attrs,
            int defStyle) {
        super(context, attrs, defStyle);
        setTypeface(OpenSans.getInstance(context).getTypeFace());
    }

}

Per XML:

<com.yourpackage.views.NativelyCustomTextView
            android:id="@+id/natively_text_view"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_margin="20dp"
            android:text="@string/natively"
            android:textSize="30sp" /> 

Programmatisch:

TextView programmaticallyTextView = (TextView) 
       findViewById(R.id.programmatically_text_view);

programmaticallyTextView.setTypeface(OpenSans.getInstance(this)
                .getTypeFace());

Alte Frage, aber ich wünschte, ich würde diese Antwort hier lesen, bevor ich mich auf die Suche nach einer guten Lösung mache. Calligraphy erweitert das android:fontFamilyAttribut, um Unterstützung für benutzerdefinierte Schriftarten in Ihrem Asset-Ordner hinzuzufügen, wie folgt:

<TextView 
  android:text="@string/hello_world"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:fontFamily="fonts/Roboto-Bold.ttf"/>

Das einzige, was Sie tun müssen, um es zu aktivieren, ist es an den Kontext der Aktivität anzuhängen, die Sie verwenden:

@Override
protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(new CalligraphyContextWrapper(newBase));
}

Sie können auch Ihr eigenes benutzerdefiniertes Attribut angeben, das ersetzt werden soll android:fontFamily

Es funktioniert auch in Themen, einschließlich AppTheme.

Verwenden von DataBinding :

@BindingAdapter({"bind:font"})
public static void setFont(TextView textView, String fontName){
 textView.setTypeface(Typeface.createFromAsset(textView.getContext().getAssets(), "fonts/" + fontName));
}

In XML:

<TextView
app:font="@{`Source-Sans-Pro-Regular.ttf`}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>

Schriftartdatei muss in sein assets/fonts/

Wenn Sie nur eine Schriftart haben, die Sie hinzufügen möchten, und weniger Code schreiben möchten, können Sie eine dedizierte Textansicht für Ihre spezifische Schriftart erstellen. Siehe Code unten.

package com.yourpackage;
import android.content.Context;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.TextView;

public class FontTextView extends TextView {
    public static Typeface FONT_NAME;


    public FontTextView(Context context) {
        super(context);
        if(FONT_NAME == null) FONT_NAME = Typeface.createFromAsset(context.getAssets(), "fonts/FontName.otf");
        this.setTypeface(FONT_NAME);
    }
    public FontTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        if(FONT_NAME == null) FONT_NAME = Typeface.createFromAsset(context.getAssets(), "fonts/FontName.otf");
        this.setTypeface(FONT_NAME);
    }
    public FontTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        if(FONT_NAME == null) FONT_NAME = Typeface.createFromAsset(context.getAssets(), "fonts/FontName.otf");
        this.setTypeface(FONT_NAME);
    }
}

In main.xml können Sie Ihre Textansicht jetzt folgendermaßen hinzufügen:

<com.yourpackage.FontTextView
    android:id="@+id/tvTimer"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="" />

Der beste Weg, dies zu tun Ab Android O Preview Release ist dieser Weg
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 Schriftdateien in den Schriftordner ein. 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> Schriftressourcendatei . 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 Schriftstil und jedes Gewichtsattribut in das Schriftart-Tag-Element ein. Das folgende XML veranschaulicht das Hinzufügen von font-bezogenen Attributen zum XML der Schriftartressource:

<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android">
    <font
    android:fontStyle="normal"
    android:fontWeight="400"
    android:font="@font/hey_regular" />
    <font
    android:fontStyle="italic"
    android:fontWeight="400"
    android:font="@font/hey_bababa" />
</font-family>

Hinzufügen von Schriftarten zu einer Textansicht:

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

Wie aus der Dokumentation

Arbeiten mit Schriftarten

Alle Schritte sind korrekt.

Erweitern Sie es TextViewund geben Sie ihm ein benutzerdefiniertes Attribut, oder verwenden Sie einfach das android: tag-Attribut, um eine Zeichenfolge mit der gewünschten Schriftart zu übergeben. Sie müssen eine Konvention auswählen und sich daran halten, da ich alle meine Schriftarten im Ordner res / assets / fonts / ablege, damit Ihre TextView-Klasse weiß, wo sie zu finden sind. Dann legen Sie in Ihrem Konstruktor die Schriftart nach dem Superaufruf einfach manuell fest.

Die einzige Möglichkeit, benutzerdefinierte Schriftarten zu verwenden, ist der Quellcode.

Denken Sie daran, dass Android auf Geräten mit sehr begrenzten Ressourcen ausgeführt wird und Schriftarten möglicherweise viel RAM benötigen. Die eingebauten Droid-Schriftarten sind speziell angefertigt und, wenn Sie bemerken, fehlen viele Zeichen und Dekorationen.

Ich könnte eine einfache Antwort auf die Frage haben, ohne die Textansicht zu erweitern und einen langen Code zu implementieren.

Code:

 TextView tv = (TextView) findViewById(R.id.textview1);
    tv.setTypeface(Typeface.createFromAsset(getAssets(), "font.ttf"));

Legen Sie die benutzerdefinierte Schriftartdatei wie gewohnt im Assets-Ordner ab und versuchen Sie dies. Für mich geht das. Ich verstehe nur nicht, warum Peter einen so großen Code für diese einfache Sache gegeben hat oder er seine Antwort in der alten Version gegeben hat.

Kann auch in der XML definiert werden, ohne benutzerdefinierte Klassen zu erstellen

style.xml

<style name="ionicons" parent="android:TextAppearance">
    <!-- Custom Attr-->
    <item name="fontPath">fonts/ionicons.ttf</item>
</style>

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:app="http://schemas.android.com/apk/res-auto"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical" >
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="@style/ionicons"
        android:text=""/>
</LinearLayout>

Ein kurzer Hinweis, da ich einfach immer vergessen habe, wo die Schriftarten abgelegt werden sollen, muss sich die Schriftart darin befinden assetsund dieser Ordner befindet sich auf derselben Ebene wie resund srcin meinem Fall auf seinerassets/fonts/ionicons.ttf

Aktualisiert Root-Layout hinzugefügt, da diese Methode xmlns:app="http://schemas.android.com/apk/res-auto"funktionieren muss

Update 2 Ich habe eine Bibliothek vergessen, die ich zuvor installiert habe und die Kalligraphie heißt

Peters Antwort ist die beste, aber sie kann verbessert werden, indem Sie die Datei styles.xml von Android verwenden, um Ihre Schriftarten für alle Textansichten in Ihrer App anzupassen.

Mein Code ist hier

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

}

In diesem Tutorial erfahren Sie, wie Sie eine benutzerdefinierte Schriftart wie @peter einrichten: http://responsiveandroid.com/2012/03/15/custom-fonts-in-android-widgets.html

Es werden auch mögliche Speicherverluste berücksichtigt, unter anderem http://code.google.com/p/android/issues/detail?id=9904 . Im Tutorial finden Sie auch ein Beispiel für das Festlegen einer benutzerdefinierten Schriftart auf einer Schaltfläche.

Sie können einfach eine benutzerdefinierte Textansichtsklasse erstellen: -

Also, was Sie zuerst tun müssen, machen Sie Custom textviewKlasse, die mit erweitert AppCompatTextView.

public class CustomTextView extends AppCompatTextView {
    private int mFont = FontUtils.FONTS_NORMAL;
    boolean fontApplied;

    public CustomTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(attrs, context);
    }

    public CustomTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(attrs, context);
    }

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

    protected void init(AttributeSet attrs, Context cxt) {
        if (!fontApplied) {
            if (attrs != null) {
                mFont = attrs.getAttributeIntValue(
                        "http://schemas.android.com/apk/res-auto", "Lato-Regular.ttf",
                        -1);
            }
            Typeface typeface = getTypeface();
            int typefaceStyle = Typeface.NORMAL;
            if (typeface != null) {
                typefaceStyle = typeface.getStyle();
            }
            if (mFont > FontUtils.FONTS) {
                typefaceStyle = mFont;
            }
            FontUtils.applyFont(this, typefaceStyle);
            fontApplied = true;
        }
    }
}

Jetzt erhalten Sie jedes Mal, wenn eine benutzerdefinierte Textansicht aufgerufen wird, einen int-Wert vom Attribut int fontValue = attrs.getAttributeIntValue("http://schemas.android.com/apk/res-auto","Lato-Regular.ttf",-1).

Oder

Wir können getTypeface () auch aus der Ansicht abrufen, die wir in unserer xml ( android:textStyle="bold|normal|italic") festgelegt haben. Also mach was immer du willst.

Jetzt setzen wir eine FontUtilsbeliebige .ttf-Schriftart in unsere Ansicht.

public class FontUtils {

    public static final int FONTS = 1;
    public static final int FONTS_NORMAL = 2;
    public static final int FONTS_BOLD = 3;
    public static final int FONTS_BOLD1 = 4;

    private static Map<String, Typeface> TYPEFACE = new HashMap<String, Typeface>();

    static Typeface getFonts(Context context, String name) {
        Typeface typeface = TYPEFACE.get(name);
        if (typeface == null) {
            typeface = Typeface.createFromAsset(context.getAssets(), name);
            TYPEFACE.put(name, typeface);
        }
        return typeface;
    }

    public static void applyFont(TextView tv, int typefaceStyle) {

        Context cxt = tv.getContext();
        Typeface typeface;

        if(typefaceStyle == Typeface.BOLD_ITALIC) {
            typeface = FontUtils.getFonts(cxt, "FaktPro-Normal.ttf");
        }else if (typefaceStyle == Typeface.BOLD || typefaceStyle == SD_FONTS_BOLD|| typefaceStyle == FONTS_BOLD1) {
            typeface = FontUtils.getFonts(cxt, "FaktPro-SemiBold.ttf");
        } else if (typefaceStyle == Typeface.ITALIC) {
            typeface = FontUtils.getFonts(cxt, "FaktPro-Thin.ttf");
        } else {
            typeface = FontUtils.getFonts(cxt, "FaktPro-Normal.ttf");
        }
        if (typeface != null) {
            tv.setTypeface(typeface);
        }
    }
}

Es kann hilfreich sein zu wissen, dass Sie ab Android 8.0 (API-Level 26) eine benutzerdefinierte Schriftart in XML verwenden können .

Sie können eine benutzerdefinierte Schriftart auf die folgende Anwendung anwenden.

1. Legen Sie die Schriftart in den Ordner res/font.

2. Bei res/values/styles.xmlVerwendung in der Anwendung Thema. <style name="AppTheme" parent="{whatever you like}"> <item name="android:fontFamily">@font/myfont</item> </style>

Fontinator ist eine Android-Bibliothek, die es einfach macht, benutzerdefinierte Schriftarten zu verwenden. https://github.com/svendvd/Fontinator

Sie können TextView nicht erweitern, um ein Widget zu erstellen oder eines in einem Widgets-Layout zu verwenden: http://developer.android.com/guide/topics/appwidgets/index.html