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

Question

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

Так что я хотел бы изменить android:fontFamily в Android, но я не вижу никаких предопределенных шрифтов в Android. Как выбрать один из предопределенных? Мне действительно не нужно определять свой собственный TypeFace, но все, что мне нужно, это нечто отличное от того, что он показывает прямо сейчас.

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

Кажется, то, что я сделал там, на самом деле не сработает! КСТАТИ android:fontFamily="Arial" была глупая попытка!

836

android android-layout textview android-textview typeface

Источник

user44852 26 авг '12 в 07:19

41 ответ

Решение

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

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

Создать папку font под res каталог. Скачать шрифт, который вы хотите, и вставить его внутри 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);

Чтобы изменить шрифт с помощью styles.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"/>

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

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

- Введите имя файла и нажмите кнопку " ОК". Новый ресурс шрифта 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.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 Custom Fonts для получения дополнительной информации

286

Источник

user6478047 23 мар '17 в 12:51

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

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

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

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

245

Источник

user1640490 26 авг '12 в 07:38

Я должен был разобрать /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();

110

Источник

user1048340 09 апр '15 в 08:38

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, основываясь на комментарии Роджера.

52

Источник

user1069068 26 авг '12 в 07:42

Код Kotlin - Textview для установки пользовательского шрифта из папки ресурсов

Установите собственный шрифт из res -> font -> avenir_next_regular.ttf

textView!!.typeface = ResourcesCompat.getFont(context!!, R.font.avenir_next_regular)

33

Источник

user9115195 20 сен '20 в 20:59

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

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

31

Источник

user710284 06 авг '15 в 22:59

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

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

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

DEFAULT
DEFAULT_BOLD
MONOSPACE
SANS_SERIF
SERIF

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

BOLD
BOLD_ITALIC
ITALIC
NORMAL

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

31

Источник

user2823516 03 окт '14 в 19:21

Это так же, как android:typeface,

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

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

Смотрите андроид: гарнитура.

27

Источник

user1300995 26 авг '12 в 07:41

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

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

25

Источник

user6766264 04 июн '19 в 08:05

Один из простых способов - добавить в проект нужный шрифт.

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

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

Загрузите ваш шрифт (.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 = ResourcesCompat.getFont(this, R.font.your_font);
 textView.setTypeface(typeface);

23

Источник

user6067590 09 окт '19 в 10:25

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

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

21

Источник

user4233479 08 окт '19 в 11:18

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

15

Источник

user862230 06 июл '14 в 13:50

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

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

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

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

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

12

Источник

user1436931 26 авг '12 в 07:38

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

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

Источник

user878126 23 апр '15 в 21:52

Если вы используете Android Studio 3.5+, изменить шрифт очень просто. Выберите текстовый виджет в представлении "Дизайн" и проверьте fontFamily в окне атрибутов. В раскрывающемся списке значений содержатся все доступные шрифты, из которых вы можете выбрать один. Если вы ищете шрифты Google, выберите вариант "Дополнительные шрифты".

Окно атрибутов

Google шрифты

10

Источник

user2978814 12 ноя '19 в 18:43

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

9

Источник

user2147814 26 июл '17 в 12:57

Вы также можете сделать это, добавив папку шрифтов в каталог res, как показано ниже.

Затем выберите Шрифт в качестве типа ресурса.

Вы можете найти доступные шрифты на https://www.1001fonts.com/, а затем распаковать файлы TTF в этот каталог шрифтов.

Наконец, просто измените XML-файл, содержащий ваше текстовое представление, добавив android:fontFamily:"@font/urfontfilename"

8

Источник

user10357600 05 дек '19 в 12:55

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

7

Источник

user290028 12 мар '14 в 02:03

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

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

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

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

6

Источник

08 апр '14 в 10:17

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

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

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

6

Источник

user8258208 16 фев '19 в 05:26

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

В AOSP шрифт Arial является допустимым, но должен быть определен с использованием "arial", а не "Arial", например, android:fontFamily = "arial". Посмотрите qucik на 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-атрибута для определения "шрифта" в макете: android:fontFamily, android: typeface и 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);
    }
}

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

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

