Android - korzystanie z niestandardowej czcionki

Zastosowałem niestandardową czcionkę TextView, ale wydaje się , że nie zmienia to kroju pisma.

Oto mój kod:

    Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
    TextView myTextView = (TextView)findViewById(R.id.myTextView);
    myTextView.setTypeface(myTypeface);

Czy ktoś może wyciągnąć mnie z tego problemu?

W Mobiletuts + jest bardzo dobry samouczek na temat formatowania tekstu dla Androida. Szybka wskazówka: dostosuj czcionki Android

EDYCJA: Sam to przetestowałem. Oto rozwiązanie. Możesz użyć podfolderu o nazwie czcionki, ale musi on znajdować się w assetsfolderze, a nie w resfolderze. Więc

zasoby / czcionki

Upewnij się również, że końcówka czcionki Mam na myśli, że końcówka samego pliku czcionki jest pisana małymi literami. Innymi słowy, nie powinno tak być, myFont.TTFale w ten sposób należy pisać myfont.ttf małymi literami

Po wypróbowaniu większości rozwiązań opisanych w tym wątku przypadkowo znalazłem Calligraphy ( https://github.com/chrisjenx/Calligraphy ) - bibliotekę Christophera Jenkinsa, która umożliwia łatwe dodawanie niestandardowych czcionek do aplikacji. Zalety jego lib w porównaniu do sugerowanych tutaj podejść to:

1. nie musisz wprowadzać własnego nadpisanego składnika TextView, korzystasz z wbudowanego TextView
2. możesz łatwo dołączyć bibliotekę za pomocą gradle
3. Biblioteka nie ogranicza wyboru czcionek; po prostu dodajesz swoje preferowane do zasobów reż
4. otrzymujesz nie tylko niestandardowe widoki tekstu - wszystkie inne tekstowe komponenty Androida będą również wyświetlane przy użyciu niestandardowej czcionki.

Wiem, że są już dobre odpowiedzi, ale oto w pełni działająca implementacja.

Oto niestandardowy widok tekstu:

package com.mycompany.myapp.widget;

/**
 * Text view with a custom font.
 * <p/>
 * In the XML, use something like {@code customAttrs:customFont="roboto-thin"}. The list of fonts
 * that are currently supported are defined in the enum {@link CustomFont}. Remember to also add
 * {@code xmlns:customAttrs="http://schemas.android.com/apk/res-auto"} in the header.
 */
public class CustomFontTextView extends TextView {

    private static final String sScheme =
            "http://schemas.android.com/apk/res-auto";
    private static final String sAttribute = "customFont";

    static enum CustomFont {
        ROBOTO_THIN("fonts/Roboto-Thin.ttf"),
        ROBOTO_LIGHT("fonts/Roboto-Light.ttf");

        private final String fileName;

        CustomFont(String fileName) {
            this.fileName = fileName;
        }

        static CustomFont fromString(String fontName) {
            return CustomFont.valueOf(fontName.toUpperCase(Locale.US));
        }

        public Typeface asTypeface(Context context) {
            return Typeface.createFromAsset(context.getAssets(), fileName);
        }
    }

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

        if (isInEditMode()) {
            return;
        } else {
            final String fontName = attrs.getAttributeValue(sScheme, sAttribute);

            if (fontName == null) {
                throw new IllegalArgumentException("You must provide \"" + sAttribute + "\" for your text view");
            } else {
                final Typeface customTypeface = CustomFont.fromString(fontName).asTypeface(context);
                setTypeface(customTypeface);
            }
        }
    }
}

Oto niestandardowe atrybuty. To powinno przejść do twojego res/attrs.xmlpliku:

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

A oto jak go wykorzystujesz. Użyję układu względnego, aby go zawinąć i pokazać customAttrdeklarację, ale oczywiście może to być dowolny układ, który już masz.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:customAttrs="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.mycompany.myapp.widget.CustomFontTextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:text="foobar"
         customAttrs:customFont="roboto_thin" />

