So ändern Sie fontFamily von TextView in Android

740

Ich möchte das android:fontFamilyin Android ändern, sehe aber keine vordefinierten Schriftarten in Android. Wie wähle ich eine der vordefinierten aus? Ich muss mein eigenes TypeFace nicht wirklich 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 getan habe, nicht wirklich funktioniert! Übrigens android:fontFamily="Arial"war ein dummer Versuch!

Tarik
quelle
Schauen
duggu

Antworten:

1660

Ab Android 4.1 / 4.2 / 5.0 sind die folgenden 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)

Geben Sie hier die Bildbeschreibung ein

in Kombination mit

android:textStyle="normal|bold|italic"

Diese 16 Varianten sind möglich:

  • Roboto regelmäßig
  • Roboto kursiv
  • Roboto mutig
  • Roboto fett kursiv
  • Roboto-Light
  • Roboto-Light kursiv
  • Roboto-Thin
  • Roboto-Thin kursiv
  • Roboto-kondensiert
  • Roboto-Condensed kursiv
  • Roboto-Condensed fett
  • Roboto-Condensed fett kursiv
  • Roboto-Schwarz
  • Roboto-Schwarz kursiv
  • Roboto-Medium
  • Roboto-Medium 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>
Jakob Eriksson
quelle
17
Vergiss das nicht: android: fontFamily = "serifenlos-dünn" // roboto thin
Sam Lu
6
Ich habe im Roboto-Musterbuch eine Variante namens "Black Small Caps" gesehen , aber ich schaffe es nicht, sie zu verwenden. Verwenden android:fontFamily="sans-serif-black-small-caps"funktioniert nicht. Weiß jemand Bescheid?
Bruyelle
3
Ich kann keine dieser Schriftfamilien finden, die Sie hier eingegeben haben. Ich kann "serifenlos" nicht zusammen finden.
Monty
9
Dies ist eine schöne Liste. Hat jemand einen Link, woher diese Informationen stammen? Es wäre schön, wenn Google dies in seiner Dokumentation an einem leicht zu findenden Ort hätte, beispielsweise für die Dokumentation von android:fontFamilyauf TextView.
Christopher Perry
8
Die endgültige Liste der Schriftarten finden Sie in system_fonts.xml, wie hier
Newtonx
207

Auf diese Weise können Sie die Schriftart 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 namens fonts erstellt.

BEARBEITEN: Wenn Sie sich fragen, wo sich Ihr Assets-Ordner befindet, lesen Sie diese Frage

Stefan Beike
quelle
34
Beachten Sie dabei, dass dies zu einem Speicherverlust führen kann . Es kann mit dieser Antwort behoben werden .
Charles Madere
@ ScootrNova Ich erhalte diesen Fehler, wenn ich Ihre Lösung verwende. Fehler: Schriftart Asset nicht gefunden gothic.ttf
Sagar Devanga
Wie wende ich das auf die gesamte App an? Im Moment im Beispiel wenden Sie es nur auf Textansicht an
Pritish Joshi
178

Ab Android-Studio 3.0 sehr einfach, die Schriftfamilie zu ändern

Mit der Support-Bibliothek 26 funktioniert es auf Geräten mit Android API Version 16 und höher

Erstellen Sie einen Ordner fontunter dem resVerzeichnis. Laden Sie die gewünschte Schriftart herunter und fügen Sie sie in den fontOrdner ein. Die Struktur sollte ungefähr so ​​aussehen wie unten

Hier

Hinweis: Ab Android Support Library 26.0 müssen Sie beide Attributgruppen (android: und app :) deklarieren, um sicherzustellen, dass Ihre Schriftarten auf Geräten mit Api 26 oder niedriger geladen werden.

Jetzt können Sie die Schriftart im Layout mit ändern

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

Programmatisch ä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 an TextView

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    style="@style/Regular"/>

Sie können auch Ihre eigene Schriftfamilie erstellen

- Klicken Sie mit der rechten Maustaste auf den Schriftartenordner und gehen Sie zu Neu> Schriftressourcendatei . Das Fenster Neue Ressourcendatei wird angezeigt.

