Ich möchte also den Android:fontFamily
in Android ändern, sehe aber keine vordefinierten Schriftarten in Android. Wie wähle ich eine der vordefinierten aus? Ich muss nicht wirklich mein eigenes TypeFace definieren, aber alles was ich brauche ist etwas anderes als das, was es gerade zeigt.
<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"
/>
Es scheint, dass das, was ich dort oben gemacht habe, nicht wirklich funktioniert! Übrigens war Android:fontFamily="Arial"
ein blöder Versuch!
Von Android 4.1/4.2/5.0 stehen die folgenden Roboto Schriftfamilien zur Verfügung:
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)
in Kombination mit
Android:textStyle="normal|bold|italic"
diese 16 Varianten sind möglich:
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>
So können Sie die Schrift programmgesteuert einstellen:
TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
"fonts/epimodem.ttf");
tv.setTypeface(face);
legen Sie die Schriftartdatei in Ihrem Assets-Ordner ab. In meinem Fall habe ich ein Unterverzeichnis mit dem Namen fonts erstellt.
EDIT: Wenn Sie sich fragen, wo sich Ihr Assets-Ordner befindet, sehen Sie diese Frage
Ich musste /system/etc/fonts.xml
in einem aktuellen Projekt analysieren. Hier sind die aktuellen Schriftfamilien ab 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 ║
╚════╩════════════════════════════╩═════════════════════════════╝
Hier ist der Parser (basierend auf 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;
}
}
}
Fühlen Sie sich frei, die oben genannte Klasse in Ihrem Projekt zu verwenden. Sie können Ihren Benutzern beispielsweise eine Auswahl von Schriftfamilien geben und die Schriftart nach ihren Vorlieben festlegen.
Ein kleines unvollständiges Beispiel:
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();
Ab Android-Studio 3.0 ist es sehr einfach, die Schriftfamilie zu ändern
Mit der Support-Bibliothek 26 funktioniert sie auf Geräten, auf denen Android API Version 16 und höher ausgeführt wird
Erstellen Sie einen Ordner font
im Verzeichnis res
. Laden Sie die gewünschte Schriftart herunter und fügen Sie sie in den Ordner font
ein. Die Struktur sollte wie folgt aussehen
Hinweis: Ab der Android Support Library 26.0 müssen Sie beide Attributsätze (Android: und app:) deklarieren, um sicherzustellen, dass die Schriftarten auf Geräten geladen werden, auf denen .__ ausgeführt wird. Api 26 oder niedriger.
Nun können Sie die Schriftart in layout mit ändern
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:fontFamily="@font/dancing_script"
app:fontFamily="@font/dancing_script"/>
Programmgesteuert ändern
Typeface typeface = getResources().getFont(R.font.myfont);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
textView.setTypeface(typeface);
Um die Schriftart mit styles.xml zu ändern, erstellen Sie einen Stil
<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>
und wende diesen Stil auf TextView
an
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
style="@style/Regular"/>
sie können auch ein eigenes Schriftfamilie erstellen.
- Klicken Sie mit der rechten Maustaste auf den Schriftartenordner und wechseln Sie zu Neu> Schriftartressourcendatei. Das Fenster "Neue Ressourcendatei" wird angezeigt.
- Geben Sie das Dateiname ein und klicken Sie auf OK. Die neue XML-Schriftartressource wird im Editor geöffnet.
Schreiben Sie hier beispielsweise Ihre eigene Schriftfamilie
<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>
hierbei handelt es sich lediglich um die Zuordnung eines bestimmten fontStyle und fontWeight zu der Fontressource, die zum Rendern dieser bestimmten Variante verwendet wird. Gültige Werte für fontStyle sind normal oder kursiv. und fontWeight entspricht der CSS-Schriftgewichtsspezifikation
1. An ändern Schriftfamilie in Layout können Sie schreiben
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:fontFamily="@font/lobster"/>
2. Ändern programmgesteuert
Typeface typeface = getResources().getFont(R.font.lobster);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
textView.setTypeface(typeface);
An Schriftart der gesamten App ändern Fügen Sie diese beiden Zeilen in AppTheme hinzu
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<item name="Android:fontFamily">@font/your_font</item>
<item name="fontFamily">@font/your_font</item>
</style>
Weitere Informationen finden Sie im Documentation , Android Custom Fonts Tutorial
In Android können Sie keine benutzerdefinierten Schriftarten im XML-Layout festlegen. Sie müssen stattdessen die bestimmte Schriftartdatei im Asset-Ordner Ihrer App bündeln und programmgesteuert festlegen. So etwas wie:
TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);
Beachten Sie, dass Sie diesen Code nur ausführen können, nachdem setContentView () aufgerufen wurde. Außerdem werden nur einige Schriftarten von Android unterstützt und sollten das Format .ttf (TrueType)
oder .otf (OpenType)
haben. Selbst dann funktionieren manche Schriftarten möglicherweise nicht.
Dies ist eine Schriftart, die definitiv unter Android funktioniert, und Sie können dies verwenden, um zu bestätigen, dass Ihr Code funktioniert, falls Ihre Fontdatei nicht von Android unterstützt wird.
Android O Update: Dies ist jetzt mit XML in Android O möglich, basierend auf Rogers Kommentar.
Roboto programmgesteuert einstellen:
Paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
Es ist dasselbe wie Android:typeface
.
integrierte Schriftarten sind:
Siehe Android: Schrift .
Wenn Sie es programmgesteuert wünschen, können Sie es verwenden
label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);
Wo SANS_SERIF
Sie verwenden können:
DEFAULT
DEFAULT_BOLD
MONOSPACE
SANS_SERIF
SERIF
Und wo ITALIC
Sie verwenden können:
BOLD
BOLD_ITALIC
ITALIC
NORMAL
Alles ist angegeben auf Android-Entwicklern
Ich verwende eine ausgezeichnete Bibliothek Kalligraphie von Chris Jenx, die Ihnen die Verwendung benutzerdefinierter Schriftarten in Ihrer Android-Anwendung ermöglicht. Versuche es!
Was Sie wollen, ist nicht möglich. Sie müssen in Ihrem Code TypeFace
einstellen.
In XML
können Sie Folgendes tun
Android:typeface="sans" | "serif" | "monospace"
andernfalls kann man mit den Schriftarten in XML nicht viel spielen. :)
Für Arial
müssen Sie in Ihrem Code den Typ face eingeben.
Eine einfache Möglichkeit zum Verwalten der Zeichensätze besteht darin, sie über Ressourcen als solche zu deklarieren:
<!--++++++++++++++++++++++++++-->
<!--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>
Dynamisch können Sie die Schriftfamilie ähnlich wie Android einstellen: fontFamily in xml, indem Sie dies verwenden,
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));
Dies ist die Liste der verwendeten Standardschriftart -Familie. Verwenden Sie eine beliebige davon, indem Sie die doppelte Anführungszeichenfolge "sans-serif-medium" ersetzen.
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" ist die ttf-Datei. Pfad wird in src/assets/fonts/mycustomfont.ttf angezeigt. Sie können mehr über die Standardschriftart in dieser Standardschriftfamilie verweisen.
Mit einigem Ausprobieren habe ich Folgendes gelernt.
Innerhalb der * .xml können Sie die Standardschriftarten mit den folgenden Funktionen kombinieren, nicht nur mit der Schrift:
Android:fontFamily="serif"
Android:textStyle="italic"
Bei diesen beiden Stilen war es in keinem anderen Fall erforderlich, die Schrift zu verwenden. Die Auswahl an Kombinationen ist mit der Schriftfamilie & TextStyle viel größer.
Der gültige Wert von Android: fontFamily ist in /system/etc/system_fonts.xml (4.x) oder /system/etc/fonts.xml (5.x) definiert. Der Gerätehersteller kann es jedoch ändern, sodass die tatsächliche Schriftart, die zum Festlegen des fontFamily-Werts verwendet wird, von der oben genannten Datei des angegebenen Geräts abhängt.
In AOSP ist die Schriftart Arial gültig, muss aber mit "arial" definiert werden, nicht mit "arial", zum Beispiel Android: fontFamily = "arial" . Werfen Sie einen Blick auf KitKats 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>
//////////////////////////////////////////// ////////////////////////
Es gibt drei relevante XML-Attribute zum Definieren einer "Schrift" in Layout - Android: fontFamily , Android: Schrift und Android: textStyle . Die Kombination aus "fontFamily" und "textStyle" oder "Schriftbild" und "TextStyle" kann verwendet werden, um das Erscheinungsbild der Schrift im Text zu ändern. Code-Snippet in TextView.Java wie folgt:
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);
}
}
Aus dem Code können wir sehen:
<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>
Wenn Sie TextView an so vielen Stellen mit derselben Schriftfamilie verwenden möchten, erweitern Sie die TextView-Klasse und stellen Sie Ihre Schriftart folgendermaßen ein:
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);
}
}
Und dann verwenden Sie diese benutzerdefinierte Klasse in XML für die Textansicht wie folgt: -
<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"
/>
Ich möchte nur erwähnen, dass die Hölle mit den Schriftarten in Android bald enden wird, denn in diesem Jahr haben wir bei Google IO endlich diese -> https://developer.Android.com/preview/features/ arbeiten-mit-fonts.html
Nun gibt es einen neuen Ressourcentyp, einen font, und Sie können alle Ihre Anwendungszeichensätze im res/fonts-Ordner ablegen und dann mit R.font.my_custom_font auf den Zugriff zugreifen, genau wie auf string. res-Werte, drawable res-Werte usw. Sie haben sogar die Möglichkeit, eine font-face xml-Datei zu erstellen, in der Ihre benutzerdefinierten Schriftarten (kursiv, fett und unterstrichen) gesetzt werden. .
Lesen Sie den Link oben für weitere Informationen. Lassen Sie uns die Unterstützung sehen.
Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);
stellen Sie die Schriftart einfach programmgesteuert auf eine beliebige Textansicht aus dem Verzeichnis res> font ein
Hier ist eine einfachere Wa y, die in einigen Fällen funktionieren kann. Das Prinzip ist, ein nicht sichtbares TextVview in Ihr XML-Layout einzufügen und dessen TypFace im Java-Code abzurufen.
Das Layout in der XML-Datei:
<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"/>
Und der Java-Code:
myText.setTypeface(textViewSelectedDescription.getTypeface());
Es hat für mich funktioniert (zB innerhalb eines TextSwitcher).
Sie setzen den Stil in res/layout/value/style.xml
so:
<style name="boldText">
<item name="Android:textStyle">bold|italic</item>
<item name="Android:textColor">#FFFFFF</item>
</style>
und diesen Stil in der main.xml
-Datei verwenden:
style="@style/boldText"
Sie können Standardschriften auch mit setTextAppearance
ändern (API 16 erforderlich), siehe 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);
}
Sie können dies auf einfache Weise tun, indem Sie folgende Bibliothek verwenden
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" />
es ist leicht und einfach zu implementieren. Kopieren Sie einfach Ihre Schriften in den Asset-Ordner und verwenden Sie den Namen in XML.
Hierfür steht eine Nice-Bibliothek zur Verfügung
implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
Der einfachste Weg die Schriftart programmatisch zu einer TextView hinzuzufügen ist, zunächst die Schriftartdatei im Ordner Assets des Projekts hinzuzufügen. Zum Beispiel sieht Ihr Schriftpfad so aus: assets/fonts/my_font.otf
Und fügen Sie es einer TextView hinzu als:
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);
Für Android-Studio 3 und höher können Sie diesen Stil verwenden und anschließend alle textView
-Schriftarten in der App ändern.
erstellen Sie diesen Stil in Ihrem style.xml
:
<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="Android:Widget.TextView">
<item name="Android:fontFamily">@font/your_custom_font</item>
</style>
Dann verwenden Sie es in Ihrem Thema:
<!-- 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>
Versuche dies:
TextView textview = (TextView) findViewById(R.id.textview);
Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);
Ich benutze Letter Press lib für meine NonTextView-Sachen wie Buttons und kianoni fontloader lib für meine TextViews. Die Verwendung von Stil in dieser Lib ist für mich einfacher als Letter Press und ich habe damit ein ideales Feedback. Dies ist großartig für diejenigen, die eine benutzerdefinierte Schriftart verwenden möchten, mit Ausnahme von Roboto Font . Ich hatte also Erfahrung mit Font-Libs . Für diejenigen, die eine benutzerdefinierte Klasse für die Änderung der Schriftart verwenden möchten, empfahl ich dringend, diese zu erstellen klasse mit diesem schnipsel
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);
}
}
Und benutze Klasse wie folgt:
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);
vielleicht diese hilfe.
Hier können Sie alle verfügbaren fontFamily-Werte und deren Namen sehen (Diese Datei wird in Android 5.0 und höher verwendet). In mobilen Geräten finden Sie es in:
/system/etc/fonts.xml (für 5.0+)
(Für Android 4.4 und darunter wird this verwendet, aber ich denke, dass fonts.xml
ein klareres Format hat und leicht verständlich ist.)
Zum Beispiel,
<!-- 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>
Das Namensattribut name="sans-serif"
des family
-Tags hat den Wert definiert, den Sie in Android verwenden können: fontFamily.
Das font
-Tag definiert die entsprechenden Zeichensatzdateien.
In diesem Fall können Sie die Quelle unter <!-- fallback fonts -->
ignorieren, die für die Fallback-Logik der Schriftarten verwendet wird.
probieren Sie diese einfachen Schritte aus ... 1. Erstellen Sie den Zeichensatzordner im Ordner res .. 2. Kopieren Sie die .ttf-Datei und fügen Sie sie in den Schriftartenordner ein. 3. Nun geben Sie den Pfad in xml wie folgt an.
Android:fontFamily="@font/frutiger"
oder was auch immer dein Dateiname ist . Das ist es glücklich Code