एंड्रॉइड में पूरे एप्लिकेशन के लिए कस्टम फ़ॉन्ट कैसे सेट करें?


83

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

मैंने कोशिश की कि यहाँ क्या पोस्ट किया गया है , लेकिन मुझे नहीं पता कि मेरी extends Applicationकक्षा कहाँ है ...

कोई मदद?

संपादित करें:

मैंने निम्नलिखित कोशिश की:

  • एक संपत्ति फ़ोल्डर जोड़ें और यहां देखे गए अनुसार फ़ॉन्ट डालें:

यहां छवि विवरण दर्ज करें

  • एक नई क्लास जोड़ें जो इससे फैली हो Application

  • मेरी इस नई कक्षा को बुलाओ AndroidManifest.xml

  • मैंने अपने स्टाइल में जाकर उसे जोड़ा।

MyApp.java:

public class MyApp extends Application {
  @Override
  public void onCreate() {
     super.onCreate();
    FontsOverride.setDefaultFont(this, "DEFAULT", "raleway_regular.ttf");
    //  This FontsOverride comes from the example I posted above
  }
  }

AndroidManifest.xml:

<application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:supportsRtl="true"
      android:name=".MyApp"
      android:theme="@style/AppTheme">
     ....

styles.xml:

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

लेकिन मेरा फॉन्ट अभी भी चेंज नहीं हो रहा है ... कोई आइडिया?

फिर MyAppक्लास कहा जाता है। लेकिन मेरे फोंट पर कोई असर नहीं ...

EDIT2: मैंने महसूस किया कि मेरे बटन के लिए कस्टम शैली सेट करने के बाद मेरे बटन कस्टम फ़ॉन्ट लागू करते हैं। यहाँ मेरी कस्टम बटन शैली है:

<style name="MyButtonStyle" parent="Widget.AppCompat.Button">
    <item name="textAllCaps">false</item>
    <item name="android:textAllCaps">false</item>
</style>

और यहाँ है कि यह अब कैसा दिखता है:

यहां छवि विवरण दर्ज करें

तो: मेरा बटन स्टाइल लागू कर रहा है, लेकिन नहीं TextView। आवेदन में सभी वस्तुओं के लिए मेरा कस्टम फ़ॉन्ट क्यों लागू नहीं किया जा रहा है, इस पर कोई विचार?


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

मुझे पता है, मुझे लगता है कि मेरा समाधान है ... लेकिन जब मैं एक वर्ग बनाता हूं जो अनुप्रयोग से विस्तारित होता है, तो मैं इसे काम नहीं कर सकता क्योंकि यह कहता है कि मेरी कक्षा का उपयोग कभी नहीं किया गया है ...
सोनहजा

मेरे उत्तर में कुछ और लिंक देखें, मददगार प्रतीत होता है, एक और बात मेरी पहली कड़ी वास्तव में बेहतर है, धन्यवाद
Androider

जवाबों:


50

एक कक्षा लिखें

public class MyApp extends Application{
// Put the onCreate code as you obtained from the post link you reffered
}

अब अगली बात AndroidManifest.xml में एप्लिकेशन टैग के लिए अपने एप्लिकेशन वर्ग के लिए नाम दें। इस मामले में यह MyApp है

<application
android:name=".MyApp"
...
>
...
</application>

इसलिए जब भी ऐप खोला जाता है, तो MyApp क्लास का ऑन-लाइन तरीका लागू किया जाएगा, और फ़ॉन्ट सेट किया जाएगा।

संपत्ति / फ़ॉन्ट / your_font_file.ttf के तहत फ़ॉन्ट फ़ाइल अपडेट करें

इस लाइन को अपने एप्लिकेशन वर्ग (MyApp) के ऑनक्रिट विधि के तहत रखें

TypefaceUtil.overrideFont(getApplicationContext(), "SERIF", "fonts/your_font_file.ttf");

TypefaceUtil के लिए स्रोत फ़ाइल

public class TypefaceUtil {

