J'essaie de définir une disposition d'interface graphique à l'aide de fichiers XML dans Android. Pour autant que je sache, il n'y a aucun moyen de spécifier que vos widgets doivent utiliser une police personnalisée (par exemple, celle que vous avez placée dans assets / font /) dans les fichiers XML et vous ne pouvez utiliser que les polices installées par le système.

Je sais que, dans le code Java, je pourrais changer la police de chaque widget manuellement en utilisant des identifiants uniques. Alternativement, je pourrais parcourir tous les widgets de Java pour effectuer ce changement, mais ce serait probablement très lent.

Quelles autres options ai-je? Existe-t-il de meilleures façons de créer des widgets qui ont une apparence personnalisée? Je ne veux pas particulièrement avoir à changer manuellement la police pour chaque nouveau widget que j'ajoute.

Vous pouvez étendre TextView pour définir des polices personnalisées comme je l'ai appris ici .

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: (en résolution / valeurs)

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

Vous mettriez "saxmono.ttf" dans le dossier des actifs .

MISE À JOUR 1/8/13

Il y a de sérieux problèmes de mémoire avec cette méthode. Voir le commentaire de chedabob ci-dessous.

J'ai 3 ans de retard pour la fête: (Cependant, cela pourrait être utile pour quelqu'un qui pourrait tomber sur ce post.

J'ai écrit une bibliothèque qui met en cache les polices de caractères et vous permet également de spécifier des polices personnalisées directement à partir de XML. Vous pouvez trouver la bibliothèque ici .

Voici à quoi ressemblerait votre mise en page XML, lorsque vous l'utiliserez.

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

Cela peut être un peu tard, mais vous devez créer une classe singleton qui renvoie la police personnalisée pour éviter les fuites de mémoire.

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 personnalisé:

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

}

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

Par programme:

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

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

Ancienne question, mais j'aimerais bien lire cette réponse ici avant de commencer ma propre recherche d'une bonne solution. La calligraphie étend l' android:fontFamilyattribut pour ajouter la prise en charge des polices personnalisées dans votre dossier d'actifs, comme ceci:

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

La seule chose que vous devez faire pour l'activer est de l'attacher au contexte de l'activité que vous utilisez:

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

Vous pouvez également spécifier votre propre attribut personnalisé à remplacer android:fontFamily

Il fonctionne également dans les thèmes, y compris l'AppTheme.

Utilisation de DataBinding :

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

En XML:

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

le fichier de police doit être dans assets/fonts/

Si vous ne souhaitez ajouter qu'une seule police et que vous voulez moins de code à écrire, vous pouvez créer un TextView dédié pour votre police spécifique. Voir le code ci-dessous.

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

Dans main.xml, vous pouvez maintenant ajouter votre textView comme ceci:

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

La meilleure façon de le faire à partir de la version préliminaire d'Android O est la suivante:
1.) Cliquez avec le bouton droit sur le dossier res et allez dans Nouveau> répertoire de ressources Android . La
fenêtre Nouveau répertoire de ressources apparaît.
2.) Dans la liste Type de ressource, sélectionnez la police , puis cliquez sur OK.
3.) Ajoutez vos fichiers de polices dans le dossier de polices . La structure de dossiers ci-dessous génère R.font.dancing_script, R.font.la_la et R.font.ba_ba.
4.) Double-cliquez un fichier de polices pour prévisualiser les polices du fichier dans l'éditeur.

Ensuite, nous devons créer une famille de polices

1.) Cliquez avec le bouton droit sur le dossier de polices et accédez à Nouveau> Fichier de ressources de polices . La fenêtre Nouveau fichier de ressources apparaît.
2.) Entrez le nom du fichier, puis cliquez sur OK . Le nouveau XML de ressource de police s'ouvre dans l'éditeur.
3.) Insérez chaque fichier de police, style et attribut de poids dans l'élément de balise de police. Le code XML suivant illustre l'ajout d'attributs liés aux polices dans le XML de ressources de polices:

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

Ajout de polices à un TextView:

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

À partir de la documentation

Travailler avec des polices

toutes les étapes sont correctes.