</RelativeLayout>

Z powodzeniem korzystałem z tego wcześniej. Jedyna różnica między naszymi implementacjami polega na tym, że nie używałem podfolderu w zasobach. Nie jestem jednak pewien, czy to coś zmieni.

Pod warunkiem, że umieściłeś czcionkę we właściwym miejscu i nie ma błędu w samym pliku czcionki, twój kod powinien tak działać, RATTLESNAKE.

Byłoby jednak o wiele łatwiej, gdybyś mógł po prostu zdefiniować czcionkę w swoim układzie xml, tak jak to:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <!-- This text view is styled with the app theme -->
    <com.innovattic.font.FontTextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This uses my font in bold italic style" />

    <!-- This text view is styled here and overrides the app theme -->
    <com.innovattic.font.FontTextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:flFont="anotherFont"
        android:textStyle="normal"
        android:text="This uses another font in normal style" />

    <!-- This text view is styled with a style and overrides the app theme -->
    <com.innovattic.font.FontTextView
        style="@style/StylishFont"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This also uses another font in normal style" />

</LinearLayout>

Z towarzyszącym res/values/styles.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">

    <!-- Application theme -->
    <!-- Use a different parent if you don't want Holo Light -->
    <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
        <item name="android:textViewStyle">@style/MyTextViewStyle</item>
    </style>

    <!-- Style to use for ALL text views (including FontTextView) -->
    <!-- Use a different parent if you don't want Holo Light -->
    <style name="MyTextViewStyle" parent="@android:style/Widget.Holo.Light.TextView">
        <item name="android:textAppearance">@style/MyTextAppearance</item>
    </style>

    <!-- Text appearance to use for ALL text views (including FontTextView) -->
    <!-- Use a different parent if you don't want Holo Light -->
    <style name="MyTextAppearance" parent="@android:style/TextAppearance.Holo">
        <!-- Alternatively, reference this font with the name "aspergit" -->
        <!-- Note that only our own TextView's will use the font attribute -->
        <item name="flFont">someFont</item>
        <item name="android:textStyle">bold|italic</item>
    </style>

    <!-- Alternative style, maybe for some other widget -->
    <style name="StylishFont">
        <item name="flFont">anotherFont</item>
        <item name="android:textStyle">normal</item>
    </style>

</resources>

Stworzyłem kilka narzędzi specjalnie do tego celu. Zapoznaj się z tym projektem z GitHub lub spójrz na ten post na blogu, który wyjaśnia całą sprawę.

Najlepszym sposobem na to Z wersji zapoznawczej Androida O jest następujący sposób:

Działa tylko, jeśli masz Android Studio w wersji 2.4 lub nowszej

1. Kliknij folder res prawym przyciskiem myszy i wybierz Nowy> katalog zasobów Androida .
   Zostanie wyświetlone okno Nowy katalog zasobów.
   
2. Na liście Typ zasobu wybierz czcionkę , a następnie kliknij przycisk OK.
   
3. Dodaj pliki czcionek w czcionki folderu .Powierzchnia struktury folderów poniżej generuje R.font.dancing_script, R.font.la_laoraz R.font.ba_ba.
   
4. Kliknij dwukrotnie plik czcionek, aby wyświetlić podgląd czcionek pliku w edytorze.

Następnie musimy stworzyć rodzinę czcionek:

1. Kliknij folder czcionek prawym przyciskiem myszy i wybierz Nowy> Plik zasobów czcionek . Zostanie wyświetlone okno Nowy plik zasobów.
   
2. Wprowadź nazwę pliku, a następnie kliknij przycisk OK . Nowy plik XML zasobów czcionek zostanie otwarty w edytorze.
   

3. Dołącz każdy plik czcionki, styl i wagę do elementu znacznika czcionki. Poniższy kod XML ilustruje dodawanie atrybutów związanych z czcionkami w kodzie XML zasobu czcionki:

Dodawanie czcionek do TextView:

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

Z dokumentacji

Praca z czcionkami

Wszystkie kroki są prawidłowe.

W przypadku czcionek niestandardowych w systemie Android utwórz folder w nazwie folderu zasobów, to „czcionki” umieść w nim żądany plik fonts.ttf lub .otf.

Jeśli rozszerzysz UIBaseFragment:

Typeface font = Typeface.createFromAsset(getActivity().getAssets(), "fonts/Arial.ttf");
        tv.setTypeface(font);

w przeciwnym razie rozszerzenie aktywności:

Typeface font = Typeface.createFromAsset(getContext().getAssets(), "fonts/Arial.ttf");
        tv.setTypeface(font);

Możesz użyć PixlUI w https://github.com/neopixl/PixlUI

zaimportuj plik .jar i użyj go w formacie XML

 <com.neopixl.pixlui.components.textview.TextView
    android:id="@+id/textView1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world"
    pixlui:typeface="GearedSlab.ttf" />

Ponieważ nie byłem zadowolony ze wszystkich prezentowanych rozwiązań na SO, wymyśliłem swoje. Opiera się na małej sztuczce ze znacznikami (tzn. Nie możesz używać znaczników w kodzie), umieszczam tam ścieżkę czcionki. Podczas definiowania widoków możesz wykonać jedną z tych czynności:

<TextView
        android:id="@+id/textViewHello1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World 1"
        android:tag="fonts/Oswald-Regular.ttf"/>

albo to:

<TextView
        android:id="@+id/textViewHello2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World 2"
        style="@style/OswaldTextAppearance"/>

<style name="OswaldTextAppearance">
        <item name="android:tag">fonts/Oswald-Regular.ttf</item>
        <item name="android:textColor">#000000</item>
</style>

Teraz możesz albo bezpośrednio uzyskać dostęp / skonfigurować widok jako:

TextView textView = TextViewHelper.setupTextView(this, R.id.textViewHello1).setText("blah");

lub po prostu skonfiguruj wszystko za pomocą:

TextViewHelper.setupTextViews(this, (ViewGroup) findViewById(R.id.parentLayout)); // parentLayout is the root view group (relative layout in my case)

A o jaką klasę magii pytasz? W większości przyklejony z innych postów SO, z metodami pomocniczymi zarówno dla aktywności, jak i fragmentów:

import android.app.Activity;
import android.content.Context;
import android.graphics.Typeface;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import java.util.HashMap;
import java.util.Map;

public class TextViewHelper {
    private static final Map<String, Typeface> mFontCache = new HashMap<>();

    private static Typeface getTypeface(Context context, String fontPath) {
        Typeface typeface;
        if (mFontCache.containsKey(fontPath)) {
            typeface = mFontCache.get(fontPath);
        } else {
            typeface = Typeface.createFromAsset(context.getAssets(), fontPath);
            mFontCache.put(fontPath, typeface);
        }
        return typeface;
    }

    public static void setupTextViews(Context context, ViewGroup parent) {
        for (int i = parent.getChildCount() - 1; i >= 0; i--) {
            final View child = parent.getChildAt(i);
            if (child instanceof ViewGroup) {
                setupTextViews(context, (ViewGroup) child);
            } else {
                if (child != null) {
                    TextViewHelper.setupTextView(context, child);
                }
            }
        }
    }

    public static void setupTextView(Context context, View view) {
        if (view instanceof TextView) {
            if (view.getTag() != null) // also inherited from TextView's style
            {
                TextView textView = (TextView) view;
                String fontPath = (String) textView.getTag();
                Typeface typeface = getTypeface(context, fontPath);
                if (typeface != null) {
                    textView.setTypeface(typeface);
                }
            }
        }
    }

    public static TextView setupTextView(View rootView, int id) {
        TextView textView = (TextView) rootView.findViewById(id);
        setupTextView(rootView.getContext().getApplicationContext(), textView);
        return textView;
    }

