Como alterar a fonteFamília do TextView no Android

Gostaria de alterar o android:fontFamilyno Android, mas não vejo fontes predefinidas no Android. Como seleciono um dos pré-definidos? Eu realmente não preciso definir meu próprio TypeFace, mas tudo o que preciso é algo diferente do que ele mostra agora.

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

Parece que o que eu fiz lá em cima não vai funcionar! BTW android:fontFamily="Arial"foi uma tentativa estúpida!

No android 4.1 / 4.2 / 5.0, as seguintes famílias de fontes Roboto estão disponíveis:

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)

em combinação com

android:textStyle="normal|bold|italic"

estas 16 variantes são possíveis:

• Roboto regular
• Roboto itálico
• Roboto bold
• Roboto negrito itálico
• Roboto-Light
• Roboto-Light itálico
• Roboto-Thin
• Roboto-Thin itálico
• Condensado por Roboto
• Itálico condensado por roboto
• Negrito Condensado por Roboto
• Itálico a negrito, condensado por roboto
• Roboto-Black
• Roboto-preto itálico
• Roboto-Medium
• Roboto-Médio itálico

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>

Esta é a maneira de definir a fonte programaticamente:

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

coloque o arquivo de fonte na sua pasta de ativos. No meu caso, criei um subdiretório chamado fontes.

EDIT: Se você se perguntar onde está sua pasta de ativos, consulte esta pergunta

A partir do Android-Studio 3.0, é muito fácil mudar a família de fontes

Usando a biblioteca de suporte 26, ele funcionará em dispositivos executando a API Android versão 16 e superior

Crie uma pasta fontno resdiretório. Baixe a fonte que desejar e cole-a dentro da fontpasta. A estrutura deve ser algo como abaixo

Nota: A partir da Biblioteca de suporte do Android 26.0, você deve declarar os dois conjuntos de atributos (android: e app:) para garantir que suas fontes sejam carregadas em dispositivos executando o Api 26 ou inferior.

Agora você pode alterar a fonte no layout usando

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

Para mudar programaticamente

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

Para alterar a fonte usando styles.xml, crie um estilo

 <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 aplique esse estilo a TextView

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

você também pode criar sua própria família de fontes

- Clique com o botão direito do mouse na pasta fonte e vá para Novo> Arquivo de Recurso Fonte . A janela Novo arquivo de recurso é exibida.

- Digite o nome do arquivo e clique em OK . O novo XML do recurso de fonte é aberto no editor.

Escreva sua própria família de fontes aqui, por exemplo

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

isso é simplesmente um mapeamento de um fontStyle e fontWeight específico para o recurso de fonte que será usado para renderizar essa variante específica. Os valores válidos para fontStyle são normais ou itálicos; e fontWeight está em conformidade com a especificação de peso da fonte CSS

1. Para alterar a família da fonte no layout, você pode escrever

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

2. Alterar programaticamente

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

Para alterar a fonte de todo o aplicativo Adicione essas duas linhas no 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>

Consulte o Tutorial sobre documentação , fontes personalizadas do Android Para obter mais informações

Eu tive que analisar /system/etc/fonts.xmlem um projeto recente. Aqui estão as famílias de fontes atuais no 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              ║
╚════╩════════════════════════════╩═════════════════════════════╝

Aqui está o analisador (baseado em 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;
        }

    }
}

Sinta-se livre para usar a classe acima em seu projeto. Por exemplo, você pode oferecer aos usuários uma seleção de famílias de fontes e definir o tipo de letra com base nas preferências deles.

Um pequeno exemplo 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();

O Android não permite que você defina fontes personalizadas no layout XML. Em vez disso, você deve agrupar o arquivo de fonte específico na pasta de ativos do seu aplicativo e configurá-lo programaticamente. Algo como:

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

Observe que você só pode executar esse código depois que setContentView () for chamado. Além disso, apenas algumas fontes são suportadas pelo Android e devem estar no formato .ttf (TrueType)ou .otf (OpenType). Mesmo assim, algumas fontes podem não funcionar.

