Jak zmienić fontFamily z TextView w Androidzie

739

Więc chciałbym zmienić android:fontFamily w Androidzie, ale nie widzę żadnych wstępnie zdefiniowanych czcionek w Androidzie. Jak wybrać jeden ze wstępnie zdefiniowanych? Tak naprawdę nie muszę definiować własnego TypeFace'a, ale wszystko, czego potrzebuję, to coś innego niż to, co pokazuje teraz.

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

Wygląda na to, że to, co tam zrobiłem, naprawdę nie zadziała! BTW android:fontFamily="Arial"była głupią próbą!

Tarik
źródło
sprawdź ten link stackoverflow.com/questions/2376250/…
duggu

Odpowiedzi:

1660

W Androidzie 4.1 / 4.2 / 5.0 dostępne są następujące rodziny czcionek 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)

wprowadź opis zdjęcia tutaj

w połączeniu z

android:textStyle="normal|bold|italic"

możliwe jest 16 wariantów:

  • Roboto regularne
  • Roboto kursywa
  • Roboto pogrubienie
  • Roboto pogrubioną kursywą
  • Roboto-Light
  • Roboto-Light kursywa
  • Roboto-Thin
  • Roboto-Thin kursywa
  • Roboto-Condensed
  • Roboto-Condensed kursywa
  • Roboto-Condensed pogrubienie
  • Roboto-Condensed pogrubiona kursywa
  • Roboto-Black
  • Kursywa Roboto-Czarna
  • Roboto-Medium
  • Roboto-średnia kursywa

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>
Jakob Eriksson
źródło
17
Nie zapomnij tego: android: fontFamily = "sans-serif-thin" // roboto thin
Sam Lu
6
W książce roboto widziałem wariant o nazwie „czarne małe czapki” , ale nie potrafię go użyć. Korzystanie android:fontFamily="sans-serif-black-small-caps"nie działa. Czy ktoś wie
tbruyelle
3
Nie jestem w stanie znaleźć żadnej z tych rodzin czcionek, które tu wpisałeś. Nie jestem w stanie znaleźć razem „sans-serif”.
Monty,
9
To ładna lista. Czy ktoś ma link do źródła informacji? Byłoby miło, gdyby Google miał to w swojej dokumentacji w łatwym do znalezienia miejscu, na przykład w dokumentacji android:fontFamilyTextView.
Christopher Perry
8
Ostateczna lista czcionek można znaleźć w system_fonts.xml jak wyjaśniono tutaj
Newtonx
207

Oto sposób programowego ustawienia czcionki:

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

umieść plik czcionek w folderze zasobów. W moim przypadku utworzyłem podkatalog o nazwie czcionki.

EDYCJA: Jeśli zastanawiasz się, gdzie jest folder zasobów, zobacz to pytanie

Stefan Beike
źródło
34
Chociaż to działa, pamiętaj, że może to spowodować wyciek pamięci . Można to naprawić za pomocą tej odpowiedzi .
Charles Madere
@ ScootrNova pojawia się ten błąd, gdy korzystam z Twojego rozwiązania. Błąd: Nie znaleziono zasobu czcionki gothic.ttf
Sagar Devanga
Jak zastosować to do całej aplikacji? W tym
momencie
176

Począwszy od Androida-Studio 3.0 bardzo łatwo zmienić rodzinę czcionek

Korzystając z biblioteki pomocy 26, będzie działać na urządzeniach z Android API w wersji 16 i wyższej

Utwórz folder fontw reskatalogu. Pobierz czcionkę, którą chcesz i wklej ją do fontfolderu. Struktura powinna wyglądać jak poniżej

Tutaj

Uwaga: Począwszy od Android Support Library 26.0, musisz zadeklarować oba zestawy atrybutów (Android: i app:), aby zapewnić ładowanie czcionek na urządzeniach z Api 26 lub starszym.

Teraz możesz zmienić czcionkę w układzie za pomocą

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

Aby zmienić programowo

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

Aby zmienić czcionkę za pomocą styles.xml, utwórz styl

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

i zastosuj ten styl do TextView

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

możesz także stworzyć własną rodzinę czcionek

