wake-up-neo.com

Wie ändere ich die Schriftart in der Textansicht?

Wie ändere ich die Schriftart in einem TextView, der standardmäßig als Arial angezeigt wird? Wie ändere ich es auf Helvetica?

278
Praveen

Erstens ist der Standardwert nicht Arial. Die Standardeinstellung ist Droid Sans.

Um zu einer anderen integrierten Schriftart zu wechseln, verwenden Sie zweitens Android:typeface in Layout-XML oder setTypeface() in Java.

Drittens gibt es keine Helvetica-Schriftart in Android. Die eingebauten Optionen sind Droid Sans (sans), Droid Sans Mono (monospace) und Droid Serif (serif). Sie können Ihre eigenen Schriften mit Ihrer Anwendung bündeln und über setTypeface() verwenden. Beachten Sie jedoch, dass die Schriftdateien groß sind und in einigen Fällen Lizenzvereinbarungen erfordern (z. B. Helvetica, a Linotype-Schriftart .

EDIT

Die Designsprache Android basiert auf traditionellen typografischen Werkzeugen wie Skalierung, Abstand, Rhythmus und Ausrichtung mit einem zugrunde liegenden Raster. Die erfolgreiche Bereitstellung dieser Tools ist unerlässlich, damit Benutzer einen Informationsbildschirm schnell verstehen können. Um diesen Einsatz von Typografie zu unterstützen, führte Ice Cream Sandwich eine neue Typenfamilie mit dem Namen Roboto ein, die speziell für die Anforderungen von Benutzeroberflächen und hochauflösenden Bildschirmen entwickelt wurde.

Das aktuelle TextView-Framework bietet Roboto in dünnen, leichten, regelmäßigen und fett gedruckten Schnitten sowie kursiv gedruckten Schnitten. Das Framework bietet auch die Roboto Condensed-Variante in Normal- und Fettdruck sowie eine Kursivschrift für jedes Gewicht.

Nach dem ICS enthält Android den Roboto-Schriftstil. Lesen Sie mehr Roboto

EDIT 2

Mit der Einführung der Support Library 26 unterstützt Android jetzt standardmäßig benutzerdefinierte Schriftarten. Sie können neue Schriftarten in res/fonts einfügen, die entweder in XML oder programmgesteuert einzeln auf TextViews gesetzt werden können. Die Standardschriftart für die gesamte Anwendung kann auch durch Definieren von styles.xml geändert werden. Die Entwicklerdokumentation zu Android enthält eine klare Anleitung hier .

337
CommonsWare

Laden Sie zuerst die .ttf -Datei der gewünschten Schriftart herunter (arial.ttf). Legen Sie es in den Ordner assets. (Erstellen Sie im Assets-Ordner einen neuen Ordner mit dem Namen fonts und platzieren Sie ihn darin.) Verwenden Sie den folgenden Code, um die Schriftart auf Ihr TextView anzuwenden:

Typeface type = Typeface.createFromAsset(getAssets(),"fonts/arial.ttf"); 
textView.setTypeface(type);
253
HjK
Typeface tf = Typeface.createFromAsset(getAssets(),
        "fonts/DroidSansFallback.ttf");
TextView tv = (TextView) findViewById(R.id.CustomFontText);
tv.setTypeface(tf);
50
Android Girl

Möglicherweise möchten Sie statische Klasse erstellen, das alle Schriftarten enthält. Auf diese Weise erstellen Sie die Schriftart nicht mehrmals, was sich negativ auf Leistung auswirken könnte. Stellen Sie einfach sicher, dass Sie einen nterordner namens "Schriftarten" unter "Assets" Ordner erstellen.

Mach etwas wie:

public class CustomFontsLoader {

public static final int FONT_NAME_1 =   0;
public static final int FONT_NAME_2 =   1;
public static final int FONT_NAME_3 =   2;

private static final int NUM_OF_CUSTOM_FONTS = 3;

private static boolean fontsLoaded = false;

private static Typeface[] fonts = new Typeface[3];

private static String[] fontPath = {
    "fonts/FONT_NAME_1.ttf",
    "fonts/FONT_NAME_2.ttf",
    "fonts/FONT_NAME_3.ttf"
};


/**
 * Returns a loaded custom font based on it's identifier. 
 * 
 * @param context - the current context
 * @param fontIdentifier = the identifier of the requested font
 * 
 * @return Typeface object of the requested font.
 */
public static Typeface getTypeface(Context context, int fontIdentifier) {
    if (!fontsLoaded) {
        loadFonts(context);
    }
    return fonts[fontIdentifier];
}


private static void loadFonts(Context context) {
    for (int i = 0; i < NUM_OF_CUSTOM_FONTS; i++) {
        fonts[i] = Typeface.createFromAsset(context.getAssets(), fontPath[i]);
    }
    fontsLoaded = true;

}
}

Auf diese Weise können Sie die Schriftart von überall in Ihrer Anwendung abrufen.

32
Daniel L.

Best Practice aller Zeiten

TextViewPlus.Java:

public class TextViewPlus extends TextView {
    private static final String TAG = "TextView";

    public TextViewPlus(Context context) {
        super(context);
    }

    public TextViewPlus(Context context, AttributeSet attrs) {
        super(context, attrs);
        setCustomFont(context, attrs);
    }

    public TextViewPlus(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setCustomFont(context, attrs);
    }

    private void setCustomFont(Context ctx, AttributeSet attrs) {
        TypedArray a = ctx.obtainStyledAttributes(attrs, R.styleable.TextViewPlus);
        String customFont = a.getString(R.styleable.TextViewPlus_customFont);
        setCustomFont(ctx, customFont);
        a.recycle();
    }

    public boolean setCustomFont(Context ctx, String asset) {
        Typeface typeface = null;
        try {
            typeface = Typeface.createFromAsset(ctx.getAssets(), asset);
        } catch (Exception e) {
            Log.e(TAG, "Unable to load typeface: "+e.getMessage());
            return false;
        }

        setTypeface(typeface);
        return true;
    }
}

attrs.xml: (Speicherort res/values)

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

Wie benutzt man:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    xmlns:foo="http://schemas.Android.com/apk/res-auto"
    Android:orientation="vertical" Android:layout_width="fill_parent"
    Android:layout_height="fill_parent">

    <com.mypackage.TextViewPlus
        Android:id="@+id/textViewPlus1"
        Android:layout_height="match_parent"
        Android:layout_width="match_parent"
        Android:text="@string/showingOffTheNewTypeface"
        foo:customFont="my_font_name_regular.otf">
    </com.mypackage.TextViewPlus>
</LinearLayout>

Hoffe das wird dir helfen.

19
Hiren Patel

Die obigen Antworten sind richtig. Stellen Sie einfach sicher, dass Sie einen Unterordner mit dem Namen "fonts" unter "assets" erstellen, wenn Sie diesen Code verwenden.

17

Eine andere Möglichkeit zur Konsolidierung der Schrifterstellung ...

public class Font {
  public static final Font  PROXIMA_NOVA    = new Font("ProximaNovaRegular.otf");
  public static final Font  FRANKLIN_GOTHIC = new Font("FranklinGothicURWBoo.ttf");
  private final String      assetName;
  private volatile Typeface typeface;

  private Font(String assetName) {
    this.assetName = assetName;
  }

  public void apply(Context context, TextView textView) {
    if (typeface == null) {
      synchronized (this) {
        if (typeface == null) {
          typeface = Typeface.createFromAsset(context.getAssets(), assetName);
        }
      }
    }
    textView.setTypeface(typeface);
  }
}

Und dann in Ihrer Tätigkeit zu verwenden ...

myTextView = (TextView) findViewById(R.id.myTextView);
Font.PROXIMA_NOVA.apply(this, myTextView);

Allerdings funktioniert diese doppelt überprüfte Sperrsprache mit dem flüchtigen Feld nur mit dem in Java 1.5+ verwendeten Speichermodell ordnungsgemäß.

14
Chris Aitchison

Es wird empfohlen, Android Support Library Version 26.0.0 oder höher zu verwenden.

SCHRITT 1: Schriftartdatei hinzufügen

  1. Erstellen Sie im Ordner res ein neues Ressourcenwörterbuch font
  2. Schriftartdatei hinzufügen (. Ttf , . Orf )

Wenn beispielsweise die Schriftartdatei helvetica_neue.ttf lautet, wird R.font.helvetica_neue generiert

SCHRITT 2: Schriftfamilie erstellen

  1. Fügen Sie im Ordner font eine neue Ressourcendatei hinzu
  2. Fügen Sie alle Schriftdatei-, Stil- und Gewichtsattribute in das Element ein.

Zum Beispiel:

<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:Android="http://schemas.Android.com/apk/res/Android">
    <font
        Android:fontStyle="normal"
        Android:fontWeight="400"
        Android:font="@font/helvetica_neue" />
</font-family>

SCHRITT 3: benutze es

In XML-Layouts:

<TextView
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:fontFamily="@font/my_font"/>

Oder fügen Sie Schriftarten hinzu:

<style name="customfontstyle" parent="@Android:style/TextAppearance.Small">
    <item name="Android:fontFamily">@font/lobster</item>
</style>

Weitere Beispiele finden Sie in der Dokumentation:

Arbeiten mit Schriftarten

12

Es ist ein bisschen alt, aber ich habe die Klasse CustomFontLoader ein bisschen verbessert und wollte sie teilen, damit sie hilfreich ist. Erstellen Sie einfach eine neue Klasse mit diesem Code.

 import Android.content.Context;
 import Android.graphics.Typeface;

public enum FontLoader {

ARIAL("arial"),
TIMES("times"),
VERDANA("verdana"),
TREBUCHET("trbuchet"),
GEORGIA("georgia"),
GENEVA("geneva"),
SANS("sans"),
COURIER("courier"),
TAHOMA("tahoma"),
LUCIDA("lucida");   


private final String name;
private Typeface typeFace;


private FontLoader(final String name) {
    this.name = name;

    typeFace=null;  
}

public static Typeface getTypeFace(Context context,String name){
    try {
        FontLoader item=FontLoader.valueOf(name.toUpperCase(Locale.getDefault()));
        if(item.typeFace==null){                
            item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");                 
        }           
        return item.typeFace;
    } catch (Exception e) {         
        return null;
    }                   
}
public static Typeface getTypeFace(Context context,int id){
    FontLoader myArray[]= FontLoader.values();
    if(!(id<myArray.length)){           
        return null;
    } 
    try {
        if(myArray[id].typeFace==null){     
            myArray[id].typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+myArray[id].name+".ttf");                       
        }       
        return myArray[id].typeFace;    
    }catch (Exception e) {          
        return null;
    }   

}

public static Typeface getTypeFaceByName(Context context,String name){      
    for(FontLoader item: FontLoader.values()){              
        if(name.equalsIgnoreCase(item.name)){
            if(item.typeFace==null){
                try{
                    item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");     
                }catch (Exception e) {          
                    return null;
                }   
            }
            return item.typeFace;
        }               
    }
    return null;
}   

public static void loadAllFonts(Context context){       
    for(FontLoader item: FontLoader.values()){              
        if(item.typeFace==null){
            try{
                item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");     
            }catch (Exception e) {
                item.typeFace=null;
            }   
        }                
    }       
}   
}

