Android - Utilisation d'une police personnalisée

J'ai appliqué une police personnalisée à un TextView, mais cela ne semble pas changer la police.

Voici mon code:

    Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
    TextView myTextView = (TextView)findViewById(R.id.myTextView);
    myTextView.setTypeface(myTypeface);

Quelqu'un peut-il me sortir de ce problème?

Sur Mobiletuts +, il y a un très bon tutoriel sur la mise en forme du texte pour Android. Petit conseil: personnalisez les polices Android

EDIT: Je l'ai testé moi-même maintenant. Voici la solution. Vous pouvez utiliser un sous-dossier appelé polices mais il doit aller dans le assetsdossier et non dans le resdossier. Alors

actifs / polices

Assurez-vous également que la fin de la police, je veux dire la fin du fichier de police lui-même, est en minuscules. En d'autres termes, cela ne devrait pas être le cas, myFont.TTFmais myfont.ttf cette manière doit être en minuscules

Après avoir essayé la plupart des solutions décrites dans ce fil, j'ai accidentellement trouvé Calligraphy ( https://github.com/chrisjenx/Calligraphy ) - une bibliothèque de Christopher Jenkins qui vous permet d'ajouter facilement des polices personnalisées à votre application. Les avantages de sa bibliothèque par rapport aux approches suggérées ici sont:

1. vous n'avez pas à introduire votre propre composant TextView remplacé, vous utilisez le TextView intégré
2. vous pouvez facilement inclure la bibliothèque en utilisant gradle
3. La bibliothèque ne limite pas votre choix de polices; vous ajoutez simplement vos préférés au répertoire d'actifs
4. vous obtenez non seulement des vues de texte personnalisées - tous les autres composants Android basés sur du texte seront également affichés en utilisant votre police personnalisée.

Je sais qu'il existe déjà de bonnes réponses, mais voici une mise en œuvre pleinement opérationnelle.

Voici la vue texte personnalisée:

package com.mycompany.myapp.widget;

/**
 * Text view with a custom font.
 * <p/>
 * In the XML, use something like {@code customAttrs:customFont="roboto-thin"}. The list of fonts
 * that are currently supported are defined in the enum {@link CustomFont}. Remember to also add
 * {@code xmlns:customAttrs="http://schemas.android.com/apk/res-auto"} in the header.
 */
public class CustomFontTextView extends TextView {

    private static final String sScheme =
            "http://schemas.android.com/apk/res-auto";
    private static final String sAttribute = "customFont";

    static enum CustomFont {
        ROBOTO_THIN("fonts/Roboto-Thin.ttf"),
        ROBOTO_LIGHT("fonts/Roboto-Light.ttf");

        private final String fileName;

        CustomFont(String fileName) {
            this.fileName = fileName;
        }

        static CustomFont fromString(String fontName) {
            return CustomFont.valueOf(fontName.toUpperCase(Locale.US));
        }

        public Typeface asTypeface(Context context) {
            return Typeface.createFromAsset(context.getAssets(), fileName);
        }
    }

    public CustomFontTextView(Context context, AttributeSet attrs) {
        super(context, attrs);

        if (isInEditMode()) {
            return;
        } else {
            final String fontName = attrs.getAttributeValue(sScheme, sAttribute);

            if (fontName == null) {
                throw new IllegalArgumentException("You must provide \"" + sAttribute + "\" for your text view");
            } else {
                final Typeface customTypeface = CustomFont.fromString(fontName).asTypeface(context);
                setTypeface(customTypeface);
            }
        }
    }
}

Voici les attributs personnalisés. Cela devrait aller dans votre res/attrs.xmldossier:

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

Et voici comment vous l'utilisez. J'utiliserai une mise en page relative pour l'envelopper et afficher la customAttrdéclaration, mais cela pourrait évidemment être la mise en page que vous avez déjà.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:customAttrs="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.mycompany.myapp.widget.CustomFontTextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:text="foobar"
         customAttrs:customFont="roboto_thin" />

</RelativeLayout>

J'ai déjà utilisé cela avec succès. La seule différence entre nos implémentations est que je n'utilisais pas de sous-dossier dans les actifs. Je ne sais pas si cela changera quoi que ce soit.

À condition que vous ayez placé la police au bon endroit et qu'il n'y ait aucune erreur dans le fichier de police lui-même, votre code devrait fonctionner comme ça, RATTLESNAKE.

Cependant, ce serait beaucoup plus facile si vous pouviez simplement définir une police dans votre mise en page XML, comme ceci:

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

Avec l'accompagnement 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>

J'ai créé quelques outils spécialement à cet effet. Reportez-vous à ce projet de GitHub, ou jetez un œil à ce billet de blog qui explique le tout.

La meilleure façon de le faire à partir de la version d'aperçu d'Android O est la suivante:

