Cómo cambiar fontFamily de TextView en Android

Desde android 4.1 / 4.2 / 5.0, están disponibles las siguientes familias de fuentes Roboto :

 android:fontFamily="sans-serif" // roboto regular android:fontFamily="sans-serif-light" // roboto light android:fontFamily="sans-serif-condensed" // roboto condensed android:fontFamily="sans-serif-black" // roboto black android:fontFamily="sans-serif-thin" // roboto thin (android 4.2) android:fontFamily="sans-serif-medium" // roboto medium (android 5.0) 

en combinación con

 android:textStyle="normal|bold|italic" 

Estas 16 variantes son posibles:

• Roboto regular
• Roboto en cursiva
• Roboto negrita
• Roboto negrita cursiva
• Roboto-Light
• Roboto-Light en cursiva
• Roboto-Delgado
• Roboto-Thin italic
• Roboto-Condensed
• Roboto-Italic condensado
• Roboto-Condensed negrita
• Roboto-Condensed negrita cursiva
• Roboto-Negro
• Roboto-Negro en cursiva
• Roboto-Medio
• Roboto-Medium en cursiva

fonts.xml

 <?xml version="1.0" encoding="utf-8"?> <resources> <string name="font_family_light">sans-serif-light</string> <string name="font_family_medium">sans-serif-medium</string> <string name="font_family_regular">sans-serif</string> <string name="font_family_condensed">sans-serif-condensed</string> <string name="font_family_black">sans-serif-black</string> <string name="font_family_thin">sans-serif-thin</string> </resources> 

Esta es la forma de establecer la fuente mediante programación:

 TextView tv = (TextView) findViewById(R.id.appname); Typeface face = Typeface.createFromAsset(getAssets(), "fonts/epimodem.ttf"); tv.setTypeface(face); 

Poner el archivo de fuente en su carpeta de activos. En mi caso creé un subdirectorio llamado fuentes.

EDIT: Si usted se pregunta dónde está su carpeta de activos ver esta pregunta

Tuve que analizar /system/etc/fonts.xml en un proyecto reciente. Aquí están las familias de fuentes actuales de Lollipop:

 ╔════╦════════════════════════════╦═════════════════════════════╗ ║ ║ FONT FAMILY ║ TTF FILE ║ ╠════╬════════════════════════════╬═════════════════════════════╣ ║ 1 ║ casual ║ ComingSoon.ttf ║ ║ 2 ║ cursive ║ DancingScript-Regular.ttf ║ ║ 3 ║ monospace ║ DroidSansMono.ttf ║ ║ 4 ║ sans-serif ║ Roboto-Regular.ttf ║ ║ 5 ║ sans-serif-black ║ Roboto-Black.ttf ║ ║ 6 ║ sans-serif-condensed ║ RobotoCondensed-Regular.ttf ║ ║ 7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf ║ ║ 8 ║ sans-serif-light ║ Roboto-Light.ttf ║ ║ 9 ║ sans-serif-medium ║ Roboto-Medium.ttf ║ ║ 10 ║ sans-serif-smallcaps ║ CarroisGothicSC-Regular.ttf ║ ║ 11 ║ sans-serif-thin ║ Roboto-Thin.ttf ║ ║ 12 ║ serif ║ NotoSerif-Regular.ttf ║ ║ 13 ║ serif-monospace ║ CutiveMono.ttf ║ ╚════╩════════════════════════════╩═════════════════════════════╝ 

