TextView üzerinde yazı tipi nasıl değiştirilir?

A'daki yazı tipini nasıl değiştirebilirim, TextViewvarsayılan olarak Arial olarak gösterilir? Nasıl değiştirilir Helvetica?

İlk olarak, varsayılan Arial değildir. Varsayılan Droid Sans'tir.

İkincisi, farklı bir yerleşik yazı tipine geçmek için, android:typefaceXML düzeninde veya setTypeface()Java'da kullanın.

Üçüncü olarak, Android'de Helvetica yazı tipi yok. Yerleşik seçenekler Droid Sans ( sans), Droid Sans Mono ( monospace) ve Droid Serif ( serif) 'dir. Kendi yazı tiplerinizi uygulamanızla bir araya getirip bunları kullanarak kullanabilirsiniz setTypeface(), ancak yazı tipi dosyalarının büyük olduğunu ve bazı durumlarda lisans sözleşmeleri gerektirdiğini unutmayın (örn. Helvetica, bir Linotype yazı tipi ).

DÜZENLE

Android tasarım dili ölçek, alan, ritim ve altta yatan bir ızgaraya hizalama gibi geleneksel tipografik araçlara dayanır. Bu araçların başarılı bir şekilde dağıtılması, kullanıcıların bir bilgi ekranını hızlı bir şekilde anlamalarına yardımcı olmak için gereklidir. Tipografinin bu şekilde kullanımını desteklemek için Ice Cream Sandwich, özellikle UI ve yüksek çözünürlüklü ekranların gereksinimleri için oluşturulan Roboto adında yeni bir tip aile tanıttı.

Mevcut TextView çerçevesi, Roboto'yu her ağırlık için italik bir stille birlikte ince, hafif, düzenli ve kalın ağırlıklarda sunar. Çerçeve, her ağırlık için italik bir stilin yanı sıra düzenli ve cesur ağırlıklarda Roboto Yoğunlaştırılmış varyantını da sunmaktadır.

ICS sonra, android Roboto yazı tipi stili içerir, Devamını oku Roboto

DÜZENLEME 2

Destek Kitaplığı 26'nın ortaya çıkmasıyla, Android artık varsayılan olarak özel yazı tiplerini destekliyor. XML / programlara ayrı ayrı XML veya programlı olarak ayarlanabilen res / fontlara yeni fontlar ekleyebilirsiniz . Tüm uygulamanın varsayılan yazı tipi stiller tanımlanarak da değiştirilebilir. Xml Android geliştirici belgelerinde bu konuda açık bir kılavuz var

Önce .ttfihtiyacınız olan yazı tipinin dosyasını indirin ( arial.ttf). Yerleştirin assets klasörde. (İç varlıklar klasörü, fontlar adlı yeni bir klasör oluşturur ve içine yerleştirir.) Yazı tipini bilgisayarınıza uygulamak için aşağıdaki kodu kullanın TextView:

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

Tüm yazı tiplerini içerecek statik sınıf oluşturmak isteyebilirsiniz . Bu şekilde, yazı tipini birden fazla kez oluşturmazsınız, bu da performansı olumsuz etkileyebilir . Varlıklar altında " yazı tipleri " adlı bir alt klasör oluşturduğunuzdan emin olun. " klasörü .

Gibi bir şey yapın:

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;

}
}

Bu şekilde, yazı tipini uygulamanızın her yerinden alabilirsiniz.

Şimdiye kadarki en iyi uygulama

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: ( res / değerlerin nereye yerleştirileceği )

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

Nasıl kullanılır:

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

Umarım bu size yardımcı olacaktır.

Yukarıdaki cevaplar doğrudur. Bu kod parçasını kullanıyorsanız, "varlıklar" klasörü altında "yazı tipleri" adlı bir alt klasör oluşturduğunuzdan emin olun.

Yazı tipi oluşturmayı birleştirmenin başka bir yolu ...

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

Ve sonra faaliyetinizde kullanmak için ...

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