cela ne fonctionne que si vous avez Android Studio-2.4 ou supérieur

1. Cliquez avec le bouton droit sur le dossier res et accédez à Nouveau> Répertoire de ressources Android . La
   fenêtre Nouveau répertoire de ressources apparaît.
   
2. Dans la liste Type de ressource, sélectionnez la police , puis cliquez sur OK.
   
3. Ajoutez vos fichiers de police dans le dossier de police .La structure de dossier génère ci - dessous R.font.dancing_script, R.font.la_laet R.font.ba_ba.
   
4. Double-cliquez sur un fichier de police pour prévisualiser les polices du fichier dans l'éditeur.

Ensuite, nous devons créer une famille de polices:

1. Cliquez avec le bouton droit sur le dossier de polices et accédez à Nouveau> Fichier de ressources de police . La fenêtre Nouveau fichier de ressources apparaît.
   
2. Entrez le nom du fichier, puis cliquez sur OK . La nouvelle ressource XML de police s'ouvre dans l'éditeur.
   

3. Insérez chaque fichier de police, style et attribut d'épaisseur dans l'élément de balise de police. Le XML suivant illustre l'ajout d'attributs liés à la police dans le XML de ressource de police:

Ajout de polices à un TextView:

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

A partir de la documentation

Travailler avec des polices

Toutes les étapes sont correctes.

Pour les polices personnalisées dans Android, créez un dossier dans le nom du dossier des actifs, il "polices" placez-y votre fichier fonts.ttf ou .otf souhaité.

Si vous étendez UIBaseFragment:

Typeface font = Typeface.createFromAsset(getActivity().getAssets(), "fonts/Arial.ttf");
        tv.setTypeface(font);

sinon si étend l'activité:

Typeface font = Typeface.createFromAsset(getContext().getAssets(), "fonts/Arial.ttf");
        tv.setTypeface(font);

Vous pouvez utiliser PixlUI à https://github.com/neopixl/PixlUI

importer leur .jar et l'utiliser en XML

 <com.neopixl.pixlui.components.textview.TextView
    android:id="@+id/textView1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world"
    pixlui:typeface="GearedSlab.ttf" />

Comme je n'étais pas satisfait de toutes les solutions présentées sur SO, j'ai trouvé la mienne. C'est basé sur une petite astuce avec des balises (c'est-à-dire que vous ne pouvez pas utiliser de balises dans votre code), j'ai mis le chemin de la police là-bas. Ainsi, lorsque vous définissez des vues, vous pouvez effectuer l'une des opérations suivantes:

<TextView
        android:id="@+id/textViewHello1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World 1"
        android:tag="fonts/Oswald-Regular.ttf"/>

ou ca:

<TextView
        android:id="@+id/textViewHello2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World 2"
        style="@style/OswaldTextAppearance"/>

<style name="OswaldTextAppearance">
        <item name="android:tag">fonts/Oswald-Regular.ttf</item>
        <item name="android:textColor">#000000</item>
</style>

Maintenant, vous pouvez soit accéder explicitement / configurer la vue comme:

TextView textView = TextViewHelper.setupTextView(this, R.id.textViewHello1).setText("blah");

ou tout simplement configurer via:

TextViewHelper.setupTextViews(this, (ViewGroup) findViewById(R.id.parentLayout)); // parentLayout is the root view group (relative layout in my case)

Et quel est le cours de magie que vous demandez? Surtout collé à partir d'un autre poste SO, avec des méthodes d'assistance pour l'activité et les fragments:

import android.app.Activity;
import android.content.Context;
import android.graphics.Typeface;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import java.util.HashMap;
import java.util.Map;

public class TextViewHelper {
    private static final Map<String, Typeface> mFontCache = new HashMap<>();

    private static Typeface getTypeface(Context context, String fontPath) {
        Typeface typeface;
        if (mFontCache.containsKey(fontPath)) {
            typeface = mFontCache.get(fontPath);
        } else {
            typeface = Typeface.createFromAsset(context.getAssets(), fontPath);
            mFontCache.put(fontPath, typeface);
        }
        return typeface;
    }

    public static void setupTextViews(Context context, ViewGroup parent) {
        for (int i = parent.getChildCount() - 1; i >= 0; i--) {
            final View child = parent.getChildAt(i);
            if (child instanceof ViewGroup) {
                setupTextViews(context, (ViewGroup) child);
            } else {
                if (child != null) {
                    TextViewHelper.setupTextView(context, child);
                }
            }
        }
    }

    public static void setupTextView(Context context, View view) {
        if (view instanceof TextView) {
            if (view.getTag() != null) // also inherited from TextView's style
            {
                TextView textView = (TextView) view;
                String fontPath = (String) textView.getTag();
                Typeface typeface = getTypeface(context, fontPath);
                if (typeface != null) {
                    textView.setTypeface(typeface);
                }
            }
        }
    }

