Android - Usando fonte personalizada

Eu apliquei uma fonte personalizada para a TextView, mas isso não parece alterar o tipo de letra.

Aqui está o meu código:

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

Alguém pode me tirar desta questão?

No Mobiletuts +, há um tutorial muito bom sobre formatação de texto para Android. Dica rápida: personalizar fontes do Android

EDIT: Testei-me agora. Aqui está a solução. Você pode usar uma subpasta chamada de fontes, mas ela deve estar na assetspasta e não na respasta. assim

ativos / fontes

Além disso, verifique se o final da fonte, ou seja, o final do próprio arquivo de fonte está em minúsculas. Em outras palavras, não deve ser, myFont.TTFmas myfont.ttf dessa maneira deve estar em letras minúsculas

Depois de tentar a maioria das soluções descritas neste tópico, encontrei acidentalmente o Calligraphy ( https://github.com/chrisjenx/Calligraphy ) - uma biblioteca de Christopher Jenkins que permite adicionar fontes personalizadas ao seu aplicativo com facilidade. As vantagens de sua biblioteca em comparação com as abordagens sugeridas aqui são:

1. você não precisa apresentar seu próprio componente TextView substituído, você usa o TextView interno
2. você pode incluir facilmente a biblioteca usando gradle
3. A biblioteca não limita sua escolha de fontes; basta adicionar seus preferidos ao diretório de ativos
4. você não apenas obtém visualizações de texto personalizadas - todos os outros componentes Android baseados em texto também serão exibidos usando sua fonte personalizada.

Eu sei que já existem boas respostas, mas aqui está uma implementação totalmente funcional.

Aqui está a exibição de texto personalizada:

package com.mycompany.myapp.widget;

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

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

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

        private final String fileName;

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

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

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

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

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

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

Aqui estão os atributos personalizados. Isso deve ir para o seu res/attrs.xmlarquivo:

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

E aqui está como você o usa. Usarei um layout relativo para envolvê-lo e mostrar a customAttrdeclaração, mas obviamente pode ser o layout que você já possui.

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

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

</RelativeLayout>

Eu usei isso com sucesso antes. A única diferença entre nossas implementações é que eu não estava usando uma subpasta em ativos. Não tenho certeza se isso vai mudar alguma coisa, no entanto.

Desde que você tenha colocado a fonte no lugar certo e não haja erro no próprio arquivo, seu código deve funcionar assim, RATTLESNAKE.

No entanto, seria muito mais fácil se você pudesse definir uma fonte no seu xml de layout, assim:

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

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

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

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

</LinearLayout>

Com o acompanhamento res/values/styles.xml:

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

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

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

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

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

</resources>

Criei algumas ferramentas especificamente para esse fim. Consulte este projeto no GitHub ou dê uma olhada nesta postagem do blog que explica tudo.

A melhor maneira de fazer isso A partir da versão de pré-visualização do Android O, é assim:

Funciona apenas se você tiver o android studio-2.4 ou superior

1. Clique com o botão direito do mouse na pasta res e vá para Novo> diretório de recursos do Android . A
   janela Novo Diretório de Recursos é exibida.
   
2. Na lista Tipo de recurso, selecione a fonte e clique em OK.
   
3. Envie seus arquivos de fonte na pasta de fontes .A estrutura de pastas abaixo gera R.font.dancing_script, R.font.la_lae R.font.ba_ba.
   
4. Clique duas vezes em um arquivo de fonte para visualizar as fontes do arquivo no editor.

Em seguida, devemos criar uma família de fontes:

1. 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.
   
2. Digite o nome do arquivo e clique em OK . O novo XML do recurso de fonte é aberto no editor.
   

3. Coloque cada atributo de arquivo, estilo e peso de fonte no elemento de marca de fonte. O XML a seguir ilustra como adicionar atributos relacionados à fonte no XML do recurso de fonte:

Adicionando fontes a um TextView:

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

A partir da documentação

Trabalhando com fontes

Todas as etapas estão corretas.

Para fontes personalizadas no Android, crie uma pasta no nome da pasta de ativos: "fontes" coloque o arquivo fonts.ttf ou .otf desejado.

Se você estender o UIBaseFragment:

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

Caso contrário, se estender a Atividade:

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

Você pode usar o PixlUI em https://github.com/neopixl/PixlUI

importe seu .jar e use-o em XML

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

Como não estava satisfeito com todas as soluções apresentadas no SO, criei as minhas. É baseado em um pequeno truque com tags (ou seja, você não pode usar tags no seu código), eu coloquei o caminho da fonte lá. Portanto, ao definir visualizações, você pode fazer o seguinte:

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

ou isto:

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

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

Agora você pode acessar / configurar explicitamente a exibição como:

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

ou apenas configure tudo via:

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

E qual é a aula de mágica que você pergunta? Colado principalmente de outras postagens de SO, com métodos auxiliares para atividade e fragmentos:

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

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

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

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

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

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

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

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

Infelizmente, não há uma boa solução para isso.

Eu já vi muitos artigos sobre o uso de um TextView personalizado, mas o que eles esquecem é que não são apenas as visualizações de texto que podem implementar fontes e há visualizações de texto ocultas em outras visualizações inacessíveis ao desenvolvedor; Eu não vou nem começar no Spannable .

Você pode usar um utilitário de fonte externa como:

Ferramenta de fonte de caligrafia

MAS Isso faz um loop em todas as visualizações do aplicativo em sua criação e, mesmo que esse utilitário perca algumas visualizações (o ViewPager renderiza a fonte normal), você tem o problema de que, quando o Google atualiza suas ferramentas de criação, isso ocasionalmente trava porque precisa direcionar propriedades obsoletas. Também é um pouco lento, pois usa o Reflection de Java .

Cabe realmente ao Google consertar isso. Precisamos de um melhor suporte de fontes no Android. Se você olhar para a solução do iOS, eles literalmente têm centenas de fontes incorporadas para seleção. Deseja uma fonte personalizada? Basta soltar um TFF e ele é utilizável.

Por enquanto, agora estávamos limitados à oferta que o Google nos oferece, que é extremamente limitada, mas felizmente otimizada para dispositivos móveis.

Certifique-se de colar o código acima em onCreate () após sua chamada para o super e a chamada para setContentView (). Esse pequeno detalhe me manteve desligado por um tempo.

Com o Android 8.0, usar Fontes personalizadas no aplicativo ficou fácil com downloadable fonts. Podemos adicionar fontes diretamente res/font/ folderna pasta do projeto e, assim, as fontes ficam automaticamente disponíveis no Android Studio.

Agora defina o fontFamilyatributo para a lista de fontes ou clique em mais e selecione a fonte de sua escolha. Isso adicionará tools:fontFamily="@font/your_font_file"linha ao seu TextView.

Isso irá gerar automaticamente alguns arquivos.

1. Na pasta de valores, ele será criado fonts_certs.xml.

2. No Manifesto, adicionará estas linhas:

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

3) preloaded_fonts.xml

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