Aquí está el analizador (basado en FontListParser ):

 import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; import android.util.Xml; /** * Helper class to get the current font families on an Android device.</p> * * Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p> */ public final class FontListParser { private static final File FONTS_XML = new File("/system/etc/fonts.xml"); private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml"); public static List<SystemFont> getSystemFonts() throws Exception { String fontsXml; if (FONTS_XML.exists()) { fontsXml = FONTS_XML.getAbsolutePath(); } else if (SYSTEM_FONTS_XML.exists()) { fontsXml = SYSTEM_FONTS_XML.getAbsolutePath(); } else { throw new RuntimeException("fonts.xml does not exist on this system"); } Config parser = parse(new FileInputStream(fontsXml)); List<SystemFont> fonts = new ArrayList<>(); for (Family family : parser.families) { if (family.name != null) { Font font = null; for (Font f : family.fonts) { font = f; if (f.weight == 400) { break; } } SystemFont systemFont = new SystemFont(family.name, font.fontName); if (fonts.contains(systemFont)) { continue; } fonts.add(new SystemFont(family.name, font.fontName)); } } for (Alias alias : parser.aliases) { if (alias.name == null || alias.toName == null || alias.weight == 0) { continue; } for (Family family : parser.families) { if (family.name == null || !family.name.equals(alias.toName)) { continue; } for (Font font : family.fonts) { if (font.weight == alias.weight) { fonts.add(new SystemFont(alias.name, font.fontName)); break; } } } } if (fonts.isEmpty()) { throw new Exception("No system fonts found."); } Collections.sort(fonts, new Comparator<SystemFont>() { @Override public int compare(SystemFont font1, SystemFont font2) { return font1.name.compareToIgnoreCase(font2.name); } }); return fonts; } public static List<SystemFont> safelyGetSystemFonts() { try { return getSystemFonts(); } catch (Exception e) { String[][] defaultSystemFonts = { { "cursive", "DancingScript-Regular.ttf" }, { "monospace", "DroidSansMono.ttf" }, { "sans-serif", "Roboto-Regular.ttf" }, { "sans-serif-light", "Roboto-Light.ttf" }, { "sans-serif-medium", "Roboto-Medium.ttf" }, { "sans-serif-black", "Roboto-Black.ttf" }, { "sans-serif-condensed", "RobotoCondensed-Regular.ttf" }, { "sans-serif-thin", "Roboto-Thin.ttf" }, { "serif", "NotoSerif-Regular.ttf" } }; List<SystemFont> fonts = new ArrayList<>(); for (String[] names : defaultSystemFonts) { File file = new File("/system/fonts", names[1]); if (file.exists()) { fonts.add(new SystemFont(names[0], file.getAbsolutePath())); } } return fonts; } } /* Parse fallback list (no names) */ public static Config parse(InputStream in) throws XmlPullParserException, IOException { try { XmlPullParser parser = Xml.newPullParser(); parser.setInput(in, null); parser.nextTag(); return readFamilies(parser); } finally { in.close(); } } private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException { Alias alias = new Alias(); alias.name = parser.getAttributeValue(null, "name"); alias.toName = parser.getAttributeValue(null, "to"); String weightStr = parser.getAttributeValue(null, "weight"); if (weightStr == null) { alias.weight = 0; } else { alias.weight = Integer.parseInt(weightStr); } skip(parser); // alias tag is empty, ignore any contents and consume end tag return alias; } private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException, IOException { Config config = new Config(); parser.require(XmlPullParser.START_TAG, null, "familyset"); while (parser.next() != XmlPullParser.END_TAG) { if (parser.getEventType() != XmlPullParser.START_TAG) { continue; } if (parser.getName().equals("family")) { config.families.add(readFamily(parser)); } else if (parser.getName().equals("alias")) { config.aliases.add(readAlias(parser)); } else { skip(parser); } } return config; } private static Family readFamily(XmlPullParser parser) throws XmlPullParserException, IOException { String name = parser.getAttributeValue(null, "name"); String lang = parser.getAttributeValue(null, "lang"); String variant = parser.getAttributeValue(null, "variant"); List<Font> fonts = new ArrayList<Font>(); while (parser.next() != XmlPullParser.END_TAG) { if (parser.getEventType() != XmlPullParser.START_TAG) { continue; } String tag = parser.getName(); if (tag.equals("font")) { String weightStr = parser.getAttributeValue(null, "weight"); int weight = weightStr == null ? 400 : Integer.parseInt(weightStr); boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style")); String filename = parser.nextText(); String fullFilename = "/system/fonts/" + filename; fonts.add(new Font(fullFilename, weight, isItalic)); } else { skip(parser); } } return new Family(name, fonts, lang, variant); } private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException { int depth = 1; while (depth > 0) { switch (parser.next()) { case XmlPullParser.START_TAG: depth++; break; case XmlPullParser.END_TAG: depth--; break; } } } private FontListParser() { } public static class Alias { public String name; public String toName; public int weight; } public static class Config { public List<Alias> aliases; public List<Family> families; Config() { families = new ArrayList<Family>(); aliases = new ArrayList<Alias>(); } } public static class Family { public List<Font> fonts; public String lang; public String name; public String variant; public Family(String name, List<Font> fonts, String lang, String variant) { this.name = name; this.fonts = fonts; this.lang = lang; this.variant = variant; } } public static class Font { public String fontName; public boolean isItalic; public int weight; Font(String fontName, int weight, boolean isItalic) { this.fontName = fontName; this.weight = weight; this.isItalic = isItalic; } } public static class SystemFont { public String name; public String path; public SystemFont(String name, String path) { this.name = name; this.path = path; } } } 