    /**
     * Using reflection to override default typeface
     * NOTICE: DO NOT FORGET TO SET TYPEFACE FOR APP THEME AS DEFAULT TYPEFACE WHICH WILL BE OVERRIDDEN
     *
     * @param context                    to work with assets
     * @param defaultFontNameToOverride  for example "monospace"
     * @param customFontFileNameInAssets file name of the font from assets
     */
    public static void overrideFont(Context context, String defaultFontNameToOverride, String customFontFileNameInAssets) {

        final Typeface customFontTypeface = Typeface.createFromAsset(context.getAssets(), customFontFileNameInAssets);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            Map<String, Typeface> newMap = new HashMap<String, Typeface>();
            newMap.put("serif", customFontTypeface);
            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 defaultFontTypefaceField = Typeface.class.getDeclaredField(defaultFontNameToOverride);
                defaultFontTypefaceField.setAccessible(true);
                defaultFontTypefaceField.set(null, customFontTypeface);
            } catch (Exception e) {
                Log.e(TypefaceUtil.class.getSimpleName(), "Can not set custom font " + customFontFileNameInAssets + " instead of " + defaultFontNameToOverride);
            }
        }
    }
}

अब अपनी style.xml फ़ाइल को अपडेट करें

नीचे दी गई लाइन को अपनी शैली में रखें जो आपकी गतिविधि के लिए प्रकट फ़ाइल में शामिल है

  <item name="android:typeface">serif</item>

उम्मीद है की यह मदद करेगा


कृपया मुझे अपना Android OS संस्करण बताएं जिस पर आप परीक्षण कर रहे हैं। मैंने लॉलीपॉप में देखा है कि हमें कुछ और ट्वीस्ट बनाने की जरूरत है
नितिन मस्टा

(: लॉलीपॉप के लिए समाधान और पिछले Android संस्करण के लिए नीचे दिए गए लिंक की जांच करें stackoverflow.com/a/36206275/2268466 )
blueware

यह टोस्ट मैसेज, अलर्ट डायलॉग में सभी ऐप फॉन्ट को बदल देता है, मैं इसमें कस्टम फॉन्ट को नहीं चाहता हूं
आदिल

1
मुझे संदेह है, कई निर्माता उपयोगकर्ता को सेटिंग्स से फोंट सिस्टम-वाइड को बदलने की अनुमति देते हैं, क्या यह परिवर्तन हमारे फ़ॉन्ट-प्रकार पर भी निर्भर करता है जिसे हम प्रोग्रामेटिक रूप से सेट करते हैं?
भूरू

कई फोंट सेट के बारे में क्या?
गौरव मंडली

82

संपादित करें

uk.co.chrisjenx:calligraphyनवीनतम Android संस्करण विकल्प के लिए लीब को अधिक बनाए नहीं रखा गया है अब https://github.com/InflationX/Calligraphy है

dependencies {
    implementation 'io.github.inflationx:calligraphy3:3.1.1'
    implementation 'io.github.inflationx:viewpump:2.0.3'
}

अपने कस्टम फोंट को संपत्ति में जोड़ें /

प्रयोग

डिफ़ॉल्ट फ़ॉन्ट के लिए

#OnCreate () विधि में अपने एप्लिकेशन वर्ग में CalligraphyConfig का उपयोग करके अपने डिफ़ॉल्ट फ़ॉन्ट को परिभाषित करें और इसे CalligraphyInterceptor में पास करें जिसे आप अपने ViewPump बिल्डर में जोड़ते हैं।

@Override
public void onCreate() {
    super.onCreate();
    ViewPump.init(ViewPump.builder()
        .addInterceptor(new CalligraphyInterceptor(
                new CalligraphyConfig.Builder()
                    .setDefaultFontPath("fonts/Roboto-RobotoRegular.ttf")
                    .setFontAttrId(R.attr.fontPath)
                    .build()))
        .build());
    //....
}

संदर्भ में संदर्भ: गतिविधि संदर्भ लपेटें:

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

कस्टम शैली

<style name="TextViewCustomFont">
    <item name="fontPath">fonts/RobotoCondensed-Regular.ttf</item>
</style>

थीम के लिए

<style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
    <item name="android:textViewStyle">@style/AppTheme.Widget.TextView</item>
</style>

<style name="AppTheme.Widget"/>

<style name="AppTheme.Widget.TextView" parent="android:Widget.Holo.Light.TextView">
    <item name="fontPath">fonts/Roboto-ThinItalic.ttf</item>
</style>

