क्या पूरे एप्लिकेशन के लिए कस्टम फ़ॉन्ट सेट करना संभव है?


270

मुझे अपने संपूर्ण एप्लिकेशन के लिए कुछ फ़ॉन्ट का उपयोग करने की आवश्यकता है। मेरे पास .ttf फ़ाइल उसी के लिए है। क्या यह संभव है कि इसे डिफ़ॉल्ट फॉन्ट के रूप में सेट किया जा सकता है, आवेदन शुरू होने के बाद और फिर आवेदन में कहीं और इसका उपयोग करें? जब सेट किया जाता है, तो मैं इसे अपने लेआउट एक्सएमएल में कैसे उपयोग करूं?


एंड्रॉयड स्टूडियो 3.0 में आप आसानी से कस्टम फोंट सेट कर सकते हैं: developer.android.com/guide/topics/ui/look-and-feel/…
MHSFisher

XML में @MHSFisher फ़ॉन्ट्स एंड्रॉइड 8.0 (एपीआई स्तर 26) के लिए एक सुविधा है
Emi Raz

1
@EmiRaz कृपया doc developer.android.com/guide/topics/ui/look-and-feel/… पढ़ें । इस सुविधा को समर्थन पुस्तकालय 26 में जोड़ा गया है, लेकिन एपीआई 16 से समर्थन।
MHSFisher

जवाबों:


449

हां प्रतिबिंब के साथ। यह काम करता है ( इस उत्तर पर आधारित ):

(नोट: कस्टम फोंट के लिए समर्थन की कमी के कारण यह वर्कअराउंड है, इसलिए यदि आप इस स्थिति को बदलना चाहते हैं, तो कृपया यहां एंड्रॉइड इश्यू को अप-वोट करने के लिए स्टार करें )। नोट: उस मुद्दे पर "मुझे भी" टिप्पणी न छोड़ें, हर कोई जिसने इसे देखा है, वह ईमेल करता है जब आप ऐसा करते हैं। तो बस "स्टार" यह कृपया।

import java.lang.reflect.Field;
import android.content.Context;
import android.graphics.Typeface;

public final class FontsOverride {

    public static void setDefaultFont(Context context,
            String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(),
                fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    }

    protected static void replaceFont(String staticTypefaceFieldName,
            final Typeface newTypeface) {
        try {
            final Field staticField = Typeface.class
                    .getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

फिर आपको कुछ डिफ़ॉल्ट फॉन्ट को ओवरलोड करने की आवश्यकता होती है, उदाहरण के लिए एप्लिकेशन क्लास में:

public final class Application extends android.app.Application {
    @Override
    public void onCreate() {
        super.onCreate();
        FontsOverride.setDefaultFont(this, "DEFAULT", "MyFontAsset.ttf");
        FontsOverride.setDefaultFont(this, "MONOSPACE", "MyFontAsset2.ttf");
        FontsOverride.setDefaultFont(this, "SERIF", "MyFontAsset3.ttf");
        FontsOverride.setDefaultFont(this, "SANS_SERIF", "MyFontAsset4.ttf");
    }
}

या बेशक यदि आप एक ही फॉन्ट फाइल का उपयोग कर रहे हैं, तो आप इसे केवल एक बार लोड करने के लिए इसमें सुधार कर सकते हैं।

हालाँकि, मैं केवल एक को ओवरराइड करता हूं "MONOSPACE", फिर भी, टाइप करने के लिए एक स्टाइल सेट करें जो कि फॉन्ट टाइपफेस एप्लीकेशन को चौड़ा करे:

<resources>
    <style name="AppBaseTheme" parent="android:Theme.Light">
    </style>

    <!-- Application theme. -->
    <style name="AppTheme" parent="AppBaseTheme">
        <item name="android:typeface">monospace</item>
    </style>
</resources>

एपीआई 21 एंड्रॉयड 5.0

मैंने टिप्पणियों में उन रिपोर्टों की जांच की है जो काम नहीं करती हैं और यह विषय के साथ असंगत प्रतीत होता है android:Theme.Material.Light

यदि वह विषय आपके लिए महत्वपूर्ण नहीं है, तो पुराने विषय का उपयोग करें, जैसे:

<style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
    <item name="android:typeface">monospace</item>
</style>

11
आप मोनोपेस को बोल्ड या इटैलिक से कैसे पार करेंगे?
क्रिस्टोफर रिवेरा

2
@ChristopherRivera वहाँ है, "DEFAULT_BOLD"लेकिन यह भी एक निजी क्षेत्र है: private static Typeface[] sDefaults;आप प्रतिबिंब और सेटिंग द्वारा इसे एक्सेस करने का प्रयास कर सकते हैं sDefaults[Typeface.ITALIC]। इसे देखें
पश्चिम

5
@ वेस्टन नॉट माइंड। मैंने इसे हासिल किया है। मेरी समझ में गलती थी। तुमने बेहतरीन काम किया है। क्या आप मुझे सिर्फ एक बात बता सकते हैं? यह DEFAULT टाइपफेस के लिए काम क्यों नहीं कर रहा है? मैंने आपके सुझाव के रूप में टाइपफेस को MONOSPACE में बदल दिया है और फिर लॉगइन लागू किया है, यह काम किया है। लेकिन DEFAULT के लिए काम नहीं कर रहा है
जे पंड्या 3

2
देशी टाइपफेस में त्रुटि नहीं की जा सकती। फिक्स्ड, फोंट पथ जोड़कर। "FontsOverride.setDefaultFont (यह," DEFAULT "," फोंट / MyFontAsset.ttf ");"
साईं

3
मुझे लगता है कि TextViewकस्टम फोंट का उपयोग करने या इस तरह के प्रतिबिंब आधारित समाधान का उपयोग करने के लिए हर जगह डिफ़ॉल्ट रूप से स्वैप करना वास्तव में कष्टप्रद है । एंड्रॉइड में उपलब्ध फोंट के सीमित सेट के साथ संयुक्त, यह अच्छे दिखने वाले एप्लिकेशन को बहुत अधिक मेहनत से विकसित करता है। मैंने एंड्रॉइड इश्यू ट्रैकर के लिए एक सुविधा अनुरोध जोड़ा है। यदि आप इस सुविधा को देखना चाहते हैं, तो आप इस मुद्दे को यहाँ देख सकते हैं: code.google.com/p/android/issues/…
सैम

64

Android में कस्टम फोंट के लिए एक महान पुस्तकालय है: सुलेख

यहाँ एक नमूना है कि इसका उपयोग कैसे करना है।

ग्रेड में आपको इस लाइन को अपने ऐप की बिल्ड.ग्रेड फ़ाइल में डालना होगा:

dependencies {
    compile 'uk.co.chrisjenx:calligraphy:2.2.0'
}

और फिर एक वर्ग बनाएं जो Applicationइस कोड को बढ़ाता है और लिखता है:

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        CalligraphyConfig.initDefault(new CalligraphyConfig.Builder()
                        .setDefaultFontPath("your font path")
                        .setFontAttrId(R.attr.fontPath)
                        .build()
        );
    }
} 

और एक्टिविटी क्लास में ऑनक्रिट से पहले इस विधि को रखें:

@Override
protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase));
}

