Comment changer fontFamily de TextView dans Android
Je voudrais donc changer le Android:fontFamily dans Android, mais je ne vois aucune police prédéfinie dans Android. Comment sélectionner l'un de ceux prédéfinis? Je n'ai pas vraiment besoin de définir mon propre TypeFace mais tout ce dont j'ai besoin est quelque chose de différent de ce que cela montre pour le moment.
<TextView
Android:id="@+id/HeaderText"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:layout_alignParentTop="true"
Android:layout_centerHorizontal="true"
Android:layout_marginTop="52dp"
Android:gravity="center"
Android:text="CallerBlocker"
Android:textSize="40dp"
Android:fontFamily="Arial"
/>
Il semble que ce que j'ai fait là-bas ne fonctionnera pas vraiment! BTW Android:fontFamily="Arial" était une tentative stupide!
À partir d'Android 4.1/4.2/5.0, les familles de polices Roboto suivantes sont disponibles:
Android:fontFamily="sans-serif" // roboto regular
Android:fontFamily="sans-serif-light" // roboto light
Android:fontFamily="sans-serif-condensed" // roboto condensed
Android:fontFamily="sans-serif-black" // roboto black
Android:fontFamily="sans-serif-thin" // roboto thin (Android 4.2)
Android:fontFamily="sans-serif-medium" // roboto medium (Android 5.0)
en combinaison avec
Android:textStyle="normal|bold|italic"
ces 16 variantes sont possibles:
- Roboto régulier
- Roboto italic
- Roboto audacieux
- Roboto gras italique
- Roboto-Light
- Roboto-Light italique
- Roboto-Thin
- Roboto-Thin italic
- Roboto-Condensé
- Roboto-Condensed italic
- Roboto-Condensed gras
- Gras italique Roboto-Condensed
- Roboto-Black
- Roboto-Black italic
- Roboto-Medium
- Roboto-Medium italic
fonts.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="font_family_light">sans-serif-light</string>
<string name="font_family_medium">sans-serif-medium</string>
<string name="font_family_regular">sans-serif</string>
<string name="font_family_condensed">sans-serif-condensed</string>
<string name="font_family_black">sans-serif-black</string>
<string name="font_family_thin">sans-serif-thin</string>
</resources>
Voici le moyen de définir la police par programme:
TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
"fonts/epimodem.ttf");
tv.setTypeface(face);
placez le fichier de police dans votre dossier d’actifs. Dans mon cas, j'ai créé un sous-répertoire appelé polices.
EDIT: Si vous vous demandez où est votre dossier de ressources voir cette question
J'ai dû analyser /system/etc/fonts.xml dans un projet récent. Voici les familles de polices actuelles de Lollipop:
╔════╦════════════════════════════╦═════════════════════════════╗
║ ║ FONT FAMILY ║ TTF FILE ║
╠════╬════════════════════════════╬═════════════════════════════╣
║ 1 ║ casual ║ ComingSoon.ttf ║
║ 2 ║ cursive ║ DancingScript-Regular.ttf ║
║ 3 ║ monospace ║ DroidSansMono.ttf ║
║ 4 ║ sans-serif ║ Roboto-Regular.ttf ║
║ 5 ║ sans-serif-black ║ Roboto-Black.ttf ║
║ 6 ║ sans-serif-condensed ║ RobotoCondensed-Regular.ttf ║
║ 7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf ║
║ 8 ║ sans-serif-light ║ Roboto-Light.ttf ║
║ 9 ║ sans-serif-medium ║ Roboto-Medium.ttf ║
║ 10 ║ sans-serif-smallcaps ║ CarroisGothicSC-Regular.ttf ║
║ 11 ║ sans-serif-thin ║ Roboto-Thin.ttf ║
║ 12 ║ serif ║ NotoSerif-Regular.ttf ║
║ 13 ║ serif-monospace ║ CutiveMono.ttf ║
╚════╩════════════════════════════╩═════════════════════════════╝
Voici l’analyseur (basé sur FontListParser ):
import Java.io.File;
import Java.io.FileInputStream;
import Java.io.IOException;
import Java.io.InputStream;
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Comparator;
import Java.util.List;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import Android.util.Xml;
/**
* Helper class to get the current font families on an Android device.</p>
*
* Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>
*/
public final class FontListParser {
private static final File FONTS_XML = new File("/system/etc/fonts.xml");
private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");
public static List<SystemFont> getSystemFonts() throws Exception {
String fontsXml;
if (FONTS_XML.exists()) {
fontsXml = FONTS_XML.getAbsolutePath();
} else if (SYSTEM_FONTS_XML.exists()) {
fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();
} else {
throw new RuntimeException("fonts.xml does not exist on this system");
}
Config parser = parse(new FileInputStream(fontsXml));
List<SystemFont> fonts = new ArrayList<>();
for (Family family : parser.families) {
if (family.name != null) {
Font font = null;
for (Font f : family.fonts) {
font = f;
if (f.weight == 400) {
break;
}
}
SystemFont systemFont = new SystemFont(family.name, font.fontName);
if (fonts.contains(systemFont)) {
continue;
}
fonts.add(new SystemFont(family.name, font.fontName));
}
}
for (Alias alias : parser.aliases) {
if (alias.name == null || alias.toName == null || alias.weight == 0) {
continue;
}
for (Family family : parser.families) {
if (family.name == null || !family.name.equals(alias.toName)) {
continue;
}
for (Font font : family.fonts) {
if (font.weight == alias.weight) {
fonts.add(new SystemFont(alias.name, font.fontName));
break;
}
}
}
}
if (fonts.isEmpty()) {
throw new Exception("No system fonts found.");
}
Collections.sort(fonts, new Comparator<SystemFont>() {
@Override
public int compare(SystemFont font1, SystemFont font2) {
return font1.name.compareToIgnoreCase(font2.name);
}
});
return fonts;
}
public static List<SystemFont> safelyGetSystemFonts() {
try {
return getSystemFonts();
} catch (Exception e) {
String[][] defaultSystemFonts = {
{
"cursive", "DancingScript-Regular.ttf"
}, {
"monospace", "DroidSansMono.ttf"
}, {
"sans-serif", "Roboto-Regular.ttf"
}, {
"sans-serif-light", "Roboto-Light.ttf"
}, {
"sans-serif-medium", "Roboto-Medium.ttf"
}, {
"sans-serif-black", "Roboto-Black.ttf"
}, {
"sans-serif-condensed", "RobotoCondensed-Regular.ttf"
}, {
"sans-serif-thin", "Roboto-Thin.ttf"
}, {
"serif", "NotoSerif-Regular.ttf"
}
};
List<SystemFont> fonts = new ArrayList<>();
for (String[] names : defaultSystemFonts) {
File file = new File("/system/fonts", names[1]);
if (file.exists()) {
fonts.add(new SystemFont(names[0], file.getAbsolutePath()));
}
}
return fonts;
}
}
/* Parse fallback list (no names) */
public static Config parse(InputStream in) throws XmlPullParserException, IOException {
try {
XmlPullParser parser = Xml.newPullParser();
parser.setInput(in, null);
parser.nextTag();
return readFamilies(parser);
} finally {
in.close();
}
}
private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {
Alias alias = new Alias();
alias.name = parser.getAttributeValue(null, "name");
alias.toName = parser.getAttributeValue(null, "to");
String weightStr = parser.getAttributeValue(null, "weight");
if (weightStr == null) {
alias.weight = 0;
} else {
alias.weight = Integer.parseInt(weightStr);
}
skip(parser); // alias tag is empty, ignore any contents and consume end tag
return alias;
}
private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,
IOException {
Config config = new Config();
parser.require(XmlPullParser.START_TAG, null, "familyset");
while (parser.next() != XmlPullParser.END_TAG) {
if (parser.getEventType() != XmlPullParser.START_TAG) {
continue;
}
if (parser.getName().equals("family")) {
config.families.add(readFamily(parser));
} else if (parser.getName().equals("alias")) {
config.aliases.add(readAlias(parser));
} else {
skip(parser);
}
}
return config;
}
private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,
IOException {
String name = parser.getAttributeValue(null, "name");
String lang = parser.getAttributeValue(null, "lang");
String variant = parser.getAttributeValue(null, "variant");
List<Font> fonts = new ArrayList<Font>();
while (parser.next() != XmlPullParser.END_TAG) {
if (parser.getEventType() != XmlPullParser.START_TAG) {
continue;
}
String tag = parser.getName();
if (tag.equals("font")) {
String weightStr = parser.getAttributeValue(null, "weight");
int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);
boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));
String filename = parser.nextText();
String fullFilename = "/system/fonts/" + filename;
fonts.add(new Font(fullFilename, weight, isItalic));
} else {
skip(parser);
}
}
return new Family(name, fonts, lang, variant);
}
private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
int depth = 1;
while (depth > 0) {
switch (parser.next()) {
case XmlPullParser.START_TAG:
depth++;
break;
case XmlPullParser.END_TAG:
depth--;
break;
}
}
}
private FontListParser() {
}
public static class Alias {
public String name;
public String toName;
public int weight;
}
public static class Config {
public List<Alias> aliases;
public List<Family> families;
Config() {
families = new ArrayList<Family>();
aliases = new ArrayList<Alias>();
}
}
public static class Family {
public List<Font> fonts;
public String lang;
public String name;
public String variant;
public Family(String name, List<Font> fonts, String lang, String variant) {
this.name = name;
this.fonts = fonts;
this.lang = lang;
this.variant = variant;
}
}
public static class Font {
public String fontName;
public boolean isItalic;
public int weight;
Font(String fontName, int weight, boolean isItalic) {
this.fontName = fontName;
this.weight = weight;
this.isItalic = isItalic;
}
}
public static class SystemFont {
public String name;
public String path;
public SystemFont(String name, String path) {
this.name = name;
this.path = path;
}
}
}
N'hésitez pas à utiliser la classe ci-dessus dans votre projet. Par exemple, vous pouvez donner à vos utilisateurs une sélection de familles de polices et définir le caractère en fonction de leurs préférences.
Un petit exemple incomplet:
final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();
String[] items = new String[fonts.size()];
for (int i = 0; i < fonts.size(); i++) {
items[i] = fonts.get(i).name;
}
new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
FontListParser.SystemFont selectedFont = fonts.get(which);
// TODO: do something with the font
Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();
}
}).show();
À partir de Android-Studio 3.0, il est très facile de changer de famille de polices.
À l'aide de la bibliothèque de support 26, il fonctionnera sur les appareils fonctionnant sous Android API version 16 et ultérieure.
Créez un dossier font dans le répertoire res. Téléchargez la police de votre choix et collez-la dans le dossier font. La structure devrait être quelque chose comme ci-dessous
Remarque: À partir de la bibliothèque de support Android 26.0, vous devez déclarer les deux ensembles d'attributs (Android: et app:) afin de garantir le chargement de vos polices sur les périphériques en cours d'exécution Api 26 ou moins.
Maintenant, vous pouvez changer la police dans layout en utilisant
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:fontFamily="@font/dancing_script"
app:fontFamily="@font/dancing_script"/>
Pour changer par programme
Typeface typeface = getResources().getFont(R.font.myfont);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
textView.setTypeface(typeface);
Pour changer la police en utilisant styles.xml, créez un style
<style name="Regular">
<item name="Android:fontFamily">@font/dancing_script</item>
<item name="fontFamily">@font/dancing_script</item>
<item name="Android:textStyle">normal</item>
</style>
et appliquer ce style à TextView
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
style="@style/Regular"/>
vous pouvez également créer votre propre famille de polices
- Cliquez avec le bouton droit sur le dossier de polices et accédez à Nouveau> Fichier de ressources de polices. La fenêtre Nouveau fichier de ressources apparaît.
- Entrez le nom du fichier , puis cliquez sur OK. Le nouveau XML de ressource de police s’ouvre dans l’éditeur.
Écrivez votre propre famille de polices ici, par exemple
<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>
il s'agit simplement d'un mappage d'un fontStyle et d'un fontWeight spécifiques avec la ressource de police qui sera utilisée pour rendre cette variante spécifique. Les valeurs valides pour fontStyle sont normal ou italique; et fontWeight est conforme à la spécification CSS font-weight
1. Pour changer famille de polices dans layout, vous pouvez écrire
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:fontFamily="@font/lobster"/>
2. Pour changer par programme
Typeface typeface = getResources().getFont(R.font.lobster);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
textView.setTypeface(typeface);
Pour changer la police de l'application entière Ajoutez ces deux lignes dans AppTheme
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<item name="Android:fontFamily">@font/your_font</item>
<item name="fontFamily">@font/your_font</item>
</style>
Voir le Documentation , Tutoriel sur les polices personnalisées Android Pour plus d'informations
Android ne vous permet pas de définir des polices personnalisées à partir de la disposition XML. Au lieu de cela, vous devez regrouper le fichier de police spécifique dans le dossier des ressources de votre application et le définir par programme. Quelque chose comme:
TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);
Notez que vous ne pouvez exécuter ce code qu'après l'appel de setContentView (). En outre, seules certaines polices sont prises en charge par Android et doivent être au format .ttf (TrueType) ou .otf (OpenType). Même dans ce cas, certaines polices peuvent ne pas fonctionner.
This est une police qui fonctionne vraiment sur Android, et vous pouvez l'utiliser pour confirmer que votre code fonctionne si votre fichier de police n'est pas pris en charge par Android.
Mise à jour Android O: Ceci est maintenant possible avec XML dans Android O , basé sur le commentaire de Roger.
Pour définir Roboto par programme:
Paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
C'est la même chose que Android:typeface.
les polices intégrées sont:
- ordinaire
- sans
- serif
- monospace
Si vous le souhaitez par programmation, vous pouvez utiliser
label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);
Où SANS_SERIF vous pouvez utiliser:
DEFAULTDEFAULT_BOLDMONOSPACESANS_SERIFSERIF
Et où ITALIC vous pouvez utiliser:
BOLDBOLD_ITALICITALICNORMAL
Tout est indiqué sur les développeurs Android
J'utilise une excellente bibliothèque Calligraphy de Chris Jenx conçu pour vous permettre d'utiliser des polices personnalisées dans votre application Android. Essaie!
Ce que tu veux n'est pas possible. Vous devez définir TypeFace dans votre code.
Dans XML ce que vous pouvez faire est
Android:typeface="sans" | "serif" | "monospace"
sinon vous ne pouvez pas jouer beaucoup avec les polices en XML. :)
Pour Arial, vous devez définir le type de visage dans votre code.
Un moyen facile de gérer les polices consiste à les déclarer via des ressources, comme suit:
<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>
<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>
<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>
Dynamiquement, vous pouvez définir une police de caractères similaire à celle d’Android: fontFamily en xml en utilisant ceci,
For Custom font:
TextView tv = ((TextView) v.findViewById(R.id.select_item_title));
Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf");
tv.setTypeface(face);
For Default font:
tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));
Il s’agit de la liste de la famille police par défaut utilisée. Utilisez-la en remplaçant la chaîne de guillemet double "sans-serif-medium".
FONT FAMILY TTF FILE
1 casual ComingSoon.ttf
2 cursive DancingScript-Regular.ttf
3 monospace DroidSansMono.ttf
4 sans-serif Roboto-Regular.ttf
5 sans-serif-black Roboto-Black.ttf
6 sans-serif-condensed RobotoCondensed-Regular.ttf
7 sans-serif-condensed-light RobotoCondensed-Light.ttf
8 sans-serif-light Roboto-Light.ttf
9 sans-serif-medium Roboto-Medium.ttf
10 sans-serif-smallcaps CarroisGothicSC-Regular.ttf
11 sans-serif-thin Roboto-Thin.ttf
12 serif NotoSerif-Regular.ttf
13 serif-monospace CutiveMono.ttf
"mycustomfont.ttf" est le fichier ttf. Path sera dans src/assets/fonts/mycustomfont.ttf, vous pouvez en savoir plus sur la police par défaut dans ce Famille de polices par défaut
Avec quelques essais et erreurs, j'ai appris ce qui suit.
Dans le fichier * .xml, vous pouvez combiner les polices d’origine avec les fonctions suivantes, et pas seulement avec les caractères:
Android:fontFamily="serif"
Android:textStyle="italic"
Avec ces deux styles, il n’était pas nécessaire d’utiliser une police de caractères dans les autres cas. La gamme de combinaisons est beaucoup plus grande avec fontfamily et textStyle.
La valeur valide d'Android: fontFamily est définie dans /system/etc/system_fonts.xml(4.x) ou /system/etc/fonts.xml(5.x). Toutefois, le fabricant du périphérique peut le modifier. Par conséquent, la police utilisée pour définir la valeur de fontFamily dépend du fichier susmentionné du périphérique spécifié.
Dans AOSP, la police Arial est valide mais doit être définie avec "arial" et non "Arial", par exemple Android: fontFamily = "arial" . Jetez un coup d'oeil rapide sur system_fonts.xml de KitKat
<family>
<nameset>
<name>sans-serif</name>
<name>arial</name>
<name>helvetica</name>
<name>tahoma</name>
<name>verdana</name>
</nameset>
<fileset>
<file>Roboto-Regular.ttf</file>
<file>Roboto-Bold.ttf</file>
<file>Roboto-Italic.ttf</file>
<file>Roboto-BoldItalic.ttf</file>
</fileset>
</family>
////////////////////////////////////////////////////////// ////////////////////////////
Il existe trois attributs XML pertinents pour définir une "police" dans la présentation - Android: fontFamily , Android: police de caractères et Android: textStyle . La combinaison de "fontFamily" et "textStyle" ou "typeface" et "textStyle" peut être utilisée pour modifier l'apparence de la police dans le texte, elle est donc utilisée seule. Extrait de code dans TextView.Java comme ceci:
private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {
Typeface tf = null;
if (familyName != null) {
tf = Typeface.create(familyName, styleIndex);
if (tf != null) {
setTypeface(tf);
return;
}
}
switch (typefaceIndex) {
case SANS:
tf = Typeface.SANS_SERIF;
break;
case SERIF:
tf = Typeface.SERIF;
break;
case MONOSPACE:
tf = Typeface.MONOSPACE;
break;
}
setTypeface(tf, styleIndex);
}
public void setTypeface(Typeface tf, int style) {
if (style > 0) {
if (tf == null) {
tf = Typeface.defaultFromStyle(style);
} else {
tf = Typeface.create(tf, style);
}
setTypeface(tf);
// now compute what (if any) algorithmic styling is needed
int typefaceStyle = tf != null ? tf.getStyle() : 0;
int need = style & ~typefaceStyle;
mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);
mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);
} else {
mTextPaint.setFakeBoldText(false);
mTextPaint.setTextSkewX(0);
setTypeface(tf);
}
}
À partir du code, nous pouvons voir:
- si "fontFamily" est défini, le "caractère" sera ignoré.
- "fonte" a des valeurs valides standard et limitées. En fait, les valeurs sont "normal" "sans" "serif" et "monospace", elles peuvent être trouvées dans system_fonts.xml (4.x) ou fonts.xml (5.x). En fait, "normal" et "sans" sont la police par défaut du système.
- "fontFamily" peut être utilisé pour définir toutes les polices des polices intégrées, tandis que "typeface" fournit uniquement les polices typiques de "sans-serif" "serif" et "monospace" (les trois principales catégories de types de police au monde) .
- Lorsque vous définissez uniquement "textStyle", nous définissons la police par défaut et le style spécifié Les valeurs effectives sont "normal", "gras", "italique" et "gras | italique".
<string name="font_family_display_4_material">sans-serif-light</string>
<string name="font_family_display_3_material">sans-serif</string>
<string name="font_family_display_2_material">sans-serif</string>
<string name="font_family_display_1_material">sans-serif</string>
<string name="font_family_headline_material">sans-serif</string>
<string name="font_family_title_material">sans-serif-medium</string>
<string name="font_family_subhead_material">sans-serif</string>
<string name="font_family_menu_material">sans-serif</string>
<string name="font_family_body_2_material">sans-serif-medium</string>
<string name="font_family_body_1_material">sans-serif</string>
<string name="font_family_caption_material">sans-serif</string>
<string name="font_family_button_material">sans-serif-medium</string>
Si vous souhaitez utiliser un TextView dans de nombreux endroits avec la même famille de polices, étendez la classe TextView et définissez votre police comme suit: -
public class ProximaNovaTextView extends TextView {
public ProximaNovaTextView(Context context) {
super(context);
applyCustomFont(context);
}
public ProximaNovaTextView(Context context, AttributeSet attrs) {
super(context, attrs);
applyCustomFont(context);
}
public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
applyCustomFont(context);
}
private void applyCustomFont(Context context) {
Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);
setTypeface(customFont);
}
}
Et puis utilisez cette classe personnalisée en XML pour le TextView comme ceci: -
<com.myapp.customview.ProximaNovaTextView
Android:id="@+id/feed_list_item_name_tv"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:textSize="14sp"
/>
Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);
définir facilement la police sur n'importe quel textview de res> répertoire de polices par programme
Voici un plus facile wa y qui peut fonctionner dans certains cas. Le principe est d'ajouter une TextVview non visible dans votre mise en page XML et de obtenir son typeFace dans le code Java.
La mise en page dans le fichier XML:
<TextView
Android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
Android:layout_width="0dp"
Android:layout_height="0dp"
Android:fontFamily="sans-serif-thin"
Android:id="@+id/textViewDescription"/>
Et le code Java:
myText.setTypeface(textViewSelectedDescription.getTypeface());
Cela a fonctionné pour moi (dans un TextSwitcher par exemple).
Vous définissez le style dans res/layout/value/style.xml comme ceci:
<style name="boldText">
<item name="Android:textStyle">bold|italic</item>
<item name="Android:textColor">#FFFFFF</item>
</style>
et pour utiliser ce style dans le fichier main.xml, utilisez:
style="@style/boldText"
Vous pouvez également modifier les polices standard avec setTextAppearance (requiert l'API 16), voir https://stackoverflow.com/a/36301508/2914140 :
<style name="styleA">
<item name="Android:fontFamily">sans-serif</item>
<item name="Android:textStyle">bold</item>
<item name="Android:textColor">?android:attr/textColorPrimary</item>
</style>
<style name="styleB">
<item name="Android:fontFamily">sans-serif-light</item>
<item name="Android:textStyle">normal</item>
<item name="Android:textColor">?android:attr/textColorTertiary</item>
</style>
if(condition){
TextViewCompat.setTextAppearance(textView, R.style.styleA);
} else {
TextViewCompat.setTextAppearance(textView,R.style.styleB);
}
Vous pouvez le faire facilement en utilisant la bibliothèque suivante
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" />
léger et facile à mettre en œuvre, il vous suffit de copier vos polices dans un dossier d’actifs et d’utiliser le nom en xml.
Il y a une belle bibliothèque disponible pour cela
implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
Le moyen le plus simple d’ajouter la police par programme à un TextView consiste tout d’abord à ajouter le fichier de police dans votre dossier Assets du projet. Par exemple, votre chemin de police ressemble à ceci: assets/fonts/my_font.otf
Et ajoutez-le à un TextView en tant que:
Kotlin
val font_path = "fonts/my_font.otf"
myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.typeface = myTypeface
Java
String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);
Pour Android-studio 3 et les versions ultérieures, vous pouvez utiliser ce style, puis toutes les polices textView sont modifiées dans l'application.
créer ce style dans votre style.xml:
<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="Android:Widget.TextView">
<item name="Android:fontFamily">@font/your_custom_font</item>
</style>
Ensuite, utilisez-le dans votre thème:
<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<!-- 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:textViewStyle">@style/defaultTextViewStyle</item>
</style>
Essaye ça:
TextView textview = (TextView) findViewById(R.id.textview);
Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);
J'utilise Letter Press lib pour les éléments de NonTextView tels que les boutons et kianoni fontloader lib pour les commentaires de TextViews car l'utilisation du style dans cette lib est plus facile que Letter Press pour moi et j'ai un retour idéal à ce sujet. C’est génial pour ceux qui veulent utiliser des polices personnalisées à l’exception de Roboto Font . C’est donc mon expérience avec les bibliothèques de polices . pour ceux qui souhaitent utiliser des classes personnalisées pour les modifications de polices. Je vous recommande vivement de créer ce classe avec cet extrait
public class TypefaceSpan extends MetricAffectingSpan {
/** An <code>LruCache</code> for previously loaded typefaces. */
private static LruCache<String, Typeface> sTypefaceCache =
new LruCache<String, Typeface>(12);
private Typeface mTypeface;
/**
* Load the {@link Android.graphics.Typeface} and apply to a {@link Android.text.Spannable}.
*/
public TypefaceSpan(Context context, String typefaceName) {
mTypeface = sTypefaceCache.get(typefaceName);
if (mTypeface == null) {
mTypeface = Typeface.createFromAsset(context.getApplicationContext()
.getAssets(), String.format("fonts/%s", typefaceName));
// Cache the loaded Typeface
sTypefaceCache.put(typefaceName, mTypeface);
}
}
@Override
public void updateMeasureState(TextPaint p) {
p.setTypeface(mTypeface);
// Note: This flag is required for proper typeface rendering
p.setFlags(p.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
}
@Override
public void updateDrawState(TextPaint tp) {
tp.setTypeface(mTypeface);
// Note: This flag is required for proper typeface rendering
tp.setFlags(tp.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
}
}
Et utilisez la classe comme ceci:
AppData = PreferenceManager.getDefaultSharedPreferences(this);
TextView bannertv= (TextView) findViewById(R.id.txtBanner);
SpannableString s = new SpannableString(getResources().getString(R.string.enterkey));
s.setSpan(new TypefaceSpan(this, AppData.getString("font-Bold",null)), 0, s.length(),
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
bannertv.setText(s);
peut-être cette aide.
Ici vous pouvez voir toutes les valeurs disponibles de fontFamily et le nom du fichier de police correspondant (utilisé par Android 5.0+). Dans l'appareil mobile, vous pouvez le trouver dans:
/system/etc/fonts.xml (pour 5.0+)
(Pour Android 4.4 et les versions antérieures, utilisez this version, mais je pense que fonts.xml a un format plus clair et facile à comprendre.)
Par exemple,
<!-- first font is default -->
20 <family name="sans-serif">
21 <font weight="100" style="normal">Roboto-Thin.ttf</font>
22 <font weight="100" style="italic">Roboto-ThinItalic.ttf</font>
23 <font weight="300" style="normal">Roboto-Light.ttf</font>
24 <font weight="300" style="italic">Roboto-LightItalic.ttf</font>
25 <font weight="400" style="normal">Roboto-Regular.ttf</font>
26 <font weight="400" style="italic">Roboto-Italic.ttf</font>
27 <font weight="500" style="normal">Roboto-Medium.ttf</font>
28 <font weight="500" style="italic">Roboto-MediumItalic.ttf</font>
29 <font weight="900" style="normal">Roboto-Black.ttf</font>
30 <font weight="900" style="italic">Roboto-BlackItalic.ttf</font>
31 <font weight="700" style="normal">Roboto-Bold.ttf</font>
32 <font weight="700" style="italic">Roboto-BoldItalic.ttf</font>
33 </family>
L'attribut name name="sans-serif" de la balise family a défini la valeur que vous pouvez utiliser dans Android: fontFamily.
La balise font définit les fichiers de polices correspondants.
Dans ce cas, vous pouvez ignorer la source sous <!-- fallback fonts -->, qui utilise la logique de secours des polices.
essayez ces étapes simples . 1. créer un dossier de polices dans le dossier res . 2. copier et coller le fichier .ttf dans le dossier de polices . 3. Maintenant, donnez le chemin en XML comme ci-dessous.
Android:fontFamily="@font/frutiger"
ou quel que soit votre nom de fichier . Thats it happy code