Porównaj ceny domen i usług IT, sprzedawców z całego świata

Android przy użyciu niestandardowej czcionki


Zastosowałem niestandardową czcionkę do
TextView
, ale wydaje się, że nie zmienia ona czcionki.
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 mnie wyciągnąć z tego pytania?
Zaproszony:
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Mobiletuts + ma bardzo dobry samouczek dotyczący formatowania tekstu dla Androida.

Szybka wskazówka: dostosowywanie czcionek
http://code.tutsplus.com/tutor ... 1601/
Android
EDYCJA: Sam to sprawdziłem. Oto rozwiązanie. Możesz użyć podfolderu czcionek, ale musi on znajdować się w folderze
asset
, a nie w folderze
res
. Więc

zasoby/czcionki

Upewnij się również, że zakończenie czcionki, mam na myśli zakończenie samego pliku czcionki, jest zapisane małymi literami. Innymi słowy, nie powinien to być
myFont.TTF
, ale
myfont.ttf

ta ścieżka musi być zapisana małymi literami
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Po wypróbowaniu większości rozwiązań opisanych w tym wątku przypadkowo znalazłem kaligrafię (

https://github.com/chrisjenx/Calligraphy
https://github.com/chrisjenx/Calligraphy) to biblioteka Christophera Jenkinsa, która ułatwia dodawanie niestandardowych czcionek do aplikacji. Zalety jego lib w stosunku do podejść sugerowanych tutaj są następujące:
  • nie musisz wprowadzać własnego, nadpisanego składnika TextView, używasz wbudowanego składnika TextView
  • możesz łatwo dołączyć bibliotekę za pomocą gradle
  • Biblioteka nie ogranicza wyboru czcionek; wystarczy dodać preferowane czcionki do katalogu zasobów
  • nie tylko otrzymujesz niestandardowe widoki tekstu - wszystkie inne komponenty tekstowe systemu Android będą również renderowane przy użyciu niestandardowej czcionki.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

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="[url=http://schemas.android.com/apk/res-auto"]http://schemas.android.com/apk/res-auto"[/url]} in the header.
*/
public class CustomFontTextView extends TextView { private static final String sScheme =
"[url=http://schemas.android.com/apk/res-auto";]http://schemas.android.com/apk/res-auto";[/url]
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 atrybuty niestandardowe. Powinno to przejść do pliku
res/attrs.xml
:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="CustomFontTextView">
<attr name="customFont" format="string"/>
</declare-styleable>
</resources>

I tak tego używasz. Użyję względnego układu, aby to podsumować i pokazać deklarację
customAttr
, ale oczywiście może to być dowolny układ, który już masz.
<RelativeLayout xmlns:android="[url=http://schemas.android.com/apk/res/android"]http://schemas.android.com/apk/res/android"[/url]
xmlns:customAttrs="[url=http://schemas.android.com/apk/res-auto"]http://schemas.android.com/apk/res-auto"[/url]
xmlns:tools="[url=http://schemas.android.com/tools"]http://schemas.android.com/tools"[/url]
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>
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

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

Anonimowy użytkownik

Potwierdzenie od:

Pod warunkiem, że umieściłeś czcionkę we właściwej lokalizacji i nie ma błędu w samym pliku czcionki, twój kod powinien działać w ten sposób, RATTLESNAKE.
Byłoby jednak znacznie łatwiej, gdybyś mógł po prostu zdefiniować czcionkę w swoim układzie XML w następujący sposób:
<LinearLayout xmlns:android="[url=http://schemas.android.com/apk/res/android"]http://schemas.android.com/apk/res/android"[/url]
xmlns:tools="[url=http://schemas.android.com/tools"]http://schemas.android.com/tools"[/url]
xmlns:app="[url=http://schemas.android.com/apk/res-auto"]http://schemas.android.com/apk/res-auto"[/url]
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="[url=http://schemas.android.com/apk/res/android"]http://schemas.android.com/apk/res/android"[/url] xmlns:tools="[url=http://schemas.android.com/tools">]http://schemas.android.com/tools">[/url] <!-- 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. Mówić do

ten projekt
https://github.com/Innovattic/ ... ation
z GitHub lub spójrz na to

post na blogu
http://blog.innovattic.com/int ... roid/
co wyjaśnia wszystko.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Najlepszym sposobem na zrobienie tego przed wydaniem Androida jest przeglądanie w ten sposób:

Działa tylko, jeśli masz Android Studio-2.4 lub nowszy

  • Kliknij prawym przyciskiem myszy res folder i idź do nowy katalog zasobów & > Android ... Nowy Pojawi się okno katalogu zasobów.
  • Na liście Typ zasobu wybierz czcionka i kliknij OK.
  • Dodaj pliki czcionek do folderu czcionek. Poniższa struktura folderów tworzy
    R.font.dancing_script
    ,
    R.font.la_la
    i
    R.font.ba_ba
    .
  • Podwójne kliknięcie plik czcionki, aby wyświetlić czcionki pliku w Edytorze.

