Comment changer la police sur le TextView?

D'abord, la valeur par défaut n'est pas Disponible. La valeur par défaut est Droid Sans.

Deuxième, pour changer intégré dans la police, android:typeface dans la mise en page XML ou setTypeface() en Java.

Troisième, il n'y a pas de police Helvetica dans Android. Intégré dans les choix sont Droid Sans (sans), Droid Sans Mono (monospace), et Droid Serif (serif). Alors que vous pouvez regrouper vos propres polices avec votre application et l'utiliser par l'intermédiaire setTypeface(), garder à l'esprit que les fichiers de police sont de grande taille et, dans certains cas, nécessiter des accords de licence (par exemple, Helvetica, une Linotype police).

MODIFIER

Android langage de conception s'appuie sur les traditionnels outils typographiques
tels que l'échelle, l'espace, le rythme, et l'alignement avec un sous-jacent de la grille.
La réussite du déploiement de ces outils est indispensable pour aider les utilisateurs à
rapidement comprendre un écran d'information. Pour permettre une telle utilisation de
la typographie, Sandwich à la Crème Glacée a introduit un nouveau type de famille nommé
Roboto, créé spécialement pour les besoins de l'INTERFACE utilisateur, et
des écrans haute résolution.

L'actuel TextView cadre offre Roboto dans mince, léger, ordinaire
et gras, avec un style italique pour chaque poids. L'
cadre offre également la Roboto Condensed variante régulière et gras
poids, avec un style italique pour chaque poids.

Après ICS, android comprend Roboto polices de style,
Lire plus Roboto

EDIT 2

Avec l'avènement de la Bibliothèque de prise en charge 26, Android prend désormais en charge les polices personnalisées par
par défaut. Vous pouvez insérer de nouvelles polices dans res/fonts qui peut être défini à TextViews individuellement, soit en XML ou par programmation. La police par défaut pour l'ensemble de l'application peut également être modifié en le définissant styles.xml L'android developer documentation est un guide clair sur ce ici

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

Meilleure pratique

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: (Où placer res/valeurs)

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

Comment utiliser:

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

Espère que cela va vous aider.

Une autre façon de consolider la création de la police...

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);
  }
}

Puis à utiliser dans votre activité...

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

Vous l'esprit, ce double-vérifier le verrouillage de l'idiome à la volatilité de domaine fonctionne correctement uniquement avec le modèle mémoire Java 1.5+.

C'est un peu vieux, mais j'ai amélioré la classe CustomFontLoader un peu et je voulais la partager afin qu'il puisse être utile. Il suffit de créer une nouvelle classe avec ce code.

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

Alors utilisez simplement ce code sur vous textview:

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

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 cette façon, vous pouvez créer une Vue qui hérite de TextView et les appels setTypeface sur son constructeur.

1. ajouter une classe 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();
}
}
}
}

1. ajouter à la bibliothèque d'actifs de la police
   
   
   

1. ajouter à attrs.xml ,
   Les chiffres devraient être dans l'ordre de la classe array.

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

1. Sélectionnez une police dans la liste
   
   
   

Lorsque votre police est stockée à l'intérieur de res/asset/fonts/Helvetica.ttf utiliser les éléments suivants:

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

Ou, si votre fichier de police est des magasins à l'intérieur de res/font/helvetica.ttf utiliser les éléments suivants:

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