este é uma fonte que definitivamente funciona no Android, e você pode usá-la para confirmar se o seu código está funcionando, caso seu arquivo de fonte não seja compatível com o Android.

Atualização do Android O: agora é possível com XML no Android O , com base no comentário de Roger.

Para definir o Roboto programaticamente:

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

É o mesmo que android:typeface.

fontes internas são:

• normal
• sans
• serifa
• monoespaço

Veja android: tipo de letra .

Se você quiser programaticamente, você pode usar

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

Onde SANS_SERIFvocê pode usar:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

E onde ITALIC você pode usar:

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Tudo é declarado nos desenvolvedores Android

Estou usando a excelente biblioteca de caligrafia de Chris Jenx, projetada para permitir que você use fontes personalizadas em seu aplicativo Android. De uma chance!

O que você quer não é possível. Você deve definir TypeFaceseu código.

No XMLque você pode fazer é

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

caso contrário, você não poderá jogar muito com as fontes em XML. :)

Para Arialvocê precisar definir o tipo face no seu código.

Uma maneira fácil de gerenciar as fontes seria declará-las por meio de recursos, como:

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

Isso é baseado no código fonte aqui e aqui

Dinamicamente, você pode definir a família de fontes semelhante ao android: fontFamily em xml usando this,

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

Esta é a lista da família de fontes padrão usada. Use qualquer uma dessas opções substituindo a sequência de aspas duplas "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" é o arquivo ttf. O caminho estará em src / assets / fonts / mycustomfont.ttf , você pode consultar mais sobre a fonte padrão nesta família de fontes Padrão

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

defina facilmente a fonte para qualquer visualização de texto do diretório res> font programaticamente

Acho que estou atrasado, mas talvez essa solução seja útil para outros. Para usar fontes personalizadas, coloque seu arquivo de fontes no diretório de fontes.

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

Com algumas tentativas e erros, aprendi o seguinte.

No * .xml, você pode combinar as fontes de estoque com as seguintes funções, não apenas com o tipo de letra:

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

Com esses dois estilos, não havia necessidade de usar o tipo de letra em nenhum outro caso. A variedade de combinações é muito maior com fontfamily & textStyle.

O valor válido do android: fontFamily é definido em /system/etc/system_fonts.xml(4.x) ou /system/etc/fonts.xml(5.x). Mas o Fabricante do dispositivo pode modificá-lo, portanto a fonte real usada pela configuração do valor fontFamily depende do arquivo mencionado acima do dispositivo especificado.

No AOSP, a fonte Arial é válida, mas deve ser definida usando "arial" e não "Arial", por exemplo, android: fontFamily = "arial" . Dê uma olhada no system_fonts.xml de 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>

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

Existem três atributos xml relevantes para definir uma "fonte" no layout - android: fontFamily , android: typeface e android: textStyle . A combinação de "fontFamily" e "textStyle" ou "typeface" e "textStyle" pode ser usada para alterar a aparência da fonte no texto, assim como usada sozinha. Fragmento de código no TextView.java, como este:

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

A partir do código, podemos ver:

1. se "fontFamily" estiver definido, o "tipo de letra" será ignorado.
2. "typeface" possui valores válidos padrão e limitados. De fato, os valores são "normal" "sans" "serif" e "monospace", eles podem ser encontrados em system_fonts.xml (4.x) ou fonts.xml (5.x). Na verdade, "normal" e "sans" são a fonte padrão do sistema.
3. "fontFamily" pode ser usado para definir todas as fontes de fontes incorporadas, enquanto "tipo de letra" fornece apenas as fontes típicas de "sans-serif" "serif" e "monospace" (as três principais categorias de tipos de fontes do mundo) .
4. Quando apenas definimos "textStyle", na verdade definimos a fonte padrão e o estilo especificado. O valor efetivo é "normal" "negrito" "itálico" e "negrito | itálico".

