¿Cómo cambiar la fuente en TextView?

¿Cómo cambiar la fuente en un TextView , de manera predeterminada se muestra como Arial? ¿Cómo cambiarlo a Helvetica ?

Primero, 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 en layout 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 ). Si bien puede agrupar sus propias fonts con su aplicación y usarlas a través de setTypeface() , tenga en cuenta que los archivos de fonts son grandes y, en algunos casos, requieren acuerdos de licencia (por ejemplo, Helvetica, una fuente de Linotype ).

EDITAR

El lenguaje de diseño de Android se basa en herramientas tipográficas tradicionales como la escala, el espacio, el ritmo y la alineación con una grilla subyacente. El despliegue exitoso de estas herramientas es esencial para ayudar a los usuarios a comprender rápidamente una pantalla de información. Para respaldar dicho 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 actual de TextView ofrece Roboto en pesos delgados, livianos, regulares y audaces, junto con un estilo de cursiva para cada peso. El marco también ofrece la variante Roboto Condensed en pesos regulares y audaces, junto con un estilo cursivo para cada peso.

Después de ICS, Android incluye el estilo de fonts Roboto, Leer más Roboto

EDIT 2

Con la llegada de Support Library 26, Android ahora admite fonts personalizadas de forma predeterminada. Puede insertar fonts nuevas en res / fonts que se pueden establecer en TextViews individualmente en XML o programáticamente. La fuente predeterminada para toda la aplicación también se puede cambiar definiéndola styles.xml La documentación del desarrollador de Android tiene una guía clara sobre esto aquí

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 crea una nueva carpeta llamada fonts y TextView dentro). Usa el siguiente código para aplicar la fuente a tu TextView :

 Typeface type = Typeface.createFromAsset(getAssets(),"fonts/arial.ttf"); textView.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 fonts. De esta forma, no creará la fuente varias veces, lo que podría tener un impacto negativo en el rendimiento . Solo asegúrese de crear una subcarpeta llamada ” fonts ” en la carpeta ” activos “.

Haz 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 desde cualquier lugar de su aplicación.

La mejor práctica de la historia

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: (Dónde colocar res / valores )

       

Cómo utilizar:

      

Espero que esto te ayudará.

Las respuestas de arriba son correctas. Solo asegúrate de crear una subcarpeta llamada “fonts” en la carpeta “activos” si estás usando esa porción de código.

Otra forma de consolidar la creación de fonts …

 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 usar en tu actividad …

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

Eso sí, este idioma de locking comprobado con el campo volátil solo funciona correctamente con el modelo de memoria utilizado en Java 1.5+.

La mejor práctica es usar Android Support Library versión 26.0.0 o superior.

PASO 1: agregar archivo de fuente

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

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

PASO 2: crea una familia de fonts

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

Por ejemplo:

      

PASO 3: usarlo

En diseños xml:

  

O agrega fonts al estilo:

  

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

Trabajando con fonts

Es un poco viejo, pero mejoré un poco la clase CustomFontLoader y quería compartirla para que me sea útil. Solo crea 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 

Entonces solo usa este código en tu vista de texto:

  Typeface typeFace=FontLoader.getTypeFace(context,"arial"); if(typeFace!=null) myTextView.setTypeface(typeFace); 
 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> typefaces = new HashMap>(); 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 tfReference = typefaces.get(assetName); if (tfReference == null || tfReference.get() == null) { final Typeface tf = Typeface.createFromAsset(context.getResources().getAssets(), assetName); typefaces.put(assetName, new WeakReference(tf)); return tf; } return tfReference.get(); } } 

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

obtener fuente del activo y establecer a 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. agregar 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(); } } } } 

  1. agregar a la fuente de la biblioteca de activos
    enter image description here

  1. agregar a attrs.xml, los números deben estar en el orden en la clase de matriz.

            

  1. Seleccione una fuente de la lista
    enter image description here

Finalmente obtuve una solución muy fácil para esto.

  1. utilice estas bibliotecas de soporte en gradle de nivel de aplicación ,

     compile 'com.android.support:appcompat-v7:26.0.2' compile 'com.android.support:support-v4:26.0.2' 
  2. luego crea un directorio llamado “font” dentro de la carpeta res

  3. poner fonts (ttf) en ese directorio de fonts, tenga en cuenta las convenciones de nombres [eg nombre no debe contener ningún carácter especial, ningún carácter en mayúscula y cualquier espacio o pestaña]
  4. Después de eso, haz referencia a esa fuente desde xml como esta

       

En este ejemplo, times_new_roman_test es un archivo de fuente ttf de ese directorio de fonts

Tal vez algo un poco más simple:

 public class Fonts { public static HashSet 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 se ha probado, pero en general este enfoque debería funcionar bien).

Cuando su fuente se almacena dentro de res/asset/fonts/Helvetica.ttf use lo siguiente:

 Typeface tf = Typeface.createFromAsset(getAssets(),"fonts/Helvetica.ttf"); txt.setTypeface(tf); 

O bien, si su archivo de fuente se almacena dentro de res/font/helvetica.ttf use lo siguiente:

 Typeface tf = ResourcesCompat.getFont(this,R.font.helvetica); txt.setTypeface(tf); 

Android usa la fuente Roboto, que es una fuente muy atractiva, con varios pesos diferentes (regular, ligero, delgado, condensado) que se ven geniales en pantallas de alta densidad.

Verifique el enlace a continuación para verificar las fonts roboto:

Cómo usar Roboto en el diseño xml

Volviendo a su pregunta, si desea cambiar la fuente de todo el Botón / Vista de Texto en su aplicación , intente agregar el código siguiente en su styles.xml para usar la fuente Roboto-light :

     

Y no te olvides de usar ‘AppTheme’ en tu AndroidManifest.xml

  ......