Jak zmienić fontFamily z TextView w Androidzie

Więc chciałbym zmienić android:fontFamily w Androidzie, ale nie widzę żadnych wstępnie zdefiniowanych czcionek w Androidzie. Jak wybrać jeden ze wstępnie zdefiniowanych? Tak naprawdę nie muszę definiować własnego TypeFace'a, ale wszystko, czego potrzebuję, to coś innego niż to, co pokazuje teraz.

<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"
 />

Wygląda na to, że to, co tam zrobiłem, naprawdę nie zadziała! BTW android:fontFamily="Arial"była głupią próbą!

W Androidzie 4.1 / 4.2 / 5.0 dostępne są następujące rodziny czcionek Roboto :

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)

w połączeniu z

android:textStyle="normal|bold|italic"

możliwe jest 16 wariantów:

• Roboto regularne
• Roboto kursywa
• Roboto pogrubienie
• Roboto pogrubioną kursywą
• Roboto-Light
• Roboto-Light kursywa
• Roboto-Thin
• Roboto-Thin kursywa
• Roboto-Condensed
• Roboto-Condensed kursywa
• Roboto-Condensed pogrubienie
• Roboto-Condensed pogrubiona kursywa
• Roboto-Black
• Kursywa Roboto-Czarna
• Roboto-Medium
• Roboto-średnia kursywa

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>

Oto sposób programowego ustawienia czcionki:

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

umieść plik czcionek w folderze zasobów. W moim przypadku utworzyłem podkatalog o nazwie czcionki.

EDYCJA: Jeśli zastanawiasz się, gdzie jest folder zasobów, zobacz to pytanie

Począwszy od Androida-Studio 3.0 bardzo łatwo zmienić rodzinę czcionek

Korzystając z biblioteki pomocy 26, będzie działać na urządzeniach z Android API w wersji 16 i wyższej

Utwórz folder fontw reskatalogu. Pobierz czcionkę, którą chcesz i wklej ją do fontfolderu. Struktura powinna wyglądać jak poniżej

Uwaga: Począwszy od Android Support Library 26.0, musisz zadeklarować oba zestawy atrybutów (Android: i app:), aby zapewnić ładowanie czcionek na urządzeniach z Api 26 lub starszym.

Teraz możesz zmienić czcionkę w układzie za pomocą

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

Aby zmienić programowo

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

Aby zmienić czcionkę za pomocą styles.xml, utwórz styl

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

i zastosuj ten styl do TextView

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

możesz także stworzyć własną rodzinę czcionek

- Kliknij folder czcionek prawym przyciskiem myszy i wybierz Nowy> Plik zasobów czcionek . Zostanie wyświetlone okno Nowy plik zasobów.

- Wprowadź nazwę pliku , a następnie kliknij OK . Nowy plik XML zasobów czcionek zostanie otwarty w edytorze.

Na przykład tutaj wpisz własną rodzinę czcionek

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

jest to po prostu mapowanie określonego fontStyle i fontWeight na zasób czcionki, który zostanie użyty do renderowania tego konkretnego wariantu. Prawidłowe wartości dla fontStyle są normalne lub kursywą; i fontWeight jest zgodny ze specyfikacją grubości czcionki CSS

1. Aby zmienić rodzinę czcionek w układzie , możesz pisać

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

2. Aby zmienić programowo

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

Aby zmienić czcionkę całej aplikacji Dodaj te dwa wiersze w AppTheme

 <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
     <item name="android:fontFamily">@font/your_font</item>
     <item name="fontFamily">@font/your_font</item>
  </style>

Zobacz dokumentację , samouczek czcionek niestandardowych Androida, aby uzyskać więcej informacji

Musiałem przeanalizować /system/etc/fonts.xmlw ostatnim projekcie. Oto aktualne rodziny czcionek od 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Oto analizator składni (oparty na 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;
        }

    }
}

Możesz użyć powyższej klasy w swoim projekcie. Na przykład możesz dać swoim użytkownikom wybór rodzin czcionek i ustawić krój pisma na podstawie ich preferencji.

Mały niekompletny przykład:

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 nie pozwala na ustawienie niestandardowych czcionek z układu XML. Zamiast tego musisz spakować określony plik czcionek w folderze zasobów aplikacji i ustawić go programowo. Coś jak:

TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);

Zauważ, że możesz uruchomić ten kod tylko po wywołaniu setContentView (). Ponadto tylko niektóre czcionki są obsługiwane przez system Android i powinny mieć format .ttf (TrueType)lub .otf (OpenType). Nawet wtedy niektóre czcionki mogą nie działać.

