Come cambiare fontFamily di TextView in Android

Quindi mi piacerebbe cambiare android:fontFamilyin Android ma non vedo alcun font predefinito in Android. Come seleziono uno di quelli predefiniti? Non ho davvero bisogno di definire il mio TypeFace ma tutto ciò di cui ho bisogno è qualcosa di diverso da quello 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 lassù non funzionerà davvero! A proposito, è android:fontFamily="Arial"stato uno stupido tentativo!

Da Android 4.1 / 4.2 / 5.0 sono disponibili le seguenti famiglie di caratteri Roboto :

android:fontFamily="sans-serif"           // roboto regular
android:fontFamily="sans-serif-light"     // roboto light
android:fontFamily="sans-serif-condensed" // roboto condensed
android:fontFamily="sans-serif-black"     // roboto black
android:fontFamily="sans-serif-thin"      // roboto thin (android 4.2)
android:fontFamily="sans-serif-medium"    // roboto medium (android 5.0)

in combinazione con

android:textStyle="normal|bold|italic"

queste 16 varianti sono possibili:

• Roboto regolare
• Roboto corsivo
• Roboto grassetto
• Roboto grassetto corsivo
• Roboto-Light
• Roboto-Light corsivo
• Roboto-sottile
• Corsivo Roboto-Thin
• Roboto-Condensed
• Corsivo condensato in roboto
• Roboto-Condensed grassetto
• Corsivo grassetto corsivo Roboto
• Roboto-Black
• Corsivo Roboto-Nero
• Roboto-Medium
• Roboto-Medium corsivo

fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="font_family_light">sans-serif-light</string>
    <string name="font_family_medium">sans-serif-medium</string>
    <string name="font_family_regular">sans-serif</string>
    <string name="font_family_condensed">sans-serif-condensed</string>
    <string name="font_family_black">sans-serif-black</string>
    <string name="font_family_thin">sans-serif-thin</string>
</resources>

Questo è il modo di 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);

inserisci il file del carattere nella cartella delle risorse. Nel mio caso ho creato una sottodirectory chiamata fonts.

EDIT: Se ti chiedi dove sia la cartella delle tue risorse, vedi questa domanda

A partire da Android-Studio 3.0 è molto semplice cambiare la famiglia di caratteri

Utilizzando la libreria di supporto 26, funzionerà su dispositivi che eseguono l'API Android versione 16 e successive

Crea una cartella fontnella resdirectory. Scarica il font che vuoi e incollalo nella fontcartella. La struttura dovrebbe essere qualcosa come sotto

Nota: a partire da Android Support Library 26.0, è necessario dichiarare entrambi i set di attributi (android: e app:) per assicurarsi che i caratteri vengano caricati su dispositivi con Api 26 o versioni precedenti.

Ora puoi cambiare carattere nel layout usando

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

Per cambiare Programatically

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

Per cambiare carattere usando styles.xml crea uno stile

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

e applica 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 del mouse sulla cartella dei caratteri e selezionare Nuovo> File delle risorse dei caratteri . Viene visualizzata la finestra Nuovo file di risorse.

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

Scrivi qui la tua famiglia di caratteri, ad 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 sulla risorsa font che verrà utilizzata per il rendering di quella specifica variante. I valori validi per fontStyle sono normali o in corsivo; e fontWeight è conforme alle specifiche di peso del font CSS

1. Per cambiare fontfamily nel layout è possibile scrivere

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

2. Per modificare a livello di codice

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

Per modificare il carattere dell'intera app Aggiungi queste due righe 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>

Consulta la documentazione , tutorial sui caratteri personalizzati Android per maggiori informazioni

Ho dovuto analizzare /system/etc/fonts.xmlun recente progetto. Ecco le famiglie di caratteri attuali a partire da 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, potresti offrire ai tuoi utenti una selezione di famiglie di caratteri e impostare il carattere tipografico 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();

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 codice. 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 un formato .ttf (TrueType)o .otf (OpenType). Anche allora, alcuni caratteri potrebbero non funzionare.

Questo è un font che funziona sicuramente su Android e puoi usarlo per confermare che il tuo codice funziona nel caso in cui il tuo file di font non sia supportato da Android.

Aggiornamento Android O: questo è ora possibile con XML in Android O , in base al commento di Roger.

Per impostare Roboto a livello di codice:

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

È lo stesso di android:typeface.

i caratteri integrati sono:

• normale
• sans
• serif
• monospace

Vedi android: carattere tipografico .

Se lo vuoi a livello di codice, potresti usarlo

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

Dove SANS_SERIFpuoi usare:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

E dove ITALICpuoi usare:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Tutto è dichiarato su Android Developers

Sto usando l'eccellente libreria Calligrafia di Chris Jenx progettata per permetterti di usare caratteri personalizzati nella tua applicazione Android. Provaci!

Quello che vuoi non è possibile. Devi impostare il TypeFacetuo codice.

In XMLquello che puoi fare è

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

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

Perché Arialdevi impostare il tipo di faccia nel tuo codice.

Un modo semplice per gestire i caratteri sarebbe dichiararli tramite risorse, in quanto tali:

<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>

<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>

<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

Questo si basa sul codice sorgente qui e qui

