Cómo cambiar fontFamily of TextView en Android

Así que me gustaría cambiar el android:fontFamily en Android, pero no veo ninguna fuente predefinida en Android. ¿Cómo selecciono uno de los predefinidos? Realmente no necesito definir mi propio TypeFace, pero todo lo que necesito es algo diferente de lo que muestra en este momento.

  

¡Parece que lo que hice allí no funcionará realmente! BTW android:fontFamily="Arial" fue un bash estúpido!

    Desde Android 4.1 / 4.2 / 5.0, están disponibles las siguientes familias de fonts 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) 

    enter image description here

    en combinación con

     android:textStyle="normal|bold|italic" 

    estas 16 variantes son posibles:

    • Roboto regular
    • Roboto cursiva
    • Roboto negrita
    • Roboto negrita cursiva
    • Roboto-Light
    • Roboto-Light cursiva
    • Roboto-Thin
    • Roboto-Thin cursiva
    • Roboto-condensado
    • Roboto-Condensado en cursiva
    • Roboto-Condensed bold
    • Roboto-Condensado negrita cursiva
    • Roboto-Negro
    • Roboto-Black cursiva
    • Roboto-Medium
    • Roboto-Medium cursiva

    fonts.xml

     < ?xml version="1.0" encoding="utf-8"?>  sans-serif-light sans-serif-medium sans-serif sans-serif-condensed sans-serif-black sans-serif-thin  

    Esta es la manera de configurar la fuente mediante progtwigción:

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

    pon el archivo de fuente en tu carpeta de activos. En mi caso, creé un subdirectorio llamado fonts.

    EDITAR: Si se pregunta dónde está su carpeta de activos, vea esta pregunta

    Tuve que analizar /system/etc/fonts.xml en un proyecto reciente. Estas son las familias de fonts actuales a partir 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. * * Usage: {@code List fonts = FontListParser.safelyGetSystemFonts();} */ 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 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 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() { @Override public int compare(SystemFont font1, SystemFont font2) { return font1.name.compareToIgnoreCase(font2.name); } }); return fonts; } public static List 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 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 fonts = new ArrayList(); 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 aliases; public List families; Config() { families = new ArrayList(); aliases = new ArrayList(); } } public static class Family { public List fonts; public String lang; public String name; public String variant; public Family(String name, List 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 de arriba en su proyecto. Por ejemplo, podría proporcionar a los usuarios una selección de familias de fonts y establecer el tipo de letra en función de sus preferencias.

    Un pequeño ejemplo incompleto:

     final List 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(); 

    A partir de Android-Studio 3.0 es muy fácil cambiar la familia de fonts

    Al usar la biblioteca de soporte 26, funcionará en dispositivos que ejecuten Android API versión 16 y superior.

    Cree una font carpeta bajo el directorio res Descargue la fuente que quiera y péguela dentro de la carpeta de font . La estructura debería ser algo como abajo

    aquí

    ahora puedes cambiar la fuente en el diseño usando

      

    Cambiar de forma programática

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

    Para cambiar la fuente usando styles.xml cree un estilo

       

    y aplica este estilo a TextView

       

    también puedes crear tu propia familia de fonts

    Haz clic derecho en la carpeta de fonts y ve a Nuevo> Archivo de recursos de fonts . Aparece la ventana Nuevo archivo de recursos.

    Ingrese el nombre del archivo y luego haga clic en Aceptar . El nuevo XML de recurso de fuente se abre en el editor.

    Escriba aquí su propia familia de fonts, por ejemplo

         

    esto es simplemente un mapeo de un fontStyle y fontWeight específicos al recurso de fuente que se usará para representar esa variante específica. Los valores válidos para fontStyle son normales o cursiva; y fontWeight cumple con la especificación CSS de peso de la fuente

    1. Para cambiar fontfamily en el diseño puede escribir

       

    2. Cambiar programáticamente

      Typeface typeface = getResources().getFont(R.font.myfont); //or to support all versions use Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont); textView.setTypeface(typeface); 

    Nota: A partir de Android Support Library 26.0, debe declarar ambos conjuntos de atributos (android: y app:) para garantizar que sus fonts se carguen en los dispositivos que ejecutan Api 26 o versiones anteriores.

      < ?xml version="1.0" encoding="utf-8"?>     

    Para cambiar la fuente de toda la aplicación Agregue estas dos líneas en AppTheme

       

    Consulte la documentación , tutorial de fonts personalizadas de Android para obtener más información.

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

     TextView textView = (TextView) findViewById(); Typeface typeFace = Typeface.createFromAsset(getAssets(), ""); textView.setTypeface(typeFace); 

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

    Esta es una fuente que definitivamente funciona en Android, y puede usar esto para confirmar que su código está funcionando en caso de que su archivo de fuente no sea compatible con Android.

    Actualización de Android O: ahora es posible con XML en Android O , según el comentario de Roger.

    Es lo mismo que android:typeface .

    las fonts incorporadas son:

    • normal
    • sin
    • serif
    • monospace

    Ver android: tipo de letra .

    Para configurar Roboto mediante progtwigción:

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

    Si lo quiere progtwigticamente, puede usar

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

    Donde SANS_SERIF puede usar:

    • DEFAULT
    • DEFAULT_BOLD
    • MONOSPACE
    • SANS_SERIF
    • SERIF

    Y donde ITALIC puede usar:

    • BOLD
    • BOLD_ITALIC
    • ITALIC
    • NORMAL

    Todo está indicado en los Desarrolladores de Android

    Estoy usando una excelente caligrafía de biblioteca de Chris Jenx diseñada para permitirle usar fonts personalizadas en su aplicación de Android. ¡Darle una oportunidad!

    Lo que quieres no es posible. Debe configurar TypeFace en su Código.

    En XML lo que puedes hacer es

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

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

    Para Arial necesitas configurar el tipo de letra en tu código.

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

         sans-serif sans-serif-light sans-serif-condensed    sans-serif-thin    sans-serif-medium sans-serif-black sans-serif-condensed-light 

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

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

    Dinámicamente puedes establecer la familia de fonts similar a android: fontFamily en xml usando 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)); 

    Estas son la lista de familias de fonts predeterminadas utilizadas, utilice cualquiera de estas sustituyendo 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. La ruta estará en src / assets / fonts / mycustomfont.ttf , puede consultar más acerca de la fuente predeterminada en esta familia de fonts predeterminada

    Con un poco de prueba y error aprendí lo siguiente.

    Dentro del * .xml puede combinar las fonts comunes con las siguientes funciones, no solo con el tipo de letra:

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

    Con estos dos estilos, no había necesidad de utilizar el tipo de letra en ningún otro caso. El rango 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 Device Manufacturer podría modificarlo, por lo que la fuente real utilizada al establecer el valor de fontFamily depende del archivo mencionado anteriormente del dispositivo especificado.

    En AOSP, la fuente Arial es válida, pero debe definirse con “arial”, no con “Arial”, por ejemplo, android: fontFamily = “arial” . Eche un vistazo rápido a system_fonts.xml de Kitkat

        sans-serif arial helvetica tahoma verdana   Roboto-Regular.ttf Roboto-Bold.ttf Roboto-Italic.ttf Roboto-BoldItalic.ttf   

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

    Hay tres atributos xml relevantes para definir una “fuente” en layout– android: fontFamily , android: typeface y android: textStyle . La combinación de “fontFamily” y “textStyle” o “tipo de letra” y “textStyle” se puede utilizar para cambiar la apariencia de la fuente en el texto, por lo que se usa solo. Fragmento de código 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); } } 

    Del código que podemos ver:

    1. si se establece “fontFamily”, se ignorará el “tipo de letra”.
    2. “tipo de letra” tiene valores válidos estándar y limitados. De hecho, los valores son “normal”, “sans”, “serif” y “monoespacio”, se pueden encontrar en system_fonts.xml (4.x) o fonts.xml (5.x). En realidad, tanto “normal” como “sin” son la fuente predeterminada del sistema.
    3. “fontFamily” se puede usar para establecer todas las fonts de fonts integradas, mientras que “tipo de letra” solo proporciona las fonts típicas de “sans-serif” “serif” y “monoespacio” (las tres categorías principales del tipo de fuente en el mundo) .
    4. Cuando solo se establece “textStyle”, en realidad establecemos la fuente predeterminada y el estilo especificado. El valor efectivo es “normal”, “negrita”, “cursiva” y “negrita | cursiva”.
     sans-serif-light sans-serif sans-serif sans-serif sans-serif sans-serif-medium sans-serif sans-serif sans-serif-medium sans-serif sans-serif sans-serif-medium 

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

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

      

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

     style="@style/boldText" 

    Aquí hay un modo más fácil que puede funcionar en algunos casos. El principio es agregar 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:

       

    Y el código de Java:

     myText.setTypeface(textViewSelectedDescription.getTypeface()); 

    Me ha funcionado (dentro de un TextSwitcher por ejemplo).

    Si desea utilizar un TextView en tantos lugares con la misma familia de fonts, amplíe la clase TextView y configure su fuente de esta 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 usa esta clase personalizada en xml para TextView como esta: –

       

    Solo quiero mencionar que el infierno con las fonts dentro de Android está por terminar, porque este año en Google IO finalmente obtuvimos esto -> https://developer.android.com/preview/features/working-with-fonts. html

    Ahora hay un nuevo tipo de recurso, una fuente y puede colocar todas las fonts de la aplicación dentro de la carpeta res / fonts y acceder luego con R.font.my_custom_font, del mismo modo que puede acceder a los valores de res de cadena , valores de res dibujables, etc. Incluso tiene posibilidades para crear el archivo xml font-face , que se configurará con las fonts personalizadas (cursiva, negrita y subrayado attr).

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

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

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

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

    Por ejemplo,

       20  21 Roboto-Thin.ttf 22 Roboto-ThinItalic.ttf 23 Roboto-Light.ttf 24 Roboto-LightItalic.ttf 25 Roboto-Regular.ttf 26 Roboto-Italic.ttf 27 Roboto-Medium.ttf 28 Roboto-MediumItalic.ttf 29 Roboto-Black.ttf 30 Roboto-BlackItalic.ttf 31 Roboto-Bold.ttf 32 Roboto-BoldItalic.ttf 33  

    El nombre del atributo name="sans-serif" de la etiqueta family definió el valor que puede usar en android: fontFamily.

    La etiqueta de font define los archivos de fuente correspondientes.

    En este caso, puede ignorar la fuente bajo , está usando la lógica de respaldo de las fonts.

    uso Letter Press lib para mis cosas NonTextView como Buttons y kianoni fontloader lib para mis TextViews porque el uso del estilo en esta lib es más fácil que Letter Press para mí y obtuve un feedback ideal con eso. esto es ideal para aquellos que quieren usar una fuente personalizada excepto Roboto Font. así que fue mi experiencia con las librerías de fonts. para aquellos que quieran usar la clase personalizada para cambiar la fuente, recomiendo crear esta clase con este fragmento

     public class TypefaceSpan extends MetricAffectingSpan { /** An LruCache for previously loaded typefaces. */ private static LruCache sTypefaceCache = new LruCache(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 usa 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.

    Puedes hacerlo de manera fácil usando la siguiente biblioteca

    https://github.com/sunnag7/FontStyler

      

    es liviano y fácil de implementar, solo copie sus fonts en la carpeta de activos y use el nombre en xml.

    prueba estos sencillos pasos. 1. crea una carpeta de fonts en la carpeta res. 2. Copie y pegue el archivo .ttf en la carpeta de fonts. 3. Ahora da la ruta en xml como a continuación.

      android:fontFamily="@font/frutiger" 

    o cual sea tu nombre de archivo Eso es código feliz