Você pode usar a biblioteca fácil e simples de terceiros EasyFonts para definir uma variedade de fontes personalizadas para o seu TextView. Ao usar esta biblioteca, você não precisa se preocupar em baixar e adicionar fontes na pasta assets / fonts. Também sobre a criação de objetos Typeface.

Ao invés de

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

Simplesmente:

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

Esta biblioteca também fornece a seguinte face da fonte.

• Roboto
• Droid Serif
• Droid Robot
• Liberdade
• Fun Raiser
• Android Nation
• Abacate Verde
• Reconhecimento

Eu tive o mesmo problema, o TTF não apareceu. Mudei o arquivo da fonte e, com o mesmo código, está funcionando.

Se você deseja carregar a fonte da rede ou estilizá-la com facilidade, pode usar:

https://github.com/shellum/fontView

Exemplo:

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

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

Bem, após sete anos, você pode alterar o aplicativo inteiro textViewou o que deseja facilmente usando as android.supportbibliotecas 26 ++.

Por exemplo:

Crie seu pacote de fontes app / src / res / font e mova sua fonte para ele.

E no tema do seu aplicativo, adicione-o como uma fonte

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

Exemplo para uso textViewapenas:

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

E adicione ao seu tema principal:

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

Atualmente, ele trabalha entre 8.1 e 4.1 API Jelly Bean E essa é uma grande variedade.

