Niestandardowe czcionki i układy XML (Android)

174

Próbuję zdefiniować układ GUI przy użyciu plików XML w systemie Android. O ile się dowiem, nie ma sposobu, aby określić, że twoje widżety powinny używać niestandardowej czcionki (np. Takiej, którą umieściłeś w asset / font /) w plikach XML i możesz używać tylko czcionek zainstalowanych przez system.

Wiem, że w kodzie Javy mogłem ręcznie zmienić czcionkę każdego widżetu, używając unikalnych identyfikatorów. Alternatywnie mógłbym powtórzyć wszystkie widżety w Javie, aby wprowadzić tę zmianę, ale prawdopodobnie byłoby to bardzo powolne.

Jakie mam inne opcje? Czy istnieją lepsze sposoby tworzenia widżetów o niestandardowym wyglądzie? Nie chcę, aby trzeba było ręcznie zmieniać czcionkę dla każdego nowego widżetu, który dodam.

DrDefrost
źródło
68
DrDefrost - zaakceptuj kilka odpowiedzi, otrzymasz więcej odpowiedzi na tej stronie.
SK9
1
Oto jeszcze jedno podobne pytanie: stackoverflow.com/questions/9030204/…
Vins
Zaktualizowano 05/2017: „Biblioteka pomocy technicznej 26.0 Beta zapewnia obsługę funkcji Czcionki w XML na urządzeniach z Androidem API w wersji 14 lub nowszej”. Zobacz: developer.android.com/preview/features/…
albert c braun

Odpowiedzi:

220

Jak się nauczyłem, możesz rozszerzyć TextView, aby ustawić niestandardowe czcionki tutaj .

TextViewPlus.java:

package com.example;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.TextView;

public class TextViewPlus extends TextView {
    private static final String TAG = "TextView";

    public TextViewPlus(Context context) {
        super(context);
    }

    public TextViewPlus(Context context, AttributeSet attrs) {
        super(context, attrs);
        setCustomFont(context, attrs);
    }

    public TextViewPlus(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setCustomFont(context, attrs);
    }

    private void setCustomFont(Context ctx, AttributeSet attrs) {
        TypedArray a = ctx.obtainStyledAttributes(attrs, R.styleable.TextViewPlus);
        String customFont = a.getString(R.styleable.TextViewPlus_customFont);
        setCustomFont(ctx, customFont);
        a.recycle();
    }

    public boolean setCustomFont(Context ctx, String asset) {
        Typeface tf = null;
        try {
        tf = Typeface.createFromAsset(ctx.getAssets(), asset);  
        } catch (Exception e) {
            Log.e(TAG, "Could not get typeface: "+e.getMessage());
            return false;
        }

        setTypeface(tf);  
        return true;
    }

}

attrs.xml: (w res / values)

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="TextViewPlus">
        <attr name="customFont" format="string"/>
    </declare-styleable>
</resources>

main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:foo="http://schemas.android.com/apk/res/com.example"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <com.example.TextViewPlus
        android:id="@+id/textViewPlus1"
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        android:text="@string/showingOffTheNewTypeface"
        foo:customFont="saxmono.ttf">
    </com.example.TextViewPlus>
</LinearLayout>

W folderze zasobów umieściłbyś plik „saxmono.ttf” .

AKTUALIZACJA 01.08.13

W przypadku tej metody istnieją poważne problemy z pamięcią. Zobacz komentarz chedabob poniżej.