    public static TextView setupTextView(View rootView, int id) {
        TextView textView = (TextView) rootView.findViewById(id);
        setupTextView(rootView.getContext().getApplicationContext(), textView);
        return textView;
    }

    public static TextView setupTextView(Activity activity, int id) {
        TextView textView = (TextView) activity.findViewById(id);
        setupTextView(activity.getApplicationContext(), textView);
        return textView;
    }
}

Malheureusement, il n'y a pas de bonne solution pour cela.

J'ai vu les nombreux articles sur l'utilisation d'un TextView personnalisé mais ce qu'ils oublient, ce n'est pas seulement les vues de texte qui peuvent implémenter des polices et il y a des vues de texte cachées dans d'autres vues inaccessibles au développeur; Je ne vais même pas commencer sur Spannable .

Vous pouvez utiliser un utilitaire de police externe comme:

Outil de police de calligraphie

MAIS cela passe en boucle sur chaque vue de l'application lors de sa création et même cet utilitaire manque certaines vues (ViewPager rend la police normale), alors vous avez le problème: lorsque Google met à jour ses outils de construction, cela se bloque parfois car il doit cibler des propriétés obsolètes. C'est aussi un peu lent car il utilise la réflexion de Java .

C'est vraiment à Google de résoudre ce problème. Nous avons besoin d'une meilleure prise en charge des polices dans Android. Si vous regardez la solution d'iOS, ils ont littéralement des centaines de polices intégrées pour sélectionner. Vous voulez une police personnalisée? Déposez simplement un TFF et il est utilisable ..

Pour l'instant se limitaient désormais à l'offre que Google nous propose qui est extrêmement limitée mais heureusement optimisée pour les mobiles.

Assurez-vous de coller le code ci-dessus dans onCreate () après votre appel au super et l'appel à setContentView (). Ce petit détail m'a gardé pendant un moment.

Avec Android 8.0, l' utilisation de polices personnalisées dans l'application est devenue facile downloadable fonts. Nous pouvons ajouter des polices directement res/font/ folderdans le dossier du projet et, ce faisant, les polices deviennent automatiquement disponibles dans Android Studio.

Maintenant, définissez l' fontFamilyattribut sur la liste des polices ou cliquez sur plus et sélectionnez la police de votre choix. Cela ajoutera une tools:fontFamily="@font/your_font_file"ligne à votre TextView.

Cela générera automatiquement quelques fichiers.

1. Dans le dossier de valeurs, il sera créé fonts_certs.xml.

2. Dans Manifest, il ajoutera ces lignes:

  <meta-data
            android:name="preloaded_fonts"
            android:resource="@array/preloaded_fonts" /> 

3. preloaded_fonts.xml

<resources>
    <array name="preloaded_fonts" translatable="false">
        <item>@font/open_sans_regular</item>
        <item>@font/open_sans_semibold</item>
    </array>
</resources>

Vous pouvez utiliser la bibliothèque tierce EasyFonts facile et simple pour définir une variété de polices personnalisées pour votre TextView. En utilisant cette bibliothèque, vous ne devriez pas avoir à vous soucier du téléchargement et de l'ajout de polices dans le dossier assets / fonts. Également à propos de la création d'objets Fonte.

Au lieu de

Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(myTypeface);

Simplement:

TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(EasyFonts.robotoThin(this));

Cette bibliothèque fournit également la police de caractères suivante.

• Roboto
• Droid Serif
• Robot Droid
• Liberté
• Fun Raiser
• Android Nation
• Avocat vert
• Reconnaissance

J'ai eu le même problème, le TTF ne s'est pas présenté. J'ai changé le fichier de police et avec le même code ça marche.

Si vous souhaitez charger la police à partir du réseau ou la styliser facilement, vous pouvez utiliser:

https://github.com/shellum/fontView

Exemple:

<!--Layout-->
<com.finalhack.fontview.FontView
        android:id="@+id/someFontIcon"
        android:layout_width="80dp"
        android:layout_height="80dp" />

//Java:
fontView.setupFont("http://blah.com/myfont.ttf", true, character, FontView.ImageType.CIRCLE);
fontView.addForegroundColor(Color.RED);
fontView.addBackgroundColor(Color.WHITE);

Eh bien, après sept ans, vous pouvez changer toute l'application textViewou ce que vous voulez facilement en utilisant les android.supportbibliothèques 26 ++.

Par exemple:

Créez votre package de polices app / src / res / font et déplacez votre police dedans.

Et dans le thème de votre application, ajoutez-le simplement en tant que police

    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
   . . . ...
    <item name="android:fontFamily">@font/demo</item>
</style>