- Geben Sie den Dateinamen 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>

Dies ist einfach eine Zuordnung eines bestimmten fontStyle und fontWeight zu der Schriftartressource, die zum Rendern dieser bestimmten Variante verwendet wird. Gültige Werte für fontStyle sind normal oder kursiv. und fontWeight entspricht der CSS-Spezifikation für die Schriftgröße

1. Um die Schriftfamilie im Layout zu ändern, können Sie schreiben

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

2. Programmgesteuert ändern

 Typeface typeface = getResources().getFont(R.font.lobster);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
 textView.setTypeface(typeface);  

So ändern Sie die Schriftart der gesamten App 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>

Sehen Sie die Dokumentation , Android benutzerdefinierten Schriftarten Tutorial Für weitere Informationen

Manohar Reddy
quelle
7
NB: Dies funktioniert derzeit nur in der Android Studio 3.0-Vorschau. Unter Android Studio 2.3.3 hat es bei mir nicht funktioniert. Hoffe das spart jemandem etwas Zeit!
Tash Pemhiwa
2
Wie können Sie die Schriftart aus einem Fragment heraus erhalten, da Sie dies nicht einfach tun können getResources()? EDIT : Diese Zeile am Ende Ihrer Antwort hat bei mir funktioniert: Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
Paradox
Irgendwie sah die Schrift in meinem Fall im Vergleich zu Caligtraphy beschädigt aus. Auch fontWeight macht nichts
Leo Droidcoder
@LeoDroidcoder es funktioniert, stellen Sie sicher, dass Sie beide android:fontWeightundapp:fontWeight
Manohar Reddy
Ich habe mehrmals nachgesehen. Es gibt keine Wirkung.
Leo Droidcoder
100

Ich musste /system/etc/fonts.xmlkürzlich ein 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 Wünschen 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();
Jared Rummler
quelle
Wissen Sie vielleicht, welche Android-Version welche Schriftart hinzugefügt hat?
Android-Entwickler
@androiddeveloper Ich nicht. Sie könnten es wahrscheinlich herausfinden, indem Sie die Änderungen hier ansehen
Jared Rummler
@ JaredRummler, vergib mir meine Unwissenheit. Warum / Was ist Gewicht == 400?
Samuel
1
@Samuel Ich habe mir diesen Code schon eine Weile nicht mehr angesehen, aber für "normale" oder "normale" Schriftarten wird eine Schriftgröße von 400 verwendet. Beispiel, Roboto-Regular hat ein Gewicht von 400.
Jared Rummler
Benötigt dies root oder so? Ich habe diesen Code auf dem Android-Emulator (Version 8.1) ausgeführt und als ich anrief getSystemFonts(), bekam ich eine Ausnahmeorg.xmlpull.v1.XmlPullParserException: END_TAG expected (position:START_TAG (empty) <axis tag='wdth' stylevalue='100.0'>@219:51 in java.io.InputStreamReader@f001fb3)
Damn Vegetables
49

In Android können Sie keine benutzerdefinierten Schriftarten aus dem XML-Layout festlegen. Stattdessen müssen Sie die spezifische Schriftartdatei im Assets-Ordner Ihrer App bündeln und programmgesteuert festlegen. 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 erst ausführen können, nachdem setContentView () aufgerufen wurde. Außerdem werden nur einige Schriftarten von Android unterstützt und sollten in einem .ttf (TrueType)oder .otf (OpenType)Format vorliegen. Selbst dann funktionieren einige Schriftarten möglicherweise nicht.

Dies ist eine Schriftart, die definitiv unter Android funktioniert. Mit dieser Schriftart können Sie bestätigen, dass Ihr Code funktioniert, falls Ihre Schriftartdatei von Android nicht unterstützt wird.

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

Raghav Sood
quelle
"Mit Android können Sie keine benutzerdefinierten Schriftarten aus dem XML-Layout festlegen." Dies wurde in Android O geändert, wodurch Sie eine benutzerdefinierte Schriftfamilie erstellen und in XML anwenden können: developer.android.com/preview/features/working-with-fonts.html
Roger Huang
27

