Cómo cambiar la fuente Familia de TextView en Android

740

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!

Tarik
fuente
echa un vistazo a este enlace stackoverflow.com/questions/2376250/…
duggu

Respuestas:

1660

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)

ingrese la descripción de la imagen aquí

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>
Jakob Eriksson
fuente
17
No olvides esto: android: fontFamily = "sans-serif-thin" // roboto thin
Sam Lu
66
Vi una variante llamada "gorrita negra" en el libro de muestras de roboto , pero no logro usarla. El uso android:fontFamily="sans-serif-black-small-caps"no funciona. Alguien sabe?
tbruyelle
3
No puedo encontrar ninguna de estas familias de fuentes. ¿Qué has escrito aquí? No puedo encontrar "sans-serif" juntas.
Monty
99
Esta es una buena lista. ¿Alguien tiene un enlace de donde proviene esta información? Sería bueno si Google tuviera esto en su documentación en un lugar fácil de encontrar, digamos para la documentación de android:fontFamilyen TextView.
Christopher Perry
8
La lista definitiva de fuentes se puede encontrar en system_fonts.xml como se explica aquí
Newtonx
207

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

Stefan Beike
fuente
34
Si bien esto funciona, tenga en cuenta que esto puede crear una pérdida de memoria . Se puede solucionar con esta respuesta .
Charles Madere
@ScootrNova me sale este error cuando uso su solución. Error: no se encontró el recurso de fuente gothic.ttf
Sagar Devanga
¿Cómo aplicar esto a toda la aplicación? En este momento, por ejemplo, lo está aplicando solo en la vista de texto
Pritish Joshi
178

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

aquí

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

Manohar Reddy
fuente
77
NB: actualmente solo funciona en Android Studio 3.0 Preview. No funcionó para mí en Android Studio 2.3.3. ¡Espero que eso ahorre algo de tiempo!
Tash Pemhiwa
2
¿Cómo podrías obtener la fuente desde un fragmento ya que no puedes hacerlo getResources()? EDITAR : Esta línea al final de su respuesta funcionó para mí: Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
Paradoja
De alguna manera, hizo que la fuente pareciera corrupta en mi caso, en comparación con Caligtraphy. También fontWeight no hace nada
Leo Droidcoder
@LeoDroidcoder funciona, asegúrese de usar ambos android:fontWeightyapp:fontWeight
Manohar Reddy
Lo revisé varias veces. No hay efecto
Leo Droidcoder
100

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();
Jared Rummler
fuente
¿Sabes quizás qué versión de Android agregó qué fuente?
Desarrollador de Android
@androiddeveloper no lo hago. Probablemente pueda averiguarlo viendo los cambios aquí: github.com/android/platform_frameworks_base/blob/…
Jared Rummler
@JaredRummler, perdona mi ignorancia. ¿Por qué / Qué es el peso == 400?
Samuel
1
@Samuel No he visto este código en mucho tiempo, pero el peso de 400 fuentes se usa para fuentes "normales" o "normales". Ejemplo, Roboto-Regular tiene un peso de 400.
Jared Rummler
¿Requiere esto root o algo? Ejecuté este código en el emulador de Android (versión 8.1), y cuando llamé getSystemFonts(), recibí una excepciónorg.xmlpull.v1.XmlPullParserException: END_TAG expected (position:START_TAG (empty) <axis tag='wdth' stylevalue='100.0'>@219:51 in java.io.InputStreamReader@f001fb3)
Damn Vegetables el
49

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.

Raghav Sood
fuente
"Android no le permite establecer fuentes personalizadas desde el diseño XML". Esto se ha cambiado en Android O, que le permite crear una familia de fuentes personalizada y aplicarlas en XML: developer.android.com/preview/features/working-with-fonts.html
Roger Huang
27

Para configurar Roboto mediante programación:

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
Oded Breiner
fuente
25

Es lo mismo que android:typeface.

las fuentes incorporadas son:

  • normal
  • sans
  • serif
  • monoespacio

Ver android: tipo de letra .

Biegleux
fuente
44
No creo que sea lo mismo, pero parece que no podemos usar ambos. Parece que ahora hay no menos de tres atributos diferentes asignados a setTypeface(). A saber fontFamily, typefacey textStyle. Pero por mi vida no puedo entender cómo se combinan con precisión para resolver una instancia de tipografía concreta. ¿Alguien ha descubierto esto? La documentación de Google es menos que útil ...
Rad Haring
23

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

Joaquin Iurchuk
fuente
15

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!

Gauravdott
fuente
sí, pero por ejemplo quiero usarlo funcionalmente, pero no quería implementar toda la biblioteca;)
Morozov
12

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.

Mohsin Naeem
fuente
11

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í

desarrollador de Android
fuente
¿Dónde declararlos?
AZ_
@AZ_ Al igual que muchos archivos de recursos, puede colocarlo en cualquier archivo XML que desee, dentro de la carpeta "res / values ​​/". Por ejemplo, póngalo en "res / values ​​/ fonts.xml". Y, para usarlo, simplemente haga lo siguiente, por ejemplo: android: fontFamily = "string / fontFamily__roboto_regular"
desarrollador de Android
Gracias, estoy usando este github.com/norbsoft/android-typeface-helper y es realmente útil
AZ_
ok, la biblioteca es probablemente para hacerlo programáticamente. aquí es para XML
desarrollador de Android
9

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

anand krish
fuente
9
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

Makvin
fuente
8

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));
Rehan Sarwar
fuente
6

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.


fuente
5

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".
Terry Liu
fuente
4

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

Frédéric
fuente
4

Prueba esto:

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

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

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

ingrese la descripción de la imagen aquí

Luego, seleccionando Fuente como tipo de recurso. ingrese la descripción de la imagen aquí

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

ingrese la descripción de la imagen aquí

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

ingrese la descripción de la imagen aquí

Wolfiebae
fuente
muy bien, gracias por esto No sé por qué otros tienen más estrellas, pero se confirma que el tuyo funciona con la vista de texto de diseño de material, debes usar app:fontFamily=, sin embargo, todo lo demás es igual.
EvOlaNdLuPiZ
Me salvaste la vida, acababa de crear una carpeta llamada font y no funcionó. De todos modos usé tu camino y funcionó
Hilal
4

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); 
Akanshi Srivastava
fuente
99
Mejor ResourcesCompat.getFontmétodo de uso
Vadim Kotov
3
<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>
Yang Peiyong
fuente
3

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"
        />
Shubham Raitka
fuente
3

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 Ventana de atributos

Fuentes de Google Fuentes de Google

Siva
fuente
2

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.

Stoycho Andreev
fuente
Lamentablemente, esto todavía no funciona con IntelliJ (aunque funciona de maravilla en Android Studio 3.0+).
Dominikus K.
Sí, pero Redmanla respuesta del usuario anterior sigue siendo una parte necesaria de la solución.
jungledev
2

Hay una buena biblioteca disponible para esto

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
Shivam Yadav
fuente
Esta biblioteca se utiliza para cambiar la fuente de todas las vistas en toda la aplicación. Esto no es aplicable para vistas de adaptador como la vista de lista. Para eso necesitamos agregar código en cada adaptador específicamente
Senthilvel S
2

El nuevo recurso de fuente permite configurar directamente fontusando

android:fontFamily="@font/my_font_in_font_folder"
Aziz
fuente
1

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"
rajender
fuente
1

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>
Ali Khaki
fuente
1

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);
oso panda
fuente
0

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.

Gnod
fuente