Dann benutze einfach diesen Code in deiner Textansicht:

 Typeface typeFace=FontLoader.getTypeFace(context,"arial");  
 if(typeFace!=null) myTextView.setTypeface(typeFace);
7
Alan

Ich habe endlich eine sehr einfache Lösung dafür gefunden.

  1. verwenden Sie diese Support-Bibliotheken in Gradle auf App-Ebene,

    compile 'com.Android.support:appcompat-v7:26.0.2'
    compile 'com.Android.support:support-v4:26.0.2'
    
  2. erstellen Sie dann ein Verzeichnis mit dem Namen "font" im Ordner res

  3. legen Sie Zeichensatzdateien (ttf) in dieses Verzeichnis. Beachten Sie dabei die Namenskonventionen. [z. B. name darf keine Sonderzeichen, Großbuchstaben und Leerzeichen oder Tabulatoren enthalten.]
  4. Verweisen Sie danach wie folgt auf diese Schriftart von xml

            <Button
            Android:id="@+id/btn_choose_employee"
            Android:layout_width="140dp"
            Android:layout_height="40dp"
            Android:layout_centerInParent="true"
            Android:background="@drawable/rounded_red_btn"
            Android:onClick="btnEmployeeClickedAction"
            Android:text="@string/searching_jobs"
            Android:textAllCaps="false"
            Android:textColor="@color/white"
            Android:fontFamily="@font/times_new_roman_test"
            />
    

