java - tarjetas - instalar fuentes en netbeans

¿Es posible establecer una fuente personalizada para toda la aplicación?

Question

Necesito usar cierta fuente para toda mi aplicación. Tengo archivo .ttf para el mismo. ¿Es posible configurar esto como fuente predeterminada al inicio de la aplicación y luego usarla en otra parte de la aplicación? Cuando está configurado, ¿cómo lo uso en mis XML de diseño?

Answer 1

A partir de Android O, ahora es posible definirlo directamente desde el XML y ¡ mi error ya está cerrado!

Vea aquí para más detalles

TL; DR:

Primero debes agregar tus fuentes al proyecto.

En segundo lugar agregas una familia de fuentes, así:

<?xml version="1.0" encoding="utf-8"?>
<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>

Finalmente, puede usar la fuente en un diseño o estilo:

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

<style name="customfontstyle" parent="@android:style/TextAppearance.Small">
    <item name="android:fontFamily">@font/lobster</item>
</style>

¡Disfrutar!

Answer 2

En resumen:

Opción # 1: use la reflexión para aplicar la fuente (combinando la respuesta de weston y Roger Huang ):

import java.lang.reflect.Field;
import android.content.Context;
import android.graphics.Typeface;

public final class FontsOverride { 

    public static void setDefaultFont(Context context,
            String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(),
                fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    } 

    protected static void replaceFont(String staticTypefaceFieldName,final Typeface newTypeface) {
        if (isVersionGreaterOrEqualToLollipop()) {
            Map<String, Typeface> newMap = new HashMap<String, Typeface>();
            newMap.put("sans-serif", newTypeface);
            try {
                final Field staticField = Typeface.class.getDeclaredField("sSystemFontMap");
                staticField.setAccessible(true);
                staticField.set(null, newMap);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } else {
            try {
                final Field staticField = Typeface.class.getDeclaredField(staticTypefaceFieldName);
                staticField.setAccessible(true);
                staticField.set(null, newTypeface);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } 
        }
    }

} 

Uso en la clase de aplicación:

public final class Application extends android.app.Application {
    @Override 
    public void onCreate() { 
        super.onCreate(); 
        FontsOverride.setDefaultFont(this, "DEFAULT", "MyFontAsset.ttf");
        FontsOverride.setDefaultFont(this, "MONOSPACE", "MyFontAsset2.ttf");
        FontsOverride.setDefaultFont(this, "SERIF", "MyFontAsset3.ttf");
        FontsOverride.setDefaultFont(this, "SANS_SERIF", "MyFontAsset4.ttf");
    } 
} 

configura un estilo para forzar la aplicación de ese tipo de letra (basado en lovefish ):

Pre-Lollipop:

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

Lollipop (API 21):

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:textAppearance">@style/CustomTextAppearance</item>
   </style>

