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

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

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

кажется, то, что я сделал там, на самом деле не сработает! Кстати!--2--> была глупая попытка!

25 ответов


из 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 regular
  • Roboto italic
  • Roboto bold
  • Roboto жирный курсив
  • Roboto-Light
  • Roboto-светлый курсив
  • Roboto-Тонкий
  • Roboto-тонкий курсив
  • Roboto-Condensed
  • Roboto-сокращенный курсив
  • Roboto-сгущенный жирный
  • Roboto-сокращенный жирный курсив
  • Roboto-Черный
  • Roboto-черный курсив
  • Roboto-Medium
  • Roboto-средний курсив

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>

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

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

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

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


мне пришлось разбирать /system/etc/fonts.xml в недавнем проекте. Вот текущие семейства шрифтов по состоянию на Lollipop:

╔════╦════════════════════════════╦═════════════════════════════╗
║    ║ FONT FAMILY                ║ TTF FILE                    ║
╠════╬════════════════════════════╬═════════════════════════════╣
║  1 ║ casual                     ║ ComingSoon.ttf              ║
║  2 ║ cursive                    ║ DancingScript-Regular.ttf   ║
║  3 ║ monospace                  ║ DroidSansMono.ttf           ║
║  4 ║ sans-serif                 ║ Roboto-Regular.ttf          ║
║  5 ║ sans-serif-black           ║ Roboto-Black.ttf            ║
║  6 ║ sans-serif-condensed       ║ RobotoCondensed-Regular.ttf ║
║  7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf   ║
║  8 ║ sans-serif-light           ║ Roboto-Light.ttf            ║
║  9 ║ sans-serif-medium          ║ Roboto-Medium.ttf           ║
║ 10 ║ sans-serif-smallcaps       ║ CarroisGothicSC-Regular.ttf ║
║ 11 ║ sans-serif-thin            ║ Roboto-Thin.ttf             ║
║ 12 ║ serif                      ║ NotoSerif-Regular.ttf       ║
║ 13 ║ serif-monospace            ║ CutiveMono.ttf              ║
╚════╩════════════════════════════╩═════════════════════════════╝

вот парсер (на основе off FontListParser):

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.util.Xml;

/**
 * Helper class to get the current font families on an Android device.</p>
 * 
 * Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>
 */
public final class FontListParser {

    private static final File FONTS_XML = new File("/system/etc/fonts.xml");

    private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");

    public static List<SystemFont> getSystemFonts() throws Exception {
        String fontsXml;
        if (FONTS_XML.exists()) {
            fontsXml = FONTS_XML.getAbsolutePath();
        } else if (SYSTEM_FONTS_XML.exists()) {
            fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();
        } else {
            throw new RuntimeException("fonts.xml does not exist on this system");
        }
        Config parser = parse(new FileInputStream(fontsXml));
        List<SystemFont> fonts = new ArrayList<>();

        for (Family family : parser.families) {
            if (family.name != null) {
                Font font = null;
                for (Font f : family.fonts) {
                    font = f;
                    if (f.weight == 400) {
                        break;
                    }
                }
                SystemFont systemFont = new SystemFont(family.name, font.fontName);
                if (fonts.contains(systemFont)) {
                    continue;
                }
                fonts.add(new SystemFont(family.name, font.fontName));
            }
        }

        for (Alias alias : parser.aliases) {
            if (alias.name == null || alias.toName == null || alias.weight == 0) {
                continue;
            }
            for (Family family : parser.families) {
                if (family.name == null || !family.name.equals(alias.toName)) {
                    continue;
                }
                for (Font font : family.fonts) {
                    if (font.weight == alias.weight) {
                        fonts.add(new SystemFont(alias.name, font.fontName));
                        break;
                    }
                }
            }
        }

        if (fonts.isEmpty()) {
            throw new Exception("No system fonts found.");
        }

        Collections.sort(fonts, new Comparator<SystemFont>() {

            @Override
            public int compare(SystemFont font1, SystemFont font2) {
                return font1.name.compareToIgnoreCase(font2.name);
            }

        });

        return fonts;
    }

    public static List<SystemFont> safelyGetSystemFonts() {
        try {
            return getSystemFonts();
        } catch (Exception e) {
            String[][] defaultSystemFonts = {
                    {
                            "cursive", "DancingScript-Regular.ttf"
                    }, {
                            "monospace", "DroidSansMono.ttf"
                    }, {
                            "sans-serif", "Roboto-Regular.ttf"
                    }, {
                            "sans-serif-light", "Roboto-Light.ttf"
                    }, {
                            "sans-serif-medium", "Roboto-Medium.ttf"
                    }, {
                            "sans-serif-black", "Roboto-Black.ttf"
                    }, {
                            "sans-serif-condensed", "RobotoCondensed-Regular.ttf"
                    }, {
                            "sans-serif-thin", "Roboto-Thin.ttf"
                    }, {
                            "serif", "NotoSerif-Regular.ttf"
                    }
            };
            List<SystemFont> fonts = new ArrayList<>();
            for (String[] names : defaultSystemFonts) {
                File file = new File("/system/fonts", names[1]);
                if (file.exists()) {
                    fonts.add(new SystemFont(names[0], file.getAbsolutePath()));
                }
            }
            return fonts;
        }
    }

