family - toolbar change font android




Come cambiare fontFamily di TextView in Android (18)

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!


È lo stesso di android:typeface .

i caratteri incorporati sono:

  • normale
  • sans
  • serif
  • monospace

Vedi android:typeface .


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


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.


Da Android 4.1 / 4.2 / 5.0, sono disponibili le seguenti famiglie di caratteri di 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 in corsivo
  • Roboto audace
  • Roboto grassetto corsivo
  • Roboto-Light
  • Corsivo di Roboto-Light
  • Roboto-sottile
  • Robotico-Sottile corsivo
  • Roboto-Condensed
  • Corsivo saturo-condensato
  • Grassetto-Condensato audace
  • Corsivo grassetto in grassetto
  • Roboto-Black
  • Roboto-Nero corsivo
  • Roboto-Medium
  • Robotico-Medium italic

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>

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


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


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

Per impostare Roboto a livello di codice:

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

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"

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.


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


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


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


Un modo semplice per gestire i caratteri sarebbe quello di 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 è basato sul codice sorgente here e here


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.


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.


prova questi semplici passaggi. 1. creare la cartella dei caratteri nella cartella res. 2. copia e incolla il file .ttf nella cartella dei font. 3. Ora dai il percorso in xml come sotto.

 android:fontFamily="@font/frutiger"

o qualunque sia il nome del tuo file. Questo è un codice felice


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




typeface