In diesem Beispiel ist times_new_roman_test eine Schriftartdatei aus diesem Schriftartverzeichnis

import Java.lang.ref.WeakReference;
import Java.util.HashMap;

import Android.content.Context;
import Android.graphics.Typeface;

public class FontsManager {

    private static FontsManager instance;

    private static HashMap<String, WeakReference<Typeface>> typefaces = new HashMap<String, WeakReference<Typeface>>();

    private static Context context;

    private FontsManager(final Context ctx) {
        if (context == null) {
            context = ctx;
        }
    }

    public static FontsManager getInstance(final Context appContext) {
        if (instance == null) {
            instance = new FontsManager(appContext);
        }
        return instance;
    }

    public static FontsManager getInstance() {
        if (instance == null) {
            throw new RuntimeException(
                    "Call getInstance(Context context) at least once to init the singleton properly");
        }
        return instance;
    }

    public Typeface getFont(final String assetName) {
        final WeakReference<Typeface> tfReference = typefaces.get(assetName);
        if (tfReference == null || tfReference.get() == null) {
            final Typeface tf = Typeface.createFromAsset(context.getResources().getAssets(),
                    assetName);
            typefaces.put(assetName, new WeakReference<Typeface>(tf));
            return tf;
        }
        return tfReference.get();
    }

}