Następnie musimy stworzyć rodzinę czcionek:
  • Kliknij prawym przyciskiem myszy folder czcionek i wybierz Utwórz & > plik zasobów czcionek ... Otworzy się nowe okno pliku zasobów.
  • Wchodzić nazwę pliku i kliknij OK ... Nowy zasób czcionek XML zostanie otwarty w edytorze.
  • Dołącz każdy plik czcionki, atrybut stylu i wagi do elementu znacznika czcionki. Poniższy kod XML ilustruje dodawanie atrybutów związanych z czcionkami do zasobu czcionek XML:

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

Jak wynika z dokumentacji

Praca z czcionkami
https://developer.android.com/ ... stkie kroki są prawidłowe.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

W przypadku czcionek niestandardowych w systemie Android utwórz folder w folderze zasobów, nazwij go „fonts” i 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);

nawet jeśli rozszerza działalność:
Typeface font = Typeface.createFromAsset(getContext().getAssets(), "fonts/Arial.ttf");
tv.setTypeface(font);
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Możesz używać PixlUI w

https://github.com/neopixl/PixlUI
https://github.com/neopixl/PixlUI
zaimportuj je .jar i użyj go w 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"/>
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:


Niestety nie ma na to dobrego rozwiązania.

Widziałem wiele artykułów na temat korzystania z niestandardowego TextView, ale zapominają, że to nie tylko widoki tekstu tworzą czcionki & amp; w innych widokach są ukryte widoki tekstu, które nie są dostępne dla programisty; Nawet nie zacznę z nimi pracować

Spannable

.
Możesz użyć zewnętrznego narzędzia do obsługi czcionek, takiego jak:
Narzędzie czcionki kaligraficznej
http://github.com/chrisjenx/Calligraphy

Ale

ta pętla pojawia się w każdym widoku w aplikacji, gdy jest tworzona, a nawet w tym narzędziu brakuje niektórych widoków (ViewPager renderuje normalną czcionkę), to masz problem, że gdy Google aktualizuje narzędzia do kompilacji, czasami ulega awarii. ponieważ musi docelowe przestarzałe właściwości. Jest również nieco powolny, gdy używa

odbicie

Java .
Naprawienie tego naprawdę 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 mieć własną czcionkę? Po prostu upuść TFF i jest użyteczny.
Na razie ograniczyliśmy się do oferty, którą oferuje nam Google, która jest niezwykle ograniczona, ale na szczęście zoptymalizowana pod kątem urządzeń mobilnych.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Ponieważ nie byłem zadowolony ze wszystkich rozwiązań przedstawionych na SO, wymyśliłem własne. Opiera się na małej sztuczce tagowania (tj. Nie możesz używać tagów w swoim kodzie), umieszczam tam ścieżkę czcionki. Dlatego podczas definiowania widoków możesz wykonać następujące 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 jawnie uzyskać dostęp do widoku/dostosować go, na przykład:
TextView textView = TextViewHelper.setupTextView(this, R.id.textViewHello1).setText("blah");

lub po prostu skonfiguruj wszystko przez:
TextViewHelper.setupTextViews(this, (ViewGroup) findViewById(R.id.parentLayout));// parentLayout is the root view group (relative layout in my case)

Co to jest klasa magiczna, pytasz? Przeważnie wklejane 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;
}
}
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Pamiętaj, aby wkleić powyższy kod do onCreate ()

po

wywołanie do szefa i wywołanie setContentView (). Ten mały szczegół sprawił, że na chwilę się rozłączyłem.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Możesz użyć łatwego & amp; prosty

EasyFonts
https://android-arsenal.com/details/1/2044
biblioteka innej firmy do instalowania różnych niestandardowych czcionek dla Twojego
TextView
. Korzystając z tej biblioteki, nie musisz martwić się o pobieranie i dodawanie czcionek do folderu zasobów/czcionek. Również o tworzeniu obiektu czcionki.
Zamiast
Typeface myTypeface = Typeface.createFromAsset(getAssets(), "fonts/myFont.ttf");
TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(myTypeface);

Właśnie:
TextView myTextView = (TextView)findViewById(R.id.myTextView);
myTextView.setTypeface(EasyFonts.robotoThin(this));

Ta biblioteka zapewnia również następującą krój czcionki.
  • Robot
  • Serif Droid
  • Robot Droid
  • Wolność
  • Fan Raiser
  • Naród Androida
  • Zielone awokado
  • Uznanie
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

OD

Android 8.0

Używanie czcionek niestandardowych w aplikacji jest łatwiejsze dzięki
czcionkom do pobrania
.
Możemy dodawać czcionki bezpośrednio do
res/font/ folder

w folderze projektu, a czcionki są automatycznie udostępniane w Android Studio.
https://i.stack.imgur.com/GbkuY.png
Teraz zainstaluj


atrybut
fontFamily
do listy czcionek lub kliknij przycisk więcej i wybierz żądaną czcionkę. to

doda wiersz
tools: fontFamily = "@ font/your_font_file"
do Twojego TextView.

Spowoduje to automatyczne utworzenie wielu plików.

1 .