Siéntase libre de usar la clase anterior en su proyecto. Por ejemplo, puede dar a sus usuarios una selección de familias de fuentes y establecer la tipografía en función de su preferencia.

Un pequeño ejemplo incompleto:

 final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts(); String[] items = new String[fonts.size()]; for (int i = 0; i < fonts.size(); i++) { items[i] = fonts.get(i).name; } new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { FontListParser.SystemFont selectedFont = fonts.get(which); // TODO: do something with the font Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show(); } }).show(); 

Android no le permite establecer fuentes personalizadas desde el diseño XML. En su lugar, debe agrupar el archivo de fuentes específico en la carpeta de activos de la aplicación y establecerlo mediante programación. Algo como:

 TextView textView = (TextView) findViewById(<your TextView ID>); Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>"); textView.setTypeface(typeFace); 

Tenga en cuenta que sólo puede ejecutar este código después de que se haya llamado a setContentView (). Además, sólo algunas fuentes son compatibles con Android y deben estar en .ttf (TrueType) o .otf (OpenType) . Incluso entonces, algunas fuentes pueden no funcionar.

Esta es una fuente que funciona definitivamente en Android, y puedes usarla para confirmar que tu código funciona si tu archivo de fuente no es compatible con Android.

Actualización de Android O: Ahora es posible con XML en Android O , basado en el comentario de Roger.

Es lo mismo que android:typeface .

Las fuentes incorporadas son:

• normal
• Sin
• Serifa
• Monospace

Ver android: tipo de letra .

Para configurar Roboto de forma programática:

 paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL)); 

Si lo desea mediante programación, puede utilizar

 label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC); 

Donde SANS_SERIF puede utilizar:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Y donde ITALIC se puede utilizar:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Todo se indica en los desarrolladores de Android

Estoy usando la caligrafía excelente de la biblioteca de Chris Jenx diseñada para permitirle utilizar fuentes de encargo en su uso androide. ¡Darle una oportunidad!

Lo que quieres no es posible. Usted debe necesitar fijar TypeFace en su código.

En XML lo que puede hacer es

 android:typeface="sans" | "serif" | "monospace" 

Aparte de esto, no se puede jugar mucho con las Fuentes en XML. 🙂

Para Arial que necesita para establecer el tipo de cara en su código.

Una manera fácil de administrar las fuentes sería declararlas a través de recursos, como tal:

 <!--++++++++++++++++++++++++++--> <!--added on API 16 (JB - 4.1)--> <!--++++++++++++++++++++++++++--> <!--the default font--> <string name="fontFamily__roboto_regular">sans-serif</string> <string name="fontFamily__roboto_light">sans-serif-light</string> <string name="fontFamily__roboto_condensed">sans-serif-condensed</string> <!--+++++++++++++++++++++++++++++--> <!--added on API 17 (JBMR1 - 4.2)--> <!--+++++++++++++++++++++++++++++--> <string name="fontFamily__roboto_thin">sans-serif-thin</string> <!--+++++++++++++++++++++++++++--> <!--added on Lollipop (LL- 5.0)--> <!--+++++++++++++++++++++++++++--> <string name="fontFamily__roboto_medium">sans-serif-medium</string> <string name="fontFamily__roboto_black">sans-serif-black</string> <string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string> 

Esto se basa en el código fuente aquí y aquí

Hice una pequeña biblioteca llamada Foundry que puede utilizar para aplicar tipos de letra personalizados a través de diseños y estilos XML.

Con algunos ensayos y errores aprendí lo siguiente.

Dentro del archivo * .xml puede combinar las fuentes de stock con las siguientes funciones, no sólo con el tipo de letra:

  android:fontFamily="serif" android:textStyle="italic" 

Con estos dos estilos, no había necesidad de utilizar la tipografía en ningún otro caso. La gama de combinaciones es mucho más grande con fontfamily y textStyle.