Jest to czcionka, która zdecydowanie działa na Androidzie, i możesz jej użyć, aby potwierdzić, że Twój kod działa, na wypadek, gdyby plik czcionki nie był obsługiwany przez Androida.

Aktualizacja Androida O: Jest to teraz możliwe dzięki XML w Androidzie O , na podstawie komentarza Rogera.

Aby ustawić Roboto programowo:

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

To jest tak samo jak android:typeface.

wbudowane czcionki to:

• normalna
• sans
• szeryf
• monospace

Zobacz android: krój pisma .

Jeśli chcesz programowo, możesz użyć

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

Gdzie SANS_SERIFmożesz użyć:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

I gdzie ITALICmożesz użyć:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Wszystko zostało napisane na Android Developers

Korzystam z doskonałej biblioteki Calligraphy autorstwa Chrisa Jenxa, zaprojektowanej tak, abyś mógł używać niestandardowych czcionek w aplikacji na Androida. Spróbuj!

To, czego chcesz, nie jest możliwe. Musisz ustawić TypeFacew swoim Kodeksie.

W XMLco można zrobić, to

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

poza tym nie można dużo grać z czcionkami w XML. :)

Aby Arialustawić typ twarzy w kodzie.

Łatwym sposobem zarządzania czcionkami byłoby zadeklarowanie ich za pomocą zasobów, takich jak:

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

Jest to oparte na kodzie źródłowym tu i tutaj

Dynamicznie możesz ustawić fontfamily podobną do Androida: fontFamily w xml za pomocą tego,

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

Oto lista używanych domyślnych czcionek , użyj dowolnego z nich, zastępując ciąg podwójnego cudzysłowu „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” to plik ttf. Ścieżka będzie w src / asset / fonts / mycustomfont.ttf , możesz dowiedzieć się więcej o czcionce domyślnej w tej rodzinie czcionek domyślnych

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

łatwo ustawić programowo czcionkę do dowolnego widoku tekstu z katalogu res> font

Myślę, że jestem za późno, ale może to rozwiązanie jest pomocne dla innych. Aby użyć niestandardowej czcionki, umieść plik czcionki w katalogu czcionek.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));

Z pewnymi próbami i błędami nauczyłem się następujących rzeczy.

W pliku * .xml można łączyć czcionki podstawowe z następującymi funkcjami, nie tylko z krojem pisma:

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

Dzięki tym dwóm stylom nie było potrzeby używania kroju pisma w żadnym innym przypadku. Zakres kombinacji jest znacznie większy dzięki fontfamily i textStyle.

Prawidłowa wartość android: fontFamily jest zdefiniowana w /system/etc/system_fonts.xml(4.x) lub /system/etc/fonts.xml(5.x). Ale producent urządzenia może go zmodyfikować, więc rzeczywista czcionka użyta do ustawienia wartości fontFamily zależy od wyżej wspomnianego pliku określonego urządzenia.

W AOSP czcionka Arial jest poprawna, ale musi być zdefiniowana przy użyciu „arial”, a nie „Arial”, na przykład android: fontFamily = „arial” . Spójrz qucik na system_fonts.xml Kitkata

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

////////////////////////////////////////////////// ////////////////////////

Istnieją trzy odpowiednie atrybuty xml do definiowania „czcionki” w układzie - android: fontFamily , android: krój czcionki i android: textStyle . Kombinacja „fontFamily” i „textStyle” lub „krój pisma” i „textStyle” może być używana do zmiany wyglądu czcionki w tekście, więc jest używana osobno. Fragment kodu w TextView.java wygląda następująco:

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

Z kodu Widzimy:

1. jeśli ustawione jest „fontFamily”, wówczas „krój czcionki” zostanie zignorowany.
2. „krój pisma” ma standardowe i ograniczone prawidłowe wartości. W rzeczywistości wartościami są „normalne” „sans”, „serif” i „monospace”, można je znaleźć w pliku system_fonts.xml (4.x) lub fonts.xml (5.x). W rzeczywistości zarówno „normal”, jak i „sans” są domyślną czcionką systemu.
3. „fontFamily” może być używany do ustawiania wszystkich czcionek czcionek wbudowanych, podczas gdy „krój czcionki” zapewnia tylko typowe czcionki „sans-serif”, „serif” i „monospace” (trzy główne kategorie typów czcionek na świecie) .
4. Gdy ustawiamy tylko „textStyle”, tak naprawdę ustawiamy domyślną czcionkę i określony styl. Skuteczne wartości to „normal”, „pogrubienie”, „kursywa” i „pogrubienie | kursywa”.

Oto łatwiejsze rozwiązanie, które może działać w niektórych przypadkach. Zasadą jest dodanie niewidocznego TextVview do twojego układu xml i pobranie jego typeFace w kodzie java.

