Bagaimana cara mengubah fontFamily of TextView di Android

Jadi saya ingin mengubah android:fontFamilydi Android tapi saya tidak melihat font yang sudah ditentukan sebelumnya di Android. Bagaimana cara memilih salah satu yang sudah ditentukan sebelumnya? Saya tidak benar-benar perlu mendefinisikan TypeFace saya sendiri tetapi semua yang saya butuhkan adalah sesuatu yang berbeda dari apa yang ditunjukkannya saat ini.

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

Sepertinya apa yang saya lakukan di sana tidak akan benar-benar bekerja! BTW android:fontFamily="Arial"adalah upaya bodoh!

Dari android 4.1 / 4.2 / 5.0, keluarga font Roboto berikut tersedia:

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)

dalam kombinasi dengan

android:textStyle="normal|bold|italic"

16 varian ini dimungkinkan:

• Roboto biasa
• Roboto italic
• Roboto berani
• Roboto dicetak miring tebal
• Roboto-Light
• Roboto-Light italic
• Roboto-Thin
• Roboto-Thin italic
• Roboto-Condensed
• Huruf miring-Roboto
• Roboto-Condensed bold
• Roboto-Condensed cetak miring tebal
• Roboto-Black
• Roboto-Black italic
• Roboto-Medium
• Roboto-Medium italic

fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="font_family_light">sans-serif-light</string>
    <string name="font_family_medium">sans-serif-medium</string>
    <string name="font_family_regular">sans-serif</string>
    <string name="font_family_condensed">sans-serif-condensed</string>
    <string name="font_family_black">sans-serif-black</string>
    <string name="font_family_thin">sans-serif-thin</string>
</resources>

Ini adalah cara untuk mengatur font secara terprogram:

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

letakkan file font di folder aset Anda. Dalam kasus saya, saya membuat subdirektori yang disebut font.

EDIT: Jika Anda bertanya-tanya di mana folder aset Anda melihat pertanyaan ini

Mulai dari Android-Studio 3.0 sangat mudah untuk mengubah keluarga font

Menggunakan perpustakaan dukungan 26, ini akan berfungsi pada perangkat yang menjalankan Android API versi 16 dan lebih tinggi

Buat folder di fontbawah resdirektori .Download font yang Anda inginkan dan rekatkan di dalam fontfolder. Strukturnya harus seperti di bawah ini

Catatan: Pada Android Support Library 26.0, Anda harus mendeklarasikan kedua set atribut (android: dan aplikasi:) untuk memastikan font Anda dimuat di perangkat yang menjalankan Api 26 atau lebih rendah.

Sekarang Anda dapat mengubah font dalam tata letak menggunakan

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

Untuk mengubah secara Programatis

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

Untuk mengubah font menggunakan styles.xml buat gaya

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

dan terapkan gaya ini ke TextView

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

Anda juga dapat membuat keluarga font Anda sendiri

- Klik kanan folder font dan pergi ke New> File sumber daya font . Jendela File Sumber Daya Baru muncul.

- Masukkan nama file , lalu klik OK . Sumber daya font baru XML terbuka di editor.

Tulis keluarga font Anda sendiri di sini, misalnya

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

ini hanyalah pemetaan dari fontStyle dan fontWeight tertentu ke sumber daya font yang akan digunakan untuk membuat varian tertentu. Nilai yang valid untuk fontStyle adalah normal atau miring; dan fontWeight sesuai dengan spesifikasi font-weight CSS

1. Untuk mengubah fontfamily dalam tata letak yang dapat Anda tulis

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

2. Untuk Mengubah Secara Programatis

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

Untuk mengubah font seluruh Aplikasi Tambahkan dua baris ini di 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>

Lihat Dokumentasi , Tutorial Huruf Kustom Android Untuk info lebih lanjut

Saya harus menguraikan /system/etc/fonts.xmldalam proyek baru-baru ini. Berikut adalah keluarga font saat ini dari 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Inilah parser (berdasarkan dari 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;
        }

    }
}

Jangan ragu untuk menggunakan kelas di atas dalam proyek Anda. Misalnya, Anda bisa memberi pengguna Anda kumpulan font font dan mengatur jenis huruf berdasarkan preferensi mereka.

Contoh kecil tidak lengkap:

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 tidak memungkinkan Anda untuk mengatur font khusus dari tata letak XML. Alih-alih, Anda harus menggabungkan file font tertentu di folder aset aplikasi Anda, dan mengaturnya secara terprogram. Sesuatu seperti:

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