Exemple à utiliser avec textViewuniquement:

<style name="fontTextView" parent="@android:style/Widget.TextView">
    <item name="android:fontFamily">monospace</item>
</style>

Et ajoutez à votre thème principal:

<item name="android:textViewStyle">@style/fontTextView</item>

Actuellement, cela fonctionne sur 8.1 à 4.1 API Jelly Bean Et c'est une large gamme.

Mise à jour de la réponse: Android 8.0 (API niveau 26) introduit une nouvelle fonctionnalité, les polices en XML. utilisez simplement la fonction Polices en XML sur les appareils exécutant Android 4.1 (API niveau 16) et supérieur, utilisez la bibliothèque de support 26.

voir ce lien

Ancienne réponse

Il existe deux façons de personnaliser les polices:

!!! ma police personnalisée dans assets / fonts / iran_sans.ttf

Voie 1: Type de réfraction typographie ||| meilleur moyen

appeler FontsOverride.setDefaultFont () dans la classe étend l'application, ce code entraînera la modification de toutes les polices logicielles, même les polices Toasts

AppController.java

public class AppController extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        //Initial Font
        FontsOverride.setDefaultFont(getApplicationContext(), "MONOSPACE", "fonts/iran_sans.ttf");

    }
}

FontsOverride.java

public class FontsOverride {

    public static void setDefaultFont(Context context, String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(), fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    }

    private static void replaceFont(String staticTypefaceFieldName, final Typeface newTypeface) {
        try {
            final Field staticField = Typeface.class.getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Méthode 2: utilisez setTypeface

pour une vue spéciale, il suffit d'appeler setTypeface () pour changer la police.

CTextView.java

public class CTextView extends TextView {

    public CTextView(Context context) {
        super(context);
        init(context,null);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context,attrs);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context,attrs);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init(context,attrs);
    }

    public void init(Context context, @Nullable AttributeSet attrs) {

        if (isInEditMode())
            return;

        // use setTypeface for change font this view
        setTypeface(FontUtils.getTypeface("fonts/iran_sans.ttf"));

    }
}

FontUtils.java

public class FontUtils {

    private static Hashtable<String, Typeface> fontCache = new Hashtable<>();

    public static Typeface getTypeface(String fontName) {
        Typeface tf = fontCache.get(fontName);
        if (tf == null) {
            try {
                tf = Typeface.createFromAsset(AppController.getInstance().getApplicationContext().getAssets(), fontName);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            fontCache.put(fontName, tf);
        }
        return tf;
    }

}

La façon correcte de le faire à partir de l'API 26 est décrite dans la documentation officielle ici:

https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html

Cela implique de placer les fichiers ttf dans le dossier res / font et de créer un fichier de famille de polices.

La solution Android la plus simple prise en charge maintenant!

Utilisez une police personnalisée en xml:

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:fontFamily="@font/[your font resource]"/>

détails du look:

https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html

• Ouvrez votre projet et sélectionnez Projet en haut à gauche
• application -> src -> main
• faites un clic droit sur le répertoire principal et créez-le en tant qu'actif
• clic droit pour assest et créer un nouveau nom de répertoire dans lequel il polices
• vous devez trouver des polices gratuites comme des polices gratuites
• donnez-le à votre Textview et appelez-le dans votre classe d'activité
• copiez vos polices dans le dossier des polices
• TextView txt = (TextView) findViewById(R.id.txt_act_spalsh_welcome); Typeface font = Typeface.createFromAsset(getAssets(), "fonts/Aramis Italic.ttf"); txt.setTypeface(font);

le nom de la police doit être correct et s'amuser

Oui, les polices téléchargeables sont si faciles, comme l'a dit Dipali .

Voici comment vous le faites ...

1. Placez a TextView.
2. Dans le volet des propriétés, sélectionnez la fontFamilyliste déroulante. S'il n'est pas là, trouvez le truc caret (le> et cliquez dessus pour le développer textAppearance) sous le.
3. Développez la liste font-familydéroulante.
4. Dans la petite liste, faites défiler jusqu'à ce que vous voyiez more fonts
5. Cela ouvrira une boîte de dialogue dans laquelle vous pourrez rechercher à partir de Google Fonts
6. Recherchez la police que vous aimez avec la barre de recherche en haut
7. Sélectionnez votre police.
8. Sélectionnez le style de la police que vous aimez (c.-à-d. Gras, normal, italique, etc.)
9. Dans le volet droit, choisissez le bouton radio indiquant Add font to project
10. Cliquez sur OK. Maintenant, votre TextView a la police que vous aimez!

BONUS: Si vous souhaitez un style tout avec du texte dans votre application avec la police choisie, il suffit d' ajouter <item name="android:fontfamily">@font/fontnamehere</item>dans votrestyles.xml