android-layout change - Come cambiare fontFamily di TextView in Android




toolbar set (22)

Se lo vuoi programmaticamente, puoi usare

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

Dove SANS_SERIF puoi usare:

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

E dove ITALIC puoi usare:

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

Tutto è indicato sugli sviluppatori Android

Quindi mi piacerebbe cambiare l' android:fontFamily in Android ma non vedo alcun carattere predefinito in Android. Come seleziono uno di quelli predefiniti? Non ho davvero bisogno di definire la mia TypeFace, ma tutto ciò di cui ho bisogno è qualcosa di diverso da ciò che mostra in questo momento.

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

Sembra che quello che ho fatto lì non funzionerà davvero! BTW android:fontFamily="Arial" stato uno stupido tentativo!


Ho creato una piccola libreria denominata Foundry che è possibile utilizzare per applicare caratteri tipografici personalizzati tramite layout e stili XML.


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

Dinamicamente puoi impostare la famiglia di font simile ad Android: fontFamily in xml usando questo,

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

Questi sono l'elenco della famiglia di font di default usata, usa uno di questi rimpiazzando la stringa di doppia quotatura "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" è il file ttf. Il percorso sarà in src / assets / fonts / mycustomfont.ttf , puoi riferirti di più sul carattere predefinito in questa famiglia di font predefinita


Se vuoi usare TextView in così tanti posti con la stessa famiglia di font, estendi la classe TextView e imposta il tuo font in questo modo: -

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

E quindi utilizzare questa classe personalizzata in xml per il TextView come questo: -

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

Con alcuni tentativi ed errori ho imparato quanto segue.

All'interno del file * .xml è possibile combinare i tipi di carattere originali con le seguenti funzioni, non solo con il carattere tipografico:

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

Con questi due stili, non è stato necessario utilizzare il carattere tipografico in nessun altro caso. La gamma di combinazioni è molto più grande con fontfamily e textStyle.


Per impostare Roboto a livello di codice:

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

Questa è anche una buona libreria di RobotoTextView . Serve davvero ai tuoi bisogni.


Puoi impostare lo stile in res/layout/value/style.xml questo modo:

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

e per usare questo stile nel file main.xml usa:

style="@style/boldText"

Il valore valido di android: fontFamily è definito in /system/etc/system_fonts.xml(4.x) o /system/etc/fonts.xml(5.x). Ma il produttore del dispositivo potrebbe modificarlo, quindi il carattere effettivo utilizzato impostando il valore fontFamily dipende dal file sopra indicato del dispositivo specificato.

In AOSP, il font Arial è valido ma deve essere definito utilizzando "arial" non "Arial", ad esempio android: fontFamily = "arial" . Dai un'occhiata a kitkat's system_fonts.xml

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

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

Ci sono tre attributi xml rilevanti per la definizione di un "font" nel layout : android: fontFamily , android: typeface e android: textStyle . La combinazione di "fontFamily" e "textStyle" o "typeface" e "textStyle" può essere utilizzata per modificare l'aspetto del carattere nel testo, quindi viene utilizzato da solo. Snippet di codice in TextView.java come questo:

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

Dal codice possiamo vedere:

  1. se "fontFamily" è impostato, il "carattere tipografico" verrà ignorato.
  2. "typeface" ha valori validi standard e limitati. Infatti, i valori sono "normali" "sans" "serif" e "monospace", possono essere trovati in system_fonts.xml (4.x) o fonts.xml (5.x). In realtà sia "normale" che "sans" sono i font di default del sistema.
  3. "fontFamily" può essere utilizzato per impostare tutti i tipi di carattere built-in, mentre "typeface" fornisce solo i caratteri tipici di "sans-serif" "serif" e "monospace" (la categoria principale di tre tipi di font nel mondo) .
  4. Quando si imposta solo "textStyle", in realtà impostiamo il carattere predefinito e lo stile specificato. I valori effettivi sono "normale" "grassetto" "corsivo" e "grassetto | corsivo".

Questo è il modo per impostare il carattere a livello di codice:

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

metti il ​​file dei font nella tua cartella delle risorse. Nel mio caso ho creato una sottodirectory chiamata fonts.

EDIT: Se ti chiedi dove è la tua cartella di beni vedere questa domanda