नीचे दिए गए समाधान द्वारा डेवलपर्स द्वारा अधिक नहीं बनाए रखा गया है


एंड्रॉइड में कस्टम फोंट के लिए एक महान पुस्तकालय है: सुलेख
यहां इसका उपयोग करने का एक नमूना है।

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

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

और फिर एक वर्ग बनाएं जो अनुप्रयोग का विस्तार करे और यह कोड लिखें:

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

आपको परिसंपत्तियों / एक "नई निर्देशिका" "फोंट" (नीचे देखें) पर बनाया जाना चाहिए, इसलिए उस कोड में "आपका फ़ॉन्ट पथ" "फोंट / SourceSansPro-Regular.ttf" होना चाहिए। (यह सिर्फ "फोंट ..." नहीं "/ फोंट .." या "संपत्ति ..")

और गतिविधि कक्षा में इस विधि को onCreate से पहले रखें:

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

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

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

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

आस्तियों पर आपको नई निर्देशिका पर राइट-क्लिक करना चाहिए, इसे "फ़ॉन्ट" कहें। खोजक में .ttfफ़ॉन्ट फ़ाइलों को वहाँ रखा।

यहां छवि विवरण दर्ज करें

इसके अलावा attrs.xml में दो लाइनें नीचे जोड़ना न भूलें, यदि आपके पास attrs.xml फ़ाइल नहीं है, तो मानों में नई फ़ाइल बनाएँ। xml

 <attr format="string" name="fontPath"/> 
    <item name="calligraphy_tag_id" type="id"/>

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