Dikkat edin, uçucu alana sahip bu çift kontrollu kilitleme deyimi sadece Java 1.5+ 'de kullanılan bellek modeliyle doğru çalışır.

En iyi uygulama, Android Destek Kitaplığı'nın 26.0.0 veya daha yeni bir sürümünü kullanmaktır.

ADIM 1: yazı tipi dosyası ekle

1. Gelen res yeni oluştur klasör yazı tipi kaynak sözlüğü
2. Yazı tipi dosyası ekle ( .ttf , .orf )

Örneğin, yazı tipi dosyası helfonica_neue.ttf olduğunda R.font.helvetica_neue oluşturur

ADIM 2: Yazı tipi ailesi oluşturma

1. Gelen yazı klasöre yeni bir kaynak dosyası eklemek
2. Öğeye her bir yazı tipi dosyasını, stilini ve ağırlık özelliğini ekleyin.

Örneğin:

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

3.ADIM: kullanın

XML düzenlerinde:

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

Veya stile yazı tipleri ekleyin:

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

Daha fazla örnek için belgeleri takip edebilirsiniz:

Yazı tipleriyle çalışma

Biraz eski, ama CustomFontLoader sınıfını biraz geliştirdim ve bunu paylaşmak istedim, böylece yardımcı olabilir. Bu kodla yeni bir sınıf oluşturmanız yeterlidir.

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

Sonra sadece metin görünümünde bu kodu kullanın:

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

Sonunda buna çok kolay bir çözüm buldum.

1. bu Destek kitaplıklarını uygulama düzeyinde derecelendirmede kullanın ,

   compile 'com.android.support:appcompat-v7:26.0.2'
   compile 'com.android.support:support-v4:26.0.2'

2. sonra res klasörü içinde "font" adlı bir dizin oluşturun

3. yazı tipi (ttf) dosyalarını bu yazı tipi dizinine koyun, adlandırma kurallarını unutmayın [egname herhangi bir özel karakter, herhangi bir büyük harf ve herhangi bir boşluk veya sekme içermemelidir]

4. Bundan sonra, bu yazı tipine xml'den böyle bir referans verin

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

Bu örnekte times_new_roman_test , o font dizininden bir font ttf dosyasıdır

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

}

Bu şekilde, TextView'den devralan ve yapıcısında setTypeface öğesini çağıran bir Görünüm oluşturabilirsiniz.

Yazı tipiniz içeride depolandığında res/asset/fonts/Helvetica.ttfaşağıdakileri kullanın:

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

Veya yazı tipi dosyanız içeride res/font/helvetica.ttfdepolanıyorsa aşağıdakileri kullanın:

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

öğeden yazı tipi al ve tüm çocuklara ayarla

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

1. sınıf FontTextView.java ekle:

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. varlık kitaplığına yazı tipi ekle
   

3. attrs.xml dosyasına ekle, Sayılar dizi sınıfında olmalıdır.

   <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. Listeden bir yazı tipi seçin
   

Android, yüksek yoğunluklu ekranlarda harika görünen birkaç farklı ağırlığa (normal, hafif, ince, yoğun) sahip gerçekten güzel görünen bir yazı tipi olan Roboto yazı tipini kullanıyor.

Roboto yazı tiplerini kontrol etmek için aşağıdaki bağlantıyı kontrol edin:

Roboto xml düzeninde nasıl kullanılır

Sorunuza geri dönerseniz , uygulamanızdaki tüm TextView / Button yazı tipini değiştirmek istiyorsanız, Roboto-light yazı tipini kullanmak için styles.xml dosyasına aşağıdaki kodu eklemeyi deneyin :

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

AndroidManifest.xml dosyasında 'AppTheme' kullanmayı unutmayın

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

Belki biraz daha basit bir şey:

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

(Bu kodun test edilmediğini unutmayın, ancak genel olarak bu yaklaşımın iyi çalışması gerekir.)