A partire da Android-Studio 3.0 è molto facile cambiare la famiglia di font

Utilizzando la libreria di supporto 26, funzionerà su dispositivi con API Android versione 16 e successive

Crea un font cartella nella directory res Scarica il font che vuoi e incollalo nella cartella dei font . La struttura dovrebbe essere qualcosa come sotto

ora puoi cambiare il carattere nel layout usando

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

Per cambiare Programatically

 Typeface typeface = getResources().getFont(R.font.myfont);
 textView.setTypeface(typeface);  

Per cambiare il carattere usando styles.xml crea uno stile

 <style name="Regular">
        <item name="android:fontFamily">@font/dancing_script</item>
        <item name="android:textStyle">normal</item>
 </style>

e applicare questo stile a TextView

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

puoi anche creare la tua famiglia di caratteri

- Fare clic con il tasto destro sulla cartella dei caratteri e andare su Nuovo> File di risorse font . Viene visualizzata la finestra Nuovo file di risorse.

- Immettere il nome del file , quindi fare clic su OK . La nuova risorsa XML di caratteri si apre nell'editor.

Scrivi qui la tua famiglia di font, per esempio

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

questa è semplicemente una mappatura di uno specifico fontStyle e fontWeight alla risorsa font che verrà usata per rendere quella specifica variante. I valori validi per fontStyle sono normali o in corsivo; e fontWeight è conforme alle specifiche del peso font CSS

1. Per cambiare la famiglia dei font nel layout puoi scrivere

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

2. Per cambiare a livello di programmazione

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

Nota: A partire dalla Libreria di supporto Android 26.0, è necessario dichiarare entrambi i set di attributi (android: e app:) per garantire il caricamento dei font sui dispositivi che eseguono l'APi 26 o inferiore.

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

Per cambiare il carattere di tutta l'applicazione Aggiungi queste due linee in 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>

Vedi la Documentation , tutorial di caratteri personalizzati Android per maggiori informazioni


Here puoi vedere tutti i valori di font font disponibili e i nomi dei file dei font corrispondenti (questo file sta usando in Android 5.0+). Nel dispositivo mobile, puoi trovarlo in:

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

(Per Android 4.4 e versioni precedenti utilizzando this versione, ma penso che fonts.xml abbia un formato più chiaro e facile da capire.)

Per esempio,

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

L'attributo name="sans-serif" del tag family definito il valore che è possibile utilizzare in Android: fontFamily.

Il tag font definisce i file di font corrispondenti.

In questo caso, puoi ignorare l'origine sotto <!-- fallback fonts --> , sta usando la logica di fallback dei font.


Quello che vuoi non è possibile. Devi aver bisogno di impostare TypeFace nel tuo codice.

In XML quello che puoi fare è

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

a parte questo, non puoi giocare molto con i caratteri in XML. :)

Per Arial è necessario impostare il tipo face nel codice.


Voglio solo ricordare che l'inferno con i caratteri all'interno di Android sta per finire, perché quest'anno su Google IO abbiamo finalmente ottenuto questo -> https://developer.android.com/preview/features/working-with-fonts. html

Ora c'è un nuovo tipo di risorsa un font e puoi inserire tutti i font dell'applicazione nella cartella res / fonts e accedere poi con R.font.my_custom_font, proprio come puoi accedere ai valori di stringa , valori di drawable ecc. Hai anche possibilità per creare un file xml font-face , che verrà impostato con i caratteri personalizzati (su italic, bold e underline attr).

Leggi il link sopra per maggiori informazioni. Vediamo il supporto.


