Cómo cambiar la fuente en el TextView?

En primer lugar, el valor predeterminado no es Arial. El valor predeterminado es Droid Sans.

En segundo lugar, para cambiar a una fuente incorporada diferente, use android:typeface de android:typeface en el diseño XML o setTypeface() en Java.

En tercer lugar, no hay fuente Helvetica en Android. Las opciones incorporadas son Droid Sans ( sans ), Droid Sans Mono ( monospace ) y Droid Serif ( serif ). Mientras que puede agrupar sus propias fuentes con su aplicación y utilizarlas a través de setTypeface() , tenga en cuenta que los archivos de fuentes son grandes y, en algunos casos, requieren acuerdos de licencia (por ejemplo, Helvetica, una fuente Linotype ).

EDITAR

El lenguaje de diseño de Android se basa en herramientas tipográficas tradicionales como escala, espacio, ritmo y alineación con una cuadrícula subyacente. El despliegue exitoso de estas herramientas es esencial para ayudar a los usuarios a comprender rápidamente una pantalla de información. Para apoyar este uso de la tipografía, Ice Cream Sandwich presentó una nueva familia de tipos llamada Roboto, creada específicamente para los requisitos de la interfaz de usuario y pantallas de alta resolución.

El marco TextView actual ofrece Roboto en pesos finos, ligeros, regulares y audaces, junto con un estilo en cursiva para cada peso. El marco también ofrece la variante Roboto Condensed en pesos regulares y audaces, junto con un estilo en cursiva para cada peso.

Después de ICS, android incluye estilo de fuentes Roboto, Leer más Roboto

Primero descargue el archivo .ttf de la fuente que necesita ( arial.ttf ). Colóquelo en la carpeta de assets (dentro de la carpeta de activos, cree una nueva carpeta llamada fuentes y colóquela dentro). Si txtyour es las textviews que desea aplicar la fuente, utilice la siguiente pieza de código,

  Typeface type = Typeface.createFromAsset(getAssets(),"fonts/Kokila.ttf"); txtyour.setTypeface(type); 

 Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/DroidSansFallback.ttf"); TextView tv = (TextView) findViewById(R.id.CustomFontText); tv.setTypeface(tf); 

Es posible que desee crear una clase estática que contendrá todas las fuentes. De esta manera, no creará la fuente varias veces que podría tener un impacto negativo en el rendimiento . Sólo asegúrese de crear una subcarpeta denominada " fuentes " en la carpeta " assets ".

Haga algo como:

 public class CustomFontsLoader { public static final int FONT_NAME_1 = 0; public static final int FONT_NAME_2 = 1; public static final int FONT_NAME_3 = 2; private static final int NUM_OF_CUSTOM_FONTS = 3; private static boolean fontsLoaded = false; private static Typeface[] fonts = new Typeface[3]; private static String[] fontPath = { "fonts/FONT_NAME_1.ttf", "fonts/FONT_NAME_2.ttf", "fonts/FONT_NAME_3.ttf" }; /** * Returns a loaded custom font based on it's identifier. * * @param context - the current context * @param fontIdentifier = the identifier of the requested font * * @return Typeface object of the requested font. */ public static Typeface getTypeface(Context context, int fontIdentifier) { if (!fontsLoaded) { loadFonts(context); } return fonts[fontIdentifier]; } private static void loadFonts(Context context) { for (int i = 0; i < NUM_OF_CUSTOM_FONTS; i++) { fonts[i] = Typeface.createFromAsset(context.getAssets(), fontPath[i]); } fontsLoaded = true; } } 

De esta manera, puede obtener la fuente de todas partes en su aplicación.

Las respuestas anteriores son correctas. Sólo asegúrese de crear una subcarpeta denominada "fuentes" en la carpeta "assets" si está utilizando ese código.

Mejor práctica siempre

TextViewPlus.java:

 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 typeface = null; try { typeface = Typeface.createFromAsset(ctx.getAssets(), asset); } catch (Exception e) { Log.e(TAG, "Unable to load typeface: "+e.getMessage()); return false; } setTypeface(typeface); return true; } } 

