Estou tentando definir um layout de GUI usando arquivos XML no Android. Pelo que pude descobrir, não há como especificar que seus widgets devem usar uma fonte personalizada (por exemplo, uma que você colocou em assets / font /) em arquivos XML e você só pode usar as fontes instaladas no sistema.

Eu sei que, no código Java, eu poderia alterar a fonte de cada widget manualmente usando IDs exclusivos. Como alternativa, eu poderia percorrer todos os widgets em Java para fazer essa alteração, mas isso provavelmente seria muito lento.

Que outras opções eu tenho? Existe alguma maneira melhor de criar widgets com uma aparência personalizada? Eu particularmente não quero ter que alterar manualmente a fonte para cada novo widget adicionado.

Você pode estender o TextView para definir fontes personalizadas, como aprendi aqui .

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: (em res / valores)

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

Você colocaria "saxmono.ttf" na pasta de ativos .

ATUALIZAÇÃO 1/8/13

Há sérias preocupações de memória com esse método. Veja o comentário de chedabob abaixo.

Estou 3 anos atrasado para a festa :( No entanto, isso pode ser útil para alguém que possa encontrar este post.

Eu escrevi uma biblioteca que armazena em cache tipos de letra e também permite que você especifique tipos de letra personalizados diretamente do XML. Você pode encontrar a biblioteca aqui .

Aqui está a aparência do seu layout XML quando você o usar.

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

Pode ser um pouco tarde, mas você precisa criar uma classe singleton que retorne o tipo de letra personalizado para evitar vazamentos de memória.

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

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

}

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

Programaticamente:

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

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

Pergunta antiga, mas com certeza gostaria de ler esta resposta aqui antes de iniciar minha própria busca por uma boa solução. A caligrafia estende o android:fontFamilyatributo para adicionar suporte a fontes personalizadas na sua pasta de ativos, da seguinte forma:

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

A única coisa que você precisa fazer para ativá-lo é anexá-lo ao contexto da atividade que você está usando:

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

Você também pode especificar seu próprio atributo personalizado para substituir android:fontFamily

Também funciona em temas, incluindo o AppTheme.

Usando DataBinding :

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

Em XML:

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

arquivo de fonte deve estar em assets/fonts/

Se você tiver apenas um tipo de letra que gostaria de adicionar e desejar menos código para escrever, poderá criar um TextView dedicado para sua fonte específica. Veja o código abaixo.

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

No main.xml, agora você pode adicionar seu textView assim:

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

A melhor maneira de fazer isso Na versão de pré-visualização do Android O, é assim:
1.) Clique com o botão direito do mouse na pasta res e vá para Novo> diretório de recursos do Android . A
janela Novo Diretório de Recursos é exibida.
2.) Na lista Tipo de recurso, selecione a fonte e clique em OK.
3.) Adicione seus arquivos de fonte na pasta de fontes . A estrutura de pastas abaixo gera R.font.dancing_script, R.font.la_la e R.font.ba_ba.
4.) Clique duas vezes em um arquivo de fonte para visualizar as fontes do arquivo no editor.

Em seguida, devemos criar uma família de fontes

1.) Clique com o botão direito do mouse na pasta fonte e vá para Novo> Arquivo de Recurso Fonte . A janela Novo arquivo de recurso é exibida.
2.) Digite o nome do arquivo e clique em OK . O novo XML do recurso de fonte é aberto no editor.
3.) Coloque cada atributo de arquivo, estilo e peso da fonte no elemento da tag da fonte. O XML a seguir ilustra como adicionar atributos relacionados à fonte no XML do recurso de fonte:

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

Adicionando fontes a um TextView:

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

A partir da documentação

Trabalhando com fontes

todas as etapas estão corretas.

Estenda TextViewe atribua a ele um atributo personalizado ou apenas use o atributo android: tag para passar uma String de qual fonte você deseja usar. Você precisará escolher uma convenção e cumpri-la, pois eu colocarei todas as minhas fontes na pasta res / assets / fonts / para que sua classe TextView saiba onde encontrá-las. Então, no seu construtor, você apenas define a fonte manualmente após a super chamada.

A única maneira de usar fontes personalizadas é através do código fonte.

Lembre-se de que o Android roda em dispositivos com recursos e fontes muito limitados, podendo exigir uma boa quantidade de RAM. As fontes internas do Droid são feitas especialmente e, se você notar, faltam muitos caracteres e decorações.

Talvez eu tenha uma resposta simples para a pergunta sem estender o TextView e implementar um código longo.

Código:

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

Coloque o arquivo de fonte personalizado na pasta de ativos, como de costume, e tente isso. Funciona para mim. Eu simplesmente não entendo por que Peter deu um código tão grande para essa coisa simples ou ele deu sua resposta na versão antiga.

Também pode ser definido no xml sem criar classes personalizadas

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>

Uma observação rápida, porque eu sempre esqueci onde colocar as fontes, é que a fonte deve estar dentro assetse essa pasta reside no mesmo nível que rese src, no meu caso, éassets/fonts/ionicons.ttf

Atualizado o layout raiz adicionado, porque esse método precisa xmlns:app="http://schemas.android.com/apk/res-auto"funcionar

Atualização 2 Esqueci uma biblioteca que eu instalei antes chamada Calligraphy

A resposta de Peter é a melhor, mas pode ser aprimorada usando o styles.xml do Android para personalizar suas fontes para todas as visualizações de texto em seu aplicativo.

Meu código está aqui

Existem duas maneiras de personalizar fontes:

!!! minha fonte personalizada em assets / fonts / iran_sans.ttf

Caminho 1: Tipo de atualização.class ||| melhor maneira

chamada FontsOverride.setDefaultFont () na classe estende Application. Esse código fará com que todas as fontes de software sejam alteradas, mesmo que brinda fontes

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

Caminho 2: use setTypeface

para uma visualização especial, basta chamar setTypeface () para alterar a fonte.

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

}

Aqui está um tutorial que mostra como configurar uma fonte personalizada como @peter descrita: http://responsiveandroid.com/2012/03/15/custom-fonts-in-android-widgets.html

também considera possíveis vazamentos de memória em http://code.google.com/p/android/issues/detail?id=9904 . Também no tutorial, há um exemplo para definir uma fonte personalizada em um botão.

Você pode criar facilmente uma classe de visualização de texto personalizada: -

Então, o que você precisa fazer primeiro, faça a Custom textviewclasse que foi estendida 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;
        }
    }
}

Agora, toda vez texto personalizado chamada vista e vamos obter o valor int de atributo int fontValue = attrs.getAttributeIntValue("http://schemas.android.com/apk/res-auto","Lato-Regular.ttf",-1).

Ou

Também podemos obter getTypeface () da exibição que definimos em nosso xml ( android:textStyle="bold|normal|italic"). Então faça o que você quiser.

Agora, criamos FontUtilspara definir qualquer fonte .ttf em nossa visualização.

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

Pode ser útil saber que, a partir do Android 8.0 (nível 26 da API), você pode usar uma fonte personalizada em XML .

Você pode aplicar uma fonte personalizada a todo o aplicativo da seguinte maneira.

1. Coloque a fonte na pasta res/font.

2. Em res/values/styles.xmluso no tema do aplicativo. <style name="AppTheme" parent="{whatever you like}"> <item name="android:fontFamily">@font/myfont</item> </style>

Fontinator é uma biblioteca do Android que facilita o uso de fontes personalizadas. https://github.com/svendvd/Fontinator

Você não pode estender o TextView para criar um widget ou usá-lo em um layout de widgets: http://developer.android.com/guide/topics/appwidgets/index.html