और आखिरी बात यह है कि आपकी मैनिफ़ेस्ट फ़ाइल इस तरह दिखनी चाहिए:

<application
   .
   .
   .
   android:name=".App">

और यह पूरी गतिविधि को आपके फ़ॉन्ट में बदल देगा! यह सरल और साफ है!


1
यह अचूक उपाय है।
nizam.sp

1
सच है, इसका बहुत सही समाधान, इस तरह से मुझे मेनू आइटम, रेडियो बटन या चेकबॉक्स फोटॉन के लिए फोंट को अपडेट करने के लिए विभिन्न वर्गों को लिखना नहीं है। यह सभी के लिए लागू होता है !! धन्यवाद :)
मनीषा

2
निश्चित रूप से एक सही समाधान नहीं: बोल्ड / इटैलिक / बोल्ड-इटैलिक शैलियों को ओवरराइट किया गया है। वर्तमान में उन परिवारों को सेट करने का कोई आसान तरीका नहीं है।
0101100101

2
अगर मैं ऐसा करूं तो मैं बोल्ड से रेगुलर कैसे स्विच कर सकता हूं?
जीएमएक्स

2
, बोल्ड इटैलिक या रेखांकन सुविधा करने के लिए, मैं का उपयोग किया है <b></b>, <u></u>और <i></i>में strings.xmlफ़ाइल और अब तक यह काम करता है।
jlively

47

हालांकि यह एक संपूर्ण अनुप्रयोग के लिए काम नहीं करेगा, यह एक गतिविधि के लिए काम करेगा और किसी अन्य गतिविधि के लिए फिर से उपयोग किया जा सकता है। मैंने अन्य दृश्यों का समर्थन करने के लिए @ FR073N के लिए अपना कोड अपडेट किया है। मैं के साथ मुद्दों के बारे में यकीन नहीं है Buttons, RadioGroupsक्योंकि उन वर्गों सभी का विस्तार, आदि TextViewतो वे ठीक काम करना चाहिए। मैंने प्रतिबिंब का उपयोग करने के लिए एक बूलियन सशर्त जोड़ा क्योंकि यह बहुत हैकिश लगता है और संभवतः विशेष रूप से प्रदर्शन से समझौता कर सकता है।

नोट: जैसा कि बताया गया है, यह गतिशील सामग्री के लिए काम नहीं करेगा! उसके लिए, इस विधि को एक विधि onCreateViewया getViewविधि के साथ कॉल करना संभव है , लेकिन इसके लिए अतिरिक्त प्रयास की आवश्यकता होती है।

/**
 * Recursively sets a {@link Typeface} to all
 * {@link TextView}s in a {@link ViewGroup}.
 */
public static final void setAppFont(ViewGroup mContainer, Typeface mFont, boolean reflect)
{
    if (mContainer == null || mFont == null) return;

    final int mCount = mContainer.getChildCount();

    // Loop through all of the children.
    for (int i = 0; i < mCount; ++i)
    {
        final View mChild = mContainer.getChildAt(i);
        if (mChild instanceof TextView)
        {
            // Set the font if it is a TextView.
            ((TextView) mChild).setTypeface(mFont);
        }
        else if (mChild instanceof ViewGroup)
        {
            // Recursively attempt another ViewGroup.
            setAppFont((ViewGroup) mChild, mFont);
        }
        else if (reflect)
        {
            try {
                Method mSetTypeface = mChild.getClass().getMethod("setTypeface", Typeface.class);
                mSetTypeface.invoke(mChild, mFont); 
            } catch (Exception e) { /* Do something... */ }
        }
    }
}

फिर इसका उपयोग करने के लिए आप कुछ इस तरह करेंगे:

final Typeface mFont = Typeface.createFromAsset(getAssets(),
"fonts/MyFont.ttf"); 
final ViewGroup mContainer = (ViewGroup) findViewById(
android.R.id.content).getRootView();
HomeActivity.setAppFont(mContainer, mFont);

उम्मीद है की वो मदद करदे।


4
मुझे लगता है कि टेक्स्टव्यू को ओवरराइड करने का सबसे अच्छा तरीका होगा। यदि आपके पास बहुत सारे विचारों वाला एप्लिकेशन है, तो यह विधि कुछ हद तक बेमानी हो सकती है।
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

1
यह हो सकता है ... लेकिन एंड्रॉइड स्पेक्स के अनुसार आप 4 स्तरों और 100 दृश्यों से अधिक चौड़े लेआउट से बचना चाहते हैं (यहां तक ​​कि यह थोड़ा सा है)। प्रदर्शन के मामले में पुनरावृत्ति खराब हो सकती है, लेकिन भले ही आपका लेआउट 20 स्तर का था जो कि महत्वपूर्ण नहीं है।
टॉम