El valor válido de android: fontFamily se define en /system/etc/system_fonts.xml(4.x) o /system/etc/fonts.xml(5.x). Pero el fabricante del dispositivo puede modificarlo, por lo que la fuente real utilizada al establecer el valor fontFamily depende del archivo mencionado anteriormente del dispositivo especificado.

En AOSP, la fuente Arial es válida pero debe definirse utilizando "arial" y no "Arial", por ejemplo android: fontFamily = "arial" . Tenga una mirada qucik en system_fonts.xml de Kitkat

  <family> <nameset> <name>sans-serif</name> <name>arial</name> <name>helvetica</name> <name>tahoma</name> <name>verdana</name> </nameset> <fileset> <file>Roboto-Regular.ttf</file> <file>Roboto-Bold.ttf</file> <file>Roboto-Italic.ttf</file> <file>Roboto-BoldItalic.ttf</file> </fileset> </family> 

////////////////////////////////////////////////// ////////////////////////

Hay tres atributos xml relevantes para definir una "fuente" en el diseño – android: fontFamily , android: typeface y android: textStyle . La combinación de "fontFamily" y "textStyle" o "tipografía" y "textStyle" se puede utilizar para cambiar la apariencia de la fuente en el texto, por lo que se utiliza solo. Código de fragmento en TextView.java como este:

  private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) { Typeface tf = null; if (familyName != null) { tf = Typeface.create(familyName, styleIndex); if (tf != null) { setTypeface(tf); return; } } switch (typefaceIndex) { case SANS: tf = Typeface.SANS_SERIF; break; case SERIF: tf = Typeface.SERIF; break; case MONOSPACE: tf = Typeface.MONOSPACE; break; } setTypeface(tf, styleIndex); } public void setTypeface(Typeface tf, int style) { if (style > 0) { if (tf == null) { tf = Typeface.defaultFromStyle(style); } else { tf = Typeface.create(tf, style); } setTypeface(tf); // now compute what (if any) algorithmic styling is needed int typefaceStyle = tf != null ? tf.getStyle() : 0; int need = style & ~typefaceStyle; mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0); mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0); } else { mTextPaint.setFakeBoldText(false); mTextPaint.setTextSkewX(0); setTypeface(tf); } } 

Desde el código Podemos ver:

1. Si se establece "fontFamily", se ignorará la "tipografía".
2. "Tipo de letra" tiene valores válidos estándar y limitados. De hecho, los valores son "normal" "sans" "serif" y "monospace", se pueden encontrar en system_fonts.xml (4.x) o fonts.xml (5.x). En realidad tanto "normal" como "sans" son la fuente predeterminada del sistema.
3. "FontFamily" se puede utilizar para establecer todas las fuentes de fuentes incorporadas, mientras que "tipografía" sólo proporcionan las fuentes típicas de "sans-serif" "serif" y "monospace" (las tres principales categorías de tipo de fuente en el mundo) .
4. Cuando sólo se establece "textStyle", en realidad se establece la fuente predeterminada y el estilo especificado. El valor efectivo es "normal", "negrita", "cursiva" y "negrita".

 <string name="font_family_display_4_material">sans-serif-light</string> <string name="font_family_display_3_material">sans-serif</string> <string name="font_family_display_2_material">sans-serif</string> <string name="font_family_display_1_material">sans-serif</string> <string name="font_family_headline_material">sans-serif</string> <string name="font_family_title_material">sans-serif-medium</string> <string name="font_family_subhead_material">sans-serif</string> <string name="font_family_menu_material">sans-serif</string> <string name="font_family_body_2_material">sans-serif-medium</string> <string name="font_family_body_1_material">sans-serif</string> <string name="font_family_caption_material">sans-serif</string> <string name="font_family_button_material">sans-serif-medium</string> 

Es demasiado temprano ahora pero

A partir de Android-O es muy fácil cambiar la familia de fuentes

Cree una font carpeta en directorio res Descargue la fuente que desea y péguela dentro de la carpeta de font . La estructura debe ser algo como abajo

Para crear su propia familia de fuentes

– Haga clic con el botón derecho en la carpeta de fuentes y vaya a Nuevo> Archivo de recursos de fuentes . Aparecerá la ventana Nuevo archivo de recursos.

– Introduzca el nombre del archivo y, a continuación, haga clic en Aceptar . El nuevo recurso de fuente XML se abre en el editor.

Escriba su propia familia de fuentes aquí, por ejemplo

 <font-family xmlns:android="http://schemas.android.com/apk/res/android"> <font android:fontStyle="normal" android:fontWeight="400" android:font="@font/lobster_regular" /> <font android:fontStyle="italic" android:fontWeight="400" android:font="@font/lobster_italic" /> </font-family> 

1. Para cambiar fontfamily en la disposición usted puede escribir

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

2. Cambiar programaticamente

  Typeface typeface = getResources().getFont(R.font.myfont); textView.setTypeface(typeface); 

Ver la documentación Para más información

Esta es también una buena biblioteca RobotoTextView . Realmente sirve sus necesidades.

Establece el estilo en res/layout/value/style.xml así:

 <style name="boldText"> <item name="android:textStyle">bold|italic</item> <item name="android:textColor">#FFFFFF</item> </style> 

Y para usar este estilo en el uso del archivo main.xml :

 style="@style/boldText" 

Esta es una forma más fácil de trabajar en algunos casos. El principio es añadir un TextVview no visible en su diseño xml y obtener su typeFace en el código java.

El diseño en el archivo xml:

  <TextView android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty." android:layout_width="0dp" android:layout_height="0dp" android:fontFamily="sans-serif-thin" android:id="@+id/textViewDescription"/> 

Y el código java:

 myText.setTypeface(textViewSelectedDescription.getTypeface()); 

Ha funcionado para mí (dentro de un TextSwitcher por ejemplo).

Si desea utilizar TextView en tantos lugares con la misma familia de fuentes, extienda la clase TextView y configure su fuente de la siguiente manera:

 public class ProximaNovaTextView extends TextView { public ProximaNovaTextView(Context context) { super(context); applyCustomFont(context); } public ProximaNovaTextView(Context context, AttributeSet attrs) { super(context, attrs); applyCustomFont(context); } public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); applyCustomFont(context); } private void applyCustomFont(Context context) { Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context); setTypeface(customFont); } } 

