Android: vous souhaitez définir des polices personnalisées pour l'ensemble de l'application et non pour l'exécution
Est-il possible de définir une police personnalisée dans chaque contrôle de l'application? Et pas nécessairement runtime? (c'est-à-dire depuis xml si possible ou une seule fois pour une application complète dans un fichier Java)
Je peux définir la police pour un contrôle à partir de ce code.
public static void setFont(TextView textView) {
Typeface tf = Typeface.createFromAsset(textView.getContext()
.getAssets(), "fonts/BPreplay.otf");
textView.setTypeface(tf);
}
Et le problème avec ce code est qu'il devrait être appelé pour chaque contrôle. Et je veux appeler cette méthode ou une méthode similaire une fois, ou si possible définir la propriété en XML. C'est possible?
EDIT: Cela fait donc longtemps et j'aimerais ajouter ce que je pense être le meilleur moyen de le faire, et rien de moins avec XML!
Donc, tout d’abord, vous allez créer une nouvelle classe qui remplace la vue que vous souhaitez personnaliser. (par exemple, voulez-vous un bouton avec une police de caractères personnalisée? Étendre Button). Faisons un exemple:
public class CustomButton extends Button {
private final static int ROBOTO = 0;
private final static int ROBOTO_CONDENSED = 1;
public CustomButton(Context context) {
super(context);
}
public CustomButton(Context context, AttributeSet attrs) {
super(context, attrs);
parseAttributes(context, attrs); //I'll explain this method later
}
public CustomButton(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
parseAttributes(context, attrs);
}
}
Maintenant, si vous n'en avez pas, ajoutez un document XML sous res/values/attrs.xml et ajoutez:
<resources>
<!-- Define the values for the attribute -->
<attr name="typeface" format="enum">
<enum name="roboto" value="0"/>
<enum name="robotoCondensed" value="1"/>
</attr>
<!-- Tell Android that the class "CustomButton" can be styled,
and which attributes it supports -->
<declare-styleable name="CustomButton">
<attr name="typeface"/>
</declare-styleable>
</resources>
D'accord, alors avec cela mis de côté, revenons à la méthode parseAttributes() de précédemment:
private void parseAttributes(Context context, AttributeSet attrs) {
TypedArray values = context.obtainStyledAttributes(attrs, R.styleable.CustomButton);
//The value 0 is a default, but shouldn't ever be used since the attr is an enum
int typeface = values.getInt(R.styleable.CustomButton_typeface, 0);
switch(typeface) {
case ROBOTO: default:
//You can instantiate your typeface anywhere, I would suggest as a
//singleton somewhere to avoid unnecessary copies
setTypeface(roboto);
break;
case ROBOTO_CONDENSED:
setTypeface(robotoCondensed);
break;
}
values.recycle();
}
Maintenant, vous êtes tous ensemble. Vous pouvez ajouter plus d'attributs pour à peu près n'importe quoi (vous pouvez en ajouter un autre pour typefaceStyle - gras, italique, etc.), mais voyons maintenant comment l'utiliser:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:custom="http://schemas.Android.com/apk/res/com.yourpackage.name"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:orientation="vertical" >
<com.yourpackage.name.CustomButton
Android:id="@+id/button"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="Click Me!"
custom:typeface="roboto" />
</LinearLayout>
La ligne xmlns:custom peut vraiment être n'importe quoi, mais la convention est celle montrée ci-dessus. Ce qui compte, c’est qu’il est unique et c’est pourquoi le nom du paquet est utilisé. Maintenant, vous utilisez simplement le préfixe custom: pour vos attributs et le préfixe Android: pour les attributs Android.
Une dernière chose: si vous voulez utiliser ceci dans un style (res/values/styles.xml), vous devez pas ajouter la ligne xmlns:custom. Référencez simplement le nom de l'attribut sans préfixe:
<style name="MyStyle>
<item name="typeface">roboto</item>
</style>
(PREVIOUS ANSWER)
Utilisation d'un caractère personnalisé sous Android
Cela devrait aider. Fondamentalement, il n’ya aucun moyen de faire cela en XML et, autant que je sache, aucun moyen plus facile de le faire en code. Vous pouvez toujours avoir une méthode setLayoutFont () qui crée le caractère une fois, puis exécute setTypeface () pour chacun. Vous devez simplement le mettre à jour chaque fois que vous ajoutez un nouvel élément à une mise en page. Quelque chose comme ci-dessous:
public void setLayoutFont() {
Typeface tf = Typeface.createFromAsset(
getBaseContext().getAssets(), "fonts/BPreplay.otf");
TextView tv1 = (TextView)findViewById(R.id.tv1);
tv1.setTypeface(tf);
TextView tv2 = (TextView)findViewById(R.id.tv2);
tv2.setTypeface(tf);
TextView tv3 = (TextView)findViewById(R.id.tv3);
tv3.setTypeface(tf);
}
EDIT: Je venais donc d'implémenter quelque chose comme ceci moi-même, et le résultat était de créer une fonction comme celle-ci:
public static void setLayoutFont(Typeface tf, TextView...params) {
for (TextView tv : params) {
tv.setTypeface(tf);
}
}
Ensuite, utilisez simplement cette méthode de onCreate () et transmettez tous les TextViews que vous souhaitez mettre à jour:
Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/BPreplay.otf");
//find views by id...
setLayoutFont(tf, tv1, tv2, tv3, tv4, tv5);
EDIT du 9/5/12:
Donc, puisque cela suscite toujours des avis et des votes, j'aimerais ajouter une méthode bien meilleure et plus complète:
Typeface mFont = Typeface.createFromAsset(getAssets(), "fonts/BPreplay.otf");
ViewGroup root = (ViewGroup)findViewById(R.id.myrootlayout);
setFont(root, mFont);
/*
* Sets the font on all TextViews in the ViewGroup. Searches
* recursively for all inner ViewGroups as well. Just add a
* check for any other views you want to set as well (EditText,
* etc.)
*/
public void setFont(ViewGroup group, Typeface font) {
int count = group.getChildCount();
View v;
for(int i = 0; i < count; i++) {
v = group.getChildAt(i);
if(v instanceof TextView || v instanceof Button /*etc.*/)
((TextView)v).setTypeface(font);
else if(v instanceof ViewGroup)
setFont((ViewGroup)v, font);
}
}
Si vous lui transmettez la racine de votre mise en page, il recherchera de manière récursive les vues TextView ou Button (ou toute autre vue que vous ajouterez à cette instruction if) dans cette mise en page et définira la police sans que vous ayez à les spécifier par ID. Ceci suppose bien sûr que vous souhaitiez définir la police sur la vue tous.
Il existe un moyen assez simple de le faire via XML. Il vous suffit de créer votre propre widget qui étend TextView.
Commencez par créer un fichier dans res/values / attrs.xml avec le contenu suivant:
<resources>
<declare-styleable name="TypefacedTextView">
<attr name="typeface" format="string" />
</declare-styleable>
</resources>
Après cela, créez votre widget personnalisé:
package your.package.widget;
public class TypefacedTextView extends TextView {
public TypefacedTextView(Context context, AttributeSet attrs) {
super(context, attrs);
//Typeface.createFromAsset doesn't work in the layout editor. Skipping...
if (isInEditMode()) {
return;
}
TypedArray styledAttrs = context.obtainStyledAttributes(attrs, R.styleable.TypefacedTextView);
String fontName = styledAttrs.getString(R.styleable.TypefacedTextView_typeface);
styledAttrs.recycle();
if (fontName != null) {
Typeface typeface = Typeface.createFromAsset(context.getAssets(), fontName);
setTypeface(typeface);
}
}
}
Comme vous pouvez le constater, le code ci-dessus lit une police dans le dossier assets /. Pour cet exemple, je suppose qu’il existe un fichier appelé "custom.ttf" dans le dossier assets. Enfin, utilisez le widget dans les XML:
<your.package.widget.TypefacedTextView
xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:your_namespace="http://schemas.Android.com/apk/res/your.package"
Android:layout_width="fill_parent"
Android:layout_height="wrap_content"
Android:text="Custom fonts in XML are easy"
Android:textColor="#FFF"
Android:textSize="14dip"
your_namespace:typeface="custom.ttf" />
Remarque: vous ne pourrez pas voir votre police personnalisée dans l'éditeur de disposition d'Eclipse. C'est pourquoi je mets le chèque isInEditMode(). Mais si vous exécutez votre application, la police personnalisée fonctionnera comme un charme.
J'espère que ça aide!
Exemple de TextView avec la police roboto:
attr.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="RobotoTextView">
<attr name="typeface"/>
</declare-styleable>
<attr name="typeface" format="enum">
<enum name="roboto_thin" value="0"/>
<enum name="roboto_thin_italic" value="1"/>
<enum name="roboto_light" value="2"/>
<enum name="roboto_light_italic" value="3"/>
<enum name="roboto_regular" value="4"/>
<enum name="roboto_italic" value="5"/>
<enum name="roboto_medium" value="6"/>
<enum name="roboto_medium_italic" value="7"/>
<enum name="roboto_bold" value="8"/>
<enum name="roboto_bold_italic" value="9"/>
<enum name="roboto_black" value="10"/>
<enum name="roboto_black_italic" value="11"/>
<enum name="roboto_condensed" value="12"/>
<enum name="roboto_condensed_italic" value="13"/>
<enum name="roboto_condensed_bold" value="14"/>
<enum name="roboto_condensed_bold_italic" value="15"/>
</attr>
</resources>
RobotoTextView.Java:
public class RobotoTextView extends TextView {
/*
* Permissible values for the "typeface" attribute.
*/
private final static int ROBOTO_THIN = 0;
private final static int ROBOTO_THIN_ITALIC = 1;
private final static int ROBOTO_LIGHT = 2;
private final static int ROBOTO_LIGHT_ITALIC = 3;
private final static int ROBOTO_REGULAR = 4;
private final static int ROBOTO_ITALIC = 5;
private final static int ROBOTO_MEDIUM = 6;
private final static int ROBOTO_MEDIUM_ITALIC = 7;
private final static int ROBOTO_BOLD = 8;
private final static int ROBOTO_BOLD_ITALIC = 9;
private final static int ROBOTO_BLACK = 10;
private final static int ROBOTO_BLACK_ITALIC = 11;
private final static int ROBOTO_CONDENSED = 12;
private final static int ROBOTO_CONDENSED_ITALIC = 13;
private final static int ROBOTO_CONDENSED_BOLD = 14;
private final static int ROBOTO_CONDENSED_BOLD_ITALIC = 15;
/**
* List of created typefaces for later reused.
*/
private final static SparseArray<Typeface> mTypefaces = new SparseArray<Typeface>(16);
/**
* Simple constructor to use when creating a view from code.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
*/
public RobotoTextView(Context context) {
super(context);
}
/**
* Constructor that is called when inflating a view from XML. This is called
* when a view is being constructed from an XML file, supplying attributes
* that were specified in the XML file. This version uses a default style of
* 0, so the only attribute values applied are those in the Context's Theme
* and the given AttributeSet.
* <p/>
* <p/>
* The method onFinishInflate() will be called after all children have been
* added.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
* @see #RobotoTextView(Context, AttributeSet, int)
*/
public RobotoTextView(Context context, AttributeSet attrs) {
super(context, attrs);
parseAttributes(context, attrs);
}
/**
* Perform inflation from XML and apply a class-specific base style. This
* constructor of View allows subclasses to use their own base style when
* they are inflating.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
* @param defStyle The default style to apply to this view. If 0, no style
* will be applied (beyond what is included in the theme). This may
* either be an attribute resource, whose value will be retrieved
* from the current theme, or an explicit style resource.
* @see #RobotoTextView(Context, AttributeSet)
*/
public RobotoTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
parseAttributes(context, attrs);
}
/**
* Parse the attributes.
*
* @param context The Context the view is running in, through which it can access the current theme, resources, etc.
* @param attrs The attributes of the XML tag that is inflating the view.
*/
private void parseAttributes(Context context, AttributeSet attrs) {
TypedArray values = context.obtainStyledAttributes(attrs, R.styleable.RobotoTextView);
int typefaceValue = values.getInt(R.styleable.RobotoTextView_typeface, 0);
values.recycle();
setTypeface(obtaintTypeface(context, typefaceValue));
}
/**
* Obtain typeface.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param typefaceValue values for the "typeface" attribute
* @return Roboto {@link Typeface}
* @throws IllegalArgumentException if unknown `typeface` attribute value.
*/
private Typeface obtaintTypeface(Context context, int typefaceValue) throws IllegalArgumentException {
Typeface typeface = mTypefaces.get(typefaceValue);
if (typeface == null) {
typeface = createTypeface(context, typefaceValue);
mTypefaces.put(typefaceValue, typeface);
}
return typeface;
}
/**
* Create typeface from assets.
*
* @param context The Context the view is running in, through which it can
* access the current theme, resources, etc.
* @param typefaceValue values for the "typeface" attribute
* @return Roboto {@link Typeface}
* @throws IllegalArgumentException if unknown `typeface` attribute value.
*/
private Typeface createTypeface(Context context, int typefaceValue) throws IllegalArgumentException {
Typeface typeface;
switch (typefaceValue) {
case ROBOTO_THIN:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Thin.ttf");
break;
case ROBOTO_THIN_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-ThinItalic.ttf");
break;
case ROBOTO_LIGHT:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Light.ttf");
break;
case ROBOTO_LIGHT_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-LightItalic.ttf");
break;
case ROBOTO_REGULAR:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Regular.ttf");
break;
case ROBOTO_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Italic.ttf");
break;
case ROBOTO_MEDIUM:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Medium.ttf");
break;
case ROBOTO_MEDIUM_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-MediumItalic.ttf");
break;
case ROBOTO_BOLD:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Bold.ttf");
break;
case ROBOTO_BOLD_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BoldItalic.ttf");
break;
case ROBOTO_BLACK:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Black.ttf");
break;
case ROBOTO_BLACK_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BlackItalic.ttf");
break;
case ROBOTO_CONDENSED:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Condensed.ttf");
break;
case ROBOTO_CONDENSED_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-CondensedItalic.ttf");
break;
case ROBOTO_CONDENSED_BOLD:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BoldCondensed.ttf");
break;
case ROBOTO_CONDENSED_BOLD_ITALIC:
typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BoldCondensedItalic.ttf");
break;
default:
throw new IllegalArgumentException("Unknown `typeface` attribute value " + typefaceValue);
}
return typeface;
}
}
Exemple d'utilisation:
<your.package.widget.RobotoTextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
app:typeface="roboto_thin"
Android:textSize="22sp"
Android:text="Roboto Thin"/>
Ressources: Polices Roboto & Noto
C'est trop tard mais ça aide l'autre
J'ai créé CustomTextView qui a un attribut appelé typeFace et s'occupe du problème des fuites de mémoire lors du chargement de polices sans la mise en cache
Première classe Fonts qui charge les polices à partir d'actifs une seule fois
import Android.content.Context;
import Android.graphics.Typeface;
import Java.util.Hashtable;
/**
* Created by tonyhaddad on 7/19/15.
*/
public class Fonts {
private Context context;
public Fonts(Context context) {
this.context = context;
}
private static Hashtable<String, Typeface> sTypeFaces = new Hashtable<String, Typeface>(
4);
public static Typeface getTypeFace(Context context, String fileName) {
Typeface tempTypeface = sTypeFaces.get(fileName);
if (tempTypeface == null) {
String fontPath=null;
if(fileName=="metabold")
fontPath ="fonts/Meta-Bold.ttf";
else if(fileName=="metanormal")
fontPath="fonts/Meta-Normal.ttf";
else if(fileName=="gsligh")
fontPath="fonts/gesslight.ttf";
else if(fileName=="bold")
fontPath="fonts/Lato-Bold.ttf";
else if(fileName=="rcr")
fontPath="fonts/RobotoCondensed-Regular.ttf";
else if(fileName=="mpr")
fontPath="fonts/MyriadPro-Regular.otf";
else if(fileName=="rr")
fontPath="fonts/Roboto-Regular.ttf";
tempTypeface = Typeface.createFromAsset(context.getAssets(), fontPath);
sTypeFaces.put(fileName, tempTypeface);
}
return tempTypeface;
}
}
alors vous devez ajouter un attribut personnalisé dans le attrs.xml ajouter ceci
<declare-styleable name="CustomFontTextView">
<attr name="typeFace" format="string" />
</declare-styleable>
puis classe personnalisée
package package_name;
/**
* Created by tonyhaddad on 8/26/15.
*/
import Android.content.Context;
import Android.content.res.TypedArray;
import Android.graphics.Typeface;
import Android.util.AttributeSet;
import Android.widget.TextView;
import package_name.R;
public class CustomFontTextView extends TextView {
String typeFace;
public CustomFontTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
if (isInEditMode()) {
return;
}
TypedArray a = context.getTheme().obtainStyledAttributes(
attrs,
R.styleable.CustomFontTextView,
0, 0);
try {
typeFace = a.getString(0);
} finally {
a.recycle();
}
if(typeFace!=null && !typeFace.equalsIgnoreCase(""))
{
Typeface tf = Fonts.getTypeFace(context, typeFace);
setTypeface(tf);
}
init();
}
public CustomFontTextView(Context context, AttributeSet attrs) {
super(context, attrs);
if (isInEditMode()) {
return;
}
TypedArray a = context.getTheme().obtainStyledAttributes(
attrs,
R.styleable.CustomFontTextView,
0, 0);
try {
typeFace = a.getString(0);
} finally {
a.recycle();
}
if(typeFace!=null && !typeFace.equalsIgnoreCase(""))
{
Typeface tf = Fonts.getTypeFace(context, typeFace);
setTypeface(tf);
}
init();
}
public CustomFontTextView(Context context) {
super(context);
if(typeFace!=null && !typeFace.equalsIgnoreCase(""))
{
Typeface tf = Fonts.getTypeFace(context, typeFace);
setTypeface(tf);
}
init();
}
private void init() {
}
public String getTypeFace() {
return typeFace;
}
public void setTypeFace(String typeFace) {
this.typeFace = typeFace;
invalidate();
requestLayout();
}
}
et enfin ajouter la vue texte
<package_name.CustomFontTextView
xmlns:custom="http://schemas.Android.com/apk/res-auto/package_name"
Android:id="@+id/txt"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:layout_centerVertical="true"
Android:layout_marginLeft="41dp"
Android:gravity="center_vertical"
Android:text="text"
Android:textColor="#000"
Android:textSize="23sp"
custom:typeFace="metanormal"/>
et vous pouvez changer la police de police progressivement avec la méthode setTypeFace
Vous pouvez également déplacer l’espace de noms personnalisé vers votre modèle parent si vous souhaitez en utiliser plusieurs à partir de cette vue.
Bonne codage :)
Si vous recherchez une solution de programmation plus générale, j'ai créé une classe statique qui peut être utilisée pour définir la police de caractères d'une vue complète (interface utilisateur d'activité). Notez que je travaille avec Mono (C #) mais que vous pouvez l’implémenter facilement avec Java.
Vous pouvez transmettre à cette classe une mise en page ou une vue spécifique que vous souhaitez personnaliser. Si vous voulez être super efficace, vous pouvez l'implémenter en utilisant le modèle Singleton.
public static class AndroidTypefaceUtility
{
static AndroidTypefaceUtility()
{
}
//Refer to the code block beneath this one, to see how to create a typeface.
public static void SetTypefaceOfView(View view, Typeface customTypeface)
{
if (customTypeface != null && view != null)
{
try
{
if (view is TextView)
(view as TextView).Typeface = customTypeface;
else if (view is Button)
(view as Button).Typeface = customTypeface;
else if (view is EditText)
(view as EditText).Typeface = customTypeface;
else if (view is ViewGroup)
SetTypefaceOfViewGroup((view as ViewGroup), customTypeface);
else
Console.Error.WriteLine("AndroidTypefaceUtility: {0} is type of {1} and does not have a typeface property", view.Id, typeof(View));
}
catch (Exception ex)
{
Console.Error.WriteLine("AndroidTypefaceUtility threw:\n{0}\n{1}", ex.GetType(), ex.StackTrace);
throw ex;
}
}
else
{
Console.Error.WriteLine("AndroidTypefaceUtility: customTypeface / view parameter should not be null");
}
}
public static void SetTypefaceOfViewGroup(ViewGroup layout, Typeface customTypeface)
{
if (customTypeface != null && layout != null)
{
for (int i = 0; i < layout.ChildCount; i++)
{
SetTypefaceOfView(layout.GetChildAt(i), customTypeface);
}
}
else
{
Console.Error.WriteLine("AndroidTypefaceUtility: customTypeface / layout parameter should not be null");
}
}
}
Dans votre activité, vous devrez créer un objet Typeface. Je crée le mien dans OnCreate () en utilisant un fichier .ttf placé dans mon répertoire Resources/Assets /. Assurez-vous que le fichier est marqué en tant qu'actif Android dans ses propriétés.
protected override void OnCreate(Bundle bundle)
{
...
LinearLayout rootLayout = (LinearLayout)FindViewById<LinearLayout>(Resource.Id.signInView_LinearLayout);
Typeface allerTypeface = Typeface.CreateFromAsset(base.Assets,"Aller_Rg.ttf");
AndroidTypefaceUtility.SetTypefaceOfViewGroup(rootLayout, allerTypeface);
}
La méthode ci-dessous, appelée onCreate () et transmise votre ViewGroup le plus externe, fonctionne pour tout sauf le texte créé dynamiquement (c'est-à-dire les listes dynamiques, les alertes, etc.). Un moyen facile d'obtenir le ViewGroup le plus externe consiste à utiliser getRootView sur l'un de vos points de vue.
public void onCreate(Bundle savedInstanceState){
//onCreate code...
EditText text = (EditText) findViewById(R.id.editText1);
setTypeFaceForViewGroup((ViewGroup) text.getRootView());
}
private void setTypeFaceForViewGroup(ViewGroup vg){
for (int i = 0; i < vg.getChildCount(); i++) {
if (vg.getChildAt(i) instanceof ViewGroup)
setTypeFaceForViewGroup((ViewGroup) vg.getChildAt(i));
else if (vg.getChildAt(i) instanceof TextView)
((TextView) vg.getChildAt(i)).setTypeface(Typeface.createFromAsset(getAssets(), "fonts/Your_Font.ttf"));
}
}
Cela devrait également fonctionner pour le contenu dynamique, il vous suffirait de l'appeler, en transmettant tout ce que vous avez créé, juste après l'avoir créé (je ne l'ai pas encore testé).
Pour économiser de la mémoire, vous souhaiterez probablement faire de la police de caractère une variable statique, plutôt que d'en créer une nouvelle à chaque fois que la boucle s'exécutera comme je l'ai fait ici.
J'aimerais ajouter une note à l'excellente solution de leocadiotine. C’est parfait, mais lors de l’utilisation de cet objet TextView personnalisé, l’application ralentit souvent, car elle doit accéder aux ressources chaque fois qu’une vue texte est créée. Je suggère d'utiliser quelque chose comme le View Holder pattern dans la Adapters, j'ai écrit un exemple:
public class Fonts {
private static final Map<String, Typeface> typefaces = new HashMap<String, Typeface>();
public static Typeface getTypeface(Context ctx, String fontName) {
Typeface typeface = typefaces.get(fontName);
if (typeface == null) {
typeface = Typeface.createFromAsset(ctx.getAssets(), fontName);
typefaces.put(fontName, typeface);
}
return typeface;
}
}
Ainsi, l’application n’accède aux actifs qu’une fois par actif et les garde en mémoire pour les besoins ultérieurs.
Malheureusement, Android ne fournit pas le moyen rapide, facile et propre que vous recherchez pour changer la police de votre application entière. Mais récemment, j'ai étudié cette question et créé des outils qui vous permettent de modifier la police sans codage (vous pouvez le faire entièrement via xml, styles et même l'apparence du texte). Elles sont basées sur des solutions similaires à celles que vous voyez dans les autres réponses ici, mais permettent beaucoup plus de flexibilité. Vous pouvez lire tout cela à ce sujet sur ce blog , et voir le projet github ici .
Voici un exemple d'application de ces outils. Mettez tous vos fichiers de polices dans assets/fonts/. Ensuite, déclarez ces polices dans un fichier xml (par exemple, res/xml/fonts.xml) et chargez ce fichier au début de votre application avec TypefaceManager.initialize(this, R.xml.fonts); (par exemple, dans le onCreate de votre classe Application). Le fichier XML ressemble à ceci:
<?xml version="1.0" encoding="utf-8"?>
<familyset>
<!-- Some Font. Can be referenced with 'someFont' or 'aspergit' -->
<family>
<nameset>
<name>aspergit</name>
<name>someFont</name>
</nameset>
<fileset>
<file>Aspergit.ttf</file>
<file>Aspergit Bold.ttf</file>
<file>Aspergit Italic.ttf</file>
<file>Aspergit Bold Italic.ttf</file>
</fileset>
</family>
<!-- Another Font. Can be referenced with 'anotherFont' or 'bodoni' -->
<family>
<nameset>
<name>bodoni</name>
<name>anotherFont</name>
</nameset>
<fileset>
<file>BodoniFLF-Roman.ttf</file>
<file>BodoniFLF-Bold.ttf</file>
</fileset>
</family>
</familyset>
Vous pouvez maintenant utiliser ces polices dans votre style ou XML (à condition d'utiliser les outils que j'ai mentionnés ci-dessus), en utilisant l'élément d'interface utilisateur personnalisé com.innovattic.font.FontTextView dans votre présentation XML. Ci-dessous, vous pouvez voir comment appliquer une police à tous les textes de votre application entière, en modifiant simplement res/values/styles.xml:
<?xml version="1.0" encoding="utf-8"?>
<resources xmlns:Android="http://schemas.Android.com/apk/res/Android" xmlns:tools="http://schemas.Android.com/tools">
<!-- Application theme -->
<!-- Use a different parent if you don't want Holo Light -->
<style name="AppTheme" parent="Android:Theme.Holo.Light.DarkActionBar">
<item name="Android:textViewStyle">@style/MyTextViewStyle</item>
</style>
<!-- Style to use for ALL text views (including FontTextView) -->
<!-- Use a different parent if you don't want Holo Light -->
<style name="MyTextViewStyle" parent="@Android:style/Widget.Holo.Light.TextView">
<item name="Android:textAppearance">@style/MyTextAppearance</item>
</style>
<!-- Text appearance to use for ALL text views (including FontTextView) -->
<!-- Use a different parent if you don't want Holo Light -->
<style name="MyTextAppearance" parent="@Android:style/TextAppearance.Holo">
<!-- Alternatively, reference this font with the name "aspergit" -->
<!-- Note that only our own TextView's will use the font attribute -->
<item name="flFont">someFont</item>
<item name="Android:textStyle">bold|italic</item>
</style>
<!-- Alternative style, maybe for some other widget -->
<style name="StylishFont">
<item name="flFont">anotherFont</item>
<item name="Android:textStyle">normal</item>
</style>
</resources>
Avec le res/layout/layout.xml joint:
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:tools="http://schemas.Android.com/tools"
xmlns:app="http://schemas.Android.com/apk/res-auto"
Android:orientation="vertical"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
tools:context=".MainActivity" >
<!-- This text view is styled with the app theme -->
<com.innovattic.font.FontTextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="This uses my font in bold italic style" />
<!-- This text view is styled here and overrides the app theme -->
<com.innovattic.font.FontTextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
app:flFont="anotherFont"
Android:textStyle="normal"
Android:text="This uses another font in normal style" />
<!-- This text view is styled with a style and overrides the app theme -->
<com.innovattic.font.FontTextView
style="@style/StylishFont"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="This also uses another font in normal style" />
</LinearLayout>
N'oubliez pas d'appliquer le thème dans votre manifeste Android.
Android 8.0 (API niveau 26) introduit une nouvelle fonctionnalité, les polices en XML.Vous pouvez créer un fichier de police et le définir dans styles.xml.
Pour ajouter des polices en tant que ressources, procédez comme suit dans Android Studio:
1.Cliquez avec le bouton droit sur le dossier res et accédez à Nouveau> Répertoire de ressources Android. La fenêtre New Resource Directory apparaît.
2.Dans la liste Type de ressource, sélectionnez la police, puis cliquez sur OK. Remarque: le nom du répertoire de ressources doit être police.
3. Ajoutez vos fichiers de polices dans le dossier des polices.
Pour créer une famille de polices, procédez comme suit:
1.Cliquez avec le bouton droit sur le dossier de polices et sélectionnez Nouveau> Fichier de ressources de polices. La fenêtre Nouveau fichier de ressources apparaît.
2. Entrez le nom du fichier, puis cliquez sur OK. Le nouveau XML de ressource de police s’ouvre dans l’éditeur.
3.Incluez chaque fichier de police, style et attribut de poids dans l'élément. Le code XML suivant illustre l’ajout d’attributs liés aux polices dans la ressource XML:
<?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>Ajout de polices au style
Ouvrez le fichier styles.xml et définissez l'attribut fontFamily sur le fichier de polices vous voulez accéder.
<style name="customfontstyle" parent="@Android:style/TextAppearance.Small"> <item name="Android:fontFamily">@font/lobster</item> </style>
Source: Polices en XML
J'ai trouvé des informations étape par étape sur ce lien, lien: https://github.com/jaydipumaretiya/CustomTypeface/
Il existe de nombreuses façons d'utiliser correctement les caractères dans Android. Vous devez placer votre fichier de caractères dans le dossier Assets directement sous votre dossier principal et l'utiliser au moment de l'exécution.
Une autre méthode plus simple consiste à utiliser la bibliothèque par défaut pour définir la police de caractères dans votre fichier xml . J'ai préféré cette bibliothèque de polices de caractères personnalisée pour définir la police de caractères TextView, EditText, Button, CheckBox, RadioButton et AutoCompleteTextView et autres wedget dans Android.
Je ne sais pas si cela modifie toute l'application, mais j'ai réussi à modifier certains composants qui ne pourraient pas autrement être modifiés en procédant ainsi:
Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/Lucida Sans Unicode.ttf");
Typeface.class.getField("DEFAULT").setAccessible(true);
Typeface.class.getField("DEFAULT_BOLD").setAccessible(true);
Typeface.class.getField("DEFAULT").set(null, tf);
Typeface.class.getField("DEFAULT_BOLD").set(null, tf);