    /* Parse fallback list (no names) */
    public static Config parse(InputStream in) throws XmlPullParserException, IOException {
        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setInput(in, null);
            parser.nextTag();
            return readFamilies(parser);
        } finally {
            in.close();
        }
    }

    private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {
        Alias alias = new Alias();
        alias.name = parser.getAttributeValue(null, "name");
        alias.toName = parser.getAttributeValue(null, "to");
        String weightStr = parser.getAttributeValue(null, "weight");
        if (weightStr == null) {
            alias.weight = 0;
        } else {
            alias.weight = Integer.parseInt(weightStr);
        }
        skip(parser); // alias tag is empty, ignore any contents and consume end tag
        return alias;
    }

    private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        Config config = new Config();
        parser.require(XmlPullParser.START_TAG, null, "familyset");
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            if (parser.getName().equals("family")) {
                config.families.add(readFamily(parser));
            } else if (parser.getName().equals("alias")) {
                config.aliases.add(readAlias(parser));
            } else {
                skip(parser);
            }
        }
        return config;
    }

    private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        String name = parser.getAttributeValue(null, "name");
        String lang = parser.getAttributeValue(null, "lang");
        String variant = parser.getAttributeValue(null, "variant");
        List<Font> fonts = new ArrayList<Font>();
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String tag = parser.getName();
            if (tag.equals("font")) {
                String weightStr = parser.getAttributeValue(null, "weight");
                int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);
                boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));
                String filename = parser.nextText();
                String fullFilename = "/system/fonts/" + filename;
                fonts.add(new Font(fullFilename, weight, isItalic));
            } else {
                skip(parser);
            }
        }
        return new Family(name, fonts, lang, variant);
    }

    private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
        int depth = 1;
        while (depth > 0) {
            switch (parser.next()) {
            case XmlPullParser.START_TAG:
                depth++;
                break;
            case XmlPullParser.END_TAG:
                depth--;
                break;
            }
        }
    }

    private FontListParser() {

    }

    public static class Alias {

        public String name;

        public String toName;

        public int weight;
    }

    public static class Config {

        public List<Alias> aliases;

        public List<Family> families;

        Config() {
            families = new ArrayList<Family>();
            aliases = new ArrayList<Alias>();
        }

    }

    public static class Family {

        public List<Font> fonts;

        public String lang;

        public String name;

        public String variant;

        public Family(String name, List<Font> fonts, String lang, String variant) {
            this.name = name;
            this.fonts = fonts;
            this.lang = lang;
            this.variant = variant;
        }

    }

    public static class Font {

        public String fontName;

        public boolean isItalic;

        public int weight;

        Font(String fontName, int weight, boolean isItalic) {
            this.fontName = fontName;
            this.weight = weight;
            this.isItalic = isItalic;
        }

    }

    public static class SystemFont {

        public String name;

        public String path;

        public SystemFont(String name, String path) {
            this.name = name;
            this.path = path;
        }

    }
}

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

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

final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();
String[] items = new String[fonts.size()];
for (int i = 0; i < fonts.size(); i++) {
    items[i] = fonts.get(i).name;
}

new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        FontListParser.SystemFont selectedFont = fonts.get(which);
        // TODO: do something with the font
        Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();
    }
}).show();

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

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

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

Here

вы можете изменить шрифт в планировка используя
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/dancing_script"/>

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

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

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

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

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

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

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

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

- введите имя файла и нажмите кнопку 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-normal или italic; и fontWeight соответствует CSS спецификация веса шрифта

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

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

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

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

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

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

чтобы изменить шрифт всего приложения, добавьте эти две строки в AppTheme

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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

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

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

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

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

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


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


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

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

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

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

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


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

<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>

<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>

<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

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


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

For Custom font:

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

For Default font:

 tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));

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

FONT FAMILY                    TTF FILE                    

1  casual                      ComingSoon.ttf              
2  cursive                     DancingScript-Regular.ttf   
3  monospace                   DroidSansMono.ttf           
4  sans-serif                  Roboto-Regular.ttf          
5  sans-serif-black            Roboto-Black.ttf            
6  sans-serif-condensed        RobotoCondensed-Regular.ttf 
7  sans-serif-condensed-light  RobotoCondensed-Light.ttf   
8  sans-serif-light            Roboto-Light.ttf            
9  sans-serif-medium           Roboto-Medium.ttf           
10  sans-serif-smallcaps       CarroisGothicSC-Regular.ttf 
11  sans-serif-thin            Roboto-Thin.ttf             
12  serif                      NotoSerif-Regular.ttf       
13  serif-monospace            CutiveMono.ttf              