- Kliknij folder czcionek prawym przyciskiem myszy i wybierz Nowy> Plik zasobów czcionek . Zostanie wyświetlone okno Nowy plik zasobów.

- Wprowadź nazwę pliku , a następnie kliknij OK . Nowy plik XML zasobów czcionek zostanie otwarty w edytorze.

Na przykład tutaj wpisz własną rodzinę czcionek

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

jest to po prostu mapowanie określonego fontStyle i fontWeight na zasób czcionki, który zostanie użyty do renderowania tego konkretnego wariantu. Prawidłowe wartości dla fontStyle są normalne lub kursywą; i fontWeight jest zgodny ze specyfikacją grubości czcionki CSS

1. Aby zmienić rodzinę czcionek w układzie , możesz pisać

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

2. Aby zmienić programowo

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

Aby zmienić czcionkę całej aplikacji Dodaj te dwa wiersze w 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>

Zobacz dokumentację , samouczek czcionek niestandardowych Androida, aby uzyskać więcej informacji

Manohar Reddy
źródło
7
Uwaga: obecnie działa to tylko w wersji zapoznawczej Android Studio 3.0. Nie działało to dla mnie w Android Studio 2.3.3. Mam nadzieję, że ktoś oszczędzi trochę czasu!
Tash Pemhiwa
2
Jak zdobyć czcionkę z fragmentu, skoro nie możesz tego zrobić getResources()? EDYCJA : Ta linia na końcu twojej odpowiedzi zadziałała dla mnie: Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
Paradoks
W jakiś sposób sprawiło to, że czcionka wyglądała na zepsutą w porównaniu do Caligtraphy. Również fontWeight nic nie robi
Leo Droidcoder
@LeoDroidcoder to działa, upewnij się, że użyłeś obu android:fontWeightiapp:fontWeight
Manohar Reddy
Sprawdziłem kilka razy. Brak efektu
Leo Droidcoder
100

Musiałem przeanalizować /system/etc/fonts.xmlw ostatnim projekcie. Oto aktualne rodziny czcionek od 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              
╚════╩════════════════════════════╩═════════════════════════════╝

Oto analizator składni (oparty na 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;
        }

    }
}

Możesz użyć powyższej klasy w swoim projekcie. Na przykład możesz dać swoim użytkownikom wybór rodzin czcionek i ustawić krój pisma na podstawie ich preferencji.

Mały niekompletny przykład:

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();
Jared Rummler
źródło
Czy wiesz może, która wersja Androida dodała jaką czcionkę?
programista Androida
@androiddeveloper Nie. Prawdopodobnie można się tego dowiedzieć, przeglądając zmiany tutaj: github.com/android/platform_frameworks_base/blob/…
Jared Rummler
@JaredRummler, wybacz moją ignorancję. Dlaczego / Co to jest waga == 400?
Samuel
1
@Samuel Dawno nie patrzyłem na ten kod, ale grubość czcionki 400 jest używana dla czcionek „normalnych” lub „zwykłych”. Przykład: Roboto-Regular ma wagę 400.
Jared Rummler
Czy to wymaga rootowania czy coś takiego? Uruchomiłem ten kod na emulatorze Androida (wersja 8.1), a kiedy zadzwoniłem getSystemFonts(), otrzymałem wyjątekorg.xmlpull.v1.XmlPullParserException: END_TAG expected (position:START_TAG (empty) <axis tag='wdth' stylevalue='100.0'>@219:51 in java.io.InputStreamReader@f001fb3)
Cholerne warzywa
49

Android nie pozwala na ustawienie niestandardowych czcionek z układu XML. Zamiast tego musisz spakować określony plik czcionek w folderze zasobów aplikacji i ustawić go programowo. Coś jak:

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

Zauważ, że możesz uruchomić ten kod tylko po wywołaniu setContentView (). Ponadto tylko niektóre czcionki są obsługiwane przez system Android i powinny mieć format .ttf (TrueType)lub .otf (OpenType). Nawet wtedy niektóre czcionki mogą nie działać.

Jest to czcionka, która zdecydowanie działa na Androidzie, i możesz jej użyć, aby potwierdzić, że Twój kod działa, na wypadek, gdyby plik czcionki nie był obsługiwany przez Androida.