Auf diese Weise können Sie eine Ansicht erstellen, die von TextView erbt und setTypeface in ihrem Konstruktor aufruft.

4
Charlie-Blake
  1. klasse FontTextView.Java hinzufügen:


public class FontTextView extends TextView {
    String fonts[] = {"HelveticaNeue.ttf", "HelveticaNeueLight.ttf", "motschcc.ttf", "symbol.ttf"};

    public FontTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(attrs);
    }

    public FontTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        if (!isInEditMode()) {
            init(attrs);
        }

    }

    public FontTextView(Context context) {
        super(context);
        if (!isInEditMode()) {
            init(null);
        }
    }

    private void init(AttributeSet attrs) {
        if (attrs != null) {
            TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.FontTextView);
            if (a.getString(R.styleable.FontTextView_font_type) != null) {
                String fontName = fonts[Integer.valueOf(a.getString(R.styleable.FontTextView_font_type))];

                if (fontName != null) {
                    Typeface myTypeface = Typeface.createFromAsset(getContext().getAssets(), "font/" + fontName);
                    setTypeface(myTypeface);
                }
                a.recycle();
            }
        }
    }
}


  1. zur Schrift der Assets-Bibliothek hinzufügen
    enter image description here


  1. add to attrs.xml, Die Zahlen sollten in der Reihenfolge der Array-Klasse liegen.

    <declare-styleable name="FontTextView">
    <attr name="font_type" format="enum">
        <enum name="HelveticaNeue" value="0"/>
        <enum name="HelveticaNeueLight" value="1"/>
        <enum name="motschcc" value="2"/>
        <enum name="symbol" value="3"/>
    </attr>
    


  1. Wählen Sie eine Schriftart aus der Liste aus
    enter image description here
