Cách thay đổi phông chữ Gia đình của TextView trong Android

Vì vậy, tôi muốn thay đổi android:fontFamilytrong Android nhưng tôi không thấy bất kỳ phông chữ được xác định trước nào trong Android. Làm cách nào để chọn một trong những cái được xác định trước? Tôi thực sự không cần phải xác định TypeFace của riêng mình nhưng tất cả những gì tôi cần là một cái gì đó khác với những gì nó hiển thị ngay bây giờ.

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

Có vẻ như những gì tôi đã làm ở đó sẽ không thực sự làm việc! BTW android:fontFamily="Arial"là một nỗ lực ngu ngốc!

Từ Android 4.1 / 4.2 / 5.0, các họ phông chữ Roboto sau đây có sẵn:

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)

kết hợp với

android:textStyle="normal|bold|italic"

16 biến thể này là có thể:

• Roboto thường xuyên
• Roboto in nghiêng
• Roboto đậm
• Roboto in nghiêng đậm
• Roboto-Light
• Roboto-Light in nghiêng
• Roboto-Thin
• Roboto-Thin in nghiêng
• Roboto-Ngưng
• Roboto-Ngưng nghiêng
• Roboto đậm đặc
• Roboto-đậm đặc in nghiêng
• Roboto-Đen
• Roboto-Đen in nghiêng
• Roboto-Trung bình
• Roboto-Medium in nghiêng

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>

Đây là cách để đặt phông chữ theo chương trình:

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

đặt tập tin phông chữ trong thư mục tài sản của bạn. Trong trường hợp của tôi, tôi đã tạo một thư mục con được gọi là phông chữ.

EDIT: Nếu bạn tự hỏi thư mục tài sản của bạn ở đâu, hãy xem câu hỏi này

Bắt đầu từ Android-Studio 3.0 họ rất dễ thay đổi họ phông chữ

Sử dụng thư viện hỗ trợ 26, nó sẽ hoạt động trên các thiết bị chạy Android API phiên bản 16 trở lên

Tạo một thư mục fonttrong thư mục res. Tải xuống phông chữ mà bạn muốn và dán nó vào fontthư mục. Cấu trúc nên là một số thứ như dưới đây

Ghi chú: Kể từ Thư viện hỗ trợ Android 26.0, bạn phải khai báo cả hai bộ thuộc tính (android: và ứng dụng :) để đảm bảo phông chữ của bạn tải trên các thiết bị chạy Api 26 trở xuống.

Bây giờ bạn có thể thay đổi phông chữ trong bố cục bằng cách sử dụng

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

Thay đổi theo chương trình

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

Để thay đổi phông chữ bằng cách sử dụng tệp phong cách, hãy tạo một kiểu

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

và áp dụng phong cách này cho TextView

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

bạn cũng có thể Tạo họ phông chữ của riêng bạn

- Nhấp chuột phải vào thư mục phông chữ và đi đến Mới> Tệp tài nguyên phông chữ . Cửa sổ Tệp tài nguyên mới xuất hiện.

- Nhập tên tệp , sau đó bấm OK . XML tài nguyên phông chữ mới mở trong trình soạn thảo.

Viết họ phông chữ của riêng bạn ở đây, ví dụ

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

đây chỉ đơn giản là ánh xạ của một phông chữ cụ thể và phông chữ đối với tài nguyên phông chữ sẽ được sử dụng để hiển thị biến thể cụ thể đó. Các giá trị hợp lệ cho fontStyle là bình thường hoặc in nghiêng; và fontweight phù hợp với đặc tả trọng lượng phông chữ CSS

1. Để thay đổi fontf Family trong bố cục, bạn có thể viết

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

2. Thay đổi theo chương trình

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

Để thay đổi phông chữ của toàn bộ Ứng dụng Thêm hai dòng này trong 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>

Xem Tài liệu , Hướng dẫn về Phông chữ Tùy chỉnh của Android để biết thêm thông tin

Tôi đã phải phân tích cú pháp /system/etc/fonts.xmltrong một dự án gần đây. Dưới đây là các họ phông chữ hiện tại kể từ 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Đây là trình phân tích cú pháp (dựa trên 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;
        }

    }
}

Hãy sử dụng các lớp trên trong dự án của bạn. Ví dụ: bạn có thể cung cấp cho người dùng lựa chọn các họ phông chữ và đặt kiểu chữ dựa trên sở thích của họ.

Một ví dụ nhỏ không đầy đủ:

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 không cho phép bạn đặt phông chữ tùy chỉnh từ bố cục XML. Thay vào đó, bạn phải gói tệp phông chữ cụ thể trong thư mục tài sản của ứng dụng và đặt nó theo chương trình. Cái gì đó như:

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

Lưu ý rằng bạn chỉ có thể chạy mã này sau khi setContentView () được gọi. Ngoài ra, chỉ một số phông chữ được Android hỗ trợ và phải ở dạng .ttf (TrueType)hoặc .otf (OpenType)định dạng. Thậm chí sau đó, một số phông chữ có thể không hoạt động.

