Sto cercando di definire un layout della GUI utilizzando i file XML in Android. Per quanto ne so, non c'è modo di specificare che i tuoi widget dovrebbero usare un font personalizzato (ad esempio uno che hai inserito in asset / font /) nei file XML e puoi usare solo i font installati dal sistema.

So che, nel codice Java, potrei cambiare manualmente il carattere di ciascun widget usando ID univoci. In alternativa, potrei scorrere su tutti i widget in Java per apportare questa modifica, ma probabilmente sarebbe molto lento.

Quali altre opzioni ho? Esistono modi migliori per creare widget con un aspetto personalizzato? Non desidero particolarmente cambiare manualmente il carattere per ogni nuovo widget che aggiungo.

Puoi estendere TextView per impostare caratteri personalizzati come ho appreso qui .

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 / valori)

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

Inserire "saxmono.ttf" nella cartella delle risorse .

AGGIORNAMENTO 1/8/13

Esistono gravi problemi di memoria con questo metodo. Vedi il commento di chedabob qui sotto.

Sono in ritardo di 3 anni per la festa :( Tuttavia questo potrebbe essere utile per qualcuno che potrebbe inciampare in questo post.

Ho scritto una libreria che memorizza nella cache caratteri tipografici e consente anche di specificare caratteri tipografici personalizzati direttamente da XML. Puoi trovare la biblioteca qui .

Ecco come sarebbe il tuo layout XML, quando lo usi.

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

Potrebbe essere un po 'tardi, ma è necessario creare una classe singleton che restituisca il carattere tipografico personalizzato per evitare perdite di memoria.

Classe TypeFace:

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

TextView personalizzato:

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

livello di programmazione:

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

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

Vecchia domanda, ma vorrei sicuramente leggere questa risposta qui prima di iniziare la mia ricerca di una buona soluzione. Calligraphy estende l' android:fontFamilyattributo per aggiungere il supporto per i caratteri personalizzati nella cartella delle risorse, in questo modo:

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

L'unica cosa che devi fare per attivarlo è collegarlo al contesto dell'attività che stai utilizzando:

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

Puoi anche specificare il tuo attributo personalizzato da sostituire android:fontFamily

Funziona anche con temi, incluso AppTheme.

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

il file del carattere deve essere in assets/fonts/

Se hai un solo carattere che desideri aggiungere e vuoi scrivere meno codice, puoi creare un TextView dedicato per il tuo carattere specifico. Vedi il codice sotto.

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, ora puoi aggiungere textView in questo modo:

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

Il modo migliore per farlo Dalla versione di anteprima di Android O è in questo modo
1.) Fai clic con il pulsante destro del mouse sulla cartella res e vai su Nuovo> Directory delle risorse Android .
Viene visualizzata la finestra Nuova directory delle risorse.
2.) Nell'elenco Tipo di risorsa, selezionare il carattere , quindi fare clic su OK.
3.) Aggiungi i tuoi file di font nella cartella dei font . La struttura delle cartelle in basso genera R.font.dancing_script, R.font.la_la e R.font.ba_ba.
4.) Fare doppio clic su un file di caratteri per visualizzare in anteprima i caratteri del file nell'editor.

Quindi dobbiamo creare una famiglia di caratteri

1.) Fare clic con il tasto destro del mouse sulla cartella dei caratteri e selezionare Nuovo> File delle risorse dei caratteri . Viene visualizzata la finestra Nuovo file di risorse.
2.) Immettere il nome del file, quindi fare clic su OK . La nuova risorsa di font XML si apre nell'editor.
3.) Racchiudere ciascun file di font, stile e attributo weight nell'elemento tag font. Il seguente XML illustra l'aggiunta di attributi relativi al carattere nell'XML della risorsa carattere:

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

Aggiunta di caratteri a TextView:

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

A partire dalla documentazione

Lavorare con i caratteri

tutti i passaggi sono corretti.