इसे विस्तृत करें एप्लिकेशन वर्ग CalligraphyConfig.initDefault (नया CalligraphyConfig.Builder () .setDefaultFontPath ("फॉन्ट / GOTHAM-MEDIUM .ttf") .setFontAttrId (R.attr.fontPath) .build ()। मानों में दो पंक्तियाँ जोड़ना भी न भूलें। xml <Attr format = "string" name = "fontPath" /> <आइटम का नाम = "calligraphy_tag_id" टाइप = "id" />
Rajit Nasit

हाय @ प्रजेश! आपको "संपादित करें" पर क्लिक करना चाहिए और इसे अपने शानदार उत्तर में जोड़ना चाहिए! आप सही हैं, यह .ttf फाइलें होनी चाहिए , क्षमा करें।
फेटी

1
आप अधिक से अधिक टुकड़े का उपयोग कर सकते हैं। ताकि गतिविधि की संख्या कम हो जाए।
राजेश नसीत

1
@ पवन इसे एक कदम करने के लिए - मैं एक सरल आधार वर्ग को परिभाषित करता हूं जहां attachBaseContext(..)लागू किया गया है, और फिर मेरी सभी परियोजना गतिविधि कक्षाएं (जहां मैं चाहता हूं कि कस्टम फ़ॉन्ट) उस आधार वर्ग का विस्तार करें
जीन बो

65

मैंने जो किया वह था:

1: RES फ़ोल्डर में "नई संसाधन निर्देशिका" जोड़ी गई, दिए गए ड्रॉप-डाउन से "फ़ॉन्ट" के रूप में चयनित टाइप करें, नई निर्देशिका को "फ़ॉन्ट" नाम दिया और सहेजा गया। नया संसाधन

2: मेरे "custom_font.ttf" जोड़े गए FONT फ़ोल्डर में अभी-अभी बना है।

3: STYLES.XML में एप्लिकेशन बेस थीम में मेरा कस्टम फ़ॉन्ट जोड़ा गया

STYLES.XML

किया हुआ।


4
आपको एक फ़ॉन्ट परिवार भी बनाना होगा। उसके बाद इसने मेरे लिए काम किया। यहाँ विवरण: developer.android.com/guide/topics/ui/look-and-feel/…
keybee

यह मेरे लिए एक फ़ॉन्ट परिवार बनाने के बिना काम किया। हालाँकि, मुझे ग्रैडल संस्करण> 3 का उपयोग करना पड़ा और 27/ @keybee
Numanqmr 25'18

मेरे लिए बहुत अच्छा काम किया, यहां तक ​​कि फ़ॉन्ट परिवार के बिना भी
जूलियन अल्बर्टो

क्या आप जानते हैं कि इसे प्रोग्रामेटिक रूप से कैसे बदलना है?
माजोव

@ माजॉव #Rajeesh द्वारा दिए गए उत्तर की जाँच करें। कि आपकी मदद करनी चाहिए!
नुमानकमर

12

आप इसे एंड्रॉइड एसडीके के साथ अब कर सकते हैं, क्योंकि सेट / 2017 में यहां प्रकाशित एंड्रॉइड डेवलपर आधिकारिक यूट्यूब चैनल ।

API स्तर 26 (Android 8 Oreo) और इसके बाद के संस्करण की आवश्यकता है।

आपको बस अपनी फ़ॉन्ट फ़ाइल को res/fontफ़ोल्डर में रखना होगा और उन्हें उस स्थिति में संदर्भित करना होगा जब TextViewआपको android:fontFamilyविशेषता के साथ एक विशिष्ट की आवश्यकता होती है ।

यदि आप अपने पूरे ऐप पर एक आधार फ़ॉन्ट चाहते हैं, तो सीधे शब्दों में कहें

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

अपने में styles.xml

आप एंड्रॉइड स्टूडियो से एक कस्टम फ़ॉन्ट डाउनलोड कर सकते हैं और यदि आप चाहें तो चलते-फिरते भी। यह सब आप उपरोक्त वीडियो पर विवरण के साथ पा सकते हैं।


यह विकल्प एपीआई 26 और इसके बाद के संस्करण के लिए है। 16+ नहीं
परफेक्ट स्क्वायर

कैसे एपीआई 23 + के लिए फिक्सिंग के बारे में?
राजू आपका

12

एंड्रॉइड सरल और सर्वश्रेष्ठ समाधान प्रदान करता है जो समर्थन लाइब्रेरी 26+ द्वारा एपीआई स्तर 14 पर समर्थित है। XML में फ़ॉन्ट यह फ़ॉन्ट परिवार विकल्प का भी समर्थन करता है । आवश्यक आयात: implementation "com.android.support:support-compat:<26+ version>"

इन सरल चरणों का पालन करें और फ़ॉन्ट परिवार को बिना किसी बाधा के आपके ऐप में लागू किया जाएगा:

  1. Res के अंदर एक फॉन्ट डायरेक्टरी बनाएं
  2. अपनी फॉन्ट फाइल को फॉन्ट के अंदर पेस्ट करें
  3. फ़ॉन्ट फ़ोल्डर पर राइट-क्लिक करें और नया> फ़ॉन्ट संसाधन फ़ाइल पर जाएं। नई संसाधन फ़ाइल विंडो दिखाई देती है।
  4. निम्नलिखित विशेषताएँ जोड़ें
<?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>
  1. ऊपर xml फ़ाइल में। समर्थन पुस्तकालय का उपयोग करने के लिए केवल एप्लिकेशन का उपयोग करें । अन्यथा आप एंड्रॉइड का उपयोग कर सकते हैं यदि आपका ऐप एपीआई स्तर 26+ को लक्षित करता है।
  2. अब अपने स्टाइल में जाएँ। xml और अपने मुख्य स्टाइल में नीचे की लाइन डालें।
    <item name="android:fontFamily">@font/opensans</item>
    
  3. महत्वपूर्ण: यदि आप समर्थन पुस्तकालय का उपयोग कर रहे हैं, तभी AppCompatActivity का उपयोग करें ।
  4. या प्रोग्राम टाइपिंग सेट करने के लिए नीचे का उपयोग करें

    view.setTypeface(ResourcesCompat.getFont(context, R.font.opensans));
    

वर्तमान Android फ़ॉन्ट संसाधन सुविधा के साथ उपयुक्त है। धन्यवाद।
azwar_akbar

2

लगता है जैसे आप अपने android:fontFamilyबजाय का उपयोग कर रहे हैं ।android:typefacestyles.xml

बदलने का प्रयास करें

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

साथ में

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

1
और मैं इसे अपने आवेदन से कैसे जोड़ूं? इसका विस्तार कौन करता है?
सोनहजा

वैसे विस्तार से Applicationआप बस अपने अनुप्रयोग के Applicationवर्ग का एक उप वर्ग बना रहे हैं । इसलिए, आपको इसे कनेक्ट करने की आवश्यकता नहीं है।
सुहास

क्या कहता है इसका कभी उपयोग नहीं किया गया है?
सुहास

क्या आपने भी उसी SO पोस्ट में सुझाए अनुसार अपने ऐप की फाइल के <item name="android:typeface">default</item>अंदर लाइन जोड़ी थी? <style name="AppTheme" parent="AppBaseTheme">res -> values -> styles.xml
सुहास

हाँ, और यह भी काम नहीं करता है। बस यही मैंने अपने संपादन में डाला ... :(
सोनहजा

2

यदि आप पहले विषय का पालन करते हैं, तो यह काम करना चाहिए: यहां

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

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

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

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

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

<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

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

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

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

2
  1. शुरुआत में, आपको अपने प्रोजेक्ट संसाधनों पर राइट-क्लिक करना चाहिए, resफिर नाम से newविकल्प चुनें Android Resource Directoryऔर fontफॉर्म Resource typeको दबाएं और ओके दबाएं, इससे फॉन्ट डायरेक्टरी बन जाएगी, जिसमें आपके फॉन्ट को रखा जाएगा।

यहां छवि विवरण दर्ज करें

  1. अपनी .ttfफ़ॉन्ट फ़ाइलों को वहां रखें।

यहां छवि विवरण दर्ज करें

  1. प्रोजेक्ट स्टाइल फ़ाइल पर जाएँ जो निम्न पथ में मौजूद है res/values/styles.xml और इस तरह की शैलियाँ जोड़ें:

    <style name="SansSerifFont">
        <item name="android:fontFamily">sans-serif</item>
    </style>
    
    <style name="OpenSansFont">
        <item name="android:fontFamily">@font/open_sans</item>
    </style>
    
    <style name="IranianSansFont">
        <item name="android:fontFamily">@font/iranian_sans</item>
    </style>
    
    <style name="BYekanFont">
        <item name="android:fontFamily">@font/b_yekan</item>
    </style>
    
    <style name="DroidArabicFont">
        <item name="android:fontFamily">@font/droid_arabic</item>
    </style>
    
  2. अपने कोड पर जाएं और संपूर्ण एप्लिकेशन फ़ॉन्ट बदलने के लिए इस तरह एक वर्ग लिखें:

    public class AppFontManager {
    
        private AppCompatActivity appCompatActivity;
    
        public static final String SANS_SERIF_APP_FONT = "sans_serif";
        public static final String B_YEKAN_APP_FONT = "b_yekan";
        public static final String DROID_ARABIC_APP_FONT = "droid_arabic";
        public static final String IRANIAN_SANS_APP_FONT = "iranian_sans";
        public static final String OPEN_SANS_APP_FONT = "open_sans";
    
        public AppAppearanceManager(AppCompatActivity appCompatActivity) {
            this.appCompatActivity = appCompatActivity;
        }
    
        public void setFont(String fontName){
    
            switch (fontName){
    
                case SANS_SERIF_APP_FONT:{
                    appCompatActivity.getTheme().applyStyle(R.style.SansSerifFont, true);
                    break;
                }
    
                case B_YEKAN_APP_FONT:{
                    appCompatActivity.getTheme().applyStyle(R.style.BYekanFont, true);
                    break;
                }
    
                case DROID_ARABIC_APP_FONT:{
                    appCompatActivity.getTheme().applyStyle(R.style.DroidArabicFont, true);
                    break;
                }
    
                case IRANIAN_SANS_APP_FONT:{
                appCompatActivity.getTheme().applyStyle(R.style.IranianSansFont, true);
                    break;
                }
    
                case OPEN_SANS_APP_FONT:{
                    appCompatActivity.getTheme().applyStyle(R.style.OpenSansFont, true);
                    break;
                }
            }
        }
    }
    

    क्योंकि फोंट को प्रत्येक गतिविधियों के लिए अलग से सेट किया जाना चाहिए , मैं अधिक स्वच्छ कोड के लिए इसके लिए एक वर्ग लिखना पसंद करता हूं।

  3. फिर गतिविधि चालू करने से पहले कक्षा विधि को कॉल करें super.onCreate(savedInstanceState):

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        new AppAppearanceManager(this).setFont(APP_DEFAULT_FONT);
        super.onCreate(savedInstanceState);
    // Do you stuff there...
    }
    

    याद रखें कि यदि आप रनटाइम के दौरान फ़ॉन्ट बदलना चाहते हैं SharedPreferences, तो चुने हुए फ़ॉन्ट को या आदि में लिखें , फिर चुने गए फ़ॉन्ट को setFontउपरोक्त सभी गतिविधियों के लिए पास करें ।


1

इसमें मुख्य folder.add फोंट फ़ोल्डर में संपत्ति फ़ोल्डर बनाएँ। फ़ॉन्ट फ़ोल्डर में अपनी .ttf फ़ाइल जोड़ें।

अपने एप्लिकेशन में निम्न जोड़ें थीम:

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

TypefaceUtil के रूप में कक्षा बनाएँ

 import android.content.Context;
import android.graphics.Typeface;
import android.util.Log;

import java.lang.reflect.Field;

public class TypefaceUtil {

    /**
     * Using reflection to override default typeface
     * NOTICE: DO NOT FORGET TO SET TYPEFACE FOR APP THEME AS DEFAULT TYPEFACE WHICH WILL BE OVERRIDDEN
     * @param context to work with assets
     * @param defaultFontNameToOverride for example "monospace"
     * @param customFontFileNameInAssets file name of the font from assets
     */
    public static void overrideFont(Context context, String defaultFontNameToOverride, String customFontFileNameInAssets) {
        try {
            final Typeface customFontTypeface = Typeface.createFromAsset(context.getAssets(), customFontFileNameInAssets);

            final Field defaultFontTypefaceField = Typeface.class.getDeclaredField(defaultFontNameToOverride);
            defaultFontTypefaceField.setAccessible(true);
            defaultFontTypefaceField.set(null, customFontTypeface);
        } catch (Exception e) {
            Log.e("Can not set","Can not set custom font " + customFontFileNameInAssets + " instead of " + defaultFontNameToOverride);
        }
    }
}

इसे एप्लिकेशन क्लास या लॉन्चर गतिविधि में कॉल करें

        TypefaceUtil.overrideFont(getApplicationContext(), "fonts/roboto_regular.ttf", "fonts/roboto_regular.ttf"); // font from assets: "assets/fonts/Roboto-Regular.ttf

0

सबसे पहले, एक नया वर्ग बनाएं जो आपके द्वारा अनुकूलित किए जाने वाले दृश्य को ओवरराइड करता है। (जैसे कस्टम टाइपफेस वाला बटन चाहते हैं? विस्तार करें Button)। उदाहरण के लिए:

public class CustomButton extends Button {
    private final static int ROBOTO = 0;
    private final static int ROBOTO_CONDENSED = 1;

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

    public CustomButton(Context context, AttributeSet attrs) {
        super(context, attrs);
        parseAttributes(context, attrs); //I'll explain this method later
    }

    public CustomButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        parseAttributes(context, attrs);
    }
}