   <style name="CustomTextAppearance">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

Opción 2: Subclase todas y cada una de las Vistas donde necesite personalizar la fuente, es decir. ListView, EditTextView, Button, etc. (respuesta de Palani ):

public class CustomFontView extends TextView {

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

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

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

private void init() { 
    if (!isInEditMode()) {
        Typeface tf = Typeface.createFromAsset(getContext().getAssets(), "Futura.ttf");
        setTypeface(tf);
    } 
} 

Opción 3: implementar un rastreador de vistas que atraviese la jerarquía de vistas de su pantalla actual:

Variación # 1 (respuesta de Tom ):

public static final void setAppFont(ViewGroup mContainer, Typeface mFont, boolean reflect)
{ 
    if (mContainer == null || mFont == null) return;

    final int mCount = mContainer.getChildCount();

    // Loop through all of the children. 
    for (int i = 0; i < mCount; ++i)
    { 
        final View mChild = mContainer.getChildAt(i);
        if (mChild instanceof TextView)
        { 
            // Set the font if it is a TextView. 
            ((TextView) mChild).setTypeface(mFont);
        } 
        else if (mChild instanceof ViewGroup)
        { 
            // Recursively attempt another ViewGroup. 
            setAppFont((ViewGroup) mChild, mFont);
        } 
        else if (reflect)
        { 
            try { 
                Method mSetTypeface = mChild.getClass().getMethod("setTypeface", Typeface.class);
                mSetTypeface.invoke(mChild, mFont); 
            } catch (Exception e) { /* Do something... */ }
        } 
    } 
} 

Uso:

final ViewGroup mContainer = (ViewGroup) findViewById(
android.R.id.content).getRootView();
HomeActivity.setAppFont(mContainer, Typeface.createFromAsset(getAssets(),
"fonts/MyFont.ttf"));

Variación # 2: https://coderwall.com/p/qxxmaa/android-use-a-custom-font-everywhere .

Opción # 4: Use la tercera parte de Lib llamada Calligraphy .

Personalmente, recomendaría la opción # 4, ya que ahorra muchos dolores de cabeza.

Answer 3

Escribí una clase que asignaba el tipo de letra a las vistas en la jerarquía de vista actual y basé en las propiedades del tipo de letra actual (negrita, normal, puedes agregar otros estilos si lo deseas):

public final class TypefaceAssigner {

public final Typeface DEFAULT;
public final Typeface DEFAULT_BOLD;

@Inject
public TypefaceAssigner(AssetManager assetManager) {
    DEFAULT = Typeface.createFromAsset(assetManager, "TradeGothicLTCom.ttf");
    DEFAULT_BOLD = Typeface.createFromAsset(assetManager, "TradeGothicLTCom-Bd2.ttf");
}

public void assignTypeface(View v) {
    if (v instanceof ViewGroup) {
        for (int i = 0; i < ((ViewGroup) v).getChildCount(); i++) {
            View view = ((ViewGroup) v).getChildAt(i);
            if (view instanceof ViewGroup) {
                setTypeface(view);
            } else {
                setTypeface(view);
            }
        }
    } else {
        setTypeface(v);
    }
}

private void setTypeface(View view) {
    if (view instanceof TextView) {
        TextView textView = (TextView) view;
        Typeface typeface = textView.getTypeface();
        if (typeface != null && typeface.isBold()) {
            textView.setTypeface(DEFAULT_BOLD);
        } else {
            textView.setTypeface(DEFAULT);
        }
    }
}
}

Ahora en todos los fragmentos en onViewCreated o onCreateView, en todas las actividades en onCreate y en todos los adaptadores de vista en getView o newView solo invoque:

typefaceAssigner.assignTypeface(view);

Answer 4

Finalmente, Google se dio cuenta de la gravedad de este problema (aplicando una fuente personalizada a los componentes de la interfaz de usuario) y diseñó una solución limpia para ello.

Primero, necesita actualizar para admitir la biblioteca 26+ (es posible que también deba actualizar su gradle {4.0+}, Android Studio), luego puede crear una nueva carpeta de recursos llamada fuente. En esta carpeta, puede poner sus recursos de fuentes (.tff, ...). Entonces necesitas anular la aplicación predeterminada y forzar tu fuente personalizada en ella :)

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

Nota: si desea admitir dispositivos con una API más antigua que 16, debe usar el espacio de nombres de la aplicación en lugar de android.

Answer 5

Hay una gran biblioteca para fuentes personalizadas en android: Calligraphy

Aquí hay una muestra de cómo usarlo.

en Gradle, debe colocar esta línea en el archivo build.gradle de su aplicación:

dependencies {
    compile ''uk.co.chrisjenx:calligraphy:2.2.0''
}

y luego haga una clase que extienda la Application y escriba este código:

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        CalligraphyConfig.initDefault(new CalligraphyConfig.Builder()
                        .setDefaultFontPath("your font path")
                        .setFontAttrId(R.attr.fontPath)
                        .build()
        );
    }
} 

y en la clase de actividad coloca este método antes de onCreate:

@Override
protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase));
}

y lo último que debería ver tu archivo de manifiesto es este:

<application
   .
   .
   .
   android:name=".App">

¡Y cambiará toda la actividad a tu fuente! ¡Es simple y limpio!

Answer 6

La solución de Tom funciona muy bien, pero solo funciona con TextView y EditText.

Si desea cubrir la mayoría de las vistas (RadioGroup, TextView, Checkbox ...), he creado un método para hacerlo:

protected void changeChildrenFont(ViewGroup v, Typeface font){
    for(int i = 0; i < v.getChildCount(); i++){

        // For the ViewGroup, we''ll have to use recursivity
        if(v.getChildAt(i) instanceof ViewGroup){
            changeChildrenFont((ViewGroup) v.getChildAt(i), font);
        }
        else{
            try {
                Object[] nullArgs = null;
                //Test wether setTypeface and getTypeface methods exists
                Method methodTypeFace = v.getChildAt(i).getClass().getMethod("setTypeface", new Class[] {Typeface.class, Integer.TYPE});
                //With getTypefaca we''ll get back the style (Bold, Italic...) set in XML
                Method methodGetTypeFace = v.getChildAt(i).getClass().getMethod("getTypeface", new Class[] {});
                Typeface typeFace = ((Typeface)methodGetTypeFace.invoke(v.getChildAt(i), nullArgs));
                //Invoke the method and apply the new font with the defined style to the view if the method exists (textview,...)
                methodTypeFace.invoke(v.getChildAt(i), new Object[] {font, typeFace == null ? 0 : typeFace.getStyle()});
            }
            //Will catch the view with no such methods (listview...)
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Este método recuperará el estilo de la vista establecida en XML (negrita, cursiva ...) y los aplicará si existen.

Para el ListView, siempre creo un adaptador, y configuro la fuente dentro de getView.

Answer 7

Me gustaría mejorar la respuesta de weston para API 21 Android 5.0.

Porque

Bajo API 21, la mayoría de los estilos de texto incluyen la configuración de familia de fuentes, como:

<style name="TextAppearance.Material">
     <item name="fontFamily">@string/font_family_body_1_material</item>
</style>

Que aplica la fuente Roboto Regular por defecto:

<string name="font_family_body_1_material">sans-serif</string>

La respuesta original no aplica una fuente monoespaciada, porque android: fontFamily tiene mayor prioridad para el atributo android: tipo de letra ( reference ). Usar Theme.Holo. * Es una solución válida, ya que no hay configuraciones de Android: fontFamily dentro.

Solución

Dado que Android 5.0 coloca el tipo de letra del sistema en la variable estática Typeface.sSystemFontMap ( reference ), podemos usar la misma técnica de reflexión para reemplazarla:

protected static void replaceFont(String staticTypefaceFieldName,
        final Typeface newTypeface) {
    if (isVersionGreaterOrEqualToLollipop()) {
        Map<String, Typeface> newMap = new HashMap<String, Typeface>();
        newMap.put("sans-serif", newTypeface);
        try {
            final Field staticField = Typeface.class
                    .getDeclaredField("sSystemFontMap");
            staticField.setAccessible(true);
            staticField.set(null, newMap);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    } else {
        try {
            final Field staticField = Typeface.class
                    .getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Answer 8

Me gustaría mejorar las respuestas de weston y Roger Huang para más de API 21 Android Lollipop con el tema " Theme.AppCompat ".

Debajo de Android 4.4

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

Sobre (igual) API 5.0

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:textAppearance">@style/CustomTextAppearance</item>
   </style>

   <style name="CustomTextAppearance">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

Y el archivo util de FontsOverride es el mismo que el de la respuesta de weston . He probado en estos teléfonos:

Nexus 5 (sistema Android primario 5.1 de Android)

ZTE V5 (Android 5.1 CM12.1)

XIAOMI nota (Android 4.4 MIUI6)

HUAWEI C8850 (Android 2.3.5 DESCONOCIDO)

Answer 9

Para cambiar la familia de fuentes predeterminada de las vistas de texto, anule textViewStyle en el tema de su aplicación.

Para usar fuentes personalizadas en fontFamily, use los recursos de fuentes que se encuentran en la biblioteca de soporte.

La función se agregó en Android 26 pero se incluyó en versiones anteriores a través de supportlib.

https://developer.android.com/guide/topics/resources/font-resource.html https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html#using-support-lib

Answer 10

Puede configurar fuentes personalizadas para cada diseño una por una, con solo una llamada de función desde cada diseño pasando su Vista raíz. Primero, cree un enfoque único para acceder al objeto de fuente como este

 public class Font {
    private static Font font;
    public Typeface ROBO_LIGHT;

    private Font() {

    }

    public static Font getInstance(Context context) {
        if (font == null) {
            font = new Font();
            font.init(context);
        }
        return font;

    }

    public void init(Context context) {

        ROBO_LIGHT = Typeface.createFromAsset(context.getAssets(),
                "Roboto-Light.ttf");
    }

}

Puede definir diferentes fuentes en la clase anterior, ahora defina una clase de ayuda de fuente que aplicará fuentes:

   public class FontHelper {

    private static Font font;

    public static void applyFont(View parentView, Context context) {

        font = Font.getInstance(context);

        apply((ViewGroup)parentView);

    }

    private static void apply(ViewGroup parentView) {
        for (int i = 0; i < parentView.getChildCount(); i++) {

            View view = parentView.getChildAt(i);

//You can add any view element here on which you want to apply font 

            if (view instanceof EditText) {

                ((EditText) view).setTypeface(font.ROBO_LIGHT);

            }
            if (view instanceof TextView) {

                ((TextView) view).setTypeface(font.ROBO_LIGHT);

            }

            else if (view instanceof ViewGroup
                    && ((ViewGroup) view).getChildCount() > 0) {
                apply((ViewGroup) view);
            }

        }

    }

}

En el código anterior, estoy aplicando las fuentes solo en textView y EditText, también puede aplicar las fuentes en otros elementos de la vista de manera similar. Solo necesita pasar el ID de su grupo de Vista raíz al método de fuente aplicable anterior. por ejemplo, su diseño es:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:id="@+id/mainParent"
    tools:context="${relativePackage}.${activityClass}" >

    <RelativeLayout
        android:id="@+id/mainContainer"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_above="@+id/homeFooter"
        android:layout_below="@+id/edit" >

        <ImageView
            android:id="@+id/PreviewImg"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:src="@drawable/abc_list_longpressed_holo"
            android:visibility="gone" />

        <RelativeLayout
            android:id="@+id/visibilityLayer"
            android:layout_width="match_parent"
            android:layout_height="fill_parent" >

            <ImageView
                android:id="@+id/UseCamera"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentTop="true"
                android:layout_centerHorizontal="true"
                android:src="@drawable/camera" />

            <TextView
                android:id="@+id/tvOR"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_below="@+id/UseCamera"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="20dp"
                android:text="OR"
                android:textSize="30dp" />

            <TextView
                android:id="@+id/tvAND"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="20dp"
                android:text="OR"
                android:textSize="30dp" />

</RelativeLayout>

En el diseño anterior, la identificación del padre raíz es "Padre principal" ahora permite aplicar la fuente

public class MainActivity extends BaseFragmentActivity {

    private EditText etName;
    private EditText etPassword;
    private TextView tvTitle;
    public static boolean isHome = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

       Font font=Font.getInstance(getApplicationContext());
        FontHelper.applyFont(findViewById(R.id.mainParent),          getApplicationContext());
   }    
}

Saludos :)

Answer 11

Sí con reflexión. Esto funciona ( basado en esta respuesta ):

(Nota: esta es una solución alternativa debido a la falta de compatibilidad con las fuentes personalizadas, por lo que si desea cambiar esta situación, por favor, marque para aumentar el problema de Android aquí ). Nota: No deje comentarios "yo también" sobre ese tema, todos los que lo han recibido reciben un correo electrónico cuando lo hacen. Así que sólo "estrella", por favor.

import java.lang.reflect.Field;
import android.content.Context;
import android.graphics.Typeface;

public final class FontsOverride {

    public static void setDefaultFont(Context context,
            String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(),
                fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    }

    protected static void replaceFont(String staticTypefaceFieldName,
            final Typeface newTypeface) {
        try {
            final Field staticField = Typeface.class
                    .getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Luego debe sobrecargar las pocas fuentes predeterminadas, por ejemplo, en una clase de application :

public final class Application extends android.app.Application {
    @Override
    public void onCreate() {
        super.onCreate();
        FontsOverride.setDefaultFont(this, "DEFAULT", "MyFontAsset.ttf");
        FontsOverride.setDefaultFont(this, "MONOSPACE", "MyFontAsset2.ttf");
        FontsOverride.setDefaultFont(this, "SERIF", "MyFontAsset3.ttf");
        FontsOverride.setDefaultFont(this, "SANS_SERIF", "MyFontAsset4.ttf");
    }
}

Por supuesto, si está utilizando el mismo archivo de fuente, puede mejorar esto para cargarlo solo una vez.

Sin embargo, tiendo a anular solo uno, diga "MONOSPACE" , y luego configuro un estilo para forzar a la fuente de toda la aplicación:

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

    <!-- Application theme. -->
    <style name="AppTheme" parent="AppBaseTheme">
        <item name="android:typeface">monospace</item>
    </style>
</resources>

API 21 Android 5.0

He investigado los informes en los comentarios que no funcionan y parece ser incompatible con el tema de android:Theme.Material.Light .

Si ese tema no es importante para usted, use un tema más antiguo, por ejemplo:

<style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
    <item name="android:typeface">monospace</item>
</style>

Answer 12

Si bien esto no funcionaría para una aplicación completa, funcionaría para una Actividad y podría reutilizarse para cualquier otra Actividad. He actualizado mi código gracias a @ FR073N para admitir otras Vistas. No estoy seguro de los problemas con los Buttons , RadioGroups , etc. porque todas esas clases extienden TextView por lo que deberían funcionar bien. Agregué un condicional booleano para usar la reflexión porque parece muy imprudente y podría comprometer notablemente el rendimiento.

Nota: como se señaló, esto no funcionará para contenido dinámico! Para eso, es posible llamar a este método con un método onCreateView o getView , pero requiere un esfuerzo adicional.

/**
 * Recursively sets a {@link Typeface} to all
 * {@link TextView}s in a {@link ViewGroup}.
 */
public static final void setAppFont(ViewGroup mContainer, Typeface mFont, boolean reflect)
{
    if (mContainer == null || mFont == null) return;

    final int mCount = mContainer.getChildCount();

    // Loop through all of the children.
    for (int i = 0; i < mCount; ++i)
    {
        final View mChild = mContainer.getChildAt(i);
        if (mChild instanceof TextView)
        {
            // Set the font if it is a TextView.
            ((TextView) mChild).setTypeface(mFont);
        }
        else if (mChild instanceof ViewGroup)
        {
            // Recursively attempt another ViewGroup.
            setAppFont((ViewGroup) mChild, mFont);
        }
        else if (reflect)
        {
            try {
                Method mSetTypeface = mChild.getClass().getMethod("setTypeface", Typeface.class);
                mSetTypeface.invoke(mChild, mFont); 
            } catch (Exception e) { /* Do something... */ }
        }
    }
}

Entonces para usarlo harías algo como esto:

final Typeface mFont = Typeface.createFromAsset(getAssets(),
"fonts/MyFont.ttf"); 
final ViewGroup mContainer = (ViewGroup) findViewById(
android.R.id.content).getRootView();
HomeActivity.setAppFont(mContainer, mFont);

Espero que ayude.

Answer 13

También me gustaría mejorar la respuesta de weston para API 21 Android 5.0.

Tuve el mismo problema en mi Samsung s5, cuando utilizaba la fuente POR DEFECTO. (con las otras fuentes está funcionando bien)

Logré que funcionara configurando el tipo de letra ("sans" por ejemplo) en archivos XML, para cada vista de texto o botón

<TextView
android:layout_width="match_parent"
android:layout_height="39dp"
android:textColor="@color/abs__background_holo_light"
android:textSize="12sp"
android:gravity="bottom|center"
android:typeface="sans" />

y en MyApplication Class:

public class MyApplication extends Application {
    @Override
    public void onCreate() {
    TypefaceUtil.overrideFont(getApplicationContext(), "SANS_SERIF",
    "fonts/my_font.ttf");
    }
}

Espero eso ayude.

Answer 14

También sugeriría la ampliación de TextView y otros controles, pero sería mejor que considerara configurar la fuente en las construcciones.

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

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

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

protected void init() {
    setTypeface(Typeface.createFromAsset(getContext().getAssets(), AppConst.FONT));
}

Answer 15

Trabajando para Xamarin.Android:

Clase:

public class FontsOverride
{
    public static void SetDefaultFont(Context context, string staticTypefaceFieldName, string fontAssetName)
    {
        Typeface regular = Typeface.CreateFromAsset(context.Assets, fontAssetName);
        ReplaceFont(staticTypefaceFieldName, regular);
    }

    protected static void ReplaceFont(string staticTypefaceFieldName, Typeface newTypeface)
    {
        try
        {
            Field staticField = ((Java.Lang.Object)(newTypeface)).Class.GetDeclaredField(staticTypefaceFieldName);
            staticField.Accessible = true;
            staticField.Set(null, newTypeface);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Implementación de la aplicación:

namespace SomeAndroidApplication
{
    [Application]
    public class App : Application
    {
        public App()
        {

        }

        public App(IntPtr handle, JniHandleOwnership transfer)
            : base(handle, transfer)
        {

        }

        public override void OnCreate()
        {
            base.OnCreate();

            FontsOverride.SetDefaultFont(this, "MONOSPACE", "fonts/Roboto-Light.ttf");
        }
    }
}

Estilo:

<style name="Theme.Storehouse" parent="Theme.Sherlock">
    <item name="android:typeface">monospace</item>
</style>

Answer 16

Una solución brillante se puede encontrar aquí: https://coderwall.com/p/qxxmaa/android-use-a-custom-font-everywhere .

Simplemente extienda las actividades de BaseActivity y escriba esos métodos. También deberías almacenar mejor las fuentes como se describe aquí: https://.com/a/16902532/2914140 .

Después de algunas investigaciones, escribí un código que funciona en Samsung Galaxy Tab A (Android 5.0). Se utilizó el código de Weston y Roger Huang, así como https://.com/a/33236102/2914140 . También probado en Lenovo TAB 2 A10-70L, donde no funciona. Inserté una fuente ''Comic Sans'' aquí para ver la diferencia.

import android.content.Context;
import android.graphics.Typeface;
import android.os.Build;
import android.util.Log;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class FontsOverride {
    private static final int BOLD = 1;
    private static final int BOLD_ITALIC = 2;
    private static final int ITALIC = 3;
    private static final int LIGHT = 4;
    private static final int CONDENSED = 5;
    private static final int THIN = 6;
    private static final int MEDIUM = 7;
    private static final int REGULAR = 8;

    private Context context;

    public FontsOverride(Context context) {
        this.context = context;
    }

    public void loadFonts() {
        Map<String, Typeface> fontsMap = new HashMap<>();
        fontsMap.put("sans-serif", getTypeface("comic.ttf", REGULAR));
        fontsMap.put("sans-serif-bold", getTypeface("comic.ttf", BOLD));
        fontsMap.put("sans-serif-italic", getTypeface("comic.ttf", ITALIC));
        fontsMap.put("sans-serif-light", getTypeface("comic.ttf", LIGHT));
        fontsMap.put("sans-serif-condensed", getTypeface("comic.ttf", CONDENSED));
        fontsMap.put("sans-serif-thin", getTypeface("comic.ttf", THIN));
        fontsMap.put("sans-serif-medium", getTypeface("comic.ttf", MEDIUM));
        overrideFonts(fontsMap);
    }

    private void overrideFonts(Map<String, Typeface> typefaces) {
        if (Build.VERSION.SDK_INT == 21) {
            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", "Cannot set custom fonts");
            }
        } else {
            try {
                for (Map.Entry<String, Typeface> entry : typefaces.entrySet()) {
                    final Field staticField = Typeface.class.getDeclaredField(entry.getKey());
                    staticField.setAccessible(true);
                    staticField.set(null, entry.getValue());
                }
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    private Typeface getTypeface(String fontFileName, int fontType) {
        final Typeface tf = Typeface.createFromAsset(context.getAssets(), "fonts/" + fontFileName);
        return Typeface.create(tf, fontType);
    }
}

Para ejecutar el código en toda la aplicación, debe escribir en alguna clase como Aplicación lo siguiente:

    new FontsOverride(this).loadFonts();

Cree una carpeta ''fuentes'' dentro de ''activos'' y ponga las fuentes necesarias allí. Puede encontrar una instrucción simple aquí: https://.com/a/31697103/2914140 .

El dispositivo Lenovo también obtiene incorrectamente el valor de un tipo de letra. En la mayoría de las veces devuelve Typeface.NORMAL, a veces nulo. Incluso si un TextView está en negrita (en el diseño del archivo xml). Vea aquí: TextView isBold siempre devuelve NORMAL . De esta manera, un texto en una pantalla siempre está en una fuente regular, no en negrita ni en cursiva. Así que creo que es un error de un productor.

Answer 17

Yo sugeriría ampliar TextView, y siempre usar su TextView personalizado dentro de sus diseños XML o donde sea que necesite un TextView. En su TextView personalizado, anule setTypeface

@Override
public void setTypeface(Typeface tf, int style) {
    //to handle bold, you could also handle italic or other styles here as well
    if (style == 1){
        tf = Typeface.createFromAsset(getContext().getApplicationContext().getAssets(), "MuseoSans700.otf");
    }else{
        tf = Typeface.createFromAsset(getContext().getApplicationContext().getAssets(), "MuseoSans500.otf");
    }
    super.setTypeface(tf, 0);
}

Answer 18

en la API 26 con build.gradle 3.0.0 y superior, puede crear un directorio de fuentes en resolución y usar esta línea en su estilo

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

para cambiar build.gradle use esto en sus dependencias build.gradle

classpath ''com.android.tools.build:gradle:3.0.0''

Answer 19

es muy simple ... 1.Descargue y coloque su fuente personalizada en los activos ... luego escriba una clase separada para ver el texto de la siguiente manera: aquí usé la fuente futura

public class CusFntTextView extends TextView {

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

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

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

private void init() {
    if (!isInEditMode()) {
        Typeface tf = Typeface.createFromAsset(getContext().getAssets(), "Futura.ttf");
        setTypeface(tf);
    }
}

}

y haz lo siguiente en xml:

 <com.packagename.CusFntTextView
        android:id="@+id/tvtitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"         
        android:text="Hi Android"           
        android:textAppearance="?android:attr/textAppearanceLarge"
      />

Answer 20

Calligraphy funciona bastante bien, pero no es adecuada para mí, ya que no admite diferentes pesos (negrita, cursiva, etc.) para una familia de fuentes.

Así que probé Fontain , que te permite definir vistas personalizadas y aplicarlas a familias de fuentes personalizadas.

para usar Fontain, debe agregar lo siguiente a su módulo de aplicación build.gradle:

compile ''com.scopely:fontain:1.0.0''

Luego, en lugar de usar TextView normal, debe usar FontTextView

Ejemplo de FontTextView con contenido en mayúsculas y negrita:

 <com.scopely.fontain.views.FontTextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="@android:color/black"
            android:textColor="@android:color/white"
            android:textSize="11dp"
            android:gravity="center"
            android:id="@+id/tv1"
            app:font_family="myCustomFont"
            app:caps_mode="characters"
            app:font_weight="BOLD"/>

Answer 21

Sí, es posible establecer la fuente para toda la aplicación.

La forma más fácil de lograr esto es empaquetar las fuentes deseadas con su aplicación.

Para hacer esto, simplemente cree una carpeta / recursos en la raíz del proyecto, y ponga sus fuentes (en forma TrueType o TTF) en los recursos.

Puede, por ejemplo, crear recursos / fuentes / y colocar sus archivos TTF allí.

public class FontSampler extends Activity {
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
TextView tv=(TextView)findViewById(R.id.custom);

Typeface face=Typeface.createFromAsset(getAssets(), "fonts/HandmadeTypewriter.ttf");
tv.setTypeface(face);
}
}

Answer 22

This solución no funciona correctamente en algunas situaciones.
Así que lo extiendo:

FuentesReplacer.java

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        FontsReplacer.replaceFonts(this);
        super.onCreate();
    }

}

https://gist.github.com/orwir/6df839e3527647adc2d56bfadfaad805

Answer 23

Desde el lanzamiento de Android Oreo y su biblioteca de soporte (26.0.0) puede hacerlo fácilmente. Consulte esta respuesta en otra pregunta.

Básicamente tu estilo final se verá así:

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

Answer 24

package com.theeasylearn.demo.designdemo;
import android.content.Context;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.TextView;

public class MyButton extends TextView {

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

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

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

    private void init() {

            Typeface tf =
                    Typeface.createFromAsset(
                            getContext().getAssets(), "angelina.TTF");
            setTypeface(tf);

    }

}