tamaño - personalizar textview android studio

¿Cómo cambiar la fuente en el TextView?

Question

¿Cómo cambiar la fuente en un TextView , como predeterminado se muestra como Arial? ¿Cómo cambiarlo a Helvetica ?

Answer 1

La mejor práctica es usar la biblioteca de soporte de Android versión 26.0.0 o superior.

PASO 1: agregar archivo de fuente

1. En la carpeta res crea nuevo diccionario de recursos de fuente
2. Añadir archivo de fuente ( .ttf , .orf )

Por ejemplo, cuando el archivo de fuente será helvetica_neue.ttf que generará R.font.helvetica_neue

PASO 2: crear una familia de fuentes

1. En la carpeta de fuentes agregar nuevo archivo de recursos
2. Encierre cada archivo de fuente, estilo y atributo de peso en el elemento.

Por ejemplo:

<?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/helvetica_neue" />
</font-family>

PASO 3: utilízalo

En diseños xml:

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

O añada fuentes al estilo:

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

Para más ejemplos puedes seguir la documentación:

Trabajando con fuentes

Answer 2

La mejor práctica

TextViewPlus.java:

public class TextViewPlus extends TextView {
    private static final String TAG = "TextView";

    public TextViewPlus(Context context) {
        super(context);
    }

    public TextViewPlus(Context context, AttributeSet attrs) {
        super(context, attrs);
        setCustomFont(context, attrs);
    }

    public TextViewPlus(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setCustomFont(context, attrs);
    }

    private void setCustomFont(Context ctx, AttributeSet attrs) {
        TypedArray a = ctx.obtainStyledAttributes(attrs, R.styleable.TextViewPlus);
        String customFont = a.getString(R.styleable.TextViewPlus_customFont);
        setCustomFont(ctx, customFont);
        a.recycle();
    }

    public boolean setCustomFont(Context ctx, String asset) {
        Typeface typeface = null;
        try {
            typeface = Typeface.createFromAsset(ctx.getAssets(), asset);
        } catch (Exception e) {
            Log.e(TAG, "Unable to load typeface: "+e.getMessage());
            return false;
        }

        setTypeface(typeface);
        return true;
    }
}

attrs.xml: (Dónde colocar res / valores )

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="TextViewPlus">
        <attr name="customFont" format="string"/>
    </declare-styleable>
</resources>

Cómo utilizar:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:foo="http://schemas.android.com/apk/res-auto"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <com.mypackage.TextViewPlus
        android:id="@+id/textViewPlus1"
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        android:text="@string/showingOffTheNewTypeface"
        foo:customFont="my_font_name_regular.otf">
    </com.mypackage.TextViewPlus>
</LinearLayout>

Espero que esto te ayudará.

Answer 3

1. añadir clase FontTextView.java:

public class FontTextView extends TextView {
    String fonts[] = {"HelveticaNeue.ttf", "HelveticaNeueLight.ttf", "motschcc.ttf", "symbol.ttf"};

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

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

    }

    public FontTextView(Context context) {
        super(context);
        if (!isInEditMode()) {
            init(null);
        }
    }

    private void init(AttributeSet attrs) {
        if (attrs != null) {
            TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.FontTextView);
            if (a.getString(R.styleable.FontTextView_font_type) != null) {
                String fontName = fonts[Integer.valueOf(a.getString(R.styleable.FontTextView_font_type))];

                if (fontName != null) {
                    Typeface myTypeface = Typeface.createFromAsset(getContext().getAssets(), "font/" + fontName);
                    setTypeface(myTypeface);
                }
                a.recycle();
            }
        }
    }
}

2. añadir a la fuente de la biblioteca de activos
   

3. agregar a attrs.xml, los números deben estar en el orden en la clase de matriz.

   <declare-styleable name="FontTextView">
   <attr name="font_type" format="enum">
       <enum name="HelveticaNeue" value="0"/>
       <enum name="HelveticaNeueLight" value="1"/>
       <enum name="motschcc" value="2"/>
       <enum name="symbol" value="3"/>
   </attr>

4. Seleccione una fuente de la lista
   

Answer 4

Android usa la fuente Roboto, que es una fuente muy bonita, con varios pesos diferentes (regular, ligero, delgado, condensado) que se ven muy bien en las pantallas de alta densidad.