So programmieren Sie Roboto programmgesteuert:

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
Oded Breiner
quelle
25

Es ist das gleiche wie android:typeface.

Integrierte Schriftarten sind:

  • normal
  • ohne
  • Serife
  • Monospace

Siehe Android: Schrift .

biegleux
quelle
4
Ich denke nicht, dass es dasselbe ist, aber es scheint, dass wir nicht beide verwenden können. Es scheint, dass jetzt nicht weniger als drei verschiedene Attribute zugeordnet sind setTypeface(). Nämlich fontFamily, typefaceund textStyle. Aber ich kann für mein ganzes Leben nicht herausfinden, wie diese genau kombiniert werden, um eine konkrete Schriftinstanz aufzulösen. Hat jemand das herausgefunden? Googles Dokumentation ist weniger als hilfreich ...
Rad Haring
23

Wenn Sie es programmgesteuert möchten, können Sie es verwenden

label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);

Wo SANS_SERIFSie verwenden können:

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

Und wo können ITALICSie verwenden:

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

Alles ist auf Android-Entwicklern angegeben

Joaquin Iurchuk
quelle
15

Ich verwende eine ausgezeichnete Bibliothek Kalligraphie von Chris Jenx, mit der Sie benutzerdefinierte Schriftarten in Ihrer Android-Anwendung verwenden können. Versuche es!

Gauravdott
quelle
yep, aber zum Beispiel möchte ich es functionanl verwenden, wollte aber nicht alle Bibliothek implementieren;)
Morozov
12

Was Sie wollen, ist nicht möglich. Sie müssen TypeFaceIhren Code festlegen .

In XMLwas Sie tun können , ist

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

Ansonsten kann man mit den Fonts in XML nicht viel spielen. :) :)

Denn ArialSie müssen in Ihrem Code die Schriftart eingeben.

Mohsin Naeem
quelle
11

Eine einfache Möglichkeit, die Schriftarten zu verwalten, 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>

Dies basiert hier und hier auf dem Quellcode

Android-Entwickler
quelle
Wo soll man sie deklarieren?
AZ_
@AZ_ Wie viele Ressourcendateien können Sie diese in eine beliebige XML-Datei im Ordner "res / values ​​/" einfügen. Fügen Sie es beispielsweise in "res / values ​​/ fonts.xml" ein. Und um es zu benutzen, machen Sie einfach Folgendes: android: fontFamily = "string / fontFamily__roboto_regular"
Android-Entwickler
Danke, ich benutze diesen github.com/norbsoft/android-typeface-helper und er ist wirklich hilfreich
AZ_
ok, die Bibliothek ist wahrscheinlich dafür gedacht, es programmgesteuert zu machen. hier ist es für XML
Android Entwickler
9

Dynamisch können Sie die Schriftfamilie ähnlich wie android: fontFamily in XML festlegen, indem Sie Folgendes 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 Standardschriftfamilien . Verwenden Sie eine dieser Schriftarten , indem Sie die doppelte Anführungszeichenfolge "serifenlos-mittel" 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. Der Pfad befindet sich in src / assets / fonts / mycustomfont.ttf. Weitere Informationen zur Standardschrift finden Sie in dieser Standardschriftfamilie

anand krish
quelle
9
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

Makvin
quelle
8

Ich denke, ich bin zu spät, aber vielleicht ist diese Lösung für andere hilfreich. Wenn Sie eine benutzerdefinierte Schriftart verwenden möchten, legen Sie Ihre Schriftartdatei in Ihrem Schriftartenverzeichnis ab.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));
Rehan Sarwar
quelle
6

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, eine Schriftart zu verwenden. Die Auswahl an Kombinationen ist mit fontfamily & textStyle viel größer.


quelle
5

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 dies jedoch ändern, sodass die tatsächliche Schriftart, die beim Festlegen des fontFamily-Werts verwendet wird, von der oben genannten Datei des angegebenen Geräts abhängt.