Điều này là một phông chữ chắc chắn hoạt động trên Android và bạn có thể sử dụng nó để xác nhận rằng mã của bạn đang hoạt động trong trường hợp tệp phông chữ của bạn không được Android hỗ trợ.

Cập nhật Android O: Hiện tại có thể có XML trong Android O , dựa trên nhận xét của Rogers.

Để đặt Roboto theo chương trình:

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

Nó giống như android:typeface.

phông chữ tích hợp là:

• bình thường
• không
• serif
• không gian

Xem android: kiểu chữ .

Nếu bạn muốn nó lập trình, bạn có thể sử dụng

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

Nơi SANS_SERIFbạn có thể sử dụng:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Và nơi ITALICbạn có thể sử dụng:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Tất cả được nêu trên Nhà phát triển Android

Tôi đang sử dụng thư viện tuyệt vời Thư pháp do Chris Jenx thiết kế để cho phép bạn sử dụng phông chữ tùy chỉnh trong ứng dụng Android của mình. Hãy thử một lần!

Những gì bạn muốn là không thể. Bạn phải đặt TypeFacetrong Mã của bạn.

Trong XMLnhững gì bạn có thể làm là

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

ngoài ra thì bạn không thể chơi nhiều với các Phông chữ trong XML. :)

Đối với Arialbạn cần phải đặt khuôn mặt loại trong mã của bạn.

Một cách dễ dàng để quản lý các phông chữ sẽ là khai báo chúng thông qua các tài nguyên, như sau:

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

Điều này dựa trên mã nguồn ở đây và đây

Tự động, bạn có thể đặt phông chữ tương tự như android: fontF Family trong xml bằng cách sử dụng này,

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

Đây là danh sách họ phông chữ mặc định được sử dụng, sử dụng bất kỳ trong số này bằng cách thay thế chuỗi trích dẫn kép "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" là tệp ttf. Đường dẫn sẽ ở dạng src / nội dung / phông chữ / mycustomfont.ttf , bạn có thể tham khảo thêm về phông chữ mặc định trong họ phông chữ Mặc định này

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

dễ dàng đặt phông chữ cho bất kỳ văn bản xem nào từ res> thư mục phông chữ theo chương trình

Tôi nghĩ rằng tôi đã quá muộn nhưng có lẽ giải pháp này hữu ích cho người khác. Để sử dụng phông chữ tùy chỉnh, đặt tệp phông chữ của bạn trong thư mục phông chữ của bạn.

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

Với một số thử nghiệm và lỗi tôi đã học được sau đây.

Trong * .xml, bạn có thể kết hợp phông chữ stock với các chức năng sau, không chỉ với kiểu chữ:

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

Với hai kiểu này, không cần sử dụng kiểu chữ trong bất kỳ trường hợp nào khác. Phạm vi kết hợp lớn hơn nhiều với fontf Family & textStyle.

Giá trị hợp lệ của android: fontF Family được xác định trong /system/etc/system_fonts.xml(4.x) hoặc /system/etc/fonts.xml(5.x). Nhưng Nhà sản xuất thiết bị có thể sửa đổi nó, vì vậy phông chữ thực tế được sử dụng bằng cách đặt giá trị fontF Family tùy thuộc vào tệp được đề cập ở trên của thiết bị được chỉ định.

Trong AOSP, phông chữ Arial hợp lệ nhưng phải được xác định bằng cách sử dụng "arial" chứ không phải "Arial", ví dụ như android: fontF Family = "arial" . Có một cái nhìn qucik về system_fonts.xml của 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>

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

Có ba thuộc tính xml có liên quan để xác định "phông chữ" trong bố cục-- android: fontF Family , android: typeface và android: textStyle . Sự kết hợp của "fontF Family" và "textStyle" hoặc "typeface" và "textStyle" có thể được sử dụng để thay đổi giao diện của phông chữ trong văn bản, do đó chỉ được sử dụng một mình. Đoạn mã trong TextView.java như thế này:

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

Từ mã Chúng ta có thể thấy:

1. nếu "fontF Family" được đặt, thì "kiểu chữ" sẽ bị bỏ qua.
2. "Kiểu chữ" có các giá trị hợp lệ tiêu chuẩn và giới hạn. Trong thực tế, các giá trị là "bình thường" "sans" "serif" và "monospace", chúng có thể được tìm thấy trong system_fonts.xml (4.x) hoặc scripts.xml (5.x). Trên thực tế cả "bình thường" và "sans" là phông chữ mặc định của hệ thống.
3. "fontF Family" có thể được sử dụng để đặt tất cả các phông chữ của phông chữ tích hợp, trong khi "kiểu chữ" chỉ cung cấp các phông chữ điển hình của "sans-serif" "serif" và "monospace" (ba loại chính của loại phông chữ trên thế giới) .
4. Khi chỉ đặt "textStyle", chúng tôi thực sự đặt phông chữ mặc định và kiểu được chỉ định. Giá trị hiệu quả là "bình thường" "đậm" "in nghiêng" và "đậm | in nghiêng".