Consulte el siguiente enlace para ver las fuentes roboto:

Cómo usar Roboto en el diseño xml

De vuelta a su pregunta, si desea cambiar la fuente de todos los TextView / Button en su aplicación , intente agregar el código a continuación en su styles.xml para usar la fuente Roboto-light :

<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- Customize your theme here. -->
    ......
    <item name="android:buttonStyle">@style/MyButton</item>
    <item name="android:textViewStyle">@style/MyTextView</item>
</style>

<style name="MyButton" parent="@style/Widget.AppCompat.Button">
    <item name="android:textAllCaps">false</item>
    <item name="android:fontFamily">sans-serif-light</item>
</style>

<style name="MyTextView" parent="@style/TextAppearance.AppCompat">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

Y no olvide usar ''AppTheme'' en su AndroidManifest.xml

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    ......
</application>

Answer 5

Cuando su fuente esté almacenada dentro de res/asset/fonts/Helvetica.ttf use lo siguiente:

Typeface tf = Typeface.createFromAsset(getAssets(),"fonts/Helvetica.ttf"); 
txt.setTypeface(tf);

O, si su archivo de fuentes está almacenado dentro de res/font/helvetica.ttf use lo siguiente:

Typeface tf = ResourcesCompat.getFont(this,R.font.helvetica);
txt.setTypeface(tf);

Answer 6

En primer lugar, el valor predeterminado no es Arial. El valor predeterminado es Droid Sans.

En segundo lugar, para cambiar a una fuente incorporada diferente, use android:typeface de android:typeface en el diseño XML o setTypeface() en Java.

En tercer lugar, no hay fuente Helvetica en Android. Las opciones integradas son Droid Sans ( sans ), Droid Sans Mono ( monospace ) y Droid Serif ( serif ). Si bien puede agrupar sus propias fuentes con su aplicación y usarlas a través de setTypeface() , tenga en cuenta que los archivos de fuentes son grandes y, en algunos casos, requieren acuerdos de licencia (por ejemplo, Helvetica, una fuente Linotype ).

EDITAR

El lenguaje de diseño de Android se basa en herramientas tipográficas tradicionales como la escala, el espacio, el ritmo y la alineación con una cuadrícula subyacente. El despliegue exitoso de estas herramientas es esencial para ayudar a los usuarios a comprender rápidamente una pantalla de información. Para admitir tal uso de tipografía, Ice Cream Sandwich introdujo una nueva familia de tipos llamada Roboto, creada específicamente para los requisitos de IU y pantallas de alta resolución.

El marco TextView actual ofrece Roboto en pesos finos, ligeros, regulares y en negrita, junto con un estilo en cursiva para cada peso. El marco también ofrece la variante Roboto Condensed en pesos regulares y en negrita, junto con un estilo de cursiva para cada peso.

Después de ICS, Android incluye el estilo de fuentes Roboto, Leer más Roboto

Editar 2

Con la llegada de Support Library 26, Android ahora admite fuentes personalizadas de forma predeterminada. Puede insertar nuevas fuentes en res / fonts que se pueden establecer en TextViews individualmente en XML o mediante programación. La fuente predeterminada para toda la aplicación también se puede cambiar definiéndola styles.xml La documentación del desarrollador de Android tiene una guía clara sobre esto here

Answer 7

Es posible que desee crear una clase estática que contendrá todas las fuentes. De esa manera, no creará la fuente varias veces, lo que podría afectar negativamente al rendimiento . Solo asegúrese de crear una subcarpeta llamada " fuentes " en la carpeta "elementos".

Hacer algo como:

public class CustomFontsLoader {

public static final int FONT_NAME_1 =   0;
public static final int FONT_NAME_2 =   1;
public static final int FONT_NAME_3 =   2;

private static final int NUM_OF_CUSTOM_FONTS = 3;

private static boolean fontsLoaded = false;

private static Typeface[] fonts = new Typeface[3];

private static String[] fontPath = {
    "fonts/FONT_NAME_1.ttf",
    "fonts/FONT_NAME_2.ttf",
    "fonts/FONT_NAME_3.ttf"
};


/**
 * Returns a loaded custom font based on it''s identifier. 
 * 
 * @param context - the current context
 * @param fontIdentifier = the identifier of the requested font
 * 
 * @return Typeface object of the requested font.
 */
public static Typeface getTypeface(Context context, int fontIdentifier) {
    if (!fontsLoaded) {
        loadFonts(context);
    }
    return fonts[fontIdentifier];
}


private static void loadFonts(Context context) {
    for (int i = 0; i < NUM_OF_CUSTOM_FONTS; i++) {
        fonts[i] = Typeface.createFromAsset(context.getAssets(), fontPath[i]);
    }
    fontsLoaded = true;

}
}

De esta manera, puede obtener la fuente desde cualquier lugar de su aplicación.

Answer 8

Es un poco viejo, pero mejoré un poco la clase CustomFontLoader y quise compartirlo para que pueda ser útil. Simplemente crea una nueva clase con este código.

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

public enum FontLoader {

ARIAL("arial"),
TIMES("times"),
VERDANA("verdana"),
TREBUCHET("trbuchet"),
GEORGIA("georgia"),
GENEVA("geneva"),
SANS("sans"),
COURIER("courier"),
TAHOMA("tahoma"),
LUCIDA("lucida");   


private final String name;
private Typeface typeFace;


private FontLoader(final String name) {
    this.name = name;

    typeFace=null;  
}

public static Typeface getTypeFace(Context context,String name){
    try {
        FontLoader item=FontLoader.valueOf(name.toUpperCase(Locale.getDefault()));
        if(item.typeFace==null){                
            item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");                 
        }           
        return item.typeFace;
    } catch (Exception e) {         
        return null;
    }                   
}
public static Typeface getTypeFace(Context context,int id){
    FontLoader myArray[]= FontLoader.values();
    if(!(id<myArray.length)){           
        return null;
    } 
    try {
        if(myArray[id].typeFace==null){     
            myArray[id].typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+myArray[id].name+".ttf");                       
        }       
        return myArray[id].typeFace;    
    }catch (Exception e) {          
        return null;
    }   

}

public static Typeface getTypeFaceByName(Context context,String name){      
    for(FontLoader item: FontLoader.values()){              
        if(name.equalsIgnoreCase(item.name)){
            if(item.typeFace==null){
                try{
                    item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");     
                }catch (Exception e) {          
                    return null;
                }   
            }
            return item.typeFace;
        }               
    }
    return null;
}   

public static void loadAllFonts(Context context){       
    for(FontLoader item: FontLoader.values()){              
        if(item.typeFace==null){
            try{
                item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");     
            }catch (Exception e) {
                item.typeFace=null;
            }   
        }                
    }       
}   
}

Luego solo usa este código en tu vista de texto:

 Typeface typeFace=FontLoader.getTypeFace(context,"arial");  
 if(typeFace!=null) myTextView.setTypeface(typeFace);

Answer 9

Finalmente conseguí una solución muy fácil para esto.

1. utilizar estas bibliotecas de soporte en nivel de aplicación gradle ,

   compile ''com.android.support:appcompat-v7:26.0.2''
   compile ''com.android.support:support-v4:26.0.2''

2. luego crea un directorio llamado "fuente" dentro de la carpeta res

3. ponga los archivos de fuentes (ttf) en ese directorio de fuentes, tenga en cuenta las convenciones de denominación [por ejemplo, el nombre no debe contener ningún carácter especial, ningún carácter en mayúscula y ningún espacio o tabulador]

4. Después de eso, referencia esa fuente de xml como esta

           <Button
           android:id="@+id/btn_choose_employee"
           android:layout_width="140dp"
           android:layout_height="40dp"
           android:layout_centerInParent="true"
           android:background="@drawable/rounded_red_btn"
           android:onClick="btnEmployeeClickedAction"
           android:text="@string/searching_jobs"
           android:textAllCaps="false"
           android:textColor="@color/white"
           android:fontFamily="@font/times_new_roman_test"
           />

En este ejemplo, times_new_roman_test es un archivo fuente ttf de ese directorio de fuentes

Answer 10

Las respuestas anteriores son correctas. Solo asegúrese de crear una subcarpeta llamada "fuentes" en la carpeta "elementos" si está utilizando ese fragmento de código.