Aktualizacja Androida O: Jest to teraz możliwe dzięki XML w Androidzie O , na podstawie komentarza Rogera.

Raghav Sood
źródło
„Android nie pozwala ci ustawiać niestandardowych czcionek z układu XML”. Zostało to zmienione w Androidzie O, który pozwala tworzyć niestandardowe rodziny czcionek i stosować je w XML: developer.android.com/preview/features/working-with-fonts.html
Roger Huang
27

Aby ustawić Roboto programowo:

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
Oded Breiner
źródło
25

To jest tak samo jak android:typeface.

wbudowane czcionki to:

  • normalna
  • sans
  • szeryf
  • monospace

Zobacz android: krój pisma .

biegleux
źródło
4
Nie sądzę, że to jest to samo, ale wydaje się, że nie możemy używać obu. Wygląda na to, że są teraz przypisane nie mniej niż trzy różne atrybuty setTypeface(). Mianowicie fontFamily, typefacei textStyle. Ale nie mogę przez całe życie dowiedzieć się, jak są one dokładnie połączone, aby rozwiązać konkretną instancję kroju pisma. Czy ktoś to rozgryzł? Dokumentacja Google jest mniej niż pomocna ...
Rad Haring
23

Jeśli chcesz programowo, możesz użyć

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

Gdzie SANS_SERIFmożesz użyć:

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

I gdzie ITALICmożesz użyć:

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

Wszystko zostało napisane na Android Developers

Joaquin Iurchuk
źródło
15

Korzystam z doskonałej biblioteki Calligraphy autorstwa Chrisa Jenxa, zaprojektowanej tak, abyś mógł używać niestandardowych czcionek w aplikacji na Androida. Spróbuj!

gauravdott
źródło
Tak, ale na przykład chcę go używać functionanl, ale nie zrobił t chcą wprowadzić wszystkie biblioteki;)
Morozow
12

To, czego chcesz, nie jest możliwe. Musisz ustawić TypeFacew swoim Kodeksie.

W XMLco można zrobić, to

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

poza tym nie można dużo grać z czcionkami w XML. :)

Aby Arialustawić typ twarzy w kodzie.

Mohsin Naeem
źródło
11

Łatwym sposobem zarządzania czcionkami byłoby zadeklarowanie ich za pomocą zasobów, takich jak:

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

Jest to oparte na kodzie źródłowym tu i tutaj

programista Androida
źródło
Gdzie je zadeklarować?
AZ_
@AZ_ Podobnie jak wiele plików zasobów, możesz umieścić go w dowolnym pliku XML w folderze „res / values ​​/”. Na przykład umieść go w „res / wartości / fonts.xml”. I, aby go użyć, po prostu lubię to na przykład: android: fontFamily = "string / fontFamily__roboto_regular"
programista Androida
Dzięki, korzystam z tego github.com/norbsoft/android-typeface-helper i jest to naprawdę pomocne
AZ_
ok, biblioteka jest prawdopodobnie do robienia tego programowo. tutaj jest dla XML
programista Androida
9

Dynamicznie możesz ustawić fontfamily podobną do Androida: fontFamily w xml za pomocą tego,

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

Oto lista używanych domyślnych czcionek , użyj dowolnego z nich, zastępując ciąg podwójnego cudzysłowu „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” to plik ttf. Ścieżka będzie w src / asset / fonts / mycustomfont.ttf , możesz dowiedzieć się więcej o czcionce domyślnej w tej rodzinie czcionek domyślnych

anand krish
źródło
9
Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

łatwo ustawić programowo czcionkę do dowolnego widoku tekstu z katalogu res> font

Makvin
źródło
7

Myślę, że jestem za późno, ale może to rozwiązanie jest pomocne dla innych. Aby użyć niestandardowej czcionki, umieść plik czcionki w katalogu czcionek.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));
Rehan Sarwar
źródło
6

Z pewnymi próbami i błędami nauczyłem się następujących rzeczy.

W pliku * .xml można łączyć czcionki podstawowe z następującymi funkcjami, nie tylko z krojem pisma:

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

Dzięki tym dwóm stylom nie było potrzeby używania kroju pisma w żadnym innym przypadku. Zakres kombinacji jest znacznie większy dzięki fontfamily i textStyle.


