Comment définir la famille de polices par défaut pour toute l'application Android

J'utilise la police légère Roboto dans mon application. Pour définir la police, je dois l'ajouter android:fontFamily="sans-serif-light"à chaque vue. Existe-t-il un moyen de déclarer la police Roboto comme famille de polices par défaut pour toute l'application? J'ai essayé comme ça mais ça ne semblait pas marcher.

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

<style name="AppTheme" parent="AppBaseTheme">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

La réponse est oui.

Global Roboto light pour TextViewet Buttonclasses:

<style name="AppTheme" parent="AppBaseTheme">
    <item name="android:textViewStyle">@style/RobotoTextViewStyle</item>
    <item name="android:buttonStyle">@style/RobotoButtonStyle</item>
</style>

<style name="RobotoTextViewStyle" parent="android:Widget.TextView">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

<style name="RobotoButtonStyle" parent="android:Widget.Holo.Button">
    <item name="android:fontFamily">sans-serif-light</item>
</style>

Sélectionnez simplement le style souhaité dans la liste themes.xml , puis créez votre style personnalisé en fonction de celui d'origine. À la fin, appliquez le style comme thème de l'application.

<application
    android:theme="@style/AppTheme" >
</application>

Cela ne fonctionnera qu'avec des polices intégrées comme Roboto, mais c'était la question. Pour les polices personnalisées (chargées à partir d'actifs par exemple), cette méthode ne fonctionnera pas.

EDIT 13/08/15

Si vous utilisez des thèmes AppCompat, n'oubliez pas de supprimer le android:préfixe. Par exemple:

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="android:textViewStyle">@style/RobotoTextViewStyle</item>
    <item name="buttonStyle">@style/RobotoButtonStyle</item>
</style>

Notez que le buttonStylene contient pas de android:préfixe, mais textViewStyledoit le contenir.

Avec la sortie d'Android Oreo, vous pouvez utiliser la bibliothèque de support pour atteindre cet objectif.

1. Vérifiez dans votre application build.gradle si vous avez la bibliothèque de support > = 26.0.0
2. Ajoutez le dossier " font " à votre dossier de ressources et ajoutez-y vos polices

3. Référencez votre famille de polices par défaut dans le style principal de votre application:

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

Consultez https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html pour des informations plus détaillées.

Pour modifier la police de votre application, procédez comme suit:

1. Dans le resrépertoire intérieur , créez un nouveau répertoire et appelez-le font.
2. Insérez votre police .ttf / .otf dans le dossier de polices, assurez-vous que le nom de la police est en lettres minuscules et souligné uniquement.
3. À l'intérieur res-> values-> à l' styles.xmlintérieur <resources>-> <style>ajoutez votre police <item name="android:fontFamily">@font/font_name</item>.

Maintenant, tout le texte de votre application doit être dans la source que vous ajoutez.

LISEZ LES MISES À JOUR CI-DESSOUS

J'ai eu le même problème avec l'incorporation d'une nouvelle police et j'ai finalement réussi à travailler avec l'extension de TextView et à définir la police de caractères à l'intérieur.

public class YourTextView extends TextView {

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

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

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

    private void init() {
        Typeface tf = Typeface.createFromAsset(context.getAssets(),
            "fonts/helveticaneue.ttf");
        setTypeface(tf);
    }
}

Vous devez modifier les éléments TextView ultérieurement de à en dans chaque élément. Et si vous utilisez UI-Creator dans Eclipse, il n'a parfois pas le droit de TextViews. C'était la seule chose qui fonctionnait pour moi ...

METTRE À JOUR

Aujourd'hui, j'utilise la réflexion pour changer les polices de caractères dans toute l'application sans étendre TextViews. Découvrez ce post SO

MISE À JOUR 2

À partir de l'API niveau 26 et disponible dans la «bibliothèque de support», vous pouvez utiliser

android:fontFamily="@font/embeddedfont"

Pour plus d'informations: Polices en XML

Ajoutez cette ligne de code dans votre res / value / styles.xml

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

le style entier ressemblera à ça

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- Customize your theme here. -->
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
    <item name="colorAccent">@color/colorAccent</item>
    <item name="android:fontFamily">@font/circular_medium</item>
</style>

changez "circular_medium" en votre propre nom de police.

Ne parlez pas de performances, pour la police personnalisée, vous pouvez avoir une boucle de méthode récursive à travers toutes les vues et définir la police de caractères s'il s'agit d'un TextView:

public class Font {
    public static void setAllTextView(ViewGroup parent) {
        for (int i = parent.getChildCount() - 1; i >= 0; i--) {
            final View child = parent.getChildAt(i);
            if (child instanceof ViewGroup) {
                setAllTextView((ViewGroup) child);
            } else if (child instanceof TextView) {
                ((TextView) child).setTypeface(getFont());
            }
        }
    }

    public static Typeface getFont() {
        return Typeface.createFromAsset(YourApplicationContext.getInstance().getAssets(), "fonts/whateverfont.ttf");
    }
}

Dans toute votre activité, passez-lui le ViewGroup actuel après setContentView et c'est fait:

ViewGroup group = (ViewGroup) getWindow().getDecorView().findViewById(android.R.id.content);
Font.setAllTextView(group);

Pour fragment, vous pouvez faire quelque chose de similaire.

Une autre façon de le faire pour l'ensemble de l'application utilise la réflexion basée sur cette réponse

public class TypefaceUtil {
    /**
     * Using reflection to override default typefaces
     * NOTICE: DO NOT FORGET TO SET TYPEFACE FOR APP THEME AS DEFAULT TYPEFACE WHICH WILL BE
     * OVERRIDDEN
     *
     * @param typefaces map of fonts to replace
     */
    public static void overrideFonts(Map<String, Typeface> typefaces) {
        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", "Can not set custom fonts");
        }
    }

    public static Typeface getTypeface(int fontType, Context context) {
        // here you can load the Typeface from asset or use default ones
        switch (fontType) {
            case BOLD:
                return Typeface.create(SANS_SERIF, Typeface.BOLD);
            case ITALIC:
                return Typeface.create(SANS_SERIF, Typeface.ITALIC);
            case BOLD_ITALIC:
                return Typeface.create(SANS_SERIF, Typeface.BOLD_ITALIC);
            case LIGHT:
                return Typeface.create(SANS_SERIF_LIGHT, Typeface.NORMAL);
            case CONDENSED:
                return Typeface.create(SANS_SERIF_CONDENSED, Typeface.NORMAL);
            case THIN:
                return Typeface.create(SANS_SERIF_MEDIUM, Typeface.NORMAL);
            case MEDIUM:
                return Typeface.create(SANS_SERIF_THIN, Typeface.NORMAL);
            case REGULAR:
            default:
                return Typeface.create(SANS_SERIF, Typeface.NORMAL);
        }
    }
}

