Как изменить семейство шрифтов TextView в Android

Это способ установить шрифт программно:

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

поместить файл шрифта в папку активов. В моем случае я создал подкаталог под названием fonts.

EDIT: если вам интересно, где находится ваша папка активов см. этот вопрос

Я должен был разобрать /system/etc/fonts.xml в недавнем проекте. Вот текущие семейства шрифтов по состоянию на 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

---

вот парсер (на основе off 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;
        }

    }
}

---

не стесняйтесь использовать вышеуказанный класс в своем проекте. Например, вы можете предоставить своим пользователям выбор семейств шрифтов и установить шрифт на основе их предпочтений.

небольшой неполный пример:

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-Studio 3.0 его очень легко изменять шрифт

используя библиотеку поддержки 26, он будет работать на устройствах под управлением Android API версии 16 и выше

создать папку font под . Структура должна быть что-то вроде ниже

вы можете изменить шрифт в планировка используя

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

изменить программно

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

изменить шрифт с помощью стили.xml создать стиль

 <style name="Regular">
        <item name="android:fontFamily">@font/dancing_script</item>
        <item name="android:textStyle">normal</item>
 </style>

и применить этот стиль к TextView

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

вы также можете создать свой собственный семейство шрифтов

- щелкните правой кнопкой мыши папку шрифтов и перейти к New > Font resource file. Окно новый файл ресурсов кажется.

- введите имя файла и нажмите кнопку ОК. В Редакторе откроется новый XML-ресурс шрифта.

напишите свое собственное семейство шрифтов здесь, например

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

это просто отображение определенного стиля шрифта и веса шрифта на ресурс шрифта, который будет использоваться для отображения этого конкретного варианта. Допустимые значения для fontStyle являются нормальными или курсивными; и fontWeight соответствует CSS спецификация шрифта-вес

1. до изменить fontfamily in планировка можно писать

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

2. Изменить программно

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

Примечание: начиная с библиотеки поддержки Android 26.0, вы должны объявить оба набора атрибутов (android: и app: ), чтобы обеспечить загрузку шрифтов на запущенных устройствах API-интерфейс 26 или ниже.

  <?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android"
             xmlns:app="http://schemas.android.com/apk/res-auto">
    <font android:fontStyle="normal" android:fontWeight="400" android:font="@font/myfont-Regular"
          app:fontStyle="normal" app:fontWeight="400" app:font="@font/myfont-Regular"/>
    <font android:fontStyle="italic" android:fontWeight="400" android:font="@font/myfont-Italic"
          app:fontStyle="italic" app:fontWeight="400" app:font="@font/myfont-Italic" />
</font-family>

чтобы изменить шрифт всего приложения, добавьте эти две строки в 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>

посмотреть документация, Android Пользовательские Шрифты Учебник для получения дополнительной информации

Android не позволяет устанавливать пользовательские шрифты из макета XML. Вместо этого необходимо связать конкретный файл шрифта в папке ресурсов вашего приложения и установить его программно. Что-то вроде:

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

обратите внимание, что вы можете запустить этот код только после вызова setContentView (). Кроме того, только некоторые шрифты поддерживаются Android, и должно быть .ttf (TrueType) или . Даже тогда, некоторые шрифты могут не работать.

этой - это шрифт, который наверняка работает на Android, и вы можете использовать это, чтобы подтвердить, что ваш код работает в случае, если файл шрифта не поддерживается Android.

обновление Android O: теперь это возможно с XML в Android O, основываясь на комментарии Роджера.

Это то же самое как android:typeface.

встроенные шрифты:

• нормальный
• sans
• засечками
• monospace

посмотреть android: шрифт.

чтобы установить Roboto программно:

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

если вы хотите его программно, вы можете использовать

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

здесь SANS_SERIF вы можете использовать:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

и где ITALIC вы можете использовать:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

все сказано on Разработчики Android

Я использую отличную библиотеку каллиграфия Крис Дженкс разработан, чтобы позволить вам использовать пользовательские шрифты в вашем приложении для android. Дайте ему попробовать!

то, что вы хотите не возможно. Вы должны установить TypeFace в коде.

на XML что вы можете сделать, это

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

другое, то это вы не можете играть много со шрифтами в XML. :)

на Arial вам нужно установить тип лица в коде.

простым способом управления шрифтами было бы объявить их через ресурсы, как таковые:

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

это основано на исходном коде здесь и здесь

динамически вы можете установить fontfamily похож на android: fontFamily в xml с помощью этого,

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

это список шрифт по умолчанию семейство используется, используйте любой из них, заменив строку двойной кавычки "без засечек-средство"

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 " - это файл ttf. путь будет src / assets/fonts / mycustomfont.ТТФ, вы можете сослаться больше о дефолте шрифт в этом семейство шрифтов по умолчанию

Я сделал небольшую библиотеку с именем литейное который можно использовать для применения пользовательских шрифтов через XML-макеты и стили.

С некоторых проб и ошибок я узнал следующее.

в *.xml вы можете комбинировать фондовые шрифты со следующими функциями, а не только с шрифтом:

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