मैं इस बात से सहमत हूं कि इसका इत्र पर ध्यान देने योग्य प्रभाव नहीं है और मैं यह कहने की कोशिश नहीं कर रहा हूं कि आपका उत्तर गलत है। अगर मुझे ज़रूरत नहीं है तो मैं लेआउट में हर दृश्य के माध्यम से साइकिल चलाना पसंद नहीं करता। इसके अलावा, TextView का विस्तार करके, यदि आप किसी अन्य तरीके से उपस्थिति को संशोधित करना चाहते हैं, तो आपको केवल एक स्थान पर कोड बदलना होगा।
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

1
बस यह जोड़ना चाहता था कि उपरोक्त कोड में सिर्फ TextViews शामिल हैं, लेकिन ListViews, अलर्ट, टोस्ट, मैप मार्कर आदि अभी भी सिस्टम फ़ॉन्ट का उपयोग करेंगे।
सीएससी

2
दोस्तों यह फंक्शन 3 पैरामीटर्स लेता है, जब आप इसे रीसर्च करते हैं तो आपने 2 पैरामीटर्स पास किए हैं ??? कौन सा सही है? परिलक्षित क्या है ??
एमबीएच

34

संक्षेप में:

विकल्प # 1: फ़ॉन्ट लागू करने के लिए प्रतिबिंब का उपयोग करें ( वेस्टन और रोजर हुआंग के उत्तर को मिलाकर ):

import java.lang.reflect.Field;
import android.content.Context;
import android.graphics.Typeface;

public final class FontsOverride { 

    public static void setDefaultFont(Context context,
            String staticTypefaceFieldName, String fontAssetName) {
        final Typeface regular = Typeface.createFromAsset(context.getAssets(),
                fontAssetName);
        replaceFont(staticTypefaceFieldName, regular);
    } 

    protected static void replaceFont(String staticTypefaceFieldName,final Typeface newTypeface) {
        if (isVersionGreaterOrEqualToLollipop()) {
            Map<String, Typeface> newMap = new HashMap<String, Typeface>();
            newMap.put("sans-serif", newTypeface);
            try {
                final Field staticField = Typeface.class.getDeclaredField("sSystemFontMap");
                staticField.setAccessible(true);
                staticField.set(null, newMap);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } else {
            try {
                final Field staticField = Typeface.class.getDeclaredField(staticTypefaceFieldName);
                staticField.setAccessible(true);
                staticField.set(null, newTypeface);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } 
        }
    }

} 

अनुप्रयोग वर्ग में उपयोग:

public final class Application extends android.app.Application {
    @Override 
    public void onCreate() { 
        super.onCreate(); 
        FontsOverride.setDefaultFont(this, "DEFAULT", "MyFontAsset.ttf");
        FontsOverride.setDefaultFont(this, "MONOSPACE", "MyFontAsset2.ttf");
        FontsOverride.setDefaultFont(this, "SERIF", "MyFontAsset3.ttf");
        FontsOverride.setDefaultFont(this, "SANS_SERIF", "MyFontAsset4.ttf");
    } 
} 

फ़ॉन्ट टाइपफेस अनुप्रयोग को विस्तृत करने के लिए एक शैली सेट करें ( लवफिश पर आधारित ):

पूर्व लॉलीपॉप:

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

लॉलीपॉप (एपीआई 21):

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:textAppearance">@style/CustomTextAppearance</item>
   </style>

