Cómo configurar la familia de fuentes predeterminada para toda la aplicación de Android

Estoy usando la fuente Roboto light en mi aplicación. Para configurar la fuente tengo que agregar el android:fontFamily="sans-serif-light"a cada vista. ¿Hay alguna forma de declarar la fuente Roboto como familia de fuentes predeterminada para toda la aplicación? Lo intenté así, pero no pareció funcionar.

<style name="AppBaseTheme" parent="android:Theme.Light"></style>

<style name="AppTheme" parent="AppBaseTheme">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

La respuesta es sí.

Luz global Roboto para TextViewy Buttonclases:

<style name="AppTheme" parent="AppBaseTheme">
    <item name="android:textViewStyle">@style/RobotoTextViewStyle</item>
    <item name="android:buttonStyle">@style/RobotoButtonStyle</item>
</style>

<style name="RobotoTextViewStyle" parent="android:Widget.TextView">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

<style name="RobotoButtonStyle" parent="android:Widget.Holo.Button">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

Simplemente seleccione el estilo que desee de la lista themes.xml , luego cree su estilo personalizado basado en el original. Al final, aplique el estilo como tema de la aplicación.

<application
    android:theme="@style/AppTheme" >
</application>

Funcionará solo con fuentes incorporadas como Roboto, pero esa era la pregunta. Para fuentes personalizadas (cargadas de activos, por ejemplo), este método no funcionará.

EDITAR 13/08/15

Si está utilizando temas de AppCompat, recuerde eliminar el android:prefijo. Por ejemplo:

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="android:textViewStyle">@style/RobotoTextViewStyle</item>
    <item name="buttonStyle">@style/RobotoButtonStyle</item>
</style>

Tenga en cuenta buttonStyleque no contiene el android:prefijo, pero textViewStyledebe contenerlo.

Con el lanzamiento de Android Oreo, puede utilizar la biblioteca de soporte para alcanzar este objetivo.

1. Compruebe en su aplicación build.gradle si tiene la biblioteca de soporte > = 26.0.0
2. Agregue la carpeta " fuente " a su carpeta de recursos y agregue sus fuentes allí

3. Consulte su familia de fuentes predeterminada en el estilo principal de su aplicación:

   <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
      <item name="android:fontFamily">@font/your_font</item>
      <item name="fontFamily">@font/your_font</item> <!-- target android sdk versions < 26 and > 14 if theme other than AppCompat -->
   </style>

Consulte https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html para obtener información más detallada.

Para cambiar la fuente de su aplicación, siga los siguientes pasos:

1. Dentro del resdirectorio crea un nuevo directorio y llámalo font.
2. Inserte su fuente .ttf / .otf dentro de la carpeta de fuentes, asegúrese de que el nombre de la fuente sea minúscula y solo subrayado.
3. Inside res-> values-> styles.xmlinside <resources>-> <style>agrega tu fuente <item name="android:fontFamily">@font/font_name</item>.

Ahora todo el texto de su aplicación debe estar en la fuente que agregue.

LEER ACTUALIZACIONES A CONTINUACIÓN

Tuve el mismo problema con la incrustación de una nueva fuente y finalmente conseguí que funcionara extendiendo TextView y configurando la fuente tipográfica dentro.

public class YourTextView extends TextView {

    public YourTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public YourTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public YourTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        Typeface tf = Typeface.createFromAsset(context.getAssets(),
            "fonts/helveticaneue.ttf");
        setTypeface(tf);
    }
}

Debe cambiar los Elementos TextView más tarde de a en cada elemento. Y si usa el UI-Creator en Eclipse, a veces no muestra las TextViews correctamente. Fue lo único que funcionó para mí ...

ACTUALIZAR

Hoy en día estoy usando la reflexión para cambiar los tipos de letra en toda la aplicación sin extender TextViews. Mira esta publicación SO

ACTUALIZACIÓN 2

A partir del nivel de API 26 y disponible en 'biblioteca de soporte', puede usar

android:fontFamily="@font/embeddedfont"

Más información: Fuentes en XML

Agregue esta línea de código en su res / value / styles.xml

<item name="android:fontFamily">@font/circular_medium</item>

todo el estilo se verá así

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- 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:fontFamily">@font/circular_medium</item>
</style>

cambie "circular_medium" a su propio nombre de fuente.