Piotr
źródło
5
Wygląda to ładnie, jednak pojawia się błąd, gdy próbuję użyć „TextViewPlus” w pliku main.xml. Otrzymuję następujące informacje: - błąd: Błąd podczas analizowania XML: niepowiązany prefiks - Prefiks „foo” dla atrybutu „foo: customFont” powiązany z typem elementu „supportLibs.TextViewPlus” nie jest powiązany.
Majjoodi
79
Należy zauważyć, że spowoduje to wygenerowanie dziesiątek obiektów TypeFace i zajmie pamięć. W Androidzie przed 4.0 jest błąd, który nie zwalnia poprawnie TypeFaces. Najłatwiejszą rzeczą do zrobienia jest utworzenie pamięci podręcznej TypeFace z HashMap. Spowodowało to zmniejszenie zużycia pamięci w mojej aplikacji z ponad 120 MB do 18 MB. code.google.com/p/android/issues/detail?id=9904
chedabob
7
@Majjoodi: Zwykle dzieje się tak, jeśli zapomnisz dodać drugą przestrzeń nazw do swojego układu:xmlns:foo="http://schemas.android.com/apk/res/com.example
Theo
11
BARDZO WAŻNE - chciałbym tylko dwukrotnie podkreślić radę chedabob. Jeśli nie zastosujesz się do tego, będziesz mieć wyciek pamięci w pre-ICS. Rozwiązań jest kilka, jedno z nich znajduje się w linku udostępnionym przez chedabob, inne jest tutaj: stackoverflow.com/questions/8057010/listview-memory-leak . peter - zaktualizuj swoją odpowiedź - super, ale nie kompletna
Michał K
1
Jak ustawić ten atrybut niestandardowy w styles.xml oprócz innych atrybutów widoku tekstu, takich jak szerokość i wysokość?
loeschg
35

Spóźniłem się 3 lata na imprezę :( Jednak może to być przydatne dla kogoś, kto może natknąć się na ten post.

Napisałem bibliotekę, która buforuje kroje pisma, a także pozwala określić niestandardowe kroje pisma bezpośrednio z XML. Bibliotekę znajdziesz tutaj .

Oto, jak wyglądałby Twój układ XML, kiedy go używasz.

<com.mobsandgeeks.ui.TypefaceTextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world"
    geekui:customTypeface="fonts/custom_font.ttf" />
Ragunath Jawahar
źródło
Hej @ Ragunath-jawahar, jak zaimportować bibliotekę do projektu Gradle? Próbowałem, compile 'com.mobsandgeeks:android-typeface-textview:1.0'ale to nie zadziałało.
aimango
1
Będziesz potrzebować AAR, aby móc z niego korzystać w ten sposób. Jeszcze go tam nie ma. Na razie możesz skopiować źródła i utworzyć projekt biblioteki Android Studio.
Ragunath Jawahar
2
skąd pochodzi twój tag geekui?
sefirosu
3
Z przestrzeni nazw określonej w tagu nadrzędnym -xmlns:geekui="http://schemas.android.com/apk/res-auto"
Ragunath Jawahar
1
@MuhammedRefaat, tak, robi :)
Ragunath Jawahar
18

To może być trochę za późno, ale musisz utworzyć klasę pojedynczą, która zwraca niestandardowy krój pisma, aby uniknąć wycieków pamięci.

Klasa TypeFace:

public class OpenSans {

private static OpenSans instance;
private static Typeface typeface;

public static OpenSans getInstance(Context context) {
    synchronized (OpenSans.class) {
        if (instance == null) {
            instance = new OpenSans();
            typeface = Typeface.createFromAsset(context.getResources().getAssets(), "open_sans.ttf");
        }
        return instance;
    }
}

public Typeface getTypeFace() {
    return typeface;
}
}

Niestandardowy TextView:

public class NativelyCustomTextView extends TextView {

    public NativelyCustomTextView(Context context) {
        super(context);
        setTypeface(OpenSans.getInstance(context).getTypeFace());
    }

    public NativelyCustomTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setTypeface(OpenSans.getInstance(context).getTypeFace());
    }

    public NativelyCustomTextView(Context context, AttributeSet attrs,
            int defStyle) {
        super(context, attrs, defStyle);
        setTypeface(OpenSans.getInstance(context).getTypeFace());
    }

}

Według XML:

<com.yourpackage.views.NativelyCustomTextView
            android:id="@+id/natively_text_view"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_margin="20dp"
            android:text="@string/natively"
            android:textSize="30sp" /> 

Programowo:

TextView programmaticallyTextView = (TextView) 
       findViewById(R.id.programmatically_text_view);