Perhatikan bahwa Anda hanya dapat menjalankan kode ini setelah setContentView () dipanggil. Juga, hanya beberapa font yang didukung oleh Android, dan harus dalam format .ttf (TrueType)atau a .otf (OpenType). Meskipun begitu, beberapa font mungkin tidak berfungsi.

Ini adalah font yang pasti berfungsi pada Android, dan Anda dapat menggunakannya untuk mengonfirmasi bahwa kode Anda berfungsi seandainya file font Anda tidak didukung oleh Android.

Pembaruan Android O: Sekarang dimungkinkan dengan XML di Android O , berdasarkan komentar Roger.

Untuk mengatur Roboto secara terprogram:

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

Itu sama dengan android:typeface .

font bawaan adalah:

• normal
• tanpa
• serif
• ruang angkasa

Lihat android: jenis huruf .

Jika Anda menginginkannya secara terprogram, Anda dapat menggunakannya

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

Di mana SANS_SERIFAnda dapat menggunakan:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Dan di mana ITALICAnda dapat menggunakan:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Semua dinyatakan pada Pengembang Android

Saya menggunakan Kaligrafi perpustakaan yang sangat baik oleh Chris Jenx yang dirancang untuk memungkinkan Anda menggunakan font khusus di aplikasi Android Anda. Cobalah!

Apa yang Anda inginkan tidak mungkin. Anda harus mengatur TypeFacedalam Kode Anda.

Yang XMLbisa Anda lakukan adalah

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

selain ini, Anda tidak dapat bermain banyak dengan Font dalam XML. :)

Untuk ArialAnda perlu mengatur jenis wajah dalam kode Anda.

Cara mudah untuk mengelola font adalah dengan mendeklarasikannya melalui sumber daya, seperti:

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

Ini didasarkan pada kode sumber di sini dan di sini

Secara dinamis Anda dapat mengatur fontfamily mirip dengan android: fontFamily di xml dengan menggunakan ini,

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

Ini adalah daftar keluarga font default yang digunakan, gunakan semua ini dengan mengganti string kutipan ganda "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" adalah file ttf. Path akan ada di src / aset / fonts / mycustomfont.ttf , Anda dapat merujuk lebih lanjut tentang font default di keluarga font Default ini

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

atur font dengan mudah ke semua tampilan teks dari res> direktori font secara terprogram

Saya pikir saya sudah terlambat tetapi mungkin solusi ini bermanfaat bagi orang lain. Untuk menggunakan font khusus, tempatkan file font Anda di direktori font Anda.

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

Dengan beberapa trial and error saya belajar yang berikut ini.

Dalam * .xml Anda dapat menggabungkan fonta saham dengan fungsi berikut, tidak hanya dengan jenis huruf:

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

Dengan dua gaya ini, tidak perlu menggunakan jenis huruf dalam hal lain. Kisaran kombinasi jauh lebih besar dengan fontfamily & textStyle.

Nilai yang valid dari android: fontFamily didefinisikan dalam /system/etc/system_fonts.xml(4.x) atau /system/etc/fonts.xml(5.x). Tetapi Produsen Perangkat mungkin memodifikasinya, jadi font aktual yang digunakan dengan mengatur nilai fontFamily tergantung pada file yang disebutkan di atas dari perangkat yang ditentukan.

Dalam AOSP, font Arial valid tetapi harus didefinisikan menggunakan "arial" bukan "Arial", misalnya android: fontFamily = "arial" . Silakan lihat qucik di 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>

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

Ada tiga atribut xml yang relevan untuk mendefinisikan "font" dalam tata letak - android: fontFamily , android: typeface dan android: textStyle . Kombinasi "fontFamily" dan "textStyle" atau "typeface" dan "textStyle" dapat digunakan untuk mengubah tampilan font dalam teks, sehingga tidak digunakan sendiri. Cuplikan kode di TextView.java seperti ini:

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

Dari kode tersebut kita dapat melihat:

1. jika "fontFamily" diatur, maka "jenis huruf" akan diabaikan.
2. "typeface" memiliki nilai valid standar dan terbatas. Bahkan, nilainya adalah "normal" "sans" "serif" dan "monospace", mereka dapat ditemukan di system_fonts.xml (4.x) atau fonts.xml (5.x). Sebenarnya "normal" dan "sans" adalah font default sistem.
3. "fontFamily" dapat digunakan untuk mengatur semua font font yang ada di dalam, sedangkan "jenis huruf" hanya menyediakan font khas "sans-serif" "serif" dan "monospace" (tiga kategori utama jenis font di dunia) .
4. Ketika hanya mengatur "textStyle", Kami sebenarnya mengatur font default dan gaya yang ditentukan. Nilai efektifnya adalah "normal" "bold" "italic" dan "bold | italic".