Aqui está uma maneira mais fácil que pode funcionar em alguns casos. O princípio é adicionar um TextVview não visível no seu layout xml e obter seu typeFace no código java.

O layout no arquivo 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 o código java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Funcionou para mim (dentro de um TextSwitcher, por exemplo).

Tente o seguinte:

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

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

Você também pode fazer isso adicionando uma pasta de fontes no diretório res, como abaixo.

Em seguida, selecione Fonte como o tipo de recurso.

Você pode encontrar fontes disponíveis em https://www.1001fonts.com/ e, em seguida, extrair os arquivos TTF para esse diretório de fontes.

Por fim, basta alterar o arquivo XML que contém a sua visualização de texto adicionando android: fontFamily: "@ font / urfontfilename"

Uma maneira simples é adicionar a fonte desejada no projeto.

Vá para Arquivo-> Novo-> Novo Diretório de Recursos Selecione a fonte

Isso criará um novo diretório, fonte , em seus recursos.

Baixe sua fonte (.ttf) . Eu uso https://fonts.google.com para o mesmo

Adicione isso à sua pasta de fontes e use-os no XML ou programaticamente.

XML -

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

Programaticamente -

 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 você deseja usar um TextView em tantos lugares com a mesma família de fontes, estenda a classe TextView e defina sua fonte assim: -

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, em seguida, use esta classe personalizada em xml para o TextView da seguinte maneira: -

   <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 você estiver usando o Android Studio 3.5 ou superior, a alteração da fonte é super simples. Selecione o widget de texto no modo Design e marque fontFamily na janela Attribute. A lista suspensa de valores contém todas as fontes disponíveis das quais você pode selecionar uma. Se você estiver procurando por fontes do Google, clique na opção Mais fontes.

Janela de atributo

Fontes do Google

Eu só quero mencionar que o inferno com as fontes dentro do Android está prestes a terminar, porque este ano no Google IO finalmente chegamos a isso -> https://developer.android.com/preview/features/working-with-fonts. html

Agora, existe um novo tipo de recurso, uma fonte, e você pode colocar todas as fontes do seu aplicativo na pasta res / fonts e acessar com R.font.my_custom_font, assim como você pode acessar valores de string res, valores de drawable res etc. Você ainda tem chance para criar um arquivo xml font-face , que será definido com suas fontes personalizadas (sobre itálico, negrito e sublinhado).

Leia o link acima para mais informações. Vamos ver o suporte.

Existe uma boa biblioteca disponível para este

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

O novo recurso de fonte permite definir diretamente fontusando

android:fontFamily="@font/my_font_in_font_folder"

Você define o estilo res/layout/value/style.xmlassim:

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

e para usar esse estilo no main.xmlarquivo use:

style="@style/boldText"

Para o android-studio 3 e superior, você pode usar esse estilo e textViewalterar todas as fontes no aplicativo.

crie este estilo no seu style.xml:

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

Em seguida, use-o no seu 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>

A maneira mais fácil de adicionar a fonte programaticamente a um TextView é, primeiro, adicionar o arquivo de fonte na sua pasta Assets no projeto. Por exemplo, seu caminho da fonte está assim:assets/fonts/my_font.otf

E adicione-o a um TextView como:

Kotlin

val font_path = "fonts/my_font.otf"  

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

textView.typeface = myTypeface

Java

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

Aqui você pode ver todos os valores de fontFamily disponíveis e os nomes dos arquivos de fontes correspondentes (este arquivo está usando no Android 5.0+). No dispositivo móvel, você pode encontrá-lo em:

/system/etc/fonts.xml (para 5.0 ou superior)

(Para o Android 4.4 e abaixo, use esta versão, mas acho que fonts.xmltem um formato mais claro e fácil de entender.)

Por exemplo,

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

O atributo name name="sans-serif"da familytag definiu o valor que você pode usar no android: fontFamily.

A fonttag define os arquivos de fonte correspondentes.

Nesse caso, você pode ignorar a fonte em <!-- fallback fonts -->que está usando a lógica de fallback das fontes.