अब, यदि आपके पास एक नहीं है, तो XML दस्तावेज़ को नीचे res/values/attrs.xmlजोड़ें, और जोड़ें:

<resources>
    <!-- Define the values for the attribute -->
    <attr name="typeface" format="enum">
        <enum name="roboto" value="0"/>
        <enum name="robotoCondensed" value="1"/>
    </attr>

    <!-- Tell Android that the class "CustomButton" can be styled, 
         and which attributes it supports -->
    <declare-styleable name="CustomButton">
        <attr name="typeface"/>
    </declare-styleable>
</resources>

ठीक है, इसलिए उस रास्ते से, चलो parseAttributes()पहले से विधि पर वापस आते हैं :

private void parseAttributes(Context context, AttributeSet attrs) {
    TypedArray values = context.obtainStyledAttributes(attrs, R.styleable.CustomButton);

    //The value 0 is a default, but shouldn't ever be used since the attr is an enum
    int typeface = values.getInt(R.styleable.CustomButton_typeface, 0);

    switch(typeface) {
        case ROBOTO: default:
            //You can instantiate your typeface anywhere, I would suggest as a 
            //singleton somewhere to avoid unnecessary copies
            setTypeface(roboto); 
            break;
        case ROBOTO_CONDENSED:
            setTypeface(robotoCondensed);
            break;
    }

    values.recycle();
}

