Wie ändere ich die Schriftart in der Textansicht?

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

Typeface tf = Typeface.createFromAsset(getAssets(),
        "fonts/DroidSansFallback.ttf");
TextView tv = (TextView) findViewById(R.id.CustomFontText);
tv.setTypeface(tf);

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.

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.

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.

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äß.

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

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

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.

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

2. zur Schrift der Assets-Bibliothek hinzufügen
   

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

4. Wählen Sie eine Schriftart aus der Liste aus
   

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

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

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>

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