" mycustomfont.ttf " - это файл ttf. путь будет src / активы / шрифты / mycustomfont.ttf, вы можете сослаться больше о дефолте шрифт в этом семейство шрифтов по умолчанию


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


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

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

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

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


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

в AOSP шрифт Arial допустим, но должен быть определен с помощью "arial", а не" Arial", например android: fontFamily= "arial". У qucik посмотрите на Kitkat системный шрифт.в XML

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

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

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

    private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {
    Typeface tf = null;
    if (familyName != null) {
        tf = Typeface.create(familyName, styleIndex);
        if (tf != null) {
            setTypeface(tf);
            return;
        }
    }
    switch (typefaceIndex) {
        case SANS:
            tf = Typeface.SANS_SERIF;
            break;

        case SERIF:
            tf = Typeface.SERIF;
            break;

        case MONOSPACE:
            tf = Typeface.MONOSPACE;
            break;
    }
    setTypeface(tf, styleIndex);
}


    public void setTypeface(Typeface tf, int style) {
    if (style > 0) {
        if (tf == null) {
            tf = Typeface.defaultFromStyle(style);
        } else {
            tf = Typeface.create(tf, style);
        }

        setTypeface(tf);
        // now compute what (if any) algorithmic styling is needed
        int typefaceStyle = tf != null ? tf.getStyle() : 0;
        int need = style & ~typefaceStyle;
        mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);
        mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);
    } else {
        mTextPaint.setFakeBoldText(false);
        mTextPaint.setTextSkewX(0);
        setTypeface(tf);
    }
}

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

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

<string name="font_family_display_4_material">sans-serif-light</string>
<string name="font_family_display_3_material">sans-serif</string>
<string name="font_family_display_2_material">sans-serif</string>
<string name="font_family_display_1_material">sans-serif</string>
<string name="font_family_headline_material">sans-serif</string>
<string name="font_family_title_material">sans-serif-medium</string>
<string name="font_family_subhead_material">sans-serif</string>
<string name="font_family_menu_material">sans-serif</string>
<string name="font_family_body_2_material">sans-serif-medium</string>
<string name="font_family_body_1_material">sans-serif</string>
<string name="font_family_caption_material">sans-serif</string>
<string name="font_family_button_material">sans-serif-medium</string>

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


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

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

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

style="@style/boldText"

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

макет в xml-файле:

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

и код java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

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


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

public class ProximaNovaTextView extends TextView {

    public ProximaNovaTextView(Context context) {
        super(context);

        applyCustomFont(context);
    }

    public ProximaNovaTextView(Context context, AttributeSet attrs) {
        super(context, attrs);

        applyCustomFont(context);
    }

    public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {
       super(context, attrs, defStyle);

       applyCustomFont(context);
    } 

    private void applyCustomFont(Context context) {
        Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);
        setTypeface(customFont);
    }
}

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

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

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

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

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


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

/system/etc/шрифты.xml (для 5.0+)

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

например,

    <!-- first font is default -->
20    <family name="sans-serif">
21        <font weight="100" style="normal">Roboto-Thin.ttf</font>
22        <font weight="100" style="italic">Roboto-ThinItalic.ttf</font>
23        <font weight="300" style="normal">Roboto-Light.ttf</font>
24        <font weight="300" style="italic">Roboto-LightItalic.ttf</font>
25        <font weight="400" style="normal">Roboto-Regular.ttf</font>
26        <font weight="400" style="italic">Roboto-Italic.ttf</font>
27        <font weight="500" style="normal">Roboto-Medium.ttf</font>
28        <font weight="500" style="italic">Roboto-MediumItalic.ttf</font>
29        <font weight="900" style="normal">Roboto-Black.ttf</font>
30        <font weight="900" style="italic">Roboto-BlackItalic.ttf</font>
31        <font weight="700" style="normal">Roboto-Bold.ttf</font>
32        <font weight="700" style="italic">Roboto-BoldItalic.ttf</font>
33    </family>

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

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

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


Я использую письмо нажмите lib для моего NonTextView вещи, как кнопки и kianoni fontloader lib для моих TextViews причина использования стиля в этом lib более проста, чем письмо пресс для меня, и я получил идеальную обратную связь с этим. это отлично подходит для тех, кто хочет использовать пользовательский шрифт, кроме шрифта 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);

может в этом помочь.


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

https://github.com/sunnag7/FontStyler

<com.sunnag.fontstyler.FontStylerView
              android:textStyle="bold"
              android:text="@string/about_us"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:paddingTop="8dp"
              app:fontName="Lato-Bold"
              android:textSize="18sp"
              android:id="@+id/textView64" />

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


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

 android:fontFamily="@font/frutiger"

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