Cómo cambiar la fuente Familia de TextView en Android

Por lo tanto, me gustaría cambiar el android:fontFamilyen 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.

<TextView
    android:id="@+id/HeaderText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    android:layout_marginTop="52dp"
    android:gravity="center"
    android:text="CallerBlocker"
    android:textSize="40dp"
    android:fontFamily="Arial"
 />

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

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 cursiva
• Roboto bold
• Roboto negrita cursiva
• Roboto-Light
• Roboto-Light cursiva
• Roboto-Thin
• Roboto-Thin italic
• Robotocondensado
• Cursiva Roboto-Condensada
• Negrita Roboto-Condensed
• Roboto-Condensed negrita cursiva
• Roboto-Black
• Cursiva Roboto-Negra
• Roboto-Medium
• Roboto-Medium italic

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 configurar la fuente mediante programación:

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

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

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

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

Usando la biblioteca de soporte 26, funcionará en dispositivos con Android API versión 16 y superior

Cree una carpeta fonten el resdirectorio. Descargue la fuente que desee y péguela dentro de la fontcarpeta. La estructura debería ser algo como a continuación

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

Ahora puede cambiar la fuente en el diseño usando

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

Para cambiar progresivamente

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

Para cambiar la fuente usando styles.xml cree un estilo

 <style name="Regular">
        <item name="android:fontFamily">@font/dancing_script</item>
        <item name="fontFamily">@font/dancing_script</item>
        <item name="android:textStyle">normal</item>
 </style>

y aplicar este estilo a TextView

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    style="@style/Regular"/>

también puedes crear tu 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 . Aparece la ventana Nuevo archivo de recursos.

- Ingrese el nombre del archivo y luego haga clic en Aceptar . El nuevo recurso XML de fuente 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>

esto es simplemente un mapeo de un fontStyle y fontWeight específico 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 se ajusta a la especificación de peso de fuente CSS

1. Para cambiar la familia de fuentes en el diseño , puede escribir

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

2. Para cambiar programáticamente

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

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

 <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
     <item name="android:fontFamily">@font/your_font</item>
     <item name="fontFamily">@font/your_font</item>
  </style>

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

Tuve que analizar /system/etc/fonts.xmlen un proyecto reciente. Aquí están las familias de fuentes 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.</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 el tipo de letra según sus preferencias.

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 fuente específico en la carpeta de activos de su aplicación y configurarlo 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 solo puede ejecutar este código después de llamar a setContentView (). Además, solo algunas fuentes son compatibles con Android, y deben estar en formato .ttf (TrueType)o .otf (OpenType). Incluso entonces, algunas fuentes pueden no funcionar.

Esta es una fuente que definitivamente funciona en Android, y puede usarla para confirmar que su código está funcionando en caso de que Android no admita su archivo de fuente.

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

Para configurar Roboto mediante programación:

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

Es lo mismo que android:typeface.

las fuentes incorporadas son:

• normal
• sans
• serif
• monoespacio

Ver android: tipo de letra .

Si lo quieres programáticamente, puedes usar

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

Donde SANS_SERIFpuedes usar:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Y donde ITALICpuedes usar:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Todo está indicado en desarrolladores de Android

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

Lo que quieres no es posible. Debe tener que establecer TypeFacesu Código.

En XMLlo que puedes hacer es

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

aparte de esto, no puedes jugar mucho con las fuentes en XML. :)

Para ello Arial, debe establecer el tipo de letra en su código.

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

<!--++++++++++++++++++++++++++-->
<!--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í

Dinámicamente, puede configurar la familia de fuentes 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));

Esta es la lista de la familia de fuentes predeterminada utilizada, use 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. La ruta estará en src / assets / fonts / mycustomfont.ttf , puede consultar más sobre la fuente predeterminada en esta familia de fuentes predeterminadas

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

establecer fácilmente la fuente en cualquier vista de texto desde res> directorio de fuentes mediante programación

Creo que llego demasiado tarde, pero tal vez esta solución sea útil para otros. Para usar una fuente personalizada, coloque su archivo de fuente en su directorio de fuentes.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));

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

Dentro del * .xml puede combinar las fuentes de archivo con las siguientes funciones, no solo con la tipografía:

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

Con estos dos estilos, no había necesidad de usar tipografía en ningún otro caso. El rango de combinaciones es mucho más grande con fontfamily & 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 de fontFamily depende del archivo mencionado anteriormente del dispositivo especificado.