programmaticallyTextView.setTypeface(OpenSans.getInstance(this)
                .getTypeFace());
Leonardo Cardoso
źródło
Wydaje się, że działa w czasie wykonywania, ale czy ma działać również w projektancie?
Magnus Johansson
Pewnie. Możesz użyć jako xml. @Magnus
Leonardo Cardoso
Myślę, że źle zrozumiałeś, to nie działa w czasie projektowania (podgląd projektanta). (xml! = projektant). Działa dobrze, jak określono w pliku układu Xml skompilowanym do środowiska uruchomieniowego. W każdym razie używam tego rozszerzenia github.com/danh32/Fontify , które działa znacznie lepiej dla moich potrzeb (obsługuje wiele stylów czcionek, zwykłych, pogrubionych itp., A także różne nazwy czcionek, a także inne elementy sterujące poza TextView)
Magnus Johansson
2
Funkcja getTypeFace tworzy nowy krój pisma przy każdym wywołaniu ... to przeczy celowi singletona. Powinien mieć pole statyczne, które jest ustawiane przy pierwszym wywołaniu i zwraca wartość pola przy kolejnych wywołaniach.
Steven Pena
1
@chiwai masz rację! Co do pierwszego pytania, to go nie potrzebuje. Mniej więcej za drugim była to literówka.
Leonardo Cardoso,
13

Stare pytanie, ale na pewno chciałbym przeczytać tę odpowiedź tutaj, zanim zacząłem własne poszukiwania dobrego rozwiązania. Kaligrafia rozszerza android:fontFamilyatrybut, dodając obsługę niestandardowych czcionek w folderze zasobów, na przykład:

<TextView 
  android:text="@string/hello_world"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:fontFamily="fonts/Roboto-Bold.ttf"/>

Jedyne, co musisz zrobić, aby go aktywować, to dołączyć go do kontekstu działania, z którego korzystasz:

@Override
protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(new CalligraphyContextWrapper(newBase));
}

Możesz również określić własny atrybut niestandardowy do zastąpienia android:fontFamily

Działa również w motywach, w tym AppTheme.

thoutbeckers
źródło
8

Korzystanie z DataBinding :

@BindingAdapter({"bind:font"})
public static void setFont(TextView textView, String fontName){
 textView.setTypeface(Typeface.createFromAsset(textView.getContext().getAssets(), "fonts/" + fontName));
}

W XML:

<TextView
app:font="@{`Source-Sans-Pro-Regular.ttf`}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>

plik czcionki musi być w formacie assets/fonts/

Chulo
źródło
7

Jeśli masz tylko jeden krój, który chcesz dodać, i chcesz, aby napisano mniej kodu, możesz utworzyć dedykowany TextView dla określonej czcionki. Zobacz kod poniżej.

package com.yourpackage;
import android.content.Context;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.TextView;

public class FontTextView extends TextView {
    public static Typeface FONT_NAME;


    public FontTextView(Context context) {
        super(context);
        if(FONT_NAME == null) FONT_NAME = Typeface.createFromAsset(context.getAssets(), "fonts/FontName.otf");
        this.setTypeface(FONT_NAME);
    }
    public FontTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        if(FONT_NAME == null) FONT_NAME = Typeface.createFromAsset(context.getAssets(), "fonts/FontName.otf");
        this.setTypeface(FONT_NAME);
    }
    public FontTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        if(FONT_NAME == null) FONT_NAME = Typeface.createFromAsset(context.getAssets(), "fonts/FontName.otf");
        this.setTypeface(FONT_NAME);
    }
}

W main.xml możesz teraz dodać swój textView w następujący sposób:

<com.yourpackage.FontTextView
    android:id="@+id/tvTimer"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="" />
Tore Rudberg
źródło
zrób to na init () i zachowaj 3x to samo wywołanie.
ericosg,
@ericosg Otrzymuję ten błąd, gdy używam tego rozwiązania android.view.InflateException: binarny plik XML wiersz nr 9: Błąd zawyżania klasy com.ascent.adwad.utils.CustomTextView
Sagar Devanga
@SagarDevanga, trudno pomóc bez dodatkowych informacji. Może weź to tak daleko, jak tylko możesz i zadaj nowe pytanie.
ericosg
7