Attrs.xml: (Donde colocar res / valores )

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

Cómo utilizar:

 <?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-auto" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"> <com.mypackage.TextViewPlus android:id="@+id/textViewPlus1" android:layout_height="match_parent" android:layout_width="match_parent" android:text="@string/showingOffTheNewTypeface" foo:customFont="my_font_name_regular.otf"> </com.mypackage.TextViewPlus> </LinearLayout> 

Espero que esto te ayudará.

Otra forma de consolidar la creación de fuentes …

 public class Font { public static final Font PROXIMA_NOVA = new Font("ProximaNovaRegular.otf"); public static final Font FRANKLIN_GOTHIC = new Font("FranklinGothicURWBoo.ttf"); private final String assetName; private volatile Typeface typeface; private Font(String assetName) { this.assetName = assetName; } public void apply(Context context, TextView textView) { if (typeface == null) { synchronized (this) { if (typeface == null) { typeface = Typeface.createFromAsset(context.getAssets(), assetName); } } } textView.setTypeface(typeface); } } 

Y luego para usar en su actividad …

 myTextView = (TextView) findViewById(R.id.myTextView); Font.PROXIMA_NOVA.apply(this, myTextView); 

Tenga en cuenta que este idioma de bloqueo con doble comprobación con el campo volátil sólo funciona correctamente con el modelo de memoria utilizado en Java 1.5+.