5

Источник

user4188219 04 мар '15 в 08:21

Чтобы установить шрифт программой, напишите...

     TextView tv7 = new TextView(this);
     tv7.setText(" TIME ");    
     tv7.setTypeface(Typeface.create("sans-serif-condensed",Typeface.BOLD));
     tv7.setTextSize(12);
     tbrow.addView(tv7);

Имя "sans-serif-condensed" ссылается на файл fonts.xml, который должен быть создан в папке app -> res -> values, и в нем хранятся шрифты.

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

Надеюсь, это ясно!

5

Источник

user13031115 17 июн '20 в 11:36

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

4

Источник

user4412629 09 авг '16 в 09:47

Вы можете определить собственное FontFamily следующим образом:

/res/font/usual.xml:

<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:tools="http://schemas.android.com/tools"
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    tools:ignore="UnusedAttribute">
    <font
        android:fontStyle="normal"
        android:fontWeight="200"
        android:font="@font/usual_regular"
        app:fontStyle="normal"
        app:fontWeight="200"
        app:font="@font/usual_regular" />

    <font
        android:fontStyle="italic"
        android:fontWeight="200"
        android:font="@font/usual_regular_italic"
        app:fontStyle="italic"
        app:fontWeight="200"
        app:font="@font/usual_regular_italic" />

    <font
        android:fontStyle="normal"
        android:fontWeight="600"
        android:font="@font/usual_bold"
        app:fontStyle="normal"
        app:fontWeight="600"
        app:font="@font/usual_bold" />

    <font
        android:fontStyle="italic"
        android:fontWeight="600"
        android:font="@font/usual_bold_italic"
        app:fontStyle="italic"
        app:fontWeight="600"
        app:font="@font/usual_bold_italic" />
</font-family>

Теперь ты можешь сделать

android:fontFamily="@font/usual"

Предполагая, что ваш другой font ресурсы тоже есть строчными буквами и _с.

3

Источник

user2413303 08 сен '20 в 00:58

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

3

Источник

user767417 19 фев '16 в 07:33

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

3

Источник

user6284141 10 май '17 в 06:51

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

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

2

Источник

user5335382 15 мар '19 в 10:33

Вы также можете изменить стандартные шрифты с setTextAppearance (требуется API 16), см. /questions/9109234/chto-ekvivalentno-androidfontfamilysans-serif-lightv-kode-java/9109249#9109249:

<style name="styleA">
    <item name="android:fontFamily">sans-serif</item>
    <item name="android:textStyle">bold</item>
    <item name="android:textColor">?android:attr/textColorPrimary</item>
</style>
<style name="styleB">
    <item name="android:fontFamily">sans-serif-light</item>
    <item name="android:textStyle">normal</item>
    <item name="android:textColor">?android:attr/textColorTertiary</item>
</style>


if(condition){
    TextViewCompat.setTextAppearance(textView, R.style.styleA);
} else {
    TextViewCompat.setTextAppearance(textView,R.style.styleB);
}

2

Источник

user2914140 27 май '19 в 14:27

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

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

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

2

Источник

user4466472 02 июн '17 в 10:05

Другие вопросы по тегам android android-layout textview android-textview typeface

user956415 11 ноя '12 в 09:22 2012-11-11 09:22 · Accepted Answer · 2012-11-11 09:22

Начиная с 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-Light
Roboto-Light курсив
Roboto-тонкий
Робото-тонкий курсив
Roboto-Сгущенное
Роботоконденсированный курсив
Roboto-Condensed полужирный
Роботоконденсированный жирный курсив
Roboto-черный
Робото-черный курсив
Roboto-Medium
Робото-Средний курсив

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>