अब तुम सब सेट हो गए। आप किसी भी चीज़ के बारे में और अधिक विशेषताएँ जोड़ सकते हैं (आप टाइपफेसिटाइल के लिए एक और एक जोड़ सकते हैं - बोल्ड, इटैलिक, आदि) लेकिन अब देखते हैं कि इसका उपयोग कैसे करें:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:custom="http://schemas.android.com/apk/res/com.yourpackage.name"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <com.yourpackage.name.CustomButton
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me!"
        custom:typeface="roboto" />

</LinearLayout>

xmlns:customलाइन वास्तव में कुछ भी हो सकता है, लेकिन सम्मेलन क्या ऊपर दिखाया जाता है। क्या मायने रखता है कि यह अद्वितीय है, और इसलिए पैकेज नाम का उपयोग किया जाता है। अब आप बस custom:अपनी विशेषताओं के लिए उपसर्ग का उपयोग करें , और android:Android विशेषताओं के लिए उपसर्ग का उपयोग करें ।

एक आखिरी बात: यदि आप इसे एक शैली ( res/values/styles.xml) में उपयोग करना चाहते हैं , तो आपको लाइन नहीं जोड़ना चाहिए xmlns:custom। केवल उपसर्ग के साथ विशेषता के नाम को देखें:

<style name="MyStyle>
    <item name="typeface">roboto</item>