Io uso Letter Press lib per il mio materiale NonTextView come Buttons e kianoni fontloader lib per la mia causa TextViews, l'uso dello stile in questa libreria è più facile di Letter Press per me e ho ottenuto un feedback ideale con quello. questo è ottimo per coloro che vogliono usare font personalizzati ad eccezione di Roboto Font. quindi è stata la mia esperienza con le librerie di caratteri. per coloro che desiderano utilizzare la classe personalizzata per cambiare carattere, si consiglia vivamente di creare questa classe con questo snippet

    public class TypefaceSpan extends MetricAffectingSpan {
    /** An <code>LruCache</code> for previously loaded typefaces. */
    private static LruCache<String, Typeface> sTypefaceCache =
            new LruCache<String, Typeface>(12);

    private Typeface mTypeface;

    /**
     * Load the {@link android.graphics.Typeface} and apply to a {@link android.text.Spannable}.
     */
    public TypefaceSpan(Context context, String typefaceName) {
        mTypeface = sTypefaceCache.get(typefaceName);

        if (mTypeface == null) {
            mTypeface = Typeface.createFromAsset(context.getApplicationContext()
                    .getAssets(), String.format("fonts/%s", typefaceName));

            // Cache the loaded Typeface
            sTypefaceCache.put(typefaceName, mTypeface);
        }
    }

    @Override
    public void updateMeasureState(TextPaint p) {
        p.setTypeface(mTypeface);

        // Note: This flag is required for proper typeface rendering
        p.setFlags(p.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
    }

    @Override
    public void updateDrawState(TextPaint tp) {
        tp.setTypeface(mTypeface);

        // Note: This flag is required for proper typeface rendering
        tp.setFlags(tp.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
    }
}

E usa una classe come questa:

AppData = PreferenceManager.getDefaultSharedPreferences(this);
TextView bannertv= (TextView) findViewById(R.id.txtBanner);
    SpannableString s = new SpannableString(getResources().getString(R.string.enterkey));
    s.setSpan(new TypefaceSpan(this, AppData.getString("font-Bold",null)), 0, s.length(),
            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    bannertv.setText(s);

forse questo aiuto.


Per Android-Studio 3 e versioni successive puoi utilizzare questo stile e quindi tutti i textViewcambiamenti di carattere nell'app.

crea questo stile nel tuo style.xml:

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

Quindi usalo nel tuo tema:

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

Ecco un modo più semplice che può funzionare in alcuni casi. Il principio è di aggiungere un TextVview non visibile nel tuo layout xml e di ottenere il suo typeface nel codice java.

Il layout nel file xml:

 <TextView
        android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:fontFamily="sans-serif-thin"
        android:id="@+id/textViewDescription"/>

E il codice java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Ha funzionato per me (all'interno di un TextSwitcher per esempio).


Android non ti consente di impostare caratteri personalizzati dal layout XML. Invece, è necessario raggruppare il file di font specifico nella cartella delle risorse dell'app e impostarlo a livello di programmazione. Qualcosa di simile a:

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

Si noti che è possibile eseguire questo codice solo dopo aver chiamato setContentView (). Inoltre, solo alcuni caratteri sono supportati da Android e dovrebbero essere in formato .ttf (TrueType) o .otf (OpenType) . Anche in questo caso, alcuni tipi di carattere potrebbero non funzionare.

This è un font che funziona sicuramente su Android, e puoi usare questo per confermare che il tuo codice funzioni nel caso in cui il tuo file font non sia supportato da Android.

Aggiornamento O Android: ora è possibile con XML in Android O , basato sul commento di Roger.


Ho dovuto analizzare /system/etc/fonts.xml in un progetto recente. Ecco le famiglie di font attuali di 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Ecco il parser (basato su 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;
        }

    }
}

Sentiti libero di usare la classe sopra nel tuo progetto. Ad esempio, puoi fornire ai tuoi utenti una selezione di famiglie di caratteri e impostare il carattere in base alle loro preferenze.

Un piccolo esempio incompleto:

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

Puoi farlo in modo semplice usando la seguente libreria

https://github.com/sunnag7/FontStyler

<com.sunnag.fontstyler.FontStylerView
              android:textStyle="bold"
              android:text="@string/about_us"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:paddingTop="8dp"
              app:fontName="Lato-Bold"
              android:textSize="18sp"
              android:id="@+id/textView64" />

è leggero e facile da implementare, copia i tuoi font nella cartella delle risorse e usa il nome in xml.


Se utilizzi TextView basato su XML, per le tue necessità devi fare solo due cose:

  1. Identifica il tuo link nella stringa, ad esempio "questa è la mia pagina web". Puoi aggiungerlo in xml o nel codice.

  2. Nel xml che ha il TextView, aggiungi questi:


android:linksClickable="true"

android:autoLink="web"




android android-layout android-textview typeface