Resposta da atualização: O Android 8.0 (API nível 26) apresenta um novo recurso, Fontes em XML. basta usar o recurso Fontes no XML em dispositivos com Android 4.1 (nível 16 da API) e superior, use a Biblioteca de suporte 26.

veja este link

Resposta antiga

Existem duas maneiras de personalizar fontes:

!!! minha fonte personalizada em assets / fonts / iran_sans.ttf

Caminho 1: Tipo de atualização.class ||| melhor maneira

chamada FontsOverride.setDefaultFont () na classe estende Application. Esse código fará com que todas as fontes de software sejam alteradas, mesmo que brinda fontes

AppController.java

public class AppController extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        //Initial Font
        FontsOverride.setDefaultFont(getApplicationContext(), "MONOSPACE", "fonts/iran_sans.ttf");

    }
}

FontsOverride.java

public class FontsOverride {

    public static void setDefaultFont(Context context, String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(), fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    }

    private static void replaceFont(String staticTypefaceFieldName, final Typeface newTypeface) {
        try {
            final Field staticField = Typeface.class.getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

Caminho 2: use setTypeface

para uma visualização especial, basta chamar setTypeface () para alterar a fonte.

CTextView.java

public class CTextView extends TextView {

    public CTextView(Context context) {
        super(context);
        init(context,null);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context,attrs);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context,attrs);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init(context,attrs);
    }

    public void init(Context context, @Nullable AttributeSet attrs) {

        if (isInEditMode())
            return;

        // use setTypeface for change font this view
        setTypeface(FontUtils.getTypeface("fonts/iran_sans.ttf"));

    }
}

FontUtils.java

public class FontUtils {

    private static Hashtable<String, Typeface> fontCache = new Hashtable<>();

    public static Typeface getTypeface(String fontName) {
        Typeface tf = fontCache.get(fontName);
        if (tf == null) {
            try {
                tf = Typeface.createFromAsset(AppController.getInstance().getApplicationContext().getAssets(), fontName);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            fontCache.put(fontName, tf);
        }
        return tf;
    }

}

A maneira correta de fazer isso na API 26 é descrita na documentação oficial aqui:

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

Isso envolve colocar os arquivos ttf na pasta res / font e criar um arquivo da família de fontes.

A solução mais simples android suportado agora!

Use fonte personalizada em xml:

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

veja detalhes:

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

• Abra seu projeto e selecione Projeto no canto superior esquerdo
• app -> src -> principal
• clique com o botão direito do mouse no principal e crie o nome do diretório como ativo
• clique com o botão direito para confirmar e criar um novo nome de diretório para fontes
• você precisa encontrar fontes grátis, como fontes grátis
• entregue-o ao seu Textview e chame-o na sua classe Activity
• copie suas fontes dentro da pasta de fontes
• TextView txt = (TextView) findViewById(R.id.txt_act_spalsh_welcome); Typeface font = Typeface.createFromAsset(getAssets(), "fonts/Aramis Italic.ttf"); txt.setTypeface(font);

o nome da fonte deve estar correto e se divertir

Sim, as fontes para download são tão fáceis, como Dipali disse.

É assim que se faz...

1. Coloque um TextView.
2. No painel de propriedades, selecione a fontFamilylista suspensa. Se não estiver lá, encontre o sinal de intercalação (o> e clique nele para expandir textAppearance) sob o.
3. Expanda a lista font-familysuspensa.
4. Na pequena lista, role todo o caminho até ver more fonts
5. Isso abrirá uma caixa de diálogo na qual você pode pesquisar Google Fonts
6. Procure a fonte que você gosta com a barra de pesquisa na parte superior
7. Selecione sua fonte.
8. Selecione o estilo da fonte que você gosta (por exemplo, negrito, normal, itálico etc.)
9. No painel direito, escolha o botão de opção que diz Add font to project
10. Clique em OK. Agora seu TextView tem a fonte que você gosta!

BÔNUS: Se você quiser estilizar TUDO com texto em seu aplicativo com a fonte escolhida, basta adicionar <item name="android:fontfamily">@font/fontnamehere</item>ao seustyles.xml