</style>

0

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

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

सौभाग्य


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

0

नीचे दिए गए कोड की कोशिश करो, यह मेरे लिए काम करता है, आशा है कि यह आपकी भी मदद करेगा।

public class BaseActivity extends AppCompatActivity {

private Typeface typeace;
@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    typeace = Typeface.createFromAsset(getAssets(), getResources().getString(R.string.font_name));
}

@Override
protected void onStart() {
    // TODO Auto-generated method stub
    super.onStart();
    overrideFonts(this,getWindow().getDecorView());
}

private 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(typeace);
        } else if (v instanceof EditText ) {
            ((EditText) v).setTypeface(typeace);
        } else if (v instanceof Button) {
            ((Button) v).setTypeface(typeace);
        }
    } catch (Exception e) {
 }
 }
}

अब इस BaseActivity को अपनी किसी भी गतिविधि तक बढ़ाएं या यदि आप उपयोग कर रहे हैं तो आप खंड के लिए एक ही वर्ग बना सकते हैं।

नोट: - यदि आप कुछ अलग प्रकार के दृश्य प्रस्तुत करना चाहते हैं तो आपको उस प्रोग्राम को नीचे की तरह सेट करना होगा

private Typeface typeface;
typeface = Typeface.createFromAsset(getAssets(), getResources().getString(R.string.font_name_bold));
tvUserName.setTypeface(typeface);

इसलिए इसे आज़माएं और मुझे बताएं, अगर मैं आगे आपकी मदद कर सकूं


0

कोटलिन के लिए एक काम यह होगा

घोल का घोल https://gist.github.com/Johnyoat/040ca5224071d01b3f3dfc6cd4d026f7

पहला कदम

संपत्ति / फोंट / your_font_file.ttf के तहत फ़ॉन्ट फ़ाइल रखो और टाइपफ़्लूटिल नामक एक कोटलिन वर्ग बनाएं

   class TypefaceUtil{

    fun overridefonts(context: Context, defaultFontToOverride:String, customFontFileNameInAssets:String){
        try {
            val customTypeface = Typeface.createFromAsset(context.assets,customFontFileNameInAssets)
            val defaultTypefaceField = Typeface::class.java.getDeclaredField(defaultFontToOverride)
            defaultTypefaceField.isAccessible = true
            defaultTypefaceField.set(null,customTypeface)
        }catch (e:Exception){
            Timber.e("Cannot set font $customFontFileNameInAssets instead of $defaultFontToOverride")
        }
    }
}

स्टेप टू फिर अपने परonCreate

val typefaceUtil = TypefaceUtil()

typefaceUtil.overridefonts(this,"SERIF","fonts/font_file.ttf")

तीसरा कदम

इसे अपनी शैली में जोड़ें

<item name="android:typeface">serif</item>

0

आवेदन और काम में दिखाने के लिए फ़ॉन्ट नाम निचले मामले में होना चाहिए।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.