Najlepszy sposób na zrobienie tego Z wersji zapoznawczej Androida O jest następujący:
1.) Kliknij prawym przyciskiem folder res i przejdź do katalogu zasobów Nowy> Android .
Zostanie wyświetlone okno New Resource Directory.
2.) Na liście Typ zasobu wybierz czcionkę , a następnie kliknij przycisk OK.
3.) Dodaj pliki czcionek do folderu czcionek . Poniższa struktura folderów generuje R.font.dancing_script, R.font.la_la i R.font.ba_ba.
4.) Kliknij dwukrotnie plik czcionki, aby wyświetlić podgląd czcionek pliku w edytorze.

Następnie musimy stworzyć rodzinę czcionek

1.) Kliknij prawym przyciskiem myszy folder czcionek i przejdź do Nowy> Plik zasobów czcionek . Zostanie wyświetlone okno New Resource File.
2.) Wprowadź nazwę pliku, a następnie kliknij OK . W edytorze zostanie otwarty nowy kod XML zasobu czcionek.
3.) Umieść każdy plik czcionki, styl i atrybut wagi w elemencie znacznika czcionki. Poniższy kod XML ilustruje dodawanie atrybutów związanych z czcionkami w kodzie XML zasobu czcionek:

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

Dodawanie czcionek do TextView:

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

Jak z dokumentacji

Praca z czcionkami

wszystkie kroki są prawidłowe.

jeevan s
źródło
1
Najlepsza odpowiedź! Nazwa pliku czcionki musi być zapisana małymi literami.
Dmitry
Możesz również utworzyć własny styl, który zastosujesz do swojej aplikacji (w pliku AndroidManifest) i zostanie on nadany WSZYSTKIM widokom. Zamiast na przykład po prostu umieszczać go w pojedynczym TextView, ponieważ nie wpłynie to na pasek narzędzi.
goldenmaza
5

Rozszerz TextViewi nadaj mu atrybut niestandardowy lub po prostu użyj atrybutu android: tag, aby przekazać ciąg znaków, którego czcionki chcesz użyć. Będziesz musiał wybrać konwencję i trzymać się jej, na przykład umieszczę wszystkie moje czcionki w folderze res / asset / fonts /, aby Twoja klasa TextView wiedziała, gdzie je znaleźć. Następnie w konstruktorze ustawiasz czcionkę ręcznie po wywołaniu super.

Nathan Schwermann
źródło
4

Jedynym sposobem użycia niestandardowych czcionek jest użycie kodu źródłowego.

Pamiętaj tylko, że Android działa na urządzeniach z bardzo ograniczonymi zasobami, a czcionki mogą wymagać dużej ilości pamięci RAM. Wbudowane czcionki Droid są specjalnie wykonane i, jeśli zauważysz, brakuje wielu znaków i dekoracji.

Tareq Sha
źródło
„Pamiętaj tylko, że Android działa na urządzeniach z bardzo ograniczonymi zasobami” -> jest to coraz rzadziej spotykane. Telefon czterordzeniowy? Naprawdę??
Sandy
9
Zrobiłbym więcej, aby pokazać rozważenie kontekstu odpowiedzi tareqHs, która wyprzedza twój komentarz o dobre 2 i pół roku.
SK9
Pierwsza część Twojej odpowiedzi mogła być prawdziwa, kiedy pisałeś swoją odpowiedź w 2010 roku. Ta ostatnia jest superfluoy i poza tym: Droid był zły, porzucony przez Google w 2012 roku na rzecz Roboto. Brak możliwości wyboru typografii w systemie Android to wada, a nie funkcja; iOS ma wiele czcionek dostępnych dla programistów od 2008 roku na prymitywnych urządzeniach według dzisiejszych standardów.
cosmix
Ta odpowiedź jest już nieaktualna.
Martin Konecny
2