puis chaque fois que vous souhaitez remplacer les polices, vous pouvez simplement appeler la méthode et lui donner une carte des polices de caractères comme suit:

Typeface regular = TypefaceUtil.getTypeface(REGULAR, context);
Typeface light = TypefaceUtil.getTypeface(REGULAR, context);
Typeface condensed = TypefaceUtil.getTypeface(CONDENSED, context);
Typeface thin = TypefaceUtil.getTypeface(THIN, context);
Typeface medium = TypefaceUtil.getTypeface(MEDIUM, context);
Map<String, Typeface> fonts = new HashMap<>();
fonts.put("sans-serif", regular);
fonts.put("sans-serif-light", light);
fonts.put("sans-serif-condensed", condensed);
fonts.put("sans-serif-thin", thin);
fonts.put("sans-serif-medium", medium);
TypefaceUtil.overrideFonts(fonts);

pour un exemple complet, vérifiez

Cela ne fonctionne que pour Android SDK 21 et supérieur pour les versions antérieures, consultez l'exemple complet

Utilisez simplement cette bibliothèque, compilez-la dans votre fichier de notes

complie'me.anwarshahriar:calligrapher:1.0'

et l'utiliser dans la méthode onCreate dans l'activité principale

Calligrapher calligrapher = new Calligrapher(this);
calligrapher.setFont(this, "yourCustomFontHere.ttf", true);

C'est la façon la plus rapide et la plus élégante de le faire.

C'est du travail pour mon projet, source https://gist.github.com/artem-zinnatullin/7749076

Créez le répertoire des polices dans le dossier Asset, puis copiez votre police personnalisée dans le répertoire des polices, par exemple, j'utilise trebuchet.ttf;

