Как изменить fontFamily TextView в Android

Ответ 1

От android 4.1/4.2/5.0 доступны следующие семейства 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)

в сочетании с

android:textStyle="normal|bold|italic"

возможны 16 вариантов:

• Roboto Regular
• Roboto italic
• Roboto bold
• Робото выделено курсивом
• Roboto-Light
• Робото-свет курсивом
• Roboto-Thin
• Roboto-Thin italic
• Roboto-Condensed
• Roboto-Condensed italic
• Roboto-Condensed bold
• Roboto-Condensed жирным курсивом
• Roboto-Black
• Робото-черный курсив
• Roboto-Medium
• Roboto-medium italic

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>

Ответ 2

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

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

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

РЕДАКТИРОВАТЬ: Если вы задаетесь вопросом, где находится папка ваших активов, см. этот вопрос

Ответ 3

Начиная с Android-Studio 3.0 очень легко изменить семейство шрифтов

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

Создайте font папки в директории res Загрузите нужный шрифт и вставьте его в папку font. Структура должна быть такой, как показано ниже

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

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

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

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

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

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

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

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

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

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

- Щелкните правой кнопкой мыши папку шрифтов и выберите " Создать"> "Файл ресурсов шрифта". Откроется окно "Новый файл ресурсов".

- Введите имя файла и нажмите " ОК". Новый ресурс шрифта 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 на ресурс шрифта, который будет использоваться для визуализации этого конкретного варианта. Допустимые значения для fontStyle нормальные или курсивные; и fontWeight соответствует спецификации CSS font-weight

1. Чтобы изменить шрифтовую семью в макете вы можете написать

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

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

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

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

Ответ 4

Мне пришлось анализировать /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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Вот синтаксический анализатор (на основе 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();

Ответ 5

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

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

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

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

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

Ответ 6

Чтобы программно настроить Roboto:

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

Ответ 7

Это то же самое, что и android:typeface.

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

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

См. android:typeface.

Ответ 8

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

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

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

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

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

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Все объявлено в Android-разработчиках

Ответ 9

Я использую отличную библиотеку Calligraphy от Chris Jenx, предназначенную для использования пользовательских шрифтов в вашем приложении для Android. Попробуйте!

Ответ 10

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

В XML вы можете сделать

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

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

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

Ответ 11

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

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

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

Ответ 12

Динамически вы можете установить 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));

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

Ответ 13

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

Ответ 14

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

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

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

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

Ответ 15

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

В AOSP шрифт Arial действителен, но должен быть определен с использованием "arial", а не "Arial", например android: fontFamily = "arial" . Попросите qucik посмотреть Kitkat system_fonts.xml

    <family>
    <nameset>
        <name>sans-serif</name>
        <name>arial</name>
        <name>helvetica</name>
        <name>tahoma</name>
        <name>verdana</name>
    </nameset>
    <fileset>
        <file>Roboto-Regular.ttf</file>
        <file>Roboto-Bold.ttf</file>
        <file>Roboto-Italic.ttf</file>
        <file>Roboto-BoldItalic.ttf</file>
    </fileset>
</family>

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

Существует три соответствующих xml-атрибута для определения "font" в макете - android: fontFamily, android: шрифт и android: textStyle. Комбинация "fontFamily" и "textStyle" или "шрифт" и "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);
    }
}

Из кода Мы можем видеть:

• Если задано значение "fontFamily" , то "шрифт" будет проигнорирован.
• "шрифт" имеет стандартные и ограниченные допустимые значения. Фактически, значения являются "нормальными" "без", "засечками" и "моноширинами", их можно найти в system_fonts.xml(4.x) или fonts.xml(5.x). Фактически как "нормальный", так и "sans" являются шрифтом по умолчанию для системы.
• "fontFamily" можно использовать для установки всех шрифтов встроенных шрифтов, в то время как "шрифт" предоставляет только типичные шрифты "serans" "serif" и "monospace" (три основные категории шрифтов в мир).
• Когда устанавливается только "textStyle" , мы на самом деле устанавливаем шрифт по умолчанию и указанный стиль. Эффективная ценность - "нормальный", "жирный", "курсив" и "полужирный" курсив.

Ответ 16

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

легко установить шрифт для любого текстового представления из каталога res> font программно

Ответ 17

Попробуй это:

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

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

Ответ 18

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

Ответ 19

Если вы хотите использовать 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"
        />

Ответ 20

Вот проще wa y, который может работать в некоторых случаях. Принцип заключается в том, чтобы добавить не видимый TextVview в ваш xml-макет и получить его typeFace в 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).

Ответ 21

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

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

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

Ответ 22

Для этого есть хорошая библиотека

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

Ответ 23

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

Ответ 24

Вы устанавливаете стиль в 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"

Ответ 25

Для Android-Studio 3 и выше вы можете использовать этот стиль, а затем все textView шрифта textView в приложении.

создайте этот стиль в вашем style.xml:

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

Тогда используйте это в своей теме:

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

Ответ 26

Одним простым способом является добавление нужного шрифта в проект.

Перейдите на File-> New-> New Resource Directory Выберите шрифт

Это создаст новый каталог, шрифт, в ваших ресурсах.

Загрузите ваш шрифт (.ttf). Я использую https://fonts.google.com для того же

Добавьте это в папку со шрифтами, а затем используйте их в XML или программно.

XML -

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

Программно -

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

Ответ 27

Здесь вы можете увидеть все доступные значения 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 name="sans-serif" тега family определил значение, которое вы можете использовать в android: fontFamily.

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

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

Ответ 28

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

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

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

Ответ 29

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

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.

Ответ 30

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

 android:fontFamily="@font/frutiger"

или как называется ваше имя файла. Вот это счастливый код