In AOSP ist die Arial-Schriftart gültig, muss jedoch mit "arial" und nicht mit "Arial" definiert werden, z. B. android: fontFamily = "arial" . Schauen Sie sich Kitkats system_fonts.xml an

    <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 zur Definition einer "font" in layout-- android: family , android: Schrift und android: Textart . Die Kombination von "fontFamily" und "textStyle" oder "typeface" und "textStyle" kann verwendet werden, um das Erscheinungsbild von Schriftarten 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" eingestellt ist, wird die "Schrift" ignoriert.
  2. "Schrift" hat Standardwerte und begrenzte gültige Werte. Tatsächlich sind die Werte "normal", "ohne", "Serife" und "Monospace". Sie finden sie in system_fonts.xml (4.x) oder fonts.xml (5.x). Tatsächlich sind sowohl "normal" als auch "sans" die Standardschriftart des Systems.
  3. "fontFamily" kann verwendet werden, um alle Schriftarten von integrierten Schriftarten festzulegen, während "Schrift" nur die typischen Schriftarten "serifenlos", "serif" und "monospace" (die drei Hauptkategorien von Schriftarten in der Welt) enthält. .
  4. Wenn nur "textStyle" festgelegt wird, legen wir tatsächlich die Standardschriftart und den angegebenen Stil fest. Der effektive Wert ist "normal", "fett", "kursiv" und "fett | kursiv".
Terry Liu
quelle
4

Hier ist eine einfachere Möglichkeit , die in einigen Fällen funktionieren kann. Das Prinzip besteht darin, eine nicht sichtbare TextVview in Ihr XML-Layout einzufügen und deren typeFace 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 bei mir funktioniert (zum Beispiel in einem TextSwitcher).

Frédéric
quelle
4

Versuche dies:

TextView textview = (TextView) findViewById(R.id.textview);

Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);
mohamad sheikhi
quelle
4

Sie können dies auch tun, indem Sie einen Schriftartenordner unter dem Verzeichnis res wie unten hinzufügen.

Geben Sie hier die Bildbeschreibung ein

Wählen Sie dann Schriftart als Ressourcentyp aus. Geben Sie hier die Bildbeschreibung ein

Sie finden verfügbare Schriftarten unter https://www.1001fonts.com/ und extrahieren dann die TTF-Dateien in dieses Schriftartenverzeichnis.

Geben Sie hier die Bildbeschreibung ein

Zum Schluss ändern Sie einfach die XML-Datei, die Ihre Textansicht enthält, indem Sie android: fontFamily: "@ font / urfontfilename" hinzufügen.

Geben Sie hier die Bildbeschreibung ein

Wolfiebae
quelle
sehr schön, danke dafür. idk, warum andere mehr Sterne haben, aber Ihre ist bestätigt, um mit der Textansicht des Materialdesigns zu arbeiten, Sie müssen app:fontFamily=jedoch verwenden, alles andere ist das gleiche.
EvOlaNdLuPiZ
Sie haben mir das Leben gerettet, ich hatte gerade einen Ordner mit dem Namen font erstellt und es hat nicht funktioniert. Wie auch immer, ich habe deinen Weg benutzt und es hat funktioniert. Danke
Hilal
4

Eine einfache Möglichkeit besteht darin, die gewünschte Schriftart in das Projekt einzufügen.

Gehen Sie zu Datei-> Neu-> Neues Ressourcenverzeichnis. Wählen Sie die Schriftart aus

Dadurch wird ein neues Verzeichnis ( Schriftart ) in Ihren Ressourcen erstellt.

Laden Sie Ihre Schriftart (.ttf) herunter . Ich benutze https://fonts.google.com für das gleiche

Fügen Sie dies Ihrem Schriftartenordner hinzu und verwenden Sie sie dann im XML oder programmgesteuert.

XML -

<TextView 
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/your_font"/>

Programmatisch -

 Typeface typeface = getResources().getFont(R.font.your_font);
 textView.setTypeface(typeface); 
Akanshi Srivastava
quelle
9
Bessere ResourcesCompat.getFontMethode
Vadim Kotov
3
<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>
Yang Peiyong
quelle
3