En AOSP, la fuente Arial es válida pero debe definirse usando "arial" no "Arial", por ejemplo android: fontFamily = "arial" . Eche un vistazo rápido a 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 "typeface" y "textStyle" se puede usar 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 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 "normales" "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 usar para configurar todas las fuentes de fuentes incorporadas, mientras que "typeface" solo proporciona las fuentes típicas de "sans-serif", "serif" y "monospace" (las tres categorías principales de tipo de letra en el mundo) .
4. Cuando solo establecemos "textStyle", en realidad establecemos la fuente predeterminada y el estilo especificado. Los valores efectivos son "normal", "negrita", "cursiva" y "negrita | cursiva".

Aquí hay un modo más fácil que puede funcionar en algunos casos. El principio es agregar una TextVview no visible en su diseño xml y obtener su typeFace en el código de 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 de Java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

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

Prueba esto:

TextView textview = (TextView) findViewById(R.id.textview);

Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);

También puede hacerlo agregando una carpeta de fuentes en el directorio res como se muestra a continuación.

Luego, seleccionando Fuente como tipo de recurso.

Puede encontrar fuentes disponibles en https://www.1001fonts.com/ , y luego extraer los archivos TTF a este directorio de fuentes.

Finalmente, simplemente cambie el archivo XML que contiene su vista de texto agregando android: fontFamily: "@ font / urfontfilename"

Una forma simple es agregar la fuente deseada en el proyecto.

Vaya a Archivo-> Nuevo-> Nuevo directorio de recursos Seleccionar fuente

Esto creará un nuevo directorio, fuente , en sus recursos.

Descargue su fuente (.ttf) . Yo uso https://fonts.google.com para lo mismo

Agregue eso a su carpeta de fuentes y luego úselos en XML o mediante programación.

XML -

<TextView 
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/your_font"/>

Programaticamente

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

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

Si desea utilizar un TextView en tantos lugares con la misma familia de fuentes, 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 use esta clase personalizada en xml para TextView como esta: -

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

Si está utilizando Android Studio 3.5+, cambiar la fuente es muy simple. Seleccione el widget de texto en la vista Diseño y verifique fontFamily en la ventana de atributos. El menú desplegable de valores contiene todas las fuentes disponibles de las cuales puede seleccionar una. Si está buscando fuentes de Google, haga clic en la opción Más fuentes.

Ventana de atributos

Fuentes de Google

Solo quiero mencionar que el infierno con las fuentes dentro de Android está a punto de 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 recurso, escriba una fuente y puede colocar todas las fuentes de su aplicación dentro de la carpeta res / fonts y acceder luego con R.font.my_custom_font, al igual que puede acceder a los valores de res de cadena , valores de res extraíbles , etc. Incluso tiene la posibilidad para crear un archivo xml de fuente , que se configurará con sus fuentes personalizadas (sobre cursiva, negrita y subrayado).

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

Hay una buena biblioteca disponible para esto

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'

El nuevo recurso de fuente permite configurar directamente fontusando

android:fontFamily="@font/my_font_in_font_folder"

Estableces el estilo res/layout/value/style.xmlasí:

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

y para usar este estilo en main.xmlel uso de archivos:

style="@style/boldText"

Para Android-Studio 3 y superior, puede usar este estilo y luego todo textView cambios de fuente en la aplicación.

crea este estilo en tu style.xml:

<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="android:Widget.TextView">
        <item name="android:fontFamily">@font/your_custom_font</item>
</style>

Luego úsalo en tu tema:

<!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <item name="android:textViewStyle">@style/defaultTextViewStyle</item>
    </style>

La forma más fácil de agregar la fuente mediante programación a un TextView es, primero, agregar el archivo de fuente en su carpeta de Activos en el proyecto. Por ejemplo, su ruta de fuente se ve así:assets/fonts/my_font.otf

Y agréguelo a TextView como:

Kotlin

val font_path = "fonts/my_font.otf"  

myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)

textView.typeface = myTypeface

Java

String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);

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

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

(Para Android 4.4 y versiones posteriores con esta versión, pero creo que fonts.xmltiene 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 atributo name="sans-serif"de nombre de la familyetiqueta definió el valor que puede usar en android: fontFamily.

La fontetiqueta define los archivos de fuentes correspondientes.

En este caso, puede ignorar la fuente que se encuentra debajo <!-- fallback fonts -->, está usando la lógica de respaldo de las fuentes.