2
david

holen Sie sich die Schrift aus dem Asset und stellen Sie sie auf alle Kinder ein

public static void overrideFonts(final Context context, final View v) {
    try {
        if (v instanceof ViewGroup) {
            ViewGroup vg = (ViewGroup) v;
            for (int i = 0; i < vg.getChildCount(); i++) {
                View child = vg.getChildAt(i);
                overrideFonts(context, child);
         }
        } else if (v instanceof TextView ) {
            ((TextView) v).setTypeface(Typeface.createFromAsset(context.getAssets(),"DroidNaskh.ttf"));// "BKOODB.TTF"));
        }
    } catch (Exception e) {
 }
 } 
2
Akbar Rezaee

Vielleicht etwas einfacher:

public class Fonts {
  public static HashSet<String,Typeface> fonts = new HashSet<>();

  public static Typeface get(Context context, String file) {
    if (! fonts.contains(file)) {
      synchronized (this) {
        Typeface typeface = Typeface.createFromAsset(context.getAssets(), name);
        fonts.put(name, typeface);
      }
    }
    return fonts.get(file);
  }
}

// Usage
Typeface myFont = Fonts.get("arial.ttf");

(Beachten Sie, dass dieser Code nicht getestet wurde, aber im Allgemeinen sollte dieser Ansatz gut funktionieren.)

0
trans

Android verwendet die Roboto-Schrift, eine wirklich gut aussehende Schrift, mit mehreren unterschiedlichen Strichstärken (normal, leicht, dünn, komprimiert), die auf Bildschirmen mit hoher Dichte gut aussehen.

Überprüfen Sie den folgenden Link, um die Roboto-Schriftarten zu überprüfen:

Verwendung von Roboto im XML-Layout

Zurück zu Ihrer Frage, wenn Sie die Schriftart für alle TextView/Button in Ihrer App ändern möchten , versuchen Sie, den folgenden Code in Ihre styles.xml einzufügen Verwendung von Roboto-Light Schrift:

<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- Customize your theme here. -->
    ......
    <item name="Android:buttonStyle">@style/MyButton</item>
    <item name="Android:textViewStyle">@style/MyTextView</item>
</style>

<style name="MyButton" parent="@style/Widget.AppCompat.Button">
    <item name="Android:textAllCaps">false</item>
    <item name="Android:fontFamily">sans-serif-light</item>
</style>

<style name="MyTextView" parent="@style/TextAppearance.AppCompat">
    <item name="Android:fontFamily">sans-serif-light</item>
</style>

Und vergessen Sie nicht, "AppTheme" in Ihrer AndroidManifest.xml zu verwenden

<application
    Android:allowBackup="true"
    Android:icon="@mipmap/ic_launcher"
    Android:label="@string/app_name"
    Android:roundIcon="@mipmap/ic_launcher_round"
    Android:supportsRtl="true"
    Android:theme="@style/AppTheme">
    ......
</application>
0
Chandler

Wenn Ihre Schriftart in res/asset/fonts/Helvetica.ttf gespeichert ist, verwenden Sie Folgendes:

Typeface tf = Typeface.createFromAsset(getAssets(),"fonts/Helvetica.ttf"); 
txt.setTypeface(tf);

Wenn Ihre Schriftartdatei in res/font/helvetica.ttf gespeichert ist, verwenden Sie Folgendes:

Typeface tf = ResourcesCompat.getFont(this,R.font.helvetica);
txt.setTypeface(tf);
0
Pankaj Lilan