w folderze wartości utworzy
fonts_certs.xml
.

2.

w manifeście doda te 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>
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Jeśli chcesz pobrać czcionkę z sieci lub łatwo ją nadać stylowi, możesz użyć:
https://github.com/shellum/fontView
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("[url=http://blah.com/myfont.ttf"]http://blah.com/myfont.ttf"[/url], true, character, FontView.ImageType.CIRCLE);
fontView.addForegroundColor(Color.RED);
fontView.addBackgroundColor(Color.WHITE);
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Miałem ten sam problem: TTF się nie pojawiało. Zmieniłem plik czcionki i działa z tym samym kodem.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:


Zaktualizuj odpowiedź:

Android 8.0 (poziom API 26) wprowadza nową funkcję, czcionki w języku XML.
po prostu użyj funkcji czcionek w XML na urządzeniach z systemem Android 4.1 (poziom API 16) i nowszym, użyj biblioteki obsługi 26.
Zobacz

połączyć
https://developer.android.com/ ... n-xml

Stara odpowiedź

Istnieją dwa sposoby dostosowywania czcionek:

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


Metoda 1:

Refrection Typeface.class |||

Najlepszym sposobem

wywołując FontsOverride.setDefaultFont () w klasie extends Application, ten kod zmieni wszystkie czcionki programistyczne, nawet teastowe

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


Metoda 2:

Użyj setTypeface
aby uzyskać specjalny wygląd, 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;
}}
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Cóż, za siedem lat możesz łatwo zmienić całą aplikację
textView
lub cokolwiek zechcesz, korzystając z bibliotek
android.support
26 ++.
E.g:
Utwórz swój pakiet

czcionki

app/src/res/font i przenieś do niego swoją czcionkę.
https://i.stack.imgur.com/gCE99.png
W motywie 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 do użytku tylko z
textView
:
<style name="fontTextView" parent="@android:style/Widget.TextView">
<item name="android:fontFamily">monospace</item>
</style>

I dodaj do swojego głównego motywu:
<item name="android:textViewStyle">@style/fontTextView</item>

Obecnie pracuje dla

8.1 do 4.1 API Jelly Bean

i jest to szeroki zakres.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Właściwy sposób na zrobienie tego od API 26 opisano w oficjalnej dokumentacji tutaj:
https://developer.android.com/ ... face/ wygląd i styl/fonts-in-xml.html
https://developer.android.com/ ... .html
Obejmuje to umieszczenie plików ttf w folderze res/font i utworzenie pliku rodziny czcionek.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

  • Otwórz swój projekt i wybierz projekt w lewym górnym rogu
  • app --> src --> main
  • kliknij prawym przyciskiem myszy na głównym i utwórz nazwę katalogu majątek
  • kliknij prawym przyciskiem myszy, aby ocenić i utworzyć nowy katalog, nazwij go czcionki
  • musisz znaleźć darmowe czcionki, takie jak darmowe czcionki https://www.1001freefonts.com/italic-fonts.php
  • przekaż go swojemu Textview i nazwij go w swojej klasie aktywności
  • skopiuj czcionki do folderu fonts
  • TextView txt = (TextView) findViewById(R.id.txt_act_spalsh_welcome); Typeface font = Typeface.createFromAsset(getAssets(), "fonts/Aramis Italic.ttf"); txt.setTypeface(font);

nazwa czcionki powinna być poprawna i zabawna
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Tak, czcionki do pobrania są tak proste, jak powiedziano

Dipali S.

Tak to się robi ...
  • Umieść
    TextView
    .
  • Na pasku właściwości wybierz listę rozwijaną
    fontFamily
    . Jeśli go tam nie ma, znajdź daszek (& > i kliknij go, aby rozwinąć
    textAppearance
    ) poniżej.
  • Rozwiń menu
    font-family
    .
  • Na małej liście przewiń w dół, aż zobaczysz
    więcej czcionek
  • Otworzy się okno dialogowe, w którym można wyszukiwać w
    Google Fonts
  • Znajdź odpowiednią czcionkę na pasku wyszukiwania u góry
  • Wybierz swoją czcionkę.
  • Wybierz styl czcionki, który Ci się podoba (np. Pogrubienie, zwykła, kursywa itp.)
  • W prawym okienku wybierz przycisk opcji oznaczony
    Dodaj czcionkę do projektu
  • Kliknij OK. Teraz Twój TextView ma czcionkę, którą lubisz!

BONUS:
Jeśli chcesz stylizować WSZYSTKO z tekstem w aplikacji za pomocą wybranej czcionki, po prostu dodaj
& < item name = "android: fontfamily" & > @ font/fontnamehere & </item & >
do swojego
styles. xml
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Najprostsze rozwiązanie dla Androida obsługiwane teraz!
Użyj niestandardowej czcionki w formacie xml:
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/[your font resource]"/>

Zobacz więcej:
https://developer.android.com/ ... face/ wygląd i styl/fonts-in-xml.html
https://developer.android.com/ ... .html

Aby odpowiedzieć na pytania, Zaloguj się lub Zarejestruj się