źródło
5

Prawidłowa wartość android: fontFamily jest zdefiniowana w /system/etc/system_fonts.xml(4.x) lub /system/etc/fonts.xml(5.x). Ale producent urządzenia może go zmodyfikować, więc rzeczywista czcionka użyta do ustawienia wartości fontFamily zależy od wyżej wspomnianego pliku określonego urządzenia.

W AOSP czcionka Arial jest poprawna, ale musi być zdefiniowana przy użyciu „arial”, a nie „Arial”, na przykład android: fontFamily = „arial” . Spójrz qucik na system_fonts.xml Kitkata

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

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

Istnieją trzy odpowiednie atrybuty xml do definiowania „czcionki” w układzie - android: fontFamily , android: krój czcionki i android: textStyle . Kombinacja „fontFamily” i „textStyle” lub „krój pisma” i „textStyle” może być używana do zmiany wyglądu czcionki w tekście, więc jest używana osobno. Fragment kodu w TextView.java wygląda następująco:

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

Z kodu Widzimy:

  1. jeśli ustawione jest „fontFamily”, wówczas „krój czcionki” zostanie zignorowany.
  2. „krój pisma” ma standardowe i ograniczone prawidłowe wartości. W rzeczywistości wartościami są „normalne” „sans”, „serif” i „monospace”, można je znaleźć w pliku system_fonts.xml (4.x) lub fonts.xml (5.x). W rzeczywistości zarówno „normal”, jak i „sans” są domyślną czcionką systemu.
  3. „fontFamily” może być używany do ustawiania wszystkich czcionek czcionek wbudowanych, podczas gdy „krój czcionki” zapewnia tylko typowe czcionki „sans-serif”, „serif” i „monospace” (trzy główne kategorie typów czcionek na świecie) .
  4. Gdy ustawiamy tylko „textStyle”, tak naprawdę ustawiamy domyślną czcionkę i określony styl. Skuteczne wartości to „normal”, „pogrubienie”, „kursywa” i „pogrubienie | kursywa”.
Terry Liu
źródło
4

Oto łatwiejsze rozwiązanie, które może działać w niektórych przypadkach. Zasadą jest dodanie niewidocznego TextVview do twojego układu xml i pobranie jego typeFace w kodzie java.

Układ w pliku 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"/>

I kod Java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

To zadziałało dla mnie (na przykład w TextSwitcher).

Frédéric
źródło
4

Spróbuj tego:

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

Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);
mohamad sheikhi
źródło
4

Możesz to również zrobić, dodając folder czcionek w katalogu res, jak poniżej.

wprowadź opis zdjęcia tutaj

Następnie wybierz Czcionka jako typ zasobu. wprowadź opis zdjęcia tutaj

Dostępne czcionki można znaleźć na stronie https://www.1001fonts.com/ , a następnie wyodrębnić pliki TTF do tego katalogu czcionek.

wprowadź opis zdjęcia tutaj

Na koniec zmień plik XML zawierający widok tekstu, dodając android: fontFamily: „@ font / urfontfilename”

wprowadź opis zdjęcia tutaj

Wolfiebae
źródło
bardzo miło, dziękuję za to. Idk, dlaczego inni mają więcej gwiazdek, ale Twoja jest potwierdzona do pracy z widokiem tekstowym projektowania materiałów, musisz app:fontFamily=jednak użyć , wszystko inne jest takie samo.
EvOlaNdLuPiZ
Uratowałeś mi życie, właśnie utworzyłem folder o nazwie czcionka i to nie działało. W każdym razie skorzystałem z twojej drogi i zadziałało. Dzięki
Hilal
4

Jednym prostym sposobem jest dodanie żądanej czcionki w projekcie.

Przejdź do Plik-> Nowy-> Nowy katalog zasobów Wybierz czcionkę

Spowoduje to utworzenie nowego katalogu, czcionki w twoich zasobach.

Pobierz swój czcionkę (.ttf) . Używam https://fonts.google.com do tego samego

Dodaj to do folderu czcionek, a następnie użyj ich w pliku XML lub programowo.

XML -

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

Programowo -

 Typeface typeface = getResources().getFont(R.font.your_font);
 textView.setTypeface(typeface); 