Wenn Sie eine TextView an so vielen Stellen mit derselben Schriftfamilie verwenden möchten, erweitern Sie die TextView-Klasse und legen Sie Ihre Schriftart wie folgt fest: -

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);
    }
}

Verwenden Sie dann 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"
        />
Shubham Raitka
quelle
3

Wenn Sie Android Studio 3.5+ verwenden, ist das Ändern der Schriftart sehr einfach. Wählen Sie das Text-Widget in der Entwurfsansicht aus und aktivieren Sie fontFamily im Attributfenster. Die Wert-Dropdown-Liste enthält alle verfügbaren Schriftarten, aus denen Sie eine auswählen können. Wenn Sie nach Google Fonts suchen, klicken Sie auf die Option Weitere Schriftarten.

Attributfenster Attributfenster

Google Fonts Google Fonts

Siva
quelle
2

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

Jetzt gibt es einen neuen Ressourcentyp, eine Schriftart, und Sie können alle Ihre Anwendungsschriftarten im Ordner res / fonts ablegen und dann mit R.font.my_custom_font darauf zugreifen, genau wie Sie auf Zeichenfolgen- Res-Werte, zeichnbare Res-Werte usw. zugreifen können. Sie haben sogar eine Chance um eine XML-Datei für Schriftarten zu erstellen , die aus Ihren benutzerdefinierten Schriftarten besteht (über Kursiv, Fett und Unterstrich).

Lesen Sie den obigen Link für weitere Informationen. Mal sehen, die Unterstützung.

Stoycho Andreev
quelle
Leider funktioniert dies mit IntelliJ immer noch nicht (obwohl es unter Android Studio 3.0+ wie ein Zauber funktioniert).
Dominikus K.
Ja, aber Redmandie Antwort des Benutzers oben ist immer noch ein notwendiger Teil der Lösung.
Jungledev
2

Dafür steht eine schöne Bibliothek zur Verfügung

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
Shivam Yadav
quelle
Diese Bibliothek wird verwendet, um die Schriftart aller Ansichten in der gesamten Anwendung zu ändern. Dies gilt nicht für Adapteransichten wie die Listenansicht. Dafür müssen wir in jedem Adapter speziell Code hinzufügen
Senthilvel S
2

Die neue Schriftartressource ermöglicht die direkte Einstellung fontmit

android:fontFamily="@font/my_font_in_font_folder"
Aziz
quelle
1

Sie setzen den Stil res/layout/value/style.xmlso ein:

<style name="boldText">
    <item name="android:textStyle">bold|italic</item>
    <item name="android:textColor">#FFFFFF</item>
</style>

und um diesen Stil bei der main.xmlVerwendung von Dateien zu verwenden:

style="@style/boldText"
Rajender
quelle
1

Für Android-Studio 3 und höher können Sie diesen Stil und dann alle verwenden 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>

Verwenden Sie es dann 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>
Ali Khaki
quelle
1

Der einfachste Weg , die Schriftart programmgesteuert zu einer Textansicht hinzuzufügen, besteht darin, zunächst die Schriftartdatei in Ihrem Assets-Ordner im Projekt hinzuzufügen. Ihr Schriftpfad sieht beispielsweise folgendermaßen aus:assets/fonts/my_font.otf

Und fügen Sie es einer Textansicht 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);
Pandabear
quelle
0

Hier sehen Sie alle verfügbaren fontFamily-Werte und die Namen der entsprechenden Schriftdateien (diese Datei wird in Android 5.0+ verwendet). Auf Mobilgeräten finden Sie es in:

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

(Für Android 4.4 und niedriger mit dieser Version, aber ich denke, das fonts.xmlhat ein klareres Format und ist leicht zu verstehen.)

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 Attribut name name="sans-serif"des familyTags definiert den Wert, den Sie in android verwenden können: fontFamily.

Das fontTag definiert die entsprechenden Schriftdateien.

In diesem Fall können Sie die Quelle ignorieren <!-- fallback fonts -->, die für die Fallback-Logik von Schriftarten verwendet wird.

Gnod
quelle