Answer 11

Otra forma de consolidar la creación de fuentes ...

public class Font {
  public static final Font  PROXIMA_NOVA    = new Font("ProximaNovaRegular.otf");
  public static final Font  FRANKLIN_GOTHIC = new Font("FranklinGothicURWBoo.ttf");
  private final String      assetName;
  private volatile Typeface typeface;

  private Font(String assetName) {
    this.assetName = assetName;
  }

  public void apply(Context context, TextView textView) {
    if (typeface == null) {
      synchronized (this) {
        if (typeface == null) {
          typeface = Typeface.createFromAsset(context.getAssets(), assetName);
        }
      }
    }
    textView.setTypeface(typeface);
  }
}

Y luego usarlo en tu actividad ...

myTextView = (TextView) findViewById(R.id.myTextView);
Font.PROXIMA_NOVA.apply(this, myTextView);

Tenga en cuenta que este lenguaje de bloqueo de doble comprobación con el campo volátil solo funciona correctamente con el modelo de memoria utilizado en Java 1.5+.

Answer 12

Primero descargue el archivo .ttf de la fuente que necesita ( arial.ttf ). Colóquelo en la carpeta de assets . (La carpeta de activos internos crea una nueva carpeta con nombre de fuentes y la coloca dentro de ella). Use el siguiente código para aplicar la fuente a su TextView :

Typeface type = Typeface.createFromAsset(getAssets(),"fonts/arial.ttf"); 
textView.setTypeface(type);

Answer 13

Tal vez algo un poco más simple:

public class Fonts {
  public static HashSet<String,Typeface> fonts = new HashSet<>();

  public static Typeface get(Context context, String file) {
    if (! fonts.contains(file)) {
      synchronized (this) {
        Typeface typeface = Typeface.createFromAsset(context.getAssets(), name);
        fonts.put(name, typeface);
      }
    }
    return fonts.get(file);
  }
}

// Usage
Typeface myFont = Fonts.get("arial.ttf");

(Tenga en cuenta que este código no se ha probado, pero en general este enfoque debería funcionar bien).

Answer 14

obtener fuente de activo y establecer a todos los niños

public static void overrideFonts(final Context context, final View v) {
    try {
        if (v instanceof ViewGroup) {
            ViewGroup vg = (ViewGroup) v;
            for (int i = 0; i < vg.getChildCount(); i++) {
                View child = vg.getChildAt(i);
                overrideFonts(context, child);
         }
        } else if (v instanceof TextView ) {
            ((TextView) v).setTypeface(Typeface.createFromAsset(context.getAssets(),"DroidNaskh.ttf"));// "BKOODB.TTF"));
        }
    } catch (Exception e) {
 }
 } 

Answer 15

Typeface tf = Typeface.createFromAsset(getAssets(),
        "fonts/DroidSansFallback.ttf");
TextView tv = (TextView) findViewById(R.id.CustomFontText);
tv.setTypeface(tf);

Answer 16

import java.lang.ref.WeakReference;
import java.util.HashMap;

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

public class FontsManager {

    private static FontsManager instance;

    private static HashMap<String, WeakReference<Typeface>> typefaces = new HashMap<String, WeakReference<Typeface>>();

    private static Context context;

    private FontsManager(final Context ctx) {
        if (context == null) {
            context = ctx;
        }
    }

    public static FontsManager getInstance(final Context appContext) {
        if (instance == null) {
            instance = new FontsManager(appContext);
        }
        return instance;
    }

    public static FontsManager getInstance() {
        if (instance == null) {
            throw new RuntimeException(
                    "Call getInstance(Context context) at least once to init the singleton properly");
        }
        return instance;
    }

    public Typeface getFont(final String assetName) {
        final WeakReference<Typeface> tfReference = typefaces.get(assetName);
        if (tfReference == null || tfReference.get() == null) {
            final Typeface tf = Typeface.createFromAsset(context.getResources().getAssets(),
                    assetName);
            typefaces.put(assetName, new WeakReference<Typeface>(tf));
            return tf;
        }
        return tfReference.get();
    }

}

De esta manera, puede crear una Vista que herede de TextView y llama a setTypeface en su constructor.