    public static TextView setupTextView(Activity activity, int id) {
        TextView textView = (TextView) activity.findViewById(id);
        setupTextView(activity.getApplicationContext(), textView);
        return textView;
    }
}

Niestety nie ma na to dobrego rozwiązania.

Widziałem wiele artykułów na temat korzystania z niestandardowego TextView, ale zapominają o tym, że nie tylko widoki tekstowe mogą implementować czcionki, a także widoki tekstowe ukryte w innych widokach niedostępnych dla programisty; Nie zamierzam nawet zaczynać od Spannable .

Możesz użyć zewnętrznego narzędzia do czcionek, takiego jak:

Narzędzie czcionki kaligrafii

ALE To zapętla się nad każdym widokiem w aplikacji podczas jej tworzenia, a nawet to narzędzie pomija niektóre widoki (ViewPager renderuje normalną czcionkę), wtedy masz problem polegający na tym, że kiedy Google aktualizuje swoje narzędzia do kompilacji, to czasami się zawiesza, ponieważ musi być ukierunkowany na przestarzałe właściwości. Jest również trochę powolny, ponieważ wykorzystuje odbicie Java .

Naprawdę to zależy od Google. Potrzebujemy lepszej obsługi czcionek w systemie Android. Jeśli spojrzysz na rozwiązanie z iOS, mają dosłownie 100 wbudowanych czcionek do wyboru. Chcesz niestandardową czcionkę? Po prostu wrzuć TFF i można go użyć.

Na razie ograniczyliśmy się do oferty Google, która jest bardzo ograniczona, ale na szczęście zoptymalizowana pod kątem urządzeń mobilnych.

Pamiętaj, aby wkleić powyższy kod do onCreate () po wywołaniu super i wywołaniu setContentView (). Ten drobny szczegół trzymał mnie przez pewien czas rozłączony.

W systemie Android 8.0 korzystanie z niestandardowych czcionek w aplikacji stało się łatwe downloadable fonts. Możemy dodawać czcionki bezpośrednio do res/font/ folderfolderu projektu, a dzięki temu czcionki stają się automatycznie dostępne w Android Studio.

Teraz ustaw fontFamilyatrybut na listę czcionek lub kliknij więcej i wybierz czcionkę do wyboru. Spowoduje to dodanie tools:fontFamily="@font/your_font_file"wiersza do TextView.

Spowoduje to automatyczne wygenerowanie kilku plików.

1. W folderze wartości zostanie utworzonyfonts_certs.xml .

2. W Manifeście doda następujące linie:

  <meta-data
            android:name="preloaded_fonts"
            android:resource="@array/preloaded_fonts" /> 

3) preloaded_fonts.xml

<resources>
    <array name="preloaded_fonts" translatable="false">
        <item>@font/open_sans_regular</item>
        <item>@font/open_sans_semibold</item>
    </array>
</resources>

Możesz użyć łatwej i prostej biblioteki innej firmy EasyFonts, aby ustawić różne niestandardowe czcionkiTextView . Korzystając z tej biblioteki, nie musisz się martwić o pobieranie i dodawanie czcionek do folderu asset / fonts. Także o tworzeniu obiektów kroju pisma.

Zamiast

Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(myTypeface);

Po prostu:

TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(EasyFonts.robotoThin(this));

Ta biblioteka zapewnia także następującą czcionkę.

• Roboto
• Droid Serif
• Droid Robot
• Wolność
• Fun Raiser
• Android Nation
• Zielone awokado
• Uznanie

Miałem ten sam problem, TTF się nie pojawił. Zmieniłem plik czcionki i działa z tym samym kodem.

Jeśli chcesz załadować czcionkę z sieci lub łatwo ją stylizować, możesz użyć:

https://github.com/shellum/fontView

Przykład:

<!--Layout-->
<com.finalhack.fontview.FontView
        android:id="@+id/someFontIcon"
        android:layout_width="80dp"
        android:layout_height="80dp" />