   <style name="CustomTextAppearance">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

Option2: प्रत्येक और हर दृश्य को उप- वर्गित करें जहाँ आपको फ़ॉन्ट अनुकूलित करने की आवश्यकता है, अर्थात। सूची दृश्य, EditTextView, बटन, आदि ( पलानी का जवाब):

public class CustomFontView extends TextView {

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

public CustomFontView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init(); 
} 

public CustomFontView(Context context) {
    super(context);
    init(); 
} 

private void init() { 
    if (!isInEditMode()) {
        Typeface tf = Typeface.createFromAsset(getContext().getAssets(), "Futura.ttf");
        setTypeface(tf);
    } 
} 

विकल्प 3: एक दृश्य क्रॉलर को लागू करें जो आपकी वर्तमान स्क्रीन के पदानुक्रम को देखता है:

विविधता # 1 ( टॉम का जवाब):

public static final void setAppFont(ViewGroup mContainer, Typeface mFont, boolean reflect)
{ 
    if (mContainer == null || mFont == null) return;

    final int mCount = mContainer.getChildCount();

    // Loop through all of the children. 
    for (int i = 0; i < mCount; ++i)
    { 
        final View mChild = mContainer.getChildAt(i);
        if (mChild instanceof TextView)
        { 
            // Set the font if it is a TextView. 
            ((TextView) mChild).setTypeface(mFont);
        } 
        else if (mChild instanceof ViewGroup)
        { 
            // Recursively attempt another ViewGroup. 
            setAppFont((ViewGroup) mChild, mFont);
        } 
        else if (reflect)
        { 
            try { 
                Method mSetTypeface = mChild.getClass().getMethod("setTypeface", Typeface.class);
                mSetTypeface.invoke(mChild, mFont); 
            } catch (Exception e) { /* Do something... */ }
        } 
    } 
} 

उपयोग:

final ViewGroup mContainer = (ViewGroup) findViewById(
android.R.id.content).getRootView();
HomeActivity.setAppFont(mContainer, Typeface.createFromAsset(getAssets(),
"fonts/MyFont.ttf"));

रूपांतर # 2: https://coderwall.com/p/qxxmaa/android-use-a-custom-font-everywhere

विकल्प # 4: 3 पार्टी लिब का उपयोग करें जिसे सुलेख कहा जाता है ।

व्यक्तिगत रूप से, मैं विकल्प # 4 की सिफारिश करूंगा, क्योंकि यह बहुत सारे सिरदर्द बचाता है।


में विकल्प # 1 , तुम्हारा क्या मतलब है द्वारा "sans-serif"में newMap.put(, और monospaceमें styles?! मैं नाम के एक कस्टम फ़ॉन्ट का उपयोग करना चाहता हूं barana.ttf
डॉ। अंजी

विकल्प 1 में, पहला कोड स्निपेट एपीआई स्तर 22, एंड्रॉइड 5.1.1 के साथ काम नहीं करता है। लेकिन दूसरा कोड सेक्शन करता है। अगर हालत ठीक है तो क्या होना चाहिए?
user1510006

28

मैं एपीआई 21 एंड्रॉयड 5.0 के लिए वेस्टन के जवाब में सुधार करना चाहूंगा ।

कारण

एपीआई 21 के तहत, अधिकांश पाठ शैलियों में फ़ॉन्टफ़िली सेटिंग शामिल है, जैसे:

<style name="TextAppearance.Material">
     <item name="fontFamily">@string/font_family_body_1_material</item>
</style>

जो डिफ़ॉल्ट रोबोटो नियमित फ़ॉन्ट लागू करता है:

<string name="font_family_body_1_material">sans-serif</string>

मूल उत्तर मोनोस्पेस फ़ॉन्ट को लागू करने में विफल रहता है, क्योंकि android: fontFamily में Android के लिए अधिक प्राथमिकता है: टाइपफेस विशेषता ( संदर्भ )। Theme.Holo का उपयोग करना। * एक मान्य वर्कअराउंड है, क्योंकि कोई एंड्रॉइड नहीं है: fontFamily सेटिंग्स अंदर।

उपाय

चूंकि एंड्रॉइड 5.0 ने सिस्टम वेरिएबल को स्थिर वैरिएबल Typeface.sSystemFontMap ( संदर्भ ) में रखा है, हम इसे बदलने के लिए समान प्रतिबिंब तकनीक का उपयोग कर सकते हैं:

protected static void replaceFont(String staticTypefaceFieldName,
        final Typeface newTypeface) {
    if (isVersionGreaterOrEqualToLollipop()) {
        Map<String, Typeface> newMap = new HashMap<String, Typeface>();
        newMap.put("sans-serif", newTypeface);
        try {
            final Field staticField = Typeface.class
                    .getDeclaredField("sSystemFontMap");
            staticField.setAccessible(true);
            staticField.set(null, newMap);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    } else {
        try {
            final Field staticField = Typeface.class
                    .getDeclaredField(staticTypefaceFieldName);
            staticField.setAccessible(true);
            staticField.set(null, newTypeface);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

4
एल के लिए अच्छा वर्कअराउंड हालांकि, मैं सोच रहा हूं कि यह मेरे Buttonएस और टूल बार खिताब के लिए काम क्यों नहीं करता है । इस प्रकार मैं MainApplication में डिफ़ॉल्ट फ़ॉन्ट अधिभावी कर रहा हूँ: FontsOverride.setDefaultFont(this, "DEFAULT", "MyFontAsset.ttf");। मैं Nexus 5, v5.1.1
kip2

3
अरे, थैंक यू यह बहुत मददगार था, बस एक चीज: यह एंड्रॉइड 6 (एपीआई 22) पर काम नहीं करता है। फिर इस कोड को बदल दिया जाना चाहिए: Build.VERSION.SDK_INT == 21- यह सिर्फ API 21 नेक्सस में एपीआई 22 के साथ टेस्ट में है
Saeid

अभी भी मैं नेक्सस 9 में इस पद्धति का उपयोग करके कस्टम फ़ॉन्ट सेट करने में सक्षम नहीं हूं
राहुल उपाध्याय

2
कोई भी समस्या जो 5.1+ के लिए काम नहीं कर रही है। अपने मूल्यों- v21 शैलियों में टाइपफेस को ओवरराइड न करें।
मुहम्मद बाबर

@MuhammadBabar धन्यवाद आपके समाधान ने मेरा दिन बना दिया
एम। योगेश्वरन

15

इसका बहुत ही सरल ... 1. डाउनलोड करें और उर कस्टम फ़ॉन्ट को संपत्ति में रखें..इसके बाद टेक्स्ट व्यू के लिए एक अलग वर्ग लिखें: यहाँ मैं निरर्थक फ़ॉन्ट

public class CusFntTextView extends TextView {

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

public CusFntTextView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
}

public CusFntTextView(Context context) {
    super(context);
    init();
}

private void init() {
    if (!isInEditMode()) {
        Typeface tf = Typeface.createFromAsset(getContext().getAssets(), "Futura.ttf");
        setTypeface(tf);
    }
}

}

और xml में निम्न कार्य करें:

 <com.packagename.CusFntTextView
        android:id="@+id/tvtitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"         
        android:text="Hi Android"           
        android:textAppearance="?android:attr/textAppearanceLarge"
      />

हां, वह काम करता है :) लेकिन, क्या होगा अगर मैं अन्य शेष विचारों / विजेट के लिए एक ही फोंट लागू करना चाहता हूं? क्या मुझे अन्य सभी दृश्यों (संवाद / टोस्ट / एक्शनबार सहित) के लिए अलग से क्लास लिखने की ज़रूरत है?
नरेंद्र सिंह

हां, इस समाधान के लिए आपको अपने प्रत्येक दृश्य के लिए अलग-अलग कक्षाएं लिखने की आवश्यकता है।
साद बिलाल

9

मैं TextView और अन्य नियंत्रणों को विस्तारित करने का भी सुझाव दूंगा, लेकिन यह बेहतर होगा कि मैं निर्माणों में फ़ॉन्ट स्थापित करने पर विचार करूं।

public FontTextView(Context context) {
    super(context);
    init();
}

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

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

protected void init() {
    setTypeface(Typeface.createFromAsset(getContext().getAssets(), AppConst.FONT));
}

2
4.0 से पहले प्लेटफार्मों पर ऐसा करते समय सावधान रहें - यह एंड्रॉइड में बग के कारण बहुत सारे संसाधनों को लीक करेगा: code.google.com/p/android/issues/detail?id=9904
रयान एम

हम डिफ़ॉल्ट पर वापस कैसे लौट सकते हैं। मैं कुछ इस तरह से कर रहा हूं: अगर (configSaring.getString ("storeId", AppCredentials.DEFAULT_STORE_ID) .equals ("2")) {अंतिम फ़ील्ड staticField = Typeface .class.getDeclaredField (staticTypefaceFieldName); staticField.setAccessible (सही); staticField.set (null, newTypeface); } और {अंतिम फ़ील्ड staticField = Typeface.class.getDeclaredField (staticTypefaceFieldName); staticField.setAccessible (सही); staticField.set (अशक्त, अशक्त); }
किलर

8

मैं थीम " Theme.AppCompat " के साथ एपीआई 21 एंड्रॉइड लॉलीपॉप पर वेस्टन के और रोजर हुआंग के उत्तरों में सुधार करना चाहूंगा ।

Android 4.4 से नीचे

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

ओवर (बराबर) एपीआई 5.0

<resources>
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
    </style>

   <!-- Application theme. -->
   <style name="AppTheme" parent="AppBaseTheme">
       <item name="android:textAppearance">@style/CustomTextAppearance</item>
   </style>

   <style name="CustomTextAppearance">
       <item name="android:typeface">monospace</item>
   </style>
</resources>

और FontsOverride उपयोग फ़ाइल वेस्टन के उत्तर में क्या है । मैंने इन फोनों में परीक्षण किया है:

Nexus 5 (Android 5.1 प्राथमिक Android सिस्टम)

ZTE V5 (Android 5.1 CM12.1)

XIAOMI नोट (Android 4.4 MIUI6)

हुवावेई C8850 (Android 2.3.5 UNKNOWN)


8

एक शानदार समाधान यहां पाया जा सकता है: https://coderwall.com/p/qxxmaa/android-use-a-custom-font-everywhere

बस BaseActivity से गतिविधियों का विस्तार करें और उन तरीकों को लिखें। : इसके अलावा, आप कैश फोंट को यहां बताए गए बेहतर चाहिए https://stackoverflow.com/a/16902532/2914140


कुछ शोध के बाद मैंने कोड लिखा जो सैमसंग गैलेक्सी टैब ए (एंड्रॉइड 5.0) पर काम करता है। वेस्टन और रोजर हुआंग के साथ ही https://stackoverflow.com/a/33236102/2914140 का उपयोग किया गया कोड । लेनोवो TAB 2 A10-70L पर भी परीक्षण किया गया है, जहां यह काम नहीं करता है। मैंने अंतर देखने के लिए यहां एक फ़ॉन्ट 'कॉमिक सैंस' डाला।

import android.content.Context;
import android.graphics.Typeface;
import android.os.Build;
import android.util.Log;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class FontsOverride {
    private static final int BOLD = 1;
    private static final int BOLD_ITALIC = 2;
    private static final int ITALIC = 3;
    private static final int LIGHT = 4;
    private static final int CONDENSED = 5;
    private static final int THIN = 6;
    private static final int MEDIUM = 7;
    private static final int REGULAR = 8;

    private Context context;

    public FontsOverride(Context context) {
        this.context = context;
    }

    public void loadFonts() {
        Map<String, Typeface> fontsMap = new HashMap<>();
        fontsMap.put("sans-serif", getTypeface("comic.ttf", REGULAR));
        fontsMap.put("sans-serif-bold", getTypeface("comic.ttf", BOLD));
        fontsMap.put("sans-serif-italic", getTypeface("comic.ttf", ITALIC));
        fontsMap.put("sans-serif-light", getTypeface("comic.ttf", LIGHT));
        fontsMap.put("sans-serif-condensed", getTypeface("comic.ttf", CONDENSED));
        fontsMap.put("sans-serif-thin", getTypeface("comic.ttf", THIN));
        fontsMap.put("sans-serif-medium", getTypeface("comic.ttf", MEDIUM));
        overrideFonts(fontsMap);
    }

    private void overrideFonts(Map<String, Typeface> typefaces) {
        if (Build.VERSION.SDK_INT == 21) {
            try {
                final Field field = Typeface.class.getDeclaredField("sSystemFontMap");
                field.setAccessible(true);
                Map<String, Typeface> oldFonts = (Map<String, Typeface>) field.get(null);
                if (oldFonts != null) {
                    oldFonts.putAll(typefaces);
                } else {
                    oldFonts = typefaces;
                }
                field.set(null, oldFonts);
                field.setAccessible(false);
            } catch (Exception e) {
                Log.e("TypefaceUtil", "Cannot set custom fonts");
            }
        } else {
            try {
                for (Map.Entry<String, Typeface> entry : typefaces.entrySet()) {
                    final Field staticField = Typeface.class.getDeclaredField(entry.getKey());
                    staticField.setAccessible(true);
                    staticField.set(null, entry.getValue());
                }
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    private Typeface getTypeface(String fontFileName, int fontType) {
        final Typeface tf = Typeface.createFromAsset(context.getAssets(), "fonts/" + fontFileName);
        return Typeface.create(tf, fontType);
    }
}

संपूर्ण एप्लिकेशन में कोड को चलाने के लिए आपको कुछ क्लास में लिखना चाहिए जैसे कि एप्लिकेशन को निम्नलिखित:

    new FontsOverride(this).loadFonts();

'एसेट्स' के अंदर एक फोल्डर 'फोंट' बनाएं और वहां जरूरी फोंट डालें। एक सरल निर्देश यहां पाया जा सकता है: https://stackoverflow.com/a/31697103/2914140

लेनोवो डिवाइस भी गलत तरीके से एक टाइपफेस का मूल्य प्राप्त करता है। अधिकांश समय में यह Typeface.NORMAL, कभी-कभी अशक्त हो जाता है। भले ही एक TextView बोल्ड हो (xml-file लेआउट में)। यहाँ देखें: TextViewBold हमेशा NORMAL देता है । इस तरह एक स्क्रीन पर एक पाठ हमेशा एक नियमित फ़ॉन्ट में होता है, न कि बोल्ड या इटैलिक। इसलिए मुझे लगता है कि यह एक निर्माता का बग है।


मैंने android source code का अध्ययन किया, आपका उत्तर सबसे अच्छा है। यह पतले, मध्यम, हल्के या कुछ और की जगह ले सकता है। आपको बहुत - बहुत धन्यवाद!
मोहम्मद ओमिदवार

6

Xamarin.Android के लिए काम करना:

वर्ग:

public class FontsOverride
{
    public static void SetDefaultFont(Context context, string staticTypefaceFieldName, string fontAssetName)
    {
        Typeface regular = Typeface.CreateFromAsset(context.Assets, fontAssetName);
        ReplaceFont(staticTypefaceFieldName, regular);
    }

    protected static void ReplaceFont(string staticTypefaceFieldName, Typeface newTypeface)
    {
        try
        {
            Field staticField = ((Java.Lang.Object)(newTypeface)).Class.GetDeclaredField(staticTypefaceFieldName);
            staticField.Accessible = true;
            staticField.Set(null, newTypeface);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

आवेदन कार्यान्वयन:

namespace SomeAndroidApplication
{
    [Application]
    public class App : Application
    {
        public App()
        {

        }

        public App(IntPtr handle, JniHandleOwnership transfer)
            : base(handle, transfer)
        {

        }

        public override void OnCreate()
        {
            base.OnCreate();

            FontsOverride.SetDefaultFont(this, "MONOSPACE", "fonts/Roboto-Light.ttf");
        }
    }
}

अंदाज:

<style name="Theme.Storehouse" parent="Theme.Sherlock">
    <item name="android:typeface">monospace</item>
</style>

6

Android O के रूप में अब XML से सीधे परिभाषित करना संभव है और मेरा बग अब बंद हो गया है!

विवरण के लिए यहां देखें

टी एल; डॉ:

सबसे पहले आपको अपने फोंट को प्रोजेक्ट में जोड़ना होगा

दूसरा आप एक फ़ॉन्ट परिवार जोड़ते हैं, जैसे:

<?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/lobster_regular" />
    <font
        android:fontStyle="italic"
        android:fontWeight="400"
        android:font="@font/lobster_italic" />
</font-family>

अंत में, आप किसी लेआउट या शैली में फ़ॉन्ट का उपयोग कर सकते हैं:

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

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

का आनंद लें!


धन्यवाद। फ़ॉन्ट फ़ोल्डर को जोड़ने में सक्षम होने के लिए हमें एंड्रॉइड स्टूडियो 2.4 का उपयोग करना चाहिए।
फोटॉन पॉइंट

वास्तव में मुझे बस इसे अपनी शैली पर लागू करने की आवश्यकता है और इसे एप्लिकेशन के माध्यम से लागू किया जाएगा। लेकिन कुछ (प्रोग्राम रूप से जोड़े गए नियंत्रणों को जावा कोड के माध्यम से लागू करने की आवश्यकता होगी)
सॉलिडस्नेक

4

आप प्रत्येक लेआउट के लिए एक-एक करके कस्टम फोंट सेट कर सकते हैं, इसके लेआउट को पास करके हर लेआउट से सिर्फ एक फ़ंक्शन कॉल के लिए। इस तरह से फ़ॉन्ट ऑब्जेक्ट तक पहुंचने के लिए एक सिंगलटन दृष्टिकोण बनाएं

 public class Font {
    private static Font font;
    public Typeface ROBO_LIGHT;

    private Font() {

    }

    public static Font getInstance(Context context) {
        if (font == null) {
            font = new Font();
            font.init(context);
        }
        return font;

    }

    public void init(Context context) {

        ROBO_LIGHT = Typeface.createFromAsset(context.getAssets(),
                "Roboto-Light.ttf");
    }

}

आप उपरोक्त वर्ग में विभिन्न फ़ॉन्टों को परिभाषित कर सकते हैं, अब एक फ़ॉन्ट सहायक श्रेणी को परिभाषित करें जो फ़ॉन्ट लागू करेगा:

   public class FontHelper {

    private static Font font;

    public static void applyFont(View parentView, Context context) {

        font = Font.getInstance(context);

        apply((ViewGroup)parentView);

    }

    private static void apply(ViewGroup parentView) {
        for (int i = 0; i < parentView.getChildCount(); i++) {

            View view = parentView.getChildAt(i);

//You can add any view element here on which you want to apply font 

            if (view instanceof EditText) {

                ((EditText) view).setTypeface(font.ROBO_LIGHT);

            }
            if (view instanceof TextView) {

                ((TextView) view).setTypeface(font.ROBO_LIGHT);

            }

            else if (view instanceof ViewGroup
                    && ((ViewGroup) view).getChildCount() > 0) {
                apply((ViewGroup) view);
            }

        }

    }

}

उपरोक्त कोड में, मैं केवल textView और EditText पर फोंट लागू कर रहा हूं, आप अन्य व्यू एलिमेंट्स पर भी इसी तरह फोंट लगा सकते हैं। आपको बस उपर्युक्त फॉन्ट मेथड में अपने रूट व्यू ग्रुप की आईडी पास करनी होगी। उदाहरण के लिए आपका लेआउट है:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:id="@+id/mainParent"
    tools:context="${relativePackage}.${activityClass}" >

    <RelativeLayout
        android:id="@+id/mainContainer"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_above="@+id/homeFooter"
        android:layout_below="@+id/edit" >

        <ImageView
            android:id="@+id/PreviewImg"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:src="@drawable/abc_list_longpressed_holo"
            android:visibility="gone" />

        <RelativeLayout
            android:id="@+id/visibilityLayer"
            android:layout_width="match_parent"
            android:layout_height="fill_parent" >

            <ImageView
                android:id="@+id/UseCamera"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentTop="true"
                android:layout_centerHorizontal="true"
                android:src="@drawable/camera" />

            <TextView
                android:id="@+id/tvOR"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_below="@+id/UseCamera"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="20dp"
                android:text="OR"
                android:textSize="30dp" />

            <TextView
                android:id="@+id/tvAND"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="20dp"
                android:text="OR"
                android:textSize="30dp" />

</RelativeLayout>

उपरोक्त लेआउट में मूल अभिभावक आईडी "मुख्य अभिभावक" है जो अब फ़ॉन्ट लागू करने देता है

public class MainActivity extends BaseFragmentActivity {

    private EditText etName;
    private EditText etPassword;
    private TextView tvTitle;
    public static boolean isHome = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

       Font font=Font.getInstance(getApplicationContext());
        FontHelper.applyFont(findViewById(R.id.mainParent),          getApplicationContext());
   }    
}

चियर्स :)


अच्छा .. कोई और समान फ़ॉन्ट फिर से न बनाएं, सभी फ़ील्ड के लिए केवल 1 फ़ॉन्ट का उपयोग करें। :)
अरफान मिर्ज़ा

3

मेरा सुझाव है कि आप TextView का विस्तार करें, और हमेशा अपने XML लेआउट के भीतर या जहाँ भी आपको TextView की आवश्यकता हो, अपने कस्टम टेक्स्ट दृश्य का उपयोग करें। अपने कस्टम टेक्स्ट व्यू में, ओवरराइड करेंsetTypeface

@Override
public void setTypeface(Typeface tf, int style) {
    //to handle bold, you could also handle italic or other styles here as well
    if (style == 1){
        tf = Typeface.createFromAsset(getContext().getApplicationContext().getAssets(), "MuseoSans700.otf");
    }else{
        tf = Typeface.createFromAsset(getContext().getApplicationContext().getAssets(), "MuseoSans500.otf");
    }
    super.setTypeface(tf, 0);
}

2

टॉम का समाधान बहुत अच्छा काम करता है, लेकिन केवल TextView और EditText के साथ काम करता है।

यदि आप अधिकांश दृश्य (RadioGroup, TextView, चेकबॉक्स ...) को कवर करना चाहते हैं, तो मैंने एक तरीका बनाया है:

protected void changeChildrenFont(ViewGroup v, Typeface font){
    for(int i = 0; i < v.getChildCount(); i++){

        // For the ViewGroup, we'll have to use recursivity
        if(v.getChildAt(i) instanceof ViewGroup){
            changeChildrenFont((ViewGroup) v.getChildAt(i), font);
        }
        else{
            try {
                Object[] nullArgs = null;
                //Test wether setTypeface and getTypeface methods exists
                Method methodTypeFace = v.getChildAt(i).getClass().getMethod("setTypeface", new Class[] {Typeface.class, Integer.TYPE});
                //With getTypefaca we'll get back the style (Bold, Italic...) set in XML
                Method methodGetTypeFace = v.getChildAt(i).getClass().getMethod("getTypeface", new Class[] {});
                Typeface typeFace = ((Typeface)methodGetTypeFace.invoke(v.getChildAt(i), nullArgs));
                //Invoke the method and apply the new font with the defined style to the view if the method exists (textview,...)
                methodTypeFace.invoke(v.getChildAt(i), new Object[] {font, typeFace == null ? 0 : typeFace.getStyle()});
            }
            //Will catch the view with no such methods (listview...)
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

यह विधि XML में सेट किए गए दृश्य की शैली को वापस ले लेगी (बोल्ड, इटैलिक ...) और यदि वे मौजूद हैं तो उन्हें लागू करें।

ListView के लिए, मैं हमेशा एक एडाप्टर बनाता हूं, और मैं getView के अंदर फ़ॉन्ट सेट करता हूं।


2

मैंने वर्तमान दृश्य पदानुक्रम में विचारों के आधार पर टाइपफेस को असाइन करने वाला एक वर्ग लिखा है और वर्तमान टाइपफेस गुण (असमान, सामान्य ओएस आप चाहते हैं तो अन्य शैलियों को जोड़ सकते हैं):

public final class TypefaceAssigner {

public final Typeface DEFAULT;
public final Typeface DEFAULT_BOLD;

@Inject
public TypefaceAssigner(AssetManager assetManager) {
    DEFAULT = Typeface.createFromAsset(assetManager, "TradeGothicLTCom.ttf");
    DEFAULT_BOLD = Typeface.createFromAsset(assetManager, "TradeGothicLTCom-Bd2.ttf");
}

public void assignTypeface(View v) {
    if (v instanceof ViewGroup) {
        for (int i = 0; i < ((ViewGroup) v).getChildCount(); i++) {
            View view = ((ViewGroup) v).getChildAt(i);
            if (view instanceof ViewGroup) {
                setTypeface(view);
            } else {
                setTypeface(view);
            }
        }
    } else {
        setTypeface(v);
    }
}

private void setTypeface(View view) {
    if (view instanceof TextView) {
        TextView textView = (TextView) view;
        Typeface typeface = textView.getTypeface();
        if (typeface != null && typeface.isBold()) {
            textView.setTypeface(DEFAULT_BOLD);
        } else {
            textView.setTypeface(DEFAULT);
        }
    }
}
}

अब onViewCreated या onCreateView में सभी टुकड़ों में, onCreate में सभी गतिविधियों में और getView या newView में सभी व्यू एडेप्टर में केवल इनवोक करें:

typefaceAssigner.assignTypeface(view);

2

api 26 में build.gradle 3.0.0 के साथ और उच्चतर आप रेस में एक फॉन्ट डायरेक्टरी बना सकते हैं और अपनी शैली में इस लाइन का उपयोग कर सकते हैं

<item name="android:fontFamily">@font/your_font</item>

बदलाव के लिए build.gradle अपने build.gradle निर्भरता में इसका उपयोग करें

classpath 'com.android.tools.build:gradle:3.0.0'

और परियोजना में फ़ॉन्ट कैसे डालें?
अज़राफ़ती

@azerafati अपने फ़ॉन्ट को res / font
Mohammad Hosein Heidari

हाँ, tanx। मुझे वह पहले ही मिल गया। लेकिन वह itemअकेले संपूर्ण ऐप के लिए फ़ॉन्ट सेट नहीं करता है। कोई सुराग?
अज़राफ़ती

1

अंत में, Google को इस समस्या की गंभीरता का एहसास हुआ (UI घटकों के लिए कस्टम फ़ॉन्ट लागू करना) और उन्होंने इसके लिए एक स्वच्छ समाधान तैयार किया।

सबसे पहले, आपको लाइब्रेरी 26+ का समर्थन करने के लिए अद्यतन करने की आवश्यकता है (आपको अपने ग्रेड {4.0+}, एंड्रॉइड स्टूडियो) को भी अपडेट करने की आवश्यकता हो सकती है, फिर आप फ़ॉन्ट नामक एक नया संसाधन फ़ोल्डर बना सकते हैं। इस फ़ोल्डर में, आप अपने फ़ॉन्ट संसाधन (.tff, ...) डाल सकते हैं। फिर आपको उन्हें डिफ़ॉल्ट ऐप को ओवरराइड करने और अपने कस्टम फ़ॉन्ट को उसमें डालने की आवश्यकता है :)

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="android:fontFamily">@font/my_custom_font</item>
</style>

नोट: यदि आप 16 से अधिक पुराने एपीआई वाले उपकरणों का समर्थन करना चाहते हैं, तो आपको एंड्रॉइड के बजाय ऐप नेमस्पेस का उपयोग करना होगा!


0

मैं एपीआई 21 एंड्रॉइड 5.0 के लिए वेस्टन के जवाब में सुधार करना चाहूंगा।

मैं अपने सैमसंग s5 पर एक ही मुद्दा था, DEFAULT फ़ॉन्ट का उपयोग करते समय। (अन्य फोंट के साथ यह ठीक काम कर रहा है)

मैं इसे प्रत्येक टेक्स्टव्यू या बटन के लिए XML फाइलों में टाइपफेस (उदाहरण के लिए "sans") सेट करके काम करने में कामयाब रहा

<TextView
android:layout_width="match_parent"
android:layout_height="39dp"
android:textColor="@color/abs__background_holo_light"
android:textSize="12sp"
android:gravity="bottom|center"
android:typeface="sans" />

और MyApplication Class में:

public class MyApplication extends Application {
    @Override
    public void onCreate() {
    TypefaceUtil.overrideFont(getApplicationContext(), "SANS_SERIF",
    "fonts/my_font.ttf");
    }
}

आशा करता हूँ की ये काम करेगा।



0

सुलेख बहुत अच्छी तरह से काम करता है, लेकिन यह मेरे लिए उपयुक्त नहीं है, क्योंकि यह फ़ॉन्ट-परिवार के लिए विभिन्न भार (बोल्ड, इटैलिक, आदि) का समर्थन नहीं करता है।

इसलिए मैंने फॉनटेन की कोशिश की , जो आपको कस्टम व्यू को परिभाषित करने और उन्हें कस्टम फॉन्ट परिवारों को लागू करने की अनुमति देता है।

Fontain का उपयोग करने के लिए, आपको अपने एप्लिकेशन मॉड्यूल build.gradle में निम्नलिखित जोड़ना चाहिए:

compile 'com.scopely:fontain:1.0.0'

फिर, नियमित टेक्स्ट दृश्य का उपयोग करने के बजाय, आपको FontTextView का उपयोग करना चाहिए

अपरकेस और बोल्ड सामग्री के साथ FontTextView का उदाहरण:

 <com.scopely.fontain.views.FontTextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="@android:color/black"
            android:textColor="@android:color/white"
            android:textSize="11dp"
            android:gravity="center"
            android:id="@+id/tv1"
            app:font_family="myCustomFont"
            app:caps_mode="characters"
            app:font_weight="BOLD"/>

0
package com.theeasylearn.demo.designdemo;
import android.content.Context;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.widget.TextView;

public class MyButton extends TextView {

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

    public MyButton(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public MyButton(Context context) {
        super(context);
        init();
    }

    private void init() {

            Typeface tf =
                    Typeface.createFromAsset(
                            getContext().getAssets(), "angelina.TTF");
            setTypeface(tf);

    }

}

एक सही समाधान नहीं। इस समाधान का उपयोग करने के लिए डिफ़ॉल्ट एंड्रॉइड TextViews
ब्लरवेयर

0

TextViews के डिफ़ॉल्ट फ़ॉन्ट परिवार को बदलने के लिए, अपने ऐप थीम में textViewStyle को ओवरराइड करें।

FontFamily में कस्टम फ़ॉन्ट का उपयोग करने के लिए, फ़ॉन्ट संसाधनों का उपयोग करें जो समर्थन लाइब्रेरी में है।

फ़ीचर को एंड्रॉइड 26 में जोड़ा गया था, लेकिन पुराने संस्करणों को सपोर्टलिब के जरिए वापस भेज दिया गया।

https://developer.android.com/guide/topics/resource/font-resource.html https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html # का उपयोग कर-support-लिब


0

Android Oreo और इसके सपोर्ट लाइब्रेरी (26.0.0) की रिलीज़ के बाद से आप इसे आसानी से कर सकते हैं। एक अन्य प्रश्न में इस उत्तर का संदर्भ लें ।

मूल रूप से आपकी अंतिम शैली इस तरह दिखाई देगी:

<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
   <item name="fontFamily">@font/your_font</item> <!-- target android sdk versions < 26 and > 14 -->
</style>


-15

हाँ, पूरे एप्लिकेशन के लिए फ़ॉन्ट सेट करना संभव है।

इसे पूरा करने का सबसे आसान तरीका है कि आप अपने आवेदन के साथ वांछित फ़ॉन्ट (ओं) को पैकेज करें।

ऐसा करने के लिए, बस प्रोजेक्ट रूट में एक संपत्ति / फ़ोल्डर बनाएं , और संपत्ति में अपने फोंट (ट्रू टाइप या टीटीएफ, फॉर्म में) डालें।

उदाहरण के लिए, आप संपत्ति / फोंट बना सकते हैं और अपनी टीटीएफ फाइलें वहां डाल सकते हैं।

public class FontSampler extends Activity {
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
TextView tv=(TextView)findViewById(R.id.custom);

Typeface face=Typeface.createFromAsset(getAssets(), "fonts/HandmadeTypewriter.ttf");
tv.setTypeface(face);
}
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.