Estendi TextViewe assegnagli un attributo personalizzato o usa semplicemente l'attributo android: tag per passare una stringa del tipo di carattere che vuoi usare. Dovrai scegliere una convenzione e attenersi ad essa, in quanto inserirò tutti i miei caratteri nella cartella res / assets / fonts / in modo che la tua classe TextView sappia dove trovarli. Quindi nel costruttore è sufficiente impostare manualmente il carattere dopo la super chiamata.

L'unico modo per utilizzare caratteri personalizzati è tramite il codice sorgente.

Ricorda solo che Android funziona su dispositivi con risorse e caratteri molto limitati potrebbe richiedere una buona quantità di RAM. I caratteri Droid integrati sono appositamente realizzati e, se noti, mancano molti personaggi e decorazioni.

Potrei avere una risposta semplice alla domanda senza estendere TextView e implementare un codice lungo.

Codice :

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

Posiziona il file del carattere personalizzato nella cartella delle risorse come al solito e prova questo. Per me funziona. Non capisco perché Peter abbia dato un codice così grande per questa cosa semplice o abbia dato la sua risposta nella vecchia versione.

Inoltre può essere definito nel file XML senza creare classi personalizzate

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>

Una breve nota, perché ho sempre dimenticato dove mettere i caratteri, è che il carattere deve essere all'interno assetse questa cartella risiede nello stesso livello che rese src, nel mio caso, èassets/fonts/ionicons.ttf

Aggiornato il layout di root aggiunto perché questo metodo deve xmlns:app="http://schemas.android.com/apk/res-auto"funzionare

Aggiornamento 2 Dimenticato una libreria che ho installato prima chiamato Calligraphy

La risposta di Peter è la migliore, ma può essere migliorata utilizzando styles.xml da Android per personalizzare i caratteri per tutte le visualizzazioni di testo nella tua app.

Il mio codice è qui

Esistono due modi per personalizzare i caratteri:

!!! il mio carattere personalizzato in assets / fonts / iran_sans.ttf

Way 1: Refrection Typeface.class ||| miglior modo

chiama FontsOverride.setDefaultFont () nella classe estende Applicazione, questo codice farà cambiare tutti i caratteri del software, anche i caratteri Toast

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

Modo 2: utilizzare setTypeface

per una vista speciale basta chiamare setTypeface () per cambiare carattere.

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

}

Ecco un tutorial che ti mostra come impostare un carattere personalizzato come @peter descritto: http://responsiveandroid.com/2012/03/15/custom-fonts-in-android-widgets.html

tiene anche conto di potenziali perdite di memoria su http://code.google.com/p/android/issues/detail?id=9904 . Anche nel tutorial è un esempio per impostare un carattere personalizzato su un pulsante.

Puoi creare facilmente una classe di visualizzazione del testo personalizzata: -

Quindi, per prima cosa devi fare una Custom textviewlezione che si è estesa con 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;
        }
    }
}

Ora, ogni volta che visualizziamo la visualizzazione del testo personalizzato e otterremo valore int dall'attributo int fontValue = attrs.getAttributeIntValue("http://schemas.android.com/apk/res-auto","Lato-Regular.ttf",-1).

O

Possiamo anche ottenere getTypeface () dalla vista che abbiamo impostato nel nostro xml ( android:textStyle="bold|normal|italic"). Quindi fai quello che vuoi fare.

Ora, creiamo FontUtilsper impostare qualsiasi carattere .ttf nella nostra vista.

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

Può essere utile sapere che a partire da Android 8.0 (livello API 26) è possibile utilizzare un carattere personalizzato in XML .

È possibile applicare un carattere personalizzato all'intera applicazione nel modo seguente.

1. Metti il ​​carattere nella cartella res/font.

2. In res/values/styles.xmluso nel tema dell'applicazione. <style name="AppTheme" parent="{whatever you like}"> <item name="android:fontFamily">@font/myfont</item> </style>

Fontinator è una libreria Android che semplifica l'utilizzo di caratteri personalizzati. https://github.com/svendvd/Fontinator

Non è possibile estendere TextView per creare un widget o utilizzarne uno in un layout di widget: http://developer.android.com/guide/topics/appwidgets/index.html