Es un poco viejo, pero mejoré la clase CustomFontLoader un poco y quería compartirlo para que pueda ser útil. Basta con crear una nueva clase con este código.

  import android.content.Context; import android.graphics.Typeface; public enum FontLoader { ARIAL("arial"), TIMES("times"), VERDANA("verdana"), TREBUCHET("trbuchet"), GEORGIA("georgia"), GENEVA("geneva"), SANS("sans"), COURIER("courier"), TAHOMA("tahoma"), LUCIDA("lucida"); private final String name; private Typeface typeFace; private FontLoader(final String name) { this.name = name; typeFace=null; } public static Typeface getTypeFace(Context context,String name){ try { FontLoader item=FontLoader.valueOf(name.toUpperCase(Locale.getDefault())); if(item.typeFace==null){ item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf"); } return item.typeFace; } catch (Exception e) { return null; } } public static Typeface getTypeFace(Context context,int id){ FontLoader myArray[]= FontLoader.values(); if(!(id<myArray.length)){ return null; } try { if(myArray[id].typeFace==null){ myArray[id].typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+myArray[id].name+".ttf"); } return myArray[id].typeFace; }catch (Exception e) { return null; } } public static Typeface getTypeFaceByName(Context context,String name){ for(FontLoader item: FontLoader.values()){ if(name.equalsIgnoreCase(item.name)){ if(item.typeFace==null){ try{ item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf"); }catch (Exception e) { return null; } } return item.typeFace; } } return null; } public static void loadAllFonts(Context context){ for(FontLoader item: FontLoader.values()){ if(item.typeFace==null){ try{ item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf"); }catch (Exception e) { item.typeFace=null; } } } } } 

Entonces simplemente use este código en su texto:

  Typeface typeFace=FontLoader.getTypeFace(context,"arial"); if(typeFace!=null) myTextView.setTypeface(typeFace); 

La mejor práctica es usar la versión 26.0.0 o superior de la Biblioteca de soporte de Android.

PASO 1: añadir el archivo de fuentes

1. En la carpeta res crea un nuevo diccionario de fuentes
2. Añadir archivo de fuentes ( .ttf , .orf )

Por ejemplo, cuando el archivo de fuentes será helvetica_neue.ttf que generará R.font.helvetica_neue

PASO 2: crear la familia de fuentes

1. En la carpeta de fuentes, agregue un nuevo archivo de recursos
2. Incluya cada atributo de archivo de fuente, estilo y peso en el elemento.

Por ejemplo:

 <?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/helvetica_neue" /> </font-family> 

PASO 3: usarlo

En diseños xml:

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

O añade fuentes al estilo:

 <style name="customfontstyle" parent="@android:style/TextAppearance.Small"> <item name="android:fontFamily">@font/lobster</item> </style> 

Para más ejemplos puede seguir la documentación:

Trabajo con fuentes

 import java.lang.ref.WeakReference; import java.util.HashMap; import android.content.Context; import android.graphics.Typeface; public class FontsManager { private static FontsManager instance; private static HashMap<String, WeakReference<Typeface>> typefaces = new HashMap<String, WeakReference<Typeface>>(); private static Context context; private FontsManager(final Context ctx) { if (context == null) { context = ctx; } } public static FontsManager getInstance(final Context appContext) { if (instance == null) { instance = new FontsManager(appContext); } return instance; } public static FontsManager getInstance() { if (instance == null) { throw new RuntimeException( "Call getInstance(Context context) at least once to init the singleton properly"); } return instance; } public Typeface getFont(final String assetName) { final WeakReference<Typeface> tfReference = typefaces.get(assetName); if (tfReference == null || tfReference.get() == null) { final Typeface tf = Typeface.createFromAsset(context.getResources().getAssets(), assetName); typefaces.put(assetName, new WeakReference<Typeface>(tf)); return tf; } return tfReference.get(); } } 

De esta manera, puede crear una Vista que hereda de TextView y llame a setTypeface en su constructor.

Obtener la fuente del recurso y establecerla para todos los niños

 public static void overrideFonts(final Context context, final View v) { try { if (v instanceof ViewGroup) { ViewGroup vg = (ViewGroup) v; for (int i = 0; i < vg.getChildCount(); i++) { View child = vg.getChildAt(i); overrideFonts(context, child); } } else if (v instanceof TextView ) { ((TextView) v).setTypeface(Typeface.createFromAsset(context.getAssets(),"DroidNaskh.ttf"));// "BKOODB.TTF")); } } catch (Exception e) { } } 

1. Añadir clase FontTextView.java:

 public class FontTextView extends TextView { String fonts[] = {"HelveticaNeue.ttf", "HelveticaNeueLight.ttf", "motschcc.ttf", "symbol.ttf"}; public FontTextView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); init(attrs); } public FontTextView(Context context, AttributeSet attrs) { super(context, attrs); if (!isInEditMode()) { init(attrs); } } public FontTextView(Context context) { super(context); if (!isInEditMode()) { init(null); } } private void init(AttributeSet attrs) { if (attrs != null) { TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.FontTextView); if (a.getString(R.styleable.FontTextView_font_type) != null) { String fontName = fonts[Integer.valueOf(a.getString(R.styleable.FontTextView_font_type))]; if (fontName != null) { Typeface myTypeface = Typeface.createFromAsset(getContext().getAssets(), "font/" + fontName); setTypeface(myTypeface); } a.recycle(); } } } } 

2. Añadir a fuente de biblioteca de activos
   

3. Add to attrs.xml, Los números deben estar en el orden en la clase array.

    <declare-styleable name="FontTextView"> <attr name="font_type" format="enum"> <enum name="HelveticaNeue" value="0"/> <enum name="HelveticaNeueLight" value="1"/> <enum name="motschcc" value="2"/> <enum name="symbol" value="3"/> </attr> 

4. Seleccione una fuente de la lista
   

Tal vez algo un poco más simple:

 public class Fonts { public static HashSet<String,Typeface> fonts = new HashSet<>(); public static Typeface get(Context context, String file) { if (! fonts.contains(file)) { synchronized (this) { Typeface typeface = Typeface.createFromAsset(context.getAssets(), name); fonts.put(name, typeface); } } return fonts.get(file); } } // Usage Typeface myFont = Fonts.get("arial.ttf"); 

(Tenga en cuenta que este código no ha sido probado, pero en general este enfoque debería funcionar bien.)