Berikut ini adalah cara yang lebih mudah yang dapat bekerja dalam beberapa kasus. Prinsipnya adalah menambahkan TextVview yang tidak terlihat di tata letak xml Anda dan untuk mendapatkan typeFace dalam kode java.

Tata letak dalam file 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"/>

Dan kode java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Ini berhasil bagi saya (misalnya dalam TextSwitcher).

Coba ini:

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

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

Anda juga dapat melakukan ini dengan menambahkan folder font di bawah direktori res seperti di bawah ini.

Kemudian, pilih Font sebagai jenis sumber daya.

Anda dapat menemukan font yang tersedia dari https://www.1001fonts.com/ , dan kemudian mengekstrak file TTF ke direktori font ini.

Terakhir, ubah saja file XML yang berisi tampilan teks Anda dengan menambahkan android: fontFamily: "@ font / urfontfilename"

Salah satu cara sederhana adalah dengan menambahkan font yang diinginkan dalam proyek.

Pergi ke File-> Baru-> Font Pilih Direktori Direktori Baru

Ini akan membuat direktori baru, font , di sumber daya Anda.

Unduh font Anda (.ttf) . Saya menggunakan https://fonts.google.com untuk hal yang sama

Tambahkan itu ke folder font Anda kemudian gunakan dalam XML atau secara terprogram.

XML -

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

Secara terprogram -

 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>

Jika Anda ingin menggunakan TextView di banyak tempat dengan keluarga font yang sama, perluas kelas TextView dan atur font Anda seperti ini: -

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

Dan kemudian gunakan kelas khusus ini dalam xml untuk TextView seperti ini: -

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

Jika Anda menggunakan Android Studio 3.5+, Mengubah font sangat sederhana. Pilih widget teks pada tampilan Desain dan periksa fontFamily di Jendela Atribut. Dropdown nilai berisi semua font yang tersedia yang dapat Anda pilih. Jika Anda mencari Google Fonts, klik opsi More Fonts.

Jendela Atribut

Google Fonts

Saya hanya ingin menyebutkan bahwa font dengan Android akan segera berakhir, karena tahun ini di Google IO kita akhirnya mendapatkan ini -> https://developer.android.com/preview/features/working-with-fonts. html

Sekarang ada sumber daya baru ketik huruf dan Anda dapat menempatkan semua font aplikasi Anda di dalam res / font folder dan akses kemudian dengan R.font.my_custom_font, seperti Anda dapat mengakses string yang nilai res, ditarik res nilai dll Anda memiliki kesempatan bahkan untuk membuat font-face file xml , yang akan diatur font kustom Anda (tentang italic, bold dan garis bawahi attr).

Baca tautan di atas untuk info lebih lanjut. Mari kita lihat dukungannya.

Ada perpustakaan bagus yang tersedia untuk ini

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

Sumber daya font baru memungkinkan untuk mengatur secara langsung fontmenggunakan

android:fontFamily="@font/my_font_in_font_folder"

Anda mengatur gaya res/layout/value/style.xmlseperti itu:

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

dan untuk menggunakan gaya ini dalam main.xmlpenggunaan file:

style="@style/boldText"

Untuk android-studio 3 dan di atasnya, Anda dapat menggunakan gaya ini dan kemudian semua textViewperubahan font di aplikasi.

buat gaya ini di style.xml:

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

Kemudian gunakan dalam tema Anda:

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

Cara termudah untuk menambahkan font secara terprogram ke TextView adalah, pertama-tama, tambahkan file font di folder Aset Anda dalam proyek. Misalnya jalur font Anda terlihat seperti ini:assets/fonts/my_font.otf

Dan tambahkan ke TextView sebagai:

Kotlin

val font_path = "fonts/my_font.otf"  

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

textView.typeface = myTypeface

Jawa

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

Di sini Anda dapat melihat semua nilai fontFamily yang tersedia dan nama file font yang bersangkutan (File ini digunakan di android 5.0+). Di perangkat seluler, Anda dapat menemukannya di:

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

(Untuk Android 4.4 dan di bawah ini menggunakan versi ini , tapi saya pikir itu fonts.xmlmemiliki format yang lebih jelas dan mudah dimengerti.)

Sebagai contoh,

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

Atribut nama name="sans-serif"dari familytag didefinisikan nilai yang Anda dapat menggunakan di android: fontFamily.

Itu font tag mendefinisikan file font berkorespondensi.

Dalam hal ini, Anda dapat mengabaikan sumber di bawah <!-- fallback fonts -->, itu menggunakan logika fallback font.