No hablemos de rendimiento, para fuentes personalizadas puede tener un método recursivo en bucle a través de todas las vistas y establecer el tipo de letra si es TextView:

public class Font {
    public static void setAllTextView(ViewGroup parent) {
        for (int i = parent.getChildCount() - 1; i >= 0; i--) {
            final View child = parent.getChildAt(i);
            if (child instanceof ViewGroup) {
                setAllTextView((ViewGroup) child);
            } else if (child instanceof TextView) {
                ((TextView) child).setTypeface(getFont());
            }
        }
    }

    public static Typeface getFont() {
        return Typeface.createFromAsset(YourApplicationContext.getInstance().getAssets(), "fonts/whateverfont.ttf");
    }
}

En toda su actividad, pásele ViewGroup actual después de setContentView y listo:

ViewGroup group = (ViewGroup) getWindow().getDecorView().findViewById(android.R.id.content);
Font.setAllTextView(group);

Por fragmento puedes hacer algo similar.

Otra forma de hacer esto para toda la aplicación es usar la reflexión basada en esta respuesta

public class TypefaceUtil {
    /**
     * Using reflection to override default typefaces
     * NOTICE: DO NOT FORGET TO SET TYPEFACE FOR APP THEME AS DEFAULT TYPEFACE WHICH WILL BE
     * OVERRIDDEN
     *
     * @param typefaces map of fonts to replace
     */
    public static void overrideFonts(Map<String, Typeface> typefaces) {
        try {
            final Field field = Typeface.class.getDeclaredField("sSystemFontMap");
            field.setAccessible(true);
            Map<String, Typeface> oldFonts = (Map<String, Typeface>) field.get(null);
            if (oldFonts != null) {
                oldFonts.putAll(typefaces);
            } else {
                oldFonts = typefaces;
            }
            field.set(null, oldFonts);
            field.setAccessible(false);
        } catch (Exception e) {
            Log.e("TypefaceUtil", "Can not set custom fonts");
        }
    }

    public static Typeface getTypeface(int fontType, Context context) {
        // here you can load the Typeface from asset or use default ones
        switch (fontType) {
            case BOLD:
                return Typeface.create(SANS_SERIF, Typeface.BOLD);
            case ITALIC:
                return Typeface.create(SANS_SERIF, Typeface.ITALIC);
            case BOLD_ITALIC:
                return Typeface.create(SANS_SERIF, Typeface.BOLD_ITALIC);
            case LIGHT:
                return Typeface.create(SANS_SERIF_LIGHT, Typeface.NORMAL);
            case CONDENSED:
                return Typeface.create(SANS_SERIF_CONDENSED, Typeface.NORMAL);
            case THIN:
                return Typeface.create(SANS_SERIF_MEDIUM, Typeface.NORMAL);
            case MEDIUM:
                return Typeface.create(SANS_SERIF_THIN, Typeface.NORMAL);
            case REGULAR:
            default:
                return Typeface.create(SANS_SERIF, Typeface.NORMAL);
        }
    }
}

luego, cuando desee anular las fuentes, puede llamar al método y asignarle un mapa de tipos de letra de la siguiente manera:

Typeface regular = TypefaceUtil.getTypeface(REGULAR, context);
Typeface light = TypefaceUtil.getTypeface(REGULAR, context);
Typeface condensed = TypefaceUtil.getTypeface(CONDENSED, context);
Typeface thin = TypefaceUtil.getTypeface(THIN, context);
Typeface medium = TypefaceUtil.getTypeface(MEDIUM, context);
Map<String, Typeface> fonts = new HashMap<>();
fonts.put("sans-serif", regular);
fonts.put("sans-serif-light", light);
fonts.put("sans-serif-condensed", condensed);
fonts.put("sans-serif-thin", thin);
fonts.put("sans-serif-medium", medium);
TypefaceUtil.overrideFonts(fonts);

para ver el ejemplo completo

Esto solo funciona para Android SDK 21 y superior para versiones anteriores, consulte el ejemplo completo

Simplemente use esta lib compílela en su archivo de calificación

complie'me.anwarshahriar:calligrapher:1.0'

y usarlo en el método onCreate en la actividad principal

Calligrapher calligrapher = new Calligrapher(this);
calligrapher.setFont(this, "yourCustomFontHere.ttf", true);

Esta es la forma súper rápida más elegante de hacer eso.

