Comment changer fontFamily de TextView en Android
donc j'aimerais changer le android:fontFamily dans Android mais je ne vois pas de polices prédéfinies dans Android. Comment puis-je choisir l'une des réponses prédéfinies? Je n'ai pas vraiment besoin de définir ma propre police de caractère mais tout ce dont j'ai besoin c'est quelque chose de différent de ce qu'il montre en ce 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à-haut ne marchera pas vraiment! BTW android:fontFamily="Arial" était une tentative stupide!
25 réponses
à Partir de android 4.1 / 4.2 / 5.0 les suivants 151950920" Roboto familles de polices de caractères 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égulière
- Roboto " italique
- Roboto bold
- Roboto gras italique
- Roboto-Lumière
- Roboto-Light italic
- Roboto-Mince
- Roboto-Thin italic
- Roboto-Résumés
- Roboto-Condensed italic
- Roboto-Condensed bold
- Roboto-Condensed bold italic
- Roboto-Noir
- Roboto-Black italique
- Roboto-Moyen
- 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>
c'est la façon de programmer la police:
TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
"fonts/epimodem.ttf");
tv.setTypeface(face);
placez le fichier de police dans le dossier de vos biens. Dans mon cas, j'ai créé un sous-répertoire appelé polices.
EDIT: Si vous vous demandez où en est votre dossier des actifs, voir cette question
j'ai dû analyser /system/etc/fonts.xml dans un projet récent. Voici les familles de polices 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 le parser (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 caractères et définir le caractère en fonction de leur préférence.
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 sa famille de polices de caractères très facile à changer
en utilisant la bibliothèque de soutien 26, il fonctionnera sur les appareils exécutant L'API Android version 16 et plus
créer un dossier font sous res répertoire .Téléchargez la police que vous voulez et collez-la dans le dossier font . La structure devrait être quelque chose comme ci-dessous
maintenant vous pouvez changer la police dans layout using
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/dancing_script"/>
pour changer programmatically
Typeface typeface = getResources().getFont(R.font.myfont);
textView.setTypeface(typeface);
pour changer la police en utilisant styles.xml créer un style
<style name="Regular">
<item name="android: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 aussi Créer votre propre famille de police
- cliquez avec le bouton droit de la souris sur le dossier de police et passez à nouveau > fichier de ressources de police . La nouvelle fenêtre du fichier ressource apparaît.
- Entrez le nom de fichier , puis cliquez sur OK . La nouvelle ressource de police XML s'ouvre dans l'éditeur.
écrivez votre propre police famille 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>
, c'est simplement une cartographie spécifique, fontStyle et fontWeight à la ressource de police qui sera utilisée pour rendre cette variante spécifique. Les valeurs valides pour fontStyle sont normales ou en italique; et fontWeight est conforme à la spécification CSS font-weight
1. à changer famille de fontfamille en layout vous peut écrire
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/lobster"/>
2. Pour Changer Programmatically
Typeface typeface = getResources().getFont(R.font.myfont);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
textView.setTypeface(typeface);
Note: à partir de la bibliothèque de Soutien Android 26.0, vous devez déclarer les deux ensembles d'attributs (android: et app:) pour assurer la charge de vos polices sur les appareils en cours d'exécution Api 26 ou plus bas.
<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<font android:fontStyle="normal" android:fontWeight="400" android:font="@font/myfont-Regular"
app:fontStyle="normal" app:fontWeight="400" app:font="@font/myfont-Regular"/>
<font android:fontStyle="italic" android:fontWeight="400" android:font="@font/myfont-Italic"
app:fontStyle="italic" app:fontWeight="400" app:font="@font/myfont-Italic" />
</font-family>
pour changer la police de l'application complète ajouter 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 la Documentation , tutoriel de polices personnalisées pour plus d'information
Android ne vous permet pas de définir des polices personnalisées à partir de la disposition XML. À la place, vous devez regrouper le fichier de police spécifique dans le dossier assets de votre application et le programmer. 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 que setContentView() a été appelé. De plus, seules certaines polices sont supportées par Android, et devraient être dans un format .ttf (TrueType) ou .otf (OpenType) . Même alors, certaines polices peuvent ne pas fonctionner.
cette est une police qui fonctionne certainement sur Android, et vous pouvez l'utiliser pour confirmer que votre code fonctionne au cas où votre fichier de police n'est pas pris en charge par Android.
mise à jour Android O: c'est maintenant possible avec XML dans Android O , basé sur le commentaire de Roger.
c'est la même chose que android:typeface .
polices intégrées sont:
- normal
- sans
- serif
- monospace
Voir android:police de caractères .
pour programmer Roboto:
paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
si vous le souhaitez programmatically, vous pouvez utiliser
label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);
où SANS_SERIF vous pouvez utiliser:
-
DEFAULT -
DEFAULT_BOLD -
MONOSPACE -
SANS_SERIF -
SERIF
et où ITALIC vous pouvez utiliser:
-
BOLD -
BOLD_ITALIC -
ITALIC -
NORMAL
Tout est dit sur les Développeurs Android
j'utilise une excellente bibliothèque Calligraphie par Chris Jenx conçu pour vous permettre d'utiliser des polices personnalisées dans votre application android. Essayez-le!
Ce que vous voulez n'est pas possible. Vous devez définir TypeFace dans votre Code.
Dans XML ce que vous pouvez faire est de
android:typeface="sans" | "serif" | "monospace"
autre alors cela, vous ne pouvez pas jouer beaucoup avec les polices en XML. :)
pour Arial vous devez taper face dans votre code.
un moyen facile de gérer les polices serait de les déclarer via des ressources, en tant que telles:
<!--++++++++++++++++++++++++++-->
<!--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 la famille fontfamily similaire à 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));
ce sont la liste de font par défaut famille utilisée, utilisez n'importe laquelle de ceci en remplaçant la chaîne de double guillemets "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. chemin sera en src/assets/fonts / mycustomfont.ttf , vous pouvez en savoir plus sur la police par défaut dans cette famille de polices par défaut
j'ai fait une petite bibliothèque nommée Foundry que vous pouvez utiliser pour appliquer des polices de caractères personnalisées à travers des mises en page et des styles XML.
avec quelques essais et erreurs j'ai appris ce qui suit.
dans le *.vous pouvez combiner les polices de caractères avec les fonctions suivantes, et pas seulement avec le caractère:
android:fontFamily="serif"
android:textStyle="italic"
avec ces deux styles, il n'était pas nécessaire d'utiliser la police de caractère dans un autre cas. La gamme de combinaisons est beaucoup plus grande avec fontfamily&textStyle.
la valeur valide de android:fontFamily est définie dans /system/etc/system_fonts.xml (4.x) ou /system/etc/fonts.xml (5.x). Mais le fabricant du périphérique peut le modifier, de sorte que la police utilisée en définissant la valeur fontFamily dépend du fichier mentionné ci-dessus du périphérique spécifié.
dans AOSP, la police Arial est valide mais doit être définie en utilisant" arial "et non" Arial", par exemple android:fontFamily=" arial " . Avoir un qucik regarder Kitkat est system_fonts.xml
<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 y a trois attributs xml pertinents pour définir une" police "dans la mise en page-- android:fontFamily , android:typeface et android:textStyle . La combinaison de "fontFamily" et "textStyle" ou "typeface" et "textStyle" peut être utilisée pour changer l'apparence de la police texte, utilisé seul. 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);
}
}
du code on peut voir:
- si "fontFamily" est défini, alors la "police de caractère" sera ignorée.
- "police" a standard et limitée à des valeurs valides. En fait, les valeurs sont "normaux" "sans" "serif" et "monospace", ils peuvent être trouvés dans system_fonts.xml (4.x) ou les polices de caractères.xml (5.x). En fait à la fois "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 seulement les polices typiques de "sans-serif" "serif"et" monospace " (les trois principales catégories de type de police dans le monde).
- lorsque seulement défini "textStyle", nous avons en fait défini la police par défaut et le style spécifié. La valeur effective sont "normaux" "bold" "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>
c'est aussi une bonne bibliothèque RobotoTextView . Il sert vraiment à vos besoins.
vous mettez le style dans res/layout/value/style.xml comme ça:
<style name="boldText">
<item name="android:textStyle">bold|italic</item>
<item name="android:textColor">#FFFFFF</item>
</style>
et d'utiliser ce style dans main.xml utilisation du fichier:
style="@style/boldText"
voici un plus facile wa y qui peut fonctionner dans certains cas. Le principe est d'ajouter un TextVview non visible dans votre mise en page xml et à d'obtenir son caractère dans le code java.
la disposition 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).
si vous voulez utiliser un TextView dans tant d'endroits avec la même famille de polices, étendez la classe TextView et définissez votre police comme ceci: -
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 ensuite utiliser 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"
/>
je veux juste mentionner que l'enfer avec les polices à L'intérieur D'Android est sur le point de finir, parce que cette année sur Google IO nous avons finalement obtenu ce - > https://developer.android.com/preview/features/working-with-fonts.html
maintenant il y a une nouvelle ressource de type a font et vous pouvez placer toutes vos polices d'application dans res/fonts folder et accéder ensuite avec R. font.my_custom_font, tout comme vous pouvez accéder à chaîne res valeurs, drawable res valeurs, etc. Vous avez même la possibilité de créer font-face fichier xml, qui va être mis de vos polices personnalisées (à propos de italic, bold et underline attr).
lire le lien ci-dessus pour plus d'informations. Nous allons voir le support.
Ici vous pouvez voir tous les disponible fontFamily valeurs et ses fichier de police de noms(Ce fichier est à utiliser dans android 5.0+). Dans mobile device, Vous pouvez le trouver dans:
/system/etc / fonts.xml (5.0+)
(pour android 4.4 et inférieur en utilisant cette" version 151980920", 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 de nom name="sans-serif" de family tag défini la valeur que vous pouvez utiliser dans android:fontFamily.
la balise font définit les fichiers de police correspondants.
dans ce cas, vous pouvez ignorer la source sous <!-- fallback fonts --> , elle utilise la logique de repli des polices.
j'utilise lettre Press lib pour mon nontextview trucs comme des boutons et kianoni fontloader lib pour mes TextViews cause de l'utilisation du style dans cette lib est plus facile que Lettre Press pour moi et j'ai obtenu un retour idéal avec cela. c'est parfait pour ceux qui veulent utiliser une police personnalisée, sauf la police Roboto. donc c'était mon expérience avec font libs. pour ceux qui veulent utiliser la classe personnalisée pour modifier la police j'ai fortement recommandé de créer cette classe avec cet extrait (151970920 )"
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 utiliser une classe comme celle-ci
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.
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" />
son poids léger et facile à mettre en œuvre, il suffit de copier vos polices dans le dossier de l'actif et utiliser le nom en xml.
essayez ces étapes simples. 1. créer un dossier de police dans le dossier res. 2. copier et coller .ttf fichier dans le dossier de police. 3. Maintenant, donnez le chemin en xml comme ci-dessous.
android:fontFamily="@font/frutiger"
ou quel que soit votre nom de fichier. C'est tout heureux de code