//Java:
fontView.setupFont("http://blah.com/myfont.ttf", true, character, FontView.ImageType.CIRCLE);
fontView.addForegroundColor(Color.RED);
fontView.addBackgroundColor(Color.WHITE);

Cóż, po siedmiu latach możesz łatwo zmienić całą aplikację textViewlub co chcesz, używając android.supportbibliotek 26 ++.

Na przykład:

Utwórz aplikację pakietu czcionek / src / res / font i przenieś do niej swoją czcionkę.

A do motywu aplikacji po prostu dodaj go jako fontFamily:

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

Przykład użycia textViewtylko z :

<style name="fontTextView" parent="@android:style/Widget.TextView">
    <item name="android:fontFamily">monospace</item>
</style>

I dodaj do głównego motywu:

<item name="android:textViewStyle">@style/fontTextView</item>

Obecnie działa na 8.1 do 4.1 API Jelly Bean I to szeroki zakres.

Zaktualizuj odpowiedź: Android 8.0 (poziom API 26) wprowadza nową funkcję, Czcionki w XML. po prostu użyj funkcji Czcionki w XML na urządzeniach z Androidem 4.1 (API poziom 16) i wyżej, skorzystaj z Biblioteki pomocy 26.

zobacz ten link

Stara odpowiedź

Istnieją dwa sposoby dostosowywania czcionek:

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

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

wywołanie FontsOverride.setDefaultFont () w klasie rozszerza aplikację, 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 wystarczy wywołać 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;
    }

}

Prawidłowy sposób wykonania tego w API 26 opisano w oficjalnej dokumentacji tutaj:

https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html

Obejmuje to umieszczenie plików ttf w folderze res / font i utworzenie pliku rodziny czcionek.

Najprostsze rozwiązanie obsługiwane teraz przez Androida!

Użyj niestandardowej czcionki w xml:

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:fontFamily="@font/[your font resource]"/>

zobacz szczegóły:

https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html

• Otwórz swój projekt i wybierz Projekt w lewym górnym rogu
• app -> src -> main
• kliknij prawym przyciskiem myszy na main i utwórz katalog nazwij go jako zasób
• kliknij prawym przyciskiem myszy, aby ocenić i utworzyć nazwę nowego katalogu czcionek
• musisz znaleźć darmowe czcionki, takie jak darmowe czcionki
• przekaż go do widoku tekstu i zadzwoń do niego na zajęciach
• skopiuj swoje czcionki do folderu czcionek
• TextView txt = (TextView) findViewById(R.id.txt_act_spalsh_welcome); Typeface font = Typeface.createFromAsset(getAssets(), "fonts/Aramis Italic.ttf"); txt.setTypeface(font);

nazwa czcionki musi być poprawna i dobrze się bawić

Tak, czcionki do pobrania są tak proste, jak powiedział Dipali .

Tak to się robi...

1. Umieść a TextView.
2. W panelu właściwości wybierz fontFamilymenu rozwijane. Jeśli go tam nie ma, znajdź to ostrzeżenie (>> i kliknij, aby rozwinąć textAppearance) pod.
3. Rozwiń listę font-familyrozwijaną.
4. Na małej liście przewiń do końca, aż zobaczysz more fonts
5. Otworzy się okno dialogowe, w którym można wyszukiwać Google Fonts
6. Wyszukaj ulubioną czcionkę za pomocą paska wyszukiwania u góry
7. Wybierz czcionkę.
8. Wybierz styl czcionki, którą lubisz (pogrubienie, normalność, kursywa itp.)
9. W prawym okienku wybierz przycisk opcji Add font to project
10. Kliknij OK. Teraz TextView ma czcionkę, którą lubisz!

BONUS: Jeśli chcesz stylizować WSZYSTKO za pomocą tekstu w aplikacji za pomocą wybranej czcionki, po prostu dodaj <item name="android:fontfamily">@font/fontnamehere</item>do swojegostyles.xml