Este es el trabajo para mi proyecto, fuente https://gist.github.com/artem-zinnatullin/7749076

Cree el directorio de fuentes dentro de la Carpeta de activos y luego copie su fuente personalizada al directorio de fuentes, por ejemplo, estoy usando trebuchet.ttf;

Crear una clase TypefaceUtil.java;

import android.content.Context;
import android.graphics.Typeface;
import android.util.Log;

import java.lang.reflect.Field;
public class TypefaceUtil {

    public static void overrideFont(Context context, String defaultFontNameToOverride, String customFontFileNameInAssets) {
        try {
            final Typeface customFontTypeface = Typeface.createFromAsset(context.getAssets(), customFontFileNameInAssets);

            final Field defaultFontTypefaceField = Typeface.class.getDeclaredField(defaultFontNameToOverride);
            defaultFontTypefaceField.setAccessible(true);
            defaultFontTypefaceField.set(null, customFontTypeface);
        } catch (Exception e) {

        }
    }
}

Editar tema en styles.xml agregar a continuación

<item name="android:typeface">serif</item>

Ejemplo en Mis estilos.xml

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- 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:typeface">serif</item><!-- Add here -->
    </style>


    <style name="AppTheme.NoActionBar">
        <item name="windowActionBar">false</item>
        <item name="windowNoTitle">true</item>
        <item name="android:windowActionBarOverlay">true</item>
        <item name="android:windowFullscreen">true</item>
    </style>
</resources>

Finalmente, en Activity or Fragment onCreate call TypefaceUtil.java

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TypefaceUtil.overrideFont(getContext(), "SERIF", "fonts/trebuchet.ttf");
    }

Android no ofrece mucho soporte para la aplicación de fuentes en toda la aplicación (consulte este problema ). Tiene 4 opciones para configurar la fuente para toda la aplicación:

• Opción 1: aplicar reflejo para cambiar la fuente del sistema
• Opción 2: crear y subclasificar clases de vista personalizadas para cada vista que necesita una fuente personalizada
• Opción 3: Implemente un rastreador de vistas que atraviese la jerarquía de vistas para la pantalla actual
• Opción 4: usar una biblioteca de terceros.

Los detalles de estas opciones se pueden encontrar aquí .

Sé que esta pregunta es bastante antigua, pero he encontrado una buena solución. Básicamente, pasa un diseño de contenedor a esta función, y aplicará la fuente a todas las vistas admitidas, y hará un ciclo recursivo en diseños secundarios:

public static void setFont(ViewGroup layout)
{
    final int childcount = layout.getChildCount();
    for (int i = 0; i < childcount; i++)
    {
        // Get the view
        View v = layout.getChildAt(i);

        // Apply the font to a possible TextView
        try {
            ((TextView) v).setTypeface(MY_CUSTOM_FONT);
            continue;
        }
        catch (Exception e) { }

        // Apply the font to a possible EditText
        try {
            ((TextView) v).setTypeface(MY_CUSTOM_FONT);
            continue;
        }
        catch (Exception e) { }

        // Recursively cicle into a possible child layout
        try {
            ViewGroup vg = (ViewGroup) v;
            Utility.setFont(vg);
            continue;
        }
        catch (Exception e) { }
    }
}

a simple conjunto de tipo de letra de aplicación a normal, sans, serifo monospace(no a una fuente personalizada!), se puede hacer esto.

defina un tema y establezca el android:typefaceatributo en el tipo de letra que desea usar en styles.xml:

<resources>

    <!-- custom normal activity theme -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <!-- other elements -->
        <item name="android:typeface">monospace</item>
    </style>

</resources>

aplicar el tema a toda la aplicación en el AndroidManifest.xmlarchivo:

<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:theme="@style/AppTheme" >
    </application>
</manifest>

referencia de Android

Pruebe esta biblioteca, es ligera y fácil de implementar.

https://github.com/sunnag7/FontStyler

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

La respuesta es no, no puedes. Ver ¿Es posible establecer una fuente personalizada para toda la aplicación? para más información.

Hay soluciones, pero nada en las líneas de "una sola línea de código aquí y todas mis fuentes serán esto lugar de eso ".

(Agradezco a Google -y a Apple- por eso). Las fuentes personalizadas tienen un lugar, pero hacerlas fáciles de reemplazar en toda la aplicación, habría creado un mundo entero de aplicaciones Comic Sans )