Comment changer la police sur le TextView?
Comment changer la police dans un TextView, par défaut, Arial? Comment le changer en Helvetica?
Tout d'abord, la valeur par défaut n'est pas Arial. La valeur par défaut est Droid Sans.
Deuxièmement, pour passer à une police intégrée différente, utilisez Android:typeface dans la présentation XML ou setTypeface() en Java.
Troisièmement, il n'y a pas de police Helvetica dans Android. Les choix intégrés sont Droid Sans (sans), Droid Sans Mono (monospace) et Droid Serif (serif). Bien que vous puissiez regrouper vos propres polices avec votre application et les utiliser via setTypeface(), gardez à l’esprit que les fichiers de polices sont volumineux et, dans certains cas, nécessitent un contrat de licence (par exemple, Helvetica, une police Linotype ).
EDIT
Le langage de conception Android repose sur des outils typographiques traditionnels tels que l'échelle, l'espace, le rythme et l'alignement sur une grille sous-jacente. Le déploiement réussi de ces outils est essentiel pour aider les utilisateurs à comprendre rapidement un écran d’informations. Pour faciliter cette utilisation de la typographie, Ice Cream Sandwich a introduit une nouvelle famille de types appelée Roboto, créée spécifiquement pour les besoins de l’interface utilisateur et des écrans haute résolution.
La structure TextView actuelle offre à Roboto des poids fins, légers, réguliers et audacieux, ainsi qu’un style italique pour chaque poids. Le cadre offre également la variante Roboto Condensed en poids réguliers et gras, avec un style italique pour chaque poids.
Après ICS, Android inclut le style de police Roboto, En savoir plus Roboto
EDIT 2
Avec l'avènement de Support Library 26, Android prend désormais en charge les polices personnalisées par défaut. Vous pouvez insérer de nouvelles polices dans res/fonts , qui peuvent être définis sur TextViews individuellement, en XML ou par programme. La police par défaut de l’ensemble de l’application peut également être modifiée en définissant styles.xml. La documentation destinée aux développeurs Android contient un guide explicite à ce sujet ici
Commencez par télécharger le fichier .ttf de la police dont vous avez besoin (arial.ttf). Placez-le dans le dossier assets. (Dans le dossier assets, créez un nouveau dossier nommé polices et placez-le à l'intérieur.) Utilisez le code suivant pour appliquer la police à votre TextView:
Typeface type = Typeface.createFromAsset(getAssets(),"fonts/arial.ttf");
textView.setTypeface(type);
Typeface tf = Typeface.createFromAsset(getAssets(),
"fonts/DroidSansFallback.ttf");
TextView tv = (TextView) findViewById(R.id.CustomFontText);
tv.setTypeface(tf);
Vous voudrez peut-être créer classe statique qui contiendra toutes les polices. De cette façon, vous ne créerez pas la police plusieurs fois, ce qui pourrait avoir un impact négatif sur performance. Assurez-vous simplement de créer un dossier sous-dossier appelé "polices" sous "ressources".
Faites quelque chose comme:
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 cette façon, vous pouvez obtenir la police de partout dans votre application.
Meilleure pratique jamais
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/values)
<?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>
J'espère que cela vous aidera.
Les réponses ci-dessus sont correctes. Assurez-vous simplement de créer un sous-dossier appelé "polices" sous le dossier "assets" si vous utilisez ce morceau de code.
Un autre moyen de consolider la création de polices ...
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);
}
}
Et puis à utiliser dans votre activité ...
myTextView = (TextView) findViewById(R.id.myTextView);
Font.PROXIMA_NOVA.apply(this, myTextView);
Notez bien que cet idiome de verrouillage à double vérification avec le champ volatile ne fonctionne correctement qu'avec le modèle de mémoire utilisé dans Java 1.5+.
La meilleure pratique consiste à utiliser Android Bibliothèque de support, version 26.0.0 ou ultérieure.
ÉTAPE 1: ajouter un fichier de police
- Dans le dossier res, créez un nouveau dictionnaire de ressources font
- Ajouter un fichier de police (. Ttf, . Orf)
Par exemple, lorsque le fichier de police sera helvetica_neue.ttf, il générera R.font.helvetica_neue
ÉTAPE 2: créer une famille de polices
- Dans le dossier font ajouter un nouveau fichier de ressources
- Incluez chaque fichier de police, style et attribut de poids dans l'élément.
Par exemple:
<?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>
ÉTAPE 3: utilisez-le
En dispositions XML:
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:fontFamily="@font/my_font"/>
Ou ajoutez des polices au style:
<style name="customfontstyle" parent="@Android:style/TextAppearance.Small">
<item name="Android:fontFamily">@font/lobster</item>
</style>
Pour plus d'exemples, vous pouvez suivre la documentation:
C'est un peu vieux, mais j'ai amélioré un peu la classe CustomFontLoader et je voulais la partager afin qu'elle puisse être utile. Créez simplement 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;
}
}
}
}
}
Ensuite, utilisez ce code sur votre textview:
Typeface typeFace=FontLoader.getTypeFace(context,"arial");
if(typeFace!=null) myTextView.setTypeface(typeFace);
J'ai finalement eu une solution très facile à cela.
utiliser ces bibliothèques de support dans niveau d'application,
compile 'com.Android.support:appcompat-v7:26.0.2' compile 'com.Android.support:support-v4:26.0.2'puis créez un répertoire nommé "font" dans le dossier res
- mettre les fichiers de polices (ttf) dans ce répertoire de polices, en gardant à l'esprit les conventions de dénomination [nom, par exemple, ne doit contenir aucun caractère spécial, aucun caractère majuscule ni espace ou tabulation]
Après cela, référencez cette police à partir de xml comme ceci
<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" />
Dans cet exemple, times_new_roman_test est un fichier de police ttf de ce répertoire de polices.
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 appelle setTypeface sur son constructeur.
- ajouter la 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();
}
}
}
}
- ajouter à la police de la bibliothèque d'actifs
![enter image description here]()
add à attrs.xml, les nombres doivent ê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>
- Sélectionnez une police dans la liste
![enter image description here]()
obtenir la police de la ressource et la configurer pour tous les enfants
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) {
}
}
Peut-être quelque chose d'un peu plus 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");
(Notez que ce code n'a pas été testé, mais en général, cette approche devrait bien fonctionner.)
Android utilise la police Roboto, qui est une police très agréable à regarder, avec différents poids (normal, léger, fin, condensé) qui ont fière allure sur des écrans haute densité.
Vérifiez le lien ci-dessous pour vérifier les polices roboto:
Comment utiliser Roboto dans une mise en page XML
Retour à votre question, si vous voulez changer la police pour tout le TextView/Button dans votre application , essayez d'ajouter du code ci-dessous dans votre styles.xml utiliser la police 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>
Et n'oubliez pas d'utiliser 'AppTheme' dans votre 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>
Lorsque votre police est stockée dans res/asset/fonts/Helvetica.ttf, utilisez les éléments suivants:
Typeface tf = Typeface.createFromAsset(getAssets(),"fonts/Helvetica.ttf");
txt.setTypeface(tf);
Ou, si votre fichier de police est stocké dans res/font/helvetica.ttf, utilisez les éléments suivants:
Typeface tf = ResourcesCompat.getFont(this,R.font.helvetica);
txt.setTypeface(tf);