[Android] TextView पर फ़ॉन्ट कैसे बदलें?


Answers

सबसे पहले आपको आवश्यक फ़ॉन्ट की arial.ttf फ़ाइल डाउनलोड करें ( arial.ttf )। इसे assets फ़ोल्डर में रखें। (संपत्ति फ़ोल्डर के अंदर फोंट नामक नया फ़ोल्डर बनाते हैं और इसे अंदर रखें।) अपने TextView में फ़ॉन्ट लागू करने के लिए निम्न कोड का उपयोग करें:

Typeface type = Typeface.createFromAsset(getAssets(),"fonts/arial.ttf"); 
textView.setTypeface(type);
Question

TextView में फ़ॉन्ट को कैसे बदलें, डिफ़ॉल्ट रूप से इसे एरियल के रूप में दिखाया गया है? इसे Helvetica कैसे बदला जाए?




  1. वर्ग FontTextView.java जोड़ें:


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. संपत्ति पुस्तकालय फ़ॉन्ट में जोड़ें


  1. attrs.xml में जोड़ें, संख्या सरणी वर्ग में क्रम में होना चाहिए।

    <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. सूची से एक फ़ॉन्ट का चयन करें



उपरोक्त उत्तरों सही हैं। अगर आप कोड के उस टुकड़े का उपयोग कर रहे हैं तो बस सुनिश्चित करें कि आप "संपत्ति" फ़ोल्डर के नीचे "फोंट" नामक उप-फ़ोल्डर बनाते हैं।




आप स्थैतिक वर्ग बनाना चाहते हैं जिसमें सभी फोंट होंगे। इस तरह, आप फ़ॉन्ट को कई बार नहीं बनाएंगे जो प्रदर्शन पर बुरी तरह प्रभावित हो सकता है। बस सुनिश्चित करें कि आप " संपत्ति " फ़ोल्डर के अंतर्गत " फोंट " नामक उप-फ़ोल्डर बनाते हैं।

कुछ ऐसा करें:

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;

}
}

इस तरह, आप अपने आवेदन में हर जगह से फ़ॉन्ट प्राप्त कर सकते हैं।




शायद थोड़ा सा सरल:

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

(ध्यान दें कि यह कोड अवांछित है, लेकिन सामान्य रूप से इस दृष्टिकोण को अच्छी तरह से काम करना चाहिए।)




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

}

इस तरह, आप एक व्यू बना सकते हैं जो टेक्स्ट व्यू से विरासत में मिलता है और इसके कन्स्ट्रक्टर पर सेट टाइप टाइप करता है।




सर्वश्रेष्ठ अभ्यास एंड्रॉइड सपोर्ट लाइब्रेरी संस्करण 26.0.0 या उससे ऊपर का उपयोग करना है।

चरण 1: फ़ॉन्ट फ़ाइल जोड़ें

  1. Res फ़ोल्डर में नया फ़ॉन्ट संसाधन शब्दकोश बनाएं
  2. फ़ॉन्ट फ़ाइल जोड़ें ( .ttf , .orf )

उदाहरण के लिए, जब फ़ॉन्ट फ़ाइल helvetica_neue.ttf होगी जो R.font.helvetica_neue उत्पन्न करेगी

चरण 2: फ़ॉन्ट परिवार बनाएं

  1. फ़ॉन्ट फ़ोल्डर में नई संसाधन फ़ाइल जोड़ें
  2. तत्व में प्रत्येक फ़ॉन्ट फ़ाइल, शैली, और वजन विशेषता संलग्न करें।

उदाहरण के लिए:

<?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: इसका इस्तेमाल करें

एक्सएमएल लेआउट में:

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

या शैली में फोंट जोड़ें:

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

अधिक उदाहरणों के लिए आप दस्तावेज़ीकरण का पालन कर सकते हैं:

फ़ॉन्ट्स के साथ काम करना




Links