Akanshi Srivastava
źródło
8
ResourcesCompat.getFontMetoda lepszego wykorzystania
Vadim Kotov
3
<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>
Yang Peiyong
źródło
3

Jeśli chcesz używać TextView w tak wielu miejscach z tą samą rodziną czcionek, rozszerz klasę TextView i ustaw czcionkę w następujący sposób: -

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

A następnie użyj tej niestandardowej klasy w XML dla TextView w następujący sposób: -

   <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"
        />
Shubham Raitka
źródło
3

Jeśli używasz Androida Studio 3.5+, zmiana czcionki jest bardzo prosta. Wybierz widget tekstowy w widoku Projekt i zaznacz fontFamily w oknie atrybutów. Lista wartości zawiera wszystkie dostępne czcionki, z których możesz wybrać jedną. Jeśli szukasz czcionek Google, kliknij opcję Więcej czcionek.

Okno atrybutów Okno atrybutów

Czcionki Google Czcionki Google

Siva
źródło
2

Chcę tylko wspomnieć, że piekło z czcionkami wewnątrz Androida wkrótce się skończy, ponieważ w tym roku na Google IO w końcu dostaliśmy to -> https://developer.android.com/preview/features/working-with-fonts. HTML

Teraz jest nowy typ czcionki czcionka i możesz umieścić wszystkie czcionki aplikacji w folderze res / fonts i uzyskać do nich dostęp za pomocą R.font.my_custom_font, podobnie jak możesz uzyskać dostęp do wartości res string , rysowalnych res res itp. Masz nawet szansę aby utworzyć plik xml font-face , w którym będą ustawione niestandardowe czcionki (o kursywie, pogrubieniu i podkreśleniu attr).

Przeczytaj powyższy link, aby uzyskać więcej informacji. Zobaczmy wsparcie.

Stoycho Andreev
źródło
Niestety, to nadal nie działa z IntelliJ (choć działa jak urok w Android Studio 3.0+).
Dominikus K.,
Tak, ale Redmanpowyższa odpowiedź użytkownika jest nadal bardzo niezbędną częścią rozwiązania.
Jungledev
2

Dostępna jest do tego ładna biblioteka

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
Shivam Yadav
źródło
Ta biblioteka służy do zmiany czcionki wszystkich widoków w całej aplikacji. Nie dotyczy to widoków adaptera, takich jak widok listy. W tym celu musimy specjalnie dodać kod do każdego adaptera
Senthilvel S
2

Nowy zasób czcionek umożliwia bezpośrednie ustawienie fontza pomocą

android:fontFamily="@font/my_font_in_font_folder"
Aziz
źródło
1

Ustawiasz styl w res/layout/value/style.xmlten sposób:

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

i aby użyć tego stylu w main.xmlużyciu pliku:

style="@style/boldText"
rajender
źródło
1

W przypadku Androida-studio 3 i nowszych możesz użyć tego stylu, a potem wszystkich textView zmian czcionek w aplikacji.

stwórz ten styl w style.xml:

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

Następnie użyj go w swoim motywie:

<!-- 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>
Ali Khaki
źródło
1

Najprostszym sposobem na programowe dodanie czcionki do TextView jest, po pierwsze, dodanie pliku czcionki w folderze Zasoby w projekcie. Na przykład ścieżka czcionki wygląda następująco:assets/fonts/my_font.otf

I dodaj go do TextView jako:

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);
Miś panda
źródło
0

Tutaj możesz zobaczyć wszystkie dostępne wartości fontFamily i odpowiadające im nazwy plików czcionek (ten plik jest używany w Androidzie 5.0+). Na urządzeniu mobilnym można go znaleźć w:

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

(Dla Androida 4.4 i niższych korzystających z tej wersji, ale myślę, że fonts.xmlma bardziej przejrzysty format i jest łatwy do zrozumienia.)

Na przykład,

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

Atrybut name name="sans-serif"of familytagu określona wartość można wykorzystać w Androidzie: fontFamily.

fontTag określenie odzwierciedla pliki czcionek.

W takim przypadku możesz zignorować źródło <!-- fallback fonts -->, którego używa do logiki rezerwowej czcionek.

Gnod
źródło