С этими двумя стилями не было необходимости использовать шрифт в любом другом случае. Диапазон комбинаций намного больше с fontfamily&textStyle.

допустимое значение android: fontFamily определяется в /system/etc / system_fonts.xml (4.x) или/system/etc / шрифты.xml (5.икс.) Но производитель устройства может изменить его, поэтому фактический шрифт, используемый при установке значения fontFamily, зависит от вышеупомянутого файла указанного устройства.

в AOSP шрифт Arial допустим, но должен быть определен с помощью "arial", а не" Arial", например android: fontFamily= "arial". Есть Кусик посмотреть на китката системный шрифт.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>

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

есть три соответствующих XML-атрибутов для определения "шрифт" в макете--android: fontFamily,android: шрифт и android: textStyle. Комбинация "fontFamily" и "textStyle" или "typeface" и "textStyle" может использоваться для изменения внешнего вида шрифта в тексте, поэтому используется отдельно. Фрагмент кода в TextView.java такой:

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

из кода мы видим:

1. если" fontFamily "установлен, то" шрифт " будет проигнорирован.
2. "шрифт" имеет стандартные и ограниченные допустимые значения. Фактически, значения являются "нормальными", "без засечек" и "моноширинными", их можно найти в system_fonts.xml (4.х) или шрифты.xml (5.икс.) На самом деле как" нормальный", так и" sans " являются шрифтом по умолчанию системы.
3. "fontFamily" можно использовать для установки всех шрифты встроенных шрифтов, в то время как" шрифт "предоставляет только типичные шрифты" sans-serif "" serif "и"monospace" (три основные категории типов шрифтов в мире).
4. когда установлен только "textStyle", мы фактически устанавливаем шрифт по умолчанию и указанный стиль. Эффективным значением являются "обычный", "жирный", "курсив"и" жирный | курсив".

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

Это тоже хорошая библиотека RobotoTextView. Это действительно служит вашим потребностям.

вы устанавливаете стиль в res/layout/value/style.xml вот так:

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

и использовать этот стиль в main.xml файл:

style="@style/boldText"

здесь легче уаy, что может работать в некоторых случаях. Принцип состоит в том, чтобы добавить не видимый TextVview в ваш XML-макет и сделать свой шрифт в коде java.

макет в 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"/>

и код java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

это сработало для меня (например, в TextSwitcher).

Если вы хотите использовать TextView во многих местах с одинаковым семейством шрифтов, расширьте класс TextView и установите шрифт следующим образом: -

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

а затем использовать этот пользовательский класс в xml для TextView следующим образом: -

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

Я просто хочу упомянуть, что ад с шрифтами внутри Android вот-вот закончится, потому что в этом году на Google IO мы наконец получили это -> https://developer.android.com/preview/features/working-with-fonts.html

теперь есть новый тип ресурса шрифт и вы можете разместить все шрифты приложения в папке res/fonts и получить доступ к ним с помощью R. font. my_custom_font, так же, как вы можете получить доступ строка значения res, drawable значения res etc. У вас есть даже шанс создать font-face xml-файл, который будет установлен из ваших пользовательских шрифтов (о курсиве, полужирном и подчеркивании attr).

читай ссылку выше для получения дополнительной информации. Давайте посмотрим на поддержку.

здесь вы можете увидеть все доступные значения fontFamily, и это соответствующие имена файлов шрифтов(этот файл используется в android 5.0+). В мобильном устройстве, вы можете найти его в:

/ system / etc / fonts.xml (для 5.0+)

(для android 4.4 и ниже с помощью этой версия, но я думаю, что fonts.xml имеет более четкий формат и легко понять.)

например,

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

имя атрибут name="sans-serif" на family тег определил значение, которое вы можете использовать в android:fontFamily.

The font тег определяет соответствующие файлы шрифтов.

в этом случае, вы можете игнорировать источник под <!-- fallback fonts -->, он использует для резервной логики шрифтов.

Я использую письмо нажмите lib для моих нетекстовых вещей, таких как кнопки и kianoni fontloader lib для моих TextViews причина использования стиля в этой библиотеке более проста, чем буквенное нажатие для меня, и я получил идеальную обратную связь с этим. это отлично подходит для тех, кто хочет использовать пользовательский шрифт, кроме шрифта Roboto. так что это был мой опыт работы с библиотеками шрифтов. для тех, кто хочет использовать пользовательский класс для изменения шрифта я настоятельно рекомендую создать этот класс с этим фрагмент

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

}

и использовать класс, как это

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

может быть, это поможет.

вы можете сделать это простым способом, используя следующую библиотеку

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

его легкий вес и простота реализации, просто скопируйте шрифты в папку активов и использовать имя в xml.

попробуйте эти простые шаги. 1. создайте папку шрифтов в папке res. 2. копирование и вставка .ttf-файл в папку шрифтов. 3. Теперь дайте путь в XML, как показано ниже.

 android:fontFamily="@font/frutiger"

или то, что когда-нибудь ваше имя файла. Вот это счастливый код