Wie man fontFamily von TextView in Android ändert

Also möchte ich den android:fontFamily wechseln android:fontFamily in Android aber ich sehe keine vordefinierten Fonts in Android. Wie wähle ich eine der vordefinierten aus? Ich muss nicht wirklich meine eigene TypeFace definieren, aber alles was ich brauche ist etwas anderes als das, was es jetzt 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, was ich dort gemacht habe, wird nicht wirklich funktionieren! BTW android:fontFamily="Arial" war ein dummer Versuch!

  • Android: TextView verknüpfen
  • Streaming-Bibliothek VLC Android
  • Android in Eclipse: Kopieren / Einfügen aus LogCat (nur "Text")
  • Diese App wird nicht ausgeführt, wenn Sie den Google Play-Dienstfehler nicht aktualisieren
  • Making RadioGroup Radio-Schaltflächen mit Bildern in Android ... Wie?
  • Warum benutzt man statische Helper-Methoden in Java schlecht?
  • Mit actionbar home als up-Taste, home-Aktivität saveInstanceState ist immer null
  • Anmelden "Java Library Code" libs für Android-Anwendungen
  • Android TV RecyclerView Fokus Interaktion
  • Recover-Datei in Android Studio?
  • Referenz android.target.classpath nicht gefunden
  • Android Fingerprint API und Private / Public Key
  • 24 Solutions collect form web for “Wie man fontFamily von TextView in Android ändert”

    Von Android 4.1 / 4.2 / 5.0 sind folgende Roboto Schriftfamilien verfügbar:

     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) 

    Bildbeschreibung hier eingeben

    in Kombination mit

     android:textStyle="normal|bold|italic" 

    Diese 16 Varianten sind möglich:

    • Roboto regelmäßig
    • Roboto kursiv
    • Roboto fett
    • Roboto fett kursiv
    • Roboto-Licht
    • Roboto-Licht kursiv
    • Roboto-Dünn
    • Roboto-Thin kursiv
    • Roboto-kondensiert
    • Roboto-kondensiert kursiv
    • Roboto-kondensiert fett
    • Roboto-kondensiert fett kursiv
    • Roboto-Schwarz
    • Roboto-Schwarz kursiv
    • Roboto-Medium
    • Roboto-Mittel kursiv

    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> 

    Dies ist der Weg, um die Schriftart programmgesteuert einzustellen:

     TextView tv = (TextView) findViewById(R.id.appname); Typeface face = Typeface.createFromAsset(getAssets(), "fonts/epimodem.ttf"); tv.setTypeface(face); 

    Legen Sie die Schriftart-Datei in Ihren Assets-Ordner. In meinem Fall habe ich ein Unterverzeichnis namens Schriften erstellt.

    EDIT: Wenn Sie sich fragen, wo ist Ihr Assistent Ordner sehen Sie diese Frage

    Ich musste in einem neueren projekt /system/etc/fonts.xml analysieren. Hier sind die aktuellen Schriftfamilien von 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 (basiert 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 obige Klasse in Ihrem Projekt zu verwenden. Zum Beispiel könnten Sie Ihren Benutzern eine Auswahl an Schriftfamilien geben und die Schriftart anhand ihrer Präferenz 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(); 

    Android erlaubt es Ihnen nicht, benutzerdefinierte Schriftarten aus dem XML-Layout festzulegen. Stattdessen müssen Sie die jeweilige Font-Datei im Assets-Ordner Ihrer App bündeln und sie programmgesteuert einstellen. 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 Fonts von Android unterstützt und sollten in einem .ttf (TrueType) oder .otf (OpenType) Format sein. Sogar dann können einige Schriften nicht funktionieren.

    Dies ist eine Schriftart, die definitiv auf Android funktioniert, und Sie können dies verwenden, um zu bestätigen, dass Ihr Code funktioniert, falls Ihre Schriftart-Datei nicht von Android unterstützt wird.

    Android O Update: Dies ist jetzt möglich mit XML in Android O , basierend auf Rogers Kommentar.

    Es ist das gleiche wie android:typeface .

    Eingebaute Schriften sind:

    • normal
    • Sans
    • Serif
    • Monospace

    Siehe android: Schriftbild .

    Um Roboto programmgesteuert einzustellen:

     paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL)); 

    Wenn du es programmatisch möchtest, kannst du es benutzen

     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 auf Android-Entwicklern angegeben

    Ich benutze ausgezeichnete Bibliothek Kalligraphie von Chris Jenx entworfen, damit Sie benutzerdefinierte Schriften in Ihrem Android-Anwendung verwenden können. Versuche es!

    Was du willst, ist nicht möglich Sie müssen TypeFace in Ihrem Code setzen müssen.

    In XML was du tun kannst, ist

     android:typeface="sans" | "serif" | "monospace" 

    Andere dann kannst du nicht viel mit den Fonts in XML spielen. 🙂

    Für Arial musst du Typ Gesicht in deinem Code setzen.

    Ein einfacher Weg, um die Schriften zu verwalten wäre, um sie über Ressourcen zu erklären, als solche:

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

    Dies basiert auf dem Quellcode hier und hier

    Ich habe eine kleine Bibliothek namens Foundry , die Sie verwenden können, um benutzerdefinierte Schriften durch XML-Layouts und Stile anzuwenden.

    Mit etwas Versuch und Irrtum lernte ich folgendes.

    Innerhalb der * .xml können Sie die Stock Fonts mit den folgenden Funktionen kombinieren, nicht nur mit Schriftart:

      android:fontFamily="serif" android:textStyle="italic" 

    Mit diesen beiden Stilen gab es keine Notwendigkeit, Schriftart in jedem anderen Fall zu verwenden. Die Kombination von Kombinationen ist viel größer mit fontfamily & textStyle.

    Der gültige Wert von android: fontFamily ist definiert in /system/etc/system_fonts.xml(4.x) oder /system/etc/fonts.xml(5.x). Aber der Gerätehersteller kann es ändern, so dass die tatsächliche Schriftart, die durch die Einstellung fontFamily Wert verwendet wird, von der oben erwähnten Datei des angegebenen Geräts abhängt.

    In AOSP ist die Arial-Schriftart gültig, muss aber mit "arial" nicht "Arial" definiert werden, zB android: fontFamily = "arial" . Haben Sie einen Qucik Blick auf Kitkat's 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 für die Definition einer "Schriftart" im Layout – android: fontFamily , android: Schriftart und Android: textStyle . Die Kombination von "fontFamily" und "textStyle" oder "Schriftart" und "textStyle" kann verwendet werden, um das Erscheinungsbild von Schriftart 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:

    1. Wenn "fontFamily" gesetzt ist, wird die "Schriftart" ignoriert.
    2. "Schriftbild" hat standardisierte und begrenzte gültige Werte. In der Tat sind die Werte "normal" "sans" "serif" und "monospace", sie können in system_fonts.xml (4.x) oder fonts.xml (5.x) gefunden werden. Eigentlich sind sowohl "normal" als auch "sans" die Standardschriftart des Systems.
    3. "FontFamily" kann verwendet werden, um alle Schriftarten von eingebauten Schriftarten festzulegen, während "Schriftbild" nur die typischen Schriftarten von "sans-serif" "serif" und "monospace" (die drei Hauptkategorien der Schriftart in der Welt) .
    4. Wenn nur "textStyle" gesetzt ist, setzen wir tatsächlich die Standardschriftart und den angegebenen Stil. Der effektive Wert ist "normal" "fett" "kursiv" und "fett kursiv".
     <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> 

    Es ist zu früh jetzt aber

    Ausgehend von Android-O seine sehr einfach zu ändern Schriftfamilie

    Erstellen Sie eine Ordner- font unter res Verzeichnis. Laden Sie die Schriftart, die immer Sie wollen und fügen Sie es in font Ordner. Die Struktur sollte etwas wie unten sein

    Hier

    Um deine eigene Schriftfamilie zu erstellen

    Klicken Sie mit der rechten Maustaste auf den Font-Ordner und gehen Sie zu Neu> Schriftart-Ressourcendatei . Das Fenster Neue Ressource-Datei wird angezeigt.

    Geben Sie den Dateinamen ein und klicken Sie dann auf OK . Die neue Font-Ressource XML öffnet sich im Editor.

    Schreiben Sie hier 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> 

    1. Um Schriftfamilie im Layout zu ändern, kannst du schreiben

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

    2. Programmatisch ändern

      Typeface typeface = getResources().getFont(R.font.myfont); textView.setTypeface(typeface); 

    Weitere Informationen finden Sie in der Dokumentation

    Das ist auch eine gute Bibliothek RobotoTextView . Es bedient wirklich Ihre Bedürfnisse.

    Sie setzen 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 verwenden Sie diesen Stil in main.xml Datei verwenden:

     style="@style/boldText" 

    Hier ist eine einfachere Wa y, die in einigen Fällen arbeiten kann. Das Prinzip ist, eine nicht sichtbare TextVview in Ihrem XML-Layout hinzuzufügen und seinen TypFace im Java-Code zu erhalten.

    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 gearbeitet (in einem TextSwitcher zum Beispiel).

    Wenn du einen TextView an so vielen Orten mit derselben Schriftfamilie verwenden möchtest, verlängere die TextView-Klasse und setze deine Schriftart so 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 benutze diese benutzerdefinierte Klasse in xml für die TextView 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" /> 

    Dynamisch können Sie die fontfamily ähnlich wie android: fontFamily in xml, indem Sie diese,

     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 Standard-Schriftfamilie verwendet, verwenden Sie eine von diesem, indem Sie die doppelte Anführungszeichenfolge "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" ist die ttf-Datei. Pfad wird in src / assets / fonts / mycustomfont.ttf sein , können Sie mehr über Standard-Schriftart in dieser Standard-Schriftfamilie verweisen

    Hier sehen Sie alle verfügbaren FontFamily-Werte und es sind die Namen der Font-Schriftart (Diese Datei wird in Android 5.0+ verwendet). Im mobilen Gerät findest du es in:

    /system/etc/fonts.xml (für 5.0+)

    (Für Android 4.4 und unten mit dieser Version, aber ich denke, dass fonts.xml hat ein fonts.xml Format und leicht zu verstehen.)

    Beispielsweise,

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

    Der Namensattribut name="sans-serif" des family Tags definierte den Wert, den du in android verwenden kannst: fontFamily.

    Der font Tag definiert die entsprechenden Schriftartdateien.

    In diesem Fall kannst du die Quelle unter <!-- fallback fonts --> ignorieren, die es für die Fallback-Logik der Schriftarten verwendet.

    Ich benutze Letter Press lib für meine NonTextView Zeug wie Buttons und Kianoni Fontloader lib für meine TextViews Ursache der Verwendung von Stil in diesem lib ist einfacher als Letter Press für mich und ich habe ein ideales Feedback mit dem. Dies ist ideal für diejenigen, die benutzerdefinierte Schrift verwenden möchten, außer Roboto Font. So war es meine Erfahrung mit font libs. Für diejenigen, die benutzerdefinierte Klasse für Änderungsschrift verwenden möchten, empfehle ich, diese Klasse mit diesem Snippet zu erstellen

     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 diese

     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

    Sie können es einfach machen, 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" /> 

    Seine leichte und einfach zu implementieren, kopieren Sie einfach Ihre Fonts in Asset-Ordner und verwenden Sie den Namen in xml.

    Ich möchte nur erwähnen, dass die Hölle mit den Schriften in Android ist zu Ende, denn in diesem Jahr auf Google IO haben wir endlich diese -> https://developer.android.com/preview/features/working-with-fonts. Html

    Jetzt gibt es eine neue Ressource-Typ eine Schriftart und Sie können alle Ihre Anwendungs-Schriften in Res / Fonts Ordner und Zugriff dann mit R.font.my_custom_font, so wie Sie auf String- Res-Werte, ziehbare Res-Werte etc. zugreifen können Sie haben sogar Chance Um Font-Face- XML-Datei zu erstellen, die von Ihren benutzerdefinierten Schriften gesetzt wird (über kursiv, fett und unterstreichen attr).

    Lesen Sie den Link oben für weitere Informationen. Lass uns die Unterstützung sehen.

    Das Android ist ein Google Android Fan-Website, Alles über Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.