Mogę mieć prostą odpowiedź na to pytanie bez rozszerzania TextView i implementowania długiego kodu.

Kod :

 TextView tv = (TextView) findViewById(R.id.textview1);
    tv.setTypeface(Typeface.createFromAsset(getAssets(), "font.ttf"));

Umieść niestandardowy plik czcionki w folderze zasobów, jak zwykle, i spróbuj tego. Mi to pasuje. Po prostu nie rozumiem, dlaczego peter podał tak obszerny kod dla tej prostej rzeczy lub dał odpowiedź w starej wersji.

San
źródło
2

Można również zdefiniować w XML bez tworzenia niestandardowych klas

style.xml

<style name="ionicons" parent="android:TextAppearance">
    <!-- Custom Attr-->
    <item name="fontPath">fonts/ionicons.ttf</item>
</style>

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:app="http://schemas.android.com/apk/res-auto"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical" >
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="@style/ionicons"
        android:text=""/>
</LinearLayout>

Szybka uwaga, bo po prostu zawsze zapomniał gdzie umieścić czcionki, jej, że czcionka musi być w środku assetsi ten folder znajduje się na tym samym poziomie resi src, w moim przypadku jegoassets/fonts/ionicons.ttf

Zaktualizowano Dodano układ główny, ponieważ ta metoda musi xmlns:app="http://schemas.android.com/apk/res-auto"działać

Aktualizacja 2 Zapomniałem o bibliotece, którą zainstalowałem wcześniej o nazwie Kaligrafia

norman784
źródło
To nie działa dla mnie. Kiedy próbuję to zbudować, pojawia się komunikat o błędzie: Błąd: (49, 5) Nie znaleziono zasobu pasującego do podanej nazwy: attr 'fontPath'.
Stef
Spróbuj dodać xmlns:app="http://schemas.android.com/apk/res-auto"do układu głównego, sprawdź również zaktualizowaną odpowiedź
norman784
Błąd nie pochodzi z pliku XML układu, ale z pliku XML stylów. Wygląda na to, że nie „wie”, czym jest fontPath.
Stef
Twoje prawo, zapomniałeś, że mam bibliotekę Calligrapy
norman784
1

Odpowiedź Piotra jest najlepsza, ale można ją poprawić, korzystając z pliku styles.xml z systemu Android, aby dostosować czcionki dla wszystkich widoków tekstu w aplikacji.

Mój kod jest tutaj

Jelle
źródło
1

Istnieją dwa sposoby dostosowywania czcionek:

!!! moja niestandardowa czcionka w asset / fonts / iran_sans.ttf

Sposób 1: Refrection Typeface.class ||| Najlepszym sposobem

wywołanie FontsOverride.setDefaultFont () w klasie rozszerza Application, Ten kod spowoduje zmianę wszystkich czcionek oprogramowania, nawet czcionek Toast

AppController.java

public class AppController extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        //Initial Font
        FontsOverride.setDefaultFont(getApplicationContext(), "MONOSPACE", "fonts/iran_sans.ttf");

    }
}

FontsOverride.java

public class FontsOverride {

    public static void setDefaultFont(Context context, String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(), fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    }

    private static void replaceFont(String staticTypefaceFieldName, final Typeface newTypeface) {
        try {
            final Field staticField = Typeface.class.getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Sposób 2: użyj setTypeface

dla specjalnego widoku po prostu wywołaj setTypeface (), aby zmienić czcionkę.

CTextView.java

public class CTextView extends TextView {

    public CTextView(Context context) {
        super(context);
        init(context,null);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context,attrs);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context,attrs);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init(context,attrs);
    }

    public void init(Context context, @Nullable AttributeSet attrs) {

        if (isInEditMode())
            return;

        // use setTypeface for change font this view
        setTypeface(FontUtils.getTypeface("fonts/iran_sans.ttf"));

    }
}

FontUtils.java

public class FontUtils {

    private static Hashtable<String, Typeface> fontCache = new Hashtable<>();