Y luego utilizar esta clase personalizada en xml para el TextView como este: –

  <com.myapp.customview.ProximaNovaTextView android:id="@+id/feed_list_item_name_tv" android:layout_width="match_parent" android:layout_height="wrap_content" android:textSize="14sp" /> 

De forma dinámica puede establecer la familia de fuentes similar a android: fontFamily en xml utilizando esto,

 For Custom font: TextView tv = ((TextView) v.findViewById(R.id.select_item_title)); Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf"); tv.setTypeface(face); For Default font: tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL)); 

Esta es la lista de la familia de fuentes predeterminada utilizada, utilice cualquiera de esto reemplazando la cadena de comillas dobles "sans-serif-medium"

 FONT FAMILY TTF FILE 1 casual ComingSoon.ttf 2 cursive DancingScript-Regular.ttf 3 monospace DroidSansMono.ttf 4 sans-serif Roboto-Regular.ttf 5 sans-serif-black Roboto-Black.ttf 6 sans-serif-condensed RobotoCondensed-Regular.ttf 7 sans-serif-condensed-light RobotoCondensed-Light.ttf 8 sans-serif-light Roboto-Light.ttf 9 sans-serif-medium Roboto-Medium.ttf 10 sans-serif-smallcaps CarroisGothicSC-Regular.ttf 11 sans-serif-thin Roboto-Thin.ttf 12 serif NotoSerif-Regular.ttf 13 serif-monospace CutiveMono.ttf 

"Mycustomfont.ttf" es el archivo ttf. Path estará en src / assets / fonts / mycustomfont.ttf , puede referirse más a la fuente predeterminada en esta familia de fuentes predeterminada

Aquí puede ver todos los valores fontFamily disponibles y sus nombres de archivo de fuente correspondientes (Este archivo se utiliza en android 5.0+). En el dispositivo móvil, puedes encontrarlo en:

/system/etc/fonts.xml (para 5.0+)

(Para Android 4.4 y por debajo de usar esta versión, pero creo que fonts.xml tiene un formato más claro y fácil de entender.)