Créez une classe TypefaceUtil.java;

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

import java.lang.reflect.Field;
public class TypefaceUtil {

    public static void overrideFont(Context context, String defaultFontNameToOverride, String customFontFileNameInAssets) {
        try {
            final Typeface customFontTypeface = Typeface.createFromAsset(context.getAssets(), customFontFileNameInAssets);

            final Field defaultFontTypefaceField = Typeface.class.getDeclaredField(defaultFontNameToOverride);
            defaultFontTypefaceField.setAccessible(true);
            defaultFontTypefaceField.set(null, customFontTypeface);
        } catch (Exception e) {

        }
    }
}

Modifier le thème dans styles.xml ajouter ci-dessous

<item name="android:typeface">serif</item>

Exemple dans My styles.xml

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <item name="android:typeface">serif</item><!-- Add here -->
    </style>


    <style name="AppTheme.NoActionBar">
        <item name="windowActionBar">false</item>
        <item name="windowNoTitle">true</item>
        <item name="android:windowActionBarOverlay">true</item>
        <item name="android:windowFullscreen">true</item>
    </style>
</resources>

Enfin, dans Activity or Fragment onCreate, appelez TypefaceUtil.java

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TypefaceUtil.overrideFont(getContext(), "SERIF", "fonts/trebuchet.ttf");
    }

Android ne fournit pas beaucoup de support pour l'application de polices sur l'ensemble de l'application (voir ce problème ). Vous avez 4 options pour définir la police de l'application entière:

• Option 1: appliquer la réflexion pour modifier la police système
• Option 2: créer et sous-classer des classes de vue personnalisées pour chaque vue nécessitant une police personnalisée
• Option3: implémenter un robot d'exploration qui traverse la hiérarchie des vues pour l'écran actuel
• Option4: utilisez une bibliothèque tierce.

Les détails de ces options sont disponibles ici .

Je sais que cette question est assez ancienne, mais j'ai trouvé une bonne solution. Fondamentalement, vous passez une disposition de conteneur à cette fonction, et elle appliquera la police à toutes les vues prises en charge, et récursivement dans les dispositions enfant:

public static void setFont(ViewGroup layout)
{
    final int childcount = layout.getChildCount();
    for (int i = 0; i < childcount; i++)
    {
        // Get the view
        View v = layout.getChildAt(i);

        // Apply the font to a possible TextView
        try {
            ((TextView) v).setTypeface(MY_CUSTOM_FONT);
            continue;
        }
        catch (Exception e) { }

        // Apply the font to a possible EditText
        try {
            ((TextView) v).setTypeface(MY_CUSTOM_FONT);
            continue;
        }
        catch (Exception e) { }

        // Recursively cicle into a possible child layout
        try {
            ViewGroup vg = (ViewGroup) v;
            Utility.setFont(vg);
            continue;
        }
        catch (Exception e) { }
    }
}

à caractère simplement ensemble de l' application à normal, sans, serifou monospace(pas une police personnalisée!), vous pouvez le faire.

définissez un thème et définissez l' android:typefaceattribut sur la police que vous souhaitez utiliser dans styles.xml:

<resources>

    <!-- custom normal activity theme -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <!-- other elements -->
        <item name="android:typeface">monospace</item>
    </style>

</resources>

appliquer le thème à l'ensemble de l'application dans le AndroidManifest.xmlfichier:

<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:theme="@style/AppTheme" >
    </application>
</manifest>

référence android

Essayez cette bibliothèque, légère et facile à implémenter

https://github.com/sunnag7/FontStyler

<com.sunnag.fontstyler.FontStylerView
              android:textStyle="bold"
              android:text="@string/about_us"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:paddingTop="8dp"
              app:fontName="Lato-Bold"
              android:textSize="18sp"
              android:id="@+id/textView64" />

La réponse est non, vous ne pouvez pas. Voir Est-il possible de définir une police personnalisée pour l'ensemble de l'application? pour plus d'informations.

Il existe des solutions de contournement, mais rien dans les lignes de "une seule ligne de code ici et toutes mes polices seront ceci au lieu de cela ".

(Je remercie Google - et Apple - pour cela). Les polices personnalisées ont une place, mais les rendre faciles à remplacer à l'échelle de l'application aurait créé un monde entier d' applications Comic Sans )