it-swarm.com.ru

Как изменить шрифт семьи 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" была глупой попыткой!

650
Tarik

Начиная с 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)

 enter image description here

в комбинации с

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>
1563
Jakob Eriksson

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

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

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

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

170
Stefan Beike

Мне пришлось проанализировать /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();
95
Jared Rummler

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

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

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

Here

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

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

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

вы также можете создать свое собственное семейство font

- Щелкните правой кнопкой мыши папку шрифтов и перейдите к New> Файл ресурса шрифта. Откроется окно «Новый файл ресурсов».

- Введите имя файла, а затем нажмите OK. Новый ресурс шрифта 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. Чтобы изменить семейство шрифтов в layout, вы можете написать

 <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 Для получения дополнительной информации

94
Manohar Reddy

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

46
Raghav Sood

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

Paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
24
Oded Breiner

Это так же, как Android:typeface.

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

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

См. Android: гарнитура .

24
biegleux

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

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

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

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

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

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

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

21
Joaquin Iurchuk

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

14
gauravdott

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

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

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

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

Для Arial вам нужно установить тип face в вашем коде.

11
Mohsin Naeem

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

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

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

9
android developer

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

8
anand krish

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

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

 Android:fontFamily="serif" 
 Android:textStyle="italic"

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

5
user3508321

Допустимое значение 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 в KitKat

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

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

  1. если установлено «fontFamily», то «гарнитура» будет игнорироваться. 
  2. «гарнитура» имеет стандартные и ограниченные допустимые значения. Фактически, значения являются «обычными», «без засечек», «с засечками» и «моноширинными», их можно найти в system_fonts.xml (4.x) или fonts.xml (5.x). На самом деле и «нормальный», и «без» являются шрифтом по умолчанию системы.
  3. «fontFamily» может использоваться для установки всех шрифтов встроенных шрифтов, в то время как «гарнитура» предоставляет только типичные шрифты «sans-serif», «serif» и «monospace» (три основных категории шрифтов в мире) ,.
  4. Когда устанавливается только «textStyle», мы фактически устанавливаем шрифт по умолчанию и указанный стиль. Эффективные значения: «нормальный», «жирный», «курсив» и «жирный | курсив».
4
Terry Liu
<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>
2
Yang Peiyong

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

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

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

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

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

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

1
Makvin

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

1
Frédéric

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

Вы также можете изменить стандартные шрифты с помощью setTextAppearance (требуется API 16), см. https://stackoverflow.com/a/36301508/2914140 :

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

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

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.

0
Sanny Nagveker

Для этого есть библиотека Nice

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
0
Shivam Yadav

Самый простой способ программно добавить шрифт в TextView - это сначала добавить файл шрифта в папку «Ресурсы» в проекте. Например, ваш путь к шрифту выглядит следующим образом: assets/fonts/my_font.otf

И добавьте его в TextView как: 

Котлин

val font_path = "fonts/my_font.otf"  

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

textView.typeface = myTypeface

Джава

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

Для Android-студии 3 и выше вы можете использовать этот стиль, а затем все изменения шрифта 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>
0
Ali Khaki

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

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

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

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

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

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

0
Setmax

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

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

(Для Android 4.4 и ниже используется this version, но я думаю, что 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 -->, он использует логику восстановления шрифтов.

0
Gnod

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

 Android:fontFamily="@font/frutiger"

или как вообще ваше имя файла . Это счастливый код

0
Syed Danish Haider