Étendez TextView-lui et donnez-lui un attribut personnalisé ou utilisez simplement l'attribut android: tag pour transmettre une chaîne de la police que vous souhaitez utiliser. Vous devrez choisir une convention et vous y tenir comme je mettrai toutes mes polices dans le dossier res / assets / fonts / afin que votre classe TextView sache où les trouver. Ensuite, dans votre constructeur, vous définissez simplement la police manuellement après le super appel.

La seule façon d'utiliser des polices personnalisées consiste à utiliser le code source.

N'oubliez pas qu'Android fonctionne sur des appareils avec des ressources très limitées et que les polices peuvent nécessiter une bonne quantité de RAM. Les polices Droid intégrées sont spécialement conçues et, si vous le remarquez, manquent de nombreux caractères et décorations.

Je pourrais avoir une réponse simple à la question sans étendre le TextView et implémenter un long code.

Code:

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

Placez le fichier de police personnalisé dans le dossier des ressources comme d'habitude et essayez ceci. Ça marche pour moi. Je ne comprends tout simplement pas pourquoi Peter a donné un code aussi énorme pour cette chose simple ou il a donné sa réponse dans une ancienne version.

Peut également être défini dans le xml sans créer de classes personnalisées

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>

Une note rapide, parce que j'oubliais toujours où mettre les polices, c'est que la police doit être à l'intérieur assetset ce dossier réside au même niveau que reset src, dans mon cas, c'estassets/fonts/ionicons.ttf

Mise à jour de la mise en page racine ajoutée car cette méthode doit xmlns:app="http://schemas.android.com/apk/res-auto"fonctionner

Mise à jour 2 J'ai oublié une bibliothèque que j'ai installée auparavant appelée Calligraphy

La réponse de Peter est la meilleure, mais elle peut être améliorée en utilisant le style.xml d'Android pour personnaliser vos polices pour toutes les vues de texte dans votre application.

Mon code est ici

Il existe deux façons de personnaliser les polices:

!!! ma police personnalisée dans assets / fonts / iran_sans.ttf

Voie 1: Réfraction Typeface.class ||| meilleur moyen

appeler FontsOverride.setDefaultFont () dans la classe étend l'application, ce code entraînera la modification de toutes les polices logicielles, même les polices Toasts

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

Méthode 2: utilisez setTypeface

pour une vue spéciale, appelez simplement setTypeface () pour changer la police.

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

}

Voici un tutoriel qui vous montre comment configurer une police personnalisée comme @peter décrit: http://responsiveandroid.com/2012/03/15/custom-fonts-in-android-widgets.html

il tient également compte des fuites de mémoire potentielles comme http://code.google.com/p/android/issues/detail?id=9904 . Le didacticiel contient également un exemple de définition d'une police personnalisée sur un bouton.

Vous pouvez créer facilement une classe textview personnalisée: -

Donc, ce que vous devez faire en premier, créez une Custom textviewclasse qui s'est étendue avec 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;
        }
    }
}

Maintenant, à chaque appel de vue de texte personnalisé, nous obtiendrons la valeur int de l'attribut int fontValue = attrs.getAttributeIntValue("http://schemas.android.com/apk/res-auto","Lato-Regular.ttf",-1) .

Ou

Nous pouvons également obtenir getTypeface () à partir de la vue que nous avons définie dans notre xml (android:textStyle="bold|normal|italic" ). Alors fais ce que tu veux faire.

Maintenant, nous faisons FontUtilspour définir n'importe quelle police .ttf dans notre vue.

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

Il peut être utile de savoir qu'à partir d'Android 8.0 (niveau d'API 26), vous pouvez utiliser une police personnalisée en XML .

Vous pouvez appliquer une police personnalisée à l'ensemble de l'application de la manière suivante.

1. Mettez la police dans le dossier res/font.

2. En l' res/values/styles.xmlutilisant dans le thème de l'application. <style name="AppTheme" parent="{whatever you like}"> <item name="android:fontFamily">@font/myfont</item> </style>

Fontinator est une bibliothèque Android qui facilite l'utilisation de polices personnalisées. https://github.com/svendvd/Fontinator

Vous ne pouvez pas étendre TextView pour créer un widget ou en utiliser un dans une présentation de widgets: http://developer.android.com/guide/topics/appwidgets/index.html