Por ejemplo,

  <!-- first font is default --> 20 <family name="sans-serif"> 21 <font weight="100" style="normal">Roboto-Thin.ttf</font> 22 <font weight="100" style="italic">Roboto-ThinItalic.ttf</font> 23 <font weight="300" style="normal">Roboto-Light.ttf</font> 24 <font weight="300" style="italic">Roboto-LightItalic.ttf</font> 25 <font weight="400" style="normal">Roboto-Regular.ttf</font> 26 <font weight="400" style="italic">Roboto-Italic.ttf</font> 27 <font weight="500" style="normal">Roboto-Medium.ttf</font> 28 <font weight="500" style="italic">Roboto-MediumItalic.ttf</font> 29 <font weight="900" style="normal">Roboto-Black.ttf</font> 30 <font weight="900" style="italic">Roboto-BlackItalic.ttf</font> 31 <font weight="700" style="normal">Roboto-Bold.ttf</font> 32 <font weight="700" style="italic">Roboto-BoldItalic.ttf</font> 33 </family> 

El nombre name="sans-serif" del tag de la family define el valor que puedes usar en android: fontFamily.

La etiqueta de font define los archivos de fuentes correspondientes.

En este caso, puede ignorar el origen bajo <!-- fallback fonts --> , está utilizando la lógica de fallback de las fuentes.

Uso Letter Press lib para mis cosas NonTextView como botones y kianoni fontloader lib para mi TextViews causa de uso de estilo en este lib es más fácil que Letter Press para mí y me dieron la retroalimentación ideal con eso. Esto es genial para aquellos que quieren utilizar fuentes personalizadas excepto la fuente Roboto. Así que fue mi experiencia con libs de fuentes. Para aquellos que quieren utilizar la clase personalizada para la fuente de cambio que altamente recomendado para crear esta clase con este fragmento

 public class TypefaceSpan extends MetricAffectingSpan { /** An <code>LruCache</code> for previously loaded typefaces. */ private static LruCache<String, Typeface> sTypefaceCache = new LruCache<String, Typeface>(12); private Typeface mTypeface; /** * Load the {@link android.graphics.Typeface} and apply to a {@link android.text.Spannable}. */ public TypefaceSpan(Context context, String typefaceName) { mTypeface = sTypefaceCache.get(typefaceName); if (mTypeface == null) { mTypeface = Typeface.createFromAsset(context.getApplicationContext() .getAssets(), String.format("fonts/%s", typefaceName)); // Cache the loaded Typeface sTypefaceCache.put(typefaceName, mTypeface); } } @Override public void updateMeasureState(TextPaint p) { p.setTypeface(mTypeface); // Note: This flag is required for proper typeface rendering p.setFlags(p.getFlags() | Paint.SUBPIXEL_TEXT_FLAG); } @Override public void updateDrawState(TextPaint tp) { tp.setTypeface(mTypeface); // Note: This flag is required for proper typeface rendering tp.setFlags(tp.getFlags() | Paint.SUBPIXEL_TEXT_FLAG); } 

}

Y usar una clase como esta

 AppData = PreferenceManager.getDefaultSharedPreferences(this); TextView bannertv= (TextView) findViewById(R.id.txtBanner); SpannableString s = new SpannableString(getResources().getString(R.string.enterkey)); s.setSpan(new TypefaceSpan(this, AppData.getString("font-Bold",null)), 0, s.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); bannertv.setText(s); 

Tal vez esta ayuda.

Usted puede hacerlo de manera fácil mediante la siguiente biblioteca

https://github.com/sunnag7/FontStyler

 <com.sunnag.fontstyler.FontStylerView android:textStyle="bold" android:text="@string/about_us" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingTop="8dp" app:fontName="Lato-Bold" android:textSize="18sp" android:id="@+id/textView64" /> 

Su peso ligero y fácil de implementar, basta con copiar sus fuentes en la carpeta de activos y utilizar el nombre en xml.

Sólo quiero mencionar que el infierno con las fuentes dentro de Android está a punto de terminar, porque este año en Google IO finalmente conseguimos esto -> https://developer.android.com/preview/features/working-with-fonts. Html

Ahora hay un nuevo tipo de recurso una fuente y puedes colocar todas tus fuentes de aplicación dentro de la carpeta res / fonts y acceder a ella con R.font.my_custom_font, al igual que puedes acceder a los valores de res de cadena , res restablecables etc. Para crear el archivo xml fuente-cara , que va a ser el conjunto de sus fuentes personalizadas (sobre italic, negrita y subrayar attr).

Lea el enlace anterior para más información. Veamos el apoyo.