    public static Typeface getTypeface(String fontName) {
        Typeface tf = fontCache.get(fontName);
        if (tf == null) {
            try {
                tf = Typeface.createFromAsset(AppController.getInstance().getApplicationContext().getAssets(), fontName);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            fontCache.put(fontName, tf);
        }
        return tf;
    }

}
Rasoul Miri
źródło
0

Możesz łatwo stworzyć niestandardową klasę Textview: -

Więc co musisz zrobić najpierw, utwórz Custom textviewklasę, która została rozszerzona o AppCompatTextView.

public class CustomTextView extends AppCompatTextView {
    private int mFont = FontUtils.FONTS_NORMAL;
    boolean fontApplied;

    public CustomTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(attrs, context);
    }

    public CustomTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(attrs, context);
    }

    public CustomTextView(Context context) {
        super(context);
        init(null, context);
    }

    protected void init(AttributeSet attrs, Context cxt) {
        if (!fontApplied) {
            if (attrs != null) {
                mFont = attrs.getAttributeIntValue(
                        "http://schemas.android.com/apk/res-auto", "Lato-Regular.ttf",
                        -1);
            }
            Typeface typeface = getTypeface();
            int typefaceStyle = Typeface.NORMAL;
            if (typeface != null) {
                typefaceStyle = typeface.getStyle();
            }
            if (mFont > FontUtils.FONTS) {
                typefaceStyle = mFont;
            }
            FontUtils.applyFont(this, typefaceStyle);
            fontApplied = true;
        }
    }
}

Teraz za każdym razem wywołanie niestandardowego widoku tekstu i otrzymamy wartość int z atrybutu int fontValue = attrs.getAttributeIntValue("http://schemas.android.com/apk/res-auto","Lato-Regular.ttf",-1).

Lub

Możemy również uzyskać getTypeface () z widoku, który ustawiliśmy w naszym xml ( android:textStyle="bold|normal|italic"). Więc rób, co chcesz robić.

Teraz możemy FontUtilsustawić dowolną czcionkę .ttf w naszym widoku.

public class FontUtils {

    public static final int FONTS = 1;
    public static final int FONTS_NORMAL = 2;
    public static final int FONTS_BOLD = 3;
    public static final int FONTS_BOLD1 = 4;

    private static Map<String, Typeface> TYPEFACE = new HashMap<String, Typeface>();

    static Typeface getFonts(Context context, String name) {
        Typeface typeface = TYPEFACE.get(name);
        if (typeface == null) {
            typeface = Typeface.createFromAsset(context.getAssets(), name);
            TYPEFACE.put(name, typeface);
        }
        return typeface;
    }

    public static void applyFont(TextView tv, int typefaceStyle) {

        Context cxt = tv.getContext();
        Typeface typeface;

        if(typefaceStyle == Typeface.BOLD_ITALIC) {
            typeface = FontUtils.getFonts(cxt, "FaktPro-Normal.ttf");
        }else if (typefaceStyle == Typeface.BOLD || typefaceStyle == SD_FONTS_BOLD|| typefaceStyle == FONTS_BOLD1) {
            typeface = FontUtils.getFonts(cxt, "FaktPro-SemiBold.ttf");
        } else if (typefaceStyle == Typeface.ITALIC) {
            typeface = FontUtils.getFonts(cxt, "FaktPro-Thin.ttf");
        } else {
            typeface = FontUtils.getFonts(cxt, "FaktPro-Normal.ttf");
        }
        if (typeface != null) {
            tv.setTypeface(typeface);
        }
    }
}
duggu
źródło
0

Warto wiedzieć, że począwszy od systemu Android 8.0 (poziom interfejsu API 26) można użyć niestandardowej czcionki w języku XML .

Możesz zastosować niestandardową czcionkę do całej aplikacji w następujący sposób.

  1. Umieść czcionkę w folderze res/font.

  2. W res/values/styles.xmlużyciu w motywie aplikacji. <style name="AppTheme" parent="{whatever you like}"> <item name="android:fontFamily">@font/myfont</item> </style>

Vic
źródło