Dinamicamente puoi impostare fontfamily 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 gli elenchi della famiglia di caratteri predefinita utilizzata, utilizzare uno di questi sostituendo la stringa di virgolette doppie "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 fare riferimento ad altri caratteri predefiniti in questa famiglia di caratteri predefiniti

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

imposta facilmente il font per qualsiasi visualizzazione di testo dalla directory res> font a livello di codice

Penso di essere in ritardo, ma forse questa soluzione è utile per gli altri. Per utilizzare il carattere personalizzato, posizionare il file del carattere nella directory dei caratteri.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));

Con qualche tentativo ed errore ho imparato quanto segue.

All'interno di * .xml è possibile combinare i caratteri stock con le seguenti funzioni, non solo con il carattere tipografico:

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

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

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

In AOSP, il carattere Arial è valido ma deve essere definito utilizzando "arial" non "Arial", ad esempio android: fontFamily = "arial" . Dai un'occhiata qucik a System_fonts.xml di Kitkat

    <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 importanti xml-attributi per la definizione di un "font" in layout-- Android: fontFamily , Android: carattere e Android: lo stile di testo . La combinazione di "fontFamily" e "textStyle" o "typeface" e "textStyle" può essere utilizzata per modificare l'aspetto del font nel testo, così viene utilizzato da solo. Snippet di codice in TextView.java in questo modo:

    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 è impostato "fontFamily", il "carattere tipografico" verrà ignorato.
2. "carattere tipografico" ha valori validi standard e limitati. In effetti, i valori sono "normali" "sans" "serif" e "monospace", si trovano in system_fonts.xml (4.x) o fonts.xml (5.x). In realtà sia "normale" che "sans" sono i caratteri predefiniti del sistema.
3. "fontFamily" può essere utilizzato per impostare tutti i tipi di carattere incorporati, mentre "carattere tipografico" fornisce solo i caratteri tipici di "sans-serif" "serif" e "monospace" (le tre principali categorie di tipo di carattere al 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".

Ecco un modo più semplice che può funzionare in alcuni casi. Il principio è quello di aggiungere un TextVview non visibile nel layout XML e di ottenere il suo tipoFace 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).

Prova questo:

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

Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);

Puoi anche farlo aggiungendo una cartella di caratteri nella directory res come di seguito.

Quindi, selezionando Carattere come tipo di risorsa.

Puoi trovare i caratteri disponibili da https://www.1001fonts.com/ e quindi estrarre i file TTF in questa directory di caratteri.

Infine, basta modificare il file XML che contiene la visualizzazione di testo aggiungendo android: fontFamily: "@ font / urfontfilename"

Un modo semplice è aggiungendo il carattere desiderato nel progetto.

Vai a File-> Nuovo-> Nuova directory delle risorse Seleziona il carattere

Questo creerà una nuova directory, font , nelle tue risorse.

Scarica il tuo carattere (.ttf) . Uso https://fonts.google.com per lo stesso

Aggiungilo alla cartella dei caratteri, quindi utilizzali nell'XML o a livello di codice.

XML -

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

Programmaticamente -

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

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

Se vuoi usare un TextView in così tanti posti con la stessa famiglia di caratteri, estendi la classe TextView e imposta il tuo carattere 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 usa questa classe personalizzata in xml per TextView in questo modo: -

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

Se stai utilizzando Android Studio 3.5+, la modifica del carattere è semplicissima. Seleziona il widget di testo nella vista Progettazione e controlla fontFamily nella finestra degli attributi. Il menu a discesa del valore contiene tutti i caratteri disponibili da cui è possibile selezionarne uno. Se stai cercando Google Fonts, fai clic sull'opzione Altri caratteri.

Finestra degli attributi

Google Fonts

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 quindi con R.font.my_custom_font, proprio come puoi accedere a valori di res di stringa , valori di res disegnabili ecc. Hai anche possibilità per creare il file xml font-face , che verrà impostato con i tuoi font personalizzati (su corsivo, grassetto e sottolineato attr).

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

C'è una bella biblioteca disponibile per questo

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'

La nuova risorsa font consente di impostare direttamente fontusando

android:fontFamily="@font/my_font_in_font_folder"

Hai impostato lo stile in res/layout/value/style.xmlquesto modo:

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

e per usare questo stile main.xmlnell'uso dei file:

style="@style/boldText"

Per Android-Studio 3 e versioni successive puoi usare questo stile e poi tutti textView modifiche ai caratteri 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>

Il modo più semplice per aggiungere il font in modo programmatico a un TextView è, innanzitutto, aggiungere il file del font nella cartella Asset del progetto. Ad esempio, il percorso del tuo carattere è simile al seguente:assets/fonts/my_font.otf

E aggiungilo a un TextView come:

Kotlin

val font_path = "fonts/my_font.otf"  

myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)

textView.typeface = myTypeface

Giava

String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);

Qui puoi vedere tutti i valori disponibili di fontFamily e i nomi dei file dei font corrispondenti (questo file viene utilizzato in Android 5.0+). Nel dispositivo mobile, puoi trovarlo in:

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

(Per Android 4.4 e versioni precedenti usando questa versione, ma penso che fonts.xmlabbia 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 name="sans-serif"del familytag ha definito il valore che puoi usare in android: fontFamily.

Il fonttag definisce i file dei caratteri corrispondenti.

In questo caso, puoi ignorare la fonte in <!-- fallback fonts -->, sta usando per la logica di fallback dei caratteri.