Układ w pliku xml:

 <TextView
        android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:fontFamily="sans-serif-thin"
        android:id="@+id/textViewDescription"/>

I kod Java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

To zadziałało dla mnie (na przykład w TextSwitcher).

Spróbuj tego:

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

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

Możesz to również zrobić, dodając folder czcionek w katalogu res, jak poniżej.

Następnie wybierz Czcionka jako typ zasobu.

Dostępne czcionki można znaleźć na stronie https://www.1001fonts.com/ , a następnie wyodrębnić pliki TTF do tego katalogu czcionek.

Na koniec zmień plik XML zawierający widok tekstu, dodając android: fontFamily: „@ font / urfontfilename”

Jednym prostym sposobem jest dodanie żądanej czcionki w projekcie.

Przejdź do Plik-> Nowy-> Nowy katalog zasobów Wybierz czcionkę

Spowoduje to utworzenie nowego katalogu, czcionki w twoich zasobach.

Pobierz swój czcionkę (.ttf) . Używam https://fonts.google.com do tego samego

Dodaj to do folderu czcionek, a następnie użyj ich w pliku XML lub programowo.

XML -

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

Programowo -

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

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

Jeśli chcesz używać TextView w tak wielu miejscach z tą samą rodziną czcionek, rozszerz klasę TextView i ustaw czcionkę w następujący sposób: -

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

A następnie użyj tej niestandardowej klasy w XML dla TextView w następujący sposób: -

   <com.myapp.customview.ProximaNovaTextView
        android:id="@+id/feed_list_item_name_tv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="14sp"
        />

Jeśli używasz Androida Studio 3.5+, zmiana czcionki jest bardzo prosta. Wybierz widget tekstowy w widoku Projekt i zaznacz fontFamily w oknie atrybutów. Lista wartości zawiera wszystkie dostępne czcionki, z których możesz wybrać jedną. Jeśli szukasz czcionek Google, kliknij opcję Więcej czcionek.

Okno atrybutów

Czcionki Google

Chcę tylko wspomnieć, że piekło z czcionkami wewnątrz Androida wkrótce się skończy, ponieważ w tym roku na Google IO w końcu dostaliśmy to -> https://developer.android.com/preview/features/working-with-fonts. HTML

Teraz jest nowy typ czcionki czcionka i możesz umieścić wszystkie czcionki aplikacji w folderze res / fonts i uzyskać do nich dostęp za pomocą R.font.my_custom_font, podobnie jak możesz uzyskać dostęp do wartości res string , rysowalnych res res itp. Masz nawet szansę aby utworzyć plik xml font-face , w którym będą ustawione niestandardowe czcionki (o kursywie, pogrubieniu i podkreśleniu attr).

Przeczytaj powyższy link, aby uzyskać więcej informacji. Zobaczmy wsparcie.

Dostępna jest do tego ładna biblioteka

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'

Nowy zasób czcionek umożliwia bezpośrednie ustawienie fontza pomocą

android:fontFamily="@font/my_font_in_font_folder"

Ustawiasz styl w res/layout/value/style.xmlten sposób:

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

i aby użyć tego stylu w main.xmlużyciu pliku:

style="@style/boldText"

W przypadku Androida-studio 3 i nowszych możesz użyć tego stylu, a potem wszystkich textView zmian czcionek w aplikacji.

stwórz ten styl w style.xml:

<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="android:Widget.TextView">
        <item name="android:fontFamily">@font/your_custom_font</item>
</style>

Następnie użyj go w swoim motywie:

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

Najprostszym sposobem na programowe dodanie czcionki do TextView jest, po pierwsze, dodanie pliku czcionki w folderze Zasoby w projekcie. Na przykład ścieżka czcionki wygląda następująco:assets/fonts/my_font.otf

I dodaj go do TextView jako:

Kotlin

val font_path = "fonts/my_font.otf"  

myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)

textView.typeface = myTypeface

Jawa

String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);

Tutaj możesz zobaczyć wszystkie dostępne wartości fontFamily i odpowiadające im nazwy plików czcionek (ten plik jest używany w Androidzie 5.0+). Na urządzeniu mobilnym można go znaleźć w:

/system/etc/fonts.xml (dla 5.0+)

(Dla Androida 4.4 i niższych korzystających z tej wersji, ale myślę, że fonts.xmlma bardziej przejrzysty format i jest łatwy do zrozumienia.)

Na przykład,

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

Atrybut name name="sans-serif"of familytagu określona wartość można wykorzystać w Androidzie: fontFamily.

fontTag określenie odzwierciedla pliki czcionek.

W takim przypadku możesz zignorować źródło <!-- fallback fonts -->, którego używa do logiki rezerwowej czcionek.