Đây là một wa y dễ dàng hơn có thể làm việc trong một số trường hợp. Nguyên tắc là thêm một TextVview không hiển thị trong bố cục xml của bạn và để lấy typeFace của nó trong mã java.

Bố cục trong tệp 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"/>

Và mã java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Nó đã làm việc cho tôi (ví dụ trong một TextSwitcher).

Thử cái này:

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

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

Bạn cũng có thể làm điều này bằng cách thêm một thư mục phông chữ trong thư mục res như bên dưới.

Sau đó, chọn Phông chữ làm loại tài nguyên.

Bạn có thể tìm thấy các phông chữ có sẵn từ https://www.1001fonts.com/ , sau đó trích xuất các tệp TTF vào thư mục phông chữ này.

Cuối cùng, chỉ cần thay đổi tệp XML chứa textview của bạn bằng cách thêm android: fontF Family: "@ font / urfontfilename"

Một cách đơn giản là bằng cách thêm phông chữ mong muốn trong dự án.

Chuyển đến Tệp-> Mới-> Thư mục tài nguyên mới Chọn phông chữ

Điều này sẽ tạo một thư mục mới, phông chữ , trong tài nguyên của bạn.

Tải xuống phông chữ của bạn (.ttf) . Tôi sử dụng https://fonts.google.com cho cùng

Thêm nó vào thư mục phông chữ của bạn sau đó sử dụng chúng trong XML hoặc lập trình.

XML -

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

Lập trình -

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

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

Nếu bạn muốn sử dụng TextView ở nhiều nơi có cùng họ phông chữ, hãy mở rộng lớp TextView và đặt phông chữ của bạn như sau: -

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

Và sau đó sử dụng lớp tùy chỉnh này trong xml cho TextView như thế này: -

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

Nếu bạn đang sử dụng Android Studio 3.5+, việc thay đổi phông chữ cực kỳ đơn giản. Chọn tiện ích văn bản trên dạng xem Thiết kế và kiểm tra phông chữ Gia đình trên Cửa sổ Thuộc tính. Danh sách thả xuống giá trị chứa tất cả các phông chữ có sẵn mà bạn có thể chọn một phông chữ. Nếu bạn đang tìm kiếm Google Fonts, Nhấp vào tùy chọn Thêm phông chữ.

Cửa sổ thuộc tính

Phông chữ Google

Tôi chỉ muốn đề cập rằng địa ngục với các phông chữ bên trong Android sắp kết thúc, bởi vì năm nay trên Google IO, cuối cùng chúng tôi đã có được điều này -> https://developer.android.com/preview/features/usiness-with-fonts. html

Bây giờ có một loại tài nguyên mới một phông chữ và bạn có thể đặt tất cả các phông chữ ứng dụng của mình vào thư mục res / phông chữ và truy cập sau đó với R.font.my_custom_font, giống như bạn có thể truy cập các giá trị độ phân giải chuỗi , giá trị độ phân giải có thể vẽ , v.v. để tạo tệp xml mặt phông chữ , sẽ được đặt các phông chữ tùy chỉnh của bạn (về chữ nghiêng, đậm và gạch chân).

Đọc liên kết trên để biết thêm. Hãy xem sự hỗ trợ.

Có một thư viện đẹp cho việc này

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

Tài nguyên phông mới cho phép đặt trực tiếp fontbằng

android:fontFamily="@font/my_font_in_font_folder"

Bạn đặt kiểu res/layout/value/style.xmlnhư thế:

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

và để sử dụng kiểu này trong main.xmltập tin sử dụng:

style="@style/boldText"

Đối với android-studio 3 trở lên, bạn có thể sử dụng kiểu này và sau đó tất cả textViewthay đổi phông chữ trong ứng dụng.

tạo phong cách này trong style.xml:

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

Sau đó sử dụng nó trong chủ đề của bạn:

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

Cách dễ nhất để thêm phông chữ theo chương trình vào TextView là, trước tiên, thêm tệp phông chữ trong thư mục Tài sản của bạn trong dự án. Ví dụ: đường dẫn phông chữ của bạn trông như thế này:assets/fonts/my_font.otf

Và thêm nó vào TextView như:

Kotlin

val font_path = "fonts/my_font.otf"  

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

textView.typeface = myTypeface

Java

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

Tại đây bạn có thể thấy tất cả các giá trị fontF Family có sẵn và tên của tệp phông chữ tương ứng (Tệp này đang sử dụng trong Android 5.0+). Trong thiết bị di động, bạn có thể tìm thấy nó trong:

/system/etc/fonts.xml (cho 5.0+)

(Đối với Android 4.4 trở xuống sử dụng phiên bản này , nhưng tôi nghĩ rằng nó fonts.xmlcó định dạng rõ ràng hơn và dễ hiểu hơn.)

Ví dụ,

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

Thuộc tính tên name="sans-serif"của familythẻ đã xác định giá trị bạn có thể sử dụng trong Android: fontF Family.

Các fontthẻ xác định các tập tin phông chữ tương ứng.

Trong trường hợp này, bạn có thể bỏ qua nguồn bên dưới <!-- fallback fonts -->, nó sử dụng cho logic dự phòng của phông chữ.