एंड्रॉइड में टेक्स्ट व्यू के फॉन्टमिली को कैसे बदलें

739

इसलिए मैं android:fontFamilyएंड्रॉइड में बदलाव करना चाहता हूं लेकिन मुझे एंड्रॉइड में कोई पूर्व-परिभाषित फोंट नहीं दिखता है। मैं पूर्व-परिभाषित लोगों में से एक का चयन कैसे करूं? मुझे वास्तव में अपने टाइपफ़ेस को परिभाषित करने की आवश्यकता नहीं है, लेकिन मुझे जो कुछ भी चाहिए वह अभी जो दिखाता है उससे कुछ अलग है।

<TextView
    android:id="@+id/HeaderText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    android:layout_marginTop="52dp"
    android:gravity="center"
    android:text="CallerBlocker"
    android:textSize="40dp"
    android:fontFamily="Arial"
 />

ऐसा लगता है कि मैंने जो किया वह वास्तव में काम नहीं करेगा! BTW android:fontFamily="Arial"एक मूर्ख प्रयास था!

android  android-layout  textview  typeface 
— तारिक
स्रोत
इस लिंक को देखें stackoverflow.com/questions/2376250/…
— duggu

जवाबों:

1660

Android 4.1 / 4.2 / 5.0 से, निम्नलिखित रोबोटो फ़ॉन्ट परिवार उपलब्ध हैं:

android:fontFamily="sans-serif"           // roboto regular
android:fontFamily="sans-serif-light"     // roboto light
android:fontFamily="sans-serif-condensed" // roboto condensed
android:fontFamily="sans-serif-black"     // roboto black
android:fontFamily="sans-serif-thin"      // roboto thin (android 4.2)
android:fontFamily="sans-serif-medium"    // roboto medium (android 5.0)

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

के साथ सम्मिलन में

android:textStyle="normal|bold|italic"

यह 16 वेरिएंट संभव हैं:

  • रोबोटो नियमित
  • रोबोटो इटैलिक
  • रोबोटो बोल्ड
  • रोबोटो बोल्ड इटैलिक
  • रोबोटो लाइट
  • रोबोटो-लाइट इटैलिक
  • रोबोटो-पतला
  • रोबोटो-थिन इटैलिक
  • रोबोटो-संघनित
  • रोबोटो-कंडेंस्ड इटैलिक
  • रोबोटो-कंडेंस्ड बोल्ड
  • रोबोटो-कंडेंस्ड बोल्ड इटैलिक
  • रोबोटो-काला
  • रोबोटो-ब्लैक इटैलिक
  • रोबोटो-मझौले
  • रोबोटो-मीडियम इटैलिक

fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="font_family_light">sans-serif-light</string>
    <string name="font_family_medium">sans-serif-medium</string>
    <string name="font_family_regular">sans-serif</string>
    <string name="font_family_condensed">sans-serif-condensed</string>
    <string name="font_family_black">sans-serif-black</string>
    <string name="font_family_thin">sans-serif-thin</string>
</resources>
— जकोब एरिकसन
स्रोत
17
इसे न भूलें: android: fontFamily = "sans-serif-thin" // roboto thin
— Sam Lu
6
मैंने रॉबोटो नमूना पुस्तक में "ब्लैक स्मॉल कैप" नामक एक संस्करण देखा , लेकिन मैं इसका उपयोग करने का प्रबंधन नहीं करता। android:fontFamily="sans-serif-black-small-caps"Doesn't काम का उपयोग करना । किसी को पता है?
— tbruyelle
3
मुझे इनमें से कोई भी फ़ॉन्ट-परिवार नहीं मिल रहा है जो आपने यहां टाइप किया है। मैं "सेन्स-सेरिफ़" को एक साथ नहीं ढूंढ पा रहा हूँ।
— मोंटी
9
यह एक अच्छी सूची है। क्या किसी के पास कोई लिंक है जहां से यह जानकारी आती है? android:fontFamilyटेक्स्टव्यू के दस्तावेज़ के लिए कहना आसान होगा, अगर Google के पास उनके दस्तावेज़ों में यह आसानी से मिल जाए ।
— क्रिस्टोफर पेरी
8
फोंट की निश्चित सूची system_fonts.xml में देखी जा सकती है जैसा कि यहाँ
— Newtonx
207

यह प्रोग्राम को फ़ॉन्ट सेट करने का तरीका है:

TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
            "fonts/epimodem.ttf");
tv.setTypeface(face);

फ़ॉन्ट फ़ाइल को अपनी संपत्ति फ़ोल्डर में रखें। मेरे मामले में मैंने फोंट नामक एक उपनिर्देशिका बनाई।

संपादित करें: यदि आप आश्चर्य करते हैं कि आपका संपत्ति फ़ोल्डर कहां है तो यह प्रश्न देखें

— स्टेफन बीक
स्रोत
34
हालांकि यह काम करता है, कृपया ध्यान दें कि यह एक मेमोरी लीक बना सकता है । इस उत्तर का उपयोग करके इसे ठीक किया जा सकता है ।
— चार्ल्स मैडरे
जब मैं आपके समाधान का उपयोग करता हूं तो @ScrrNova मुझे यह त्रुटि मिलती है। त्रुटि: फ़ॉन्ट परिसंपत्ति को गोथिक नहीं मिला ।ttf
— सागर देवंगा
इसे पूरे ऐप पर कैसे लागू करें? अभी उदाहरण में आप इसे केवल टेक्स्टव्यू पर प्रिटिश कर रहे हैं
— प्रीतिश जोशी
176

एंड्रॉइड-स्टूडियो 3.0 से शुरू करके फ़ॉन्ट परिवार को बदलना बहुत आसान है

समर्थन पुस्तकालय 26 का उपयोग करते हुए, यह एंड्रॉइड एपीआई संस्करण 16 और उच्चतर पर चलने वाले उपकरणों पर काम करेगा

निर्देशिका के fontअंतर्गत एक फ़ोल्डर बनाएँ। resजो भी आप चाहते हैं उसे डाउनलोड करें और fontफ़ोल्डर के अंदर पेस्ट करें । संरचना नीचे की तरह कुछ होनी चाहिए

यहाँ

नोट: एंड्रॉइड सपोर्ट लाइब्रेरी 26.0 के अनुसार, आपको Api 26 या उससे कम चलने वाले उपकरणों पर अपने फोंट लोड को सुनिश्चित करने के लिए विशेषताओं के दोनों सेट (android: और app:) घोषित करने होंगे।

अब आप लेआउट का उपयोग करके फ़ॉन्ट बदल सकते हैं

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

प्रोग्राम को बदलने के लिए

 Typeface typeface = getResources().getFont(R.font.myfont);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
 textView.setTypeface(typeface);

Style.xml का उपयोग करके फ़ॉन्ट बदलने के लिए एक शैली बनाएं

 <style name="Regular">
        <item name="android:fontFamily">@font/dancing_script</item>
        <item name="fontFamily">@font/dancing_script</item>
        <item name="android:textStyle">normal</item>
 </style>

और इस शैली को लागू करें TextView

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    style="@style/Regular"/>

आप अपना स्वयं का फ़ॉन्ट परिवार भी बना सकते हैं

- फ़ॉन्ट फ़ोल्डर पर राइट-क्लिक करें और नया> फ़ॉन्ट संसाधन फ़ाइल पर जाएं । नई संसाधन फ़ाइल विंडो दिखाई देती है।

- फ़ाइल नाम दर्ज करें , और उसके बाद ठीक क्लिक करें । नया फॉन्ट संसाधन XML संपादक में खुलता है।

अपने स्वयं के फ़ॉन्ट परिवार को यहाँ लिखें, उदाहरण के लिए

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

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

1. लेआउट में fontfamily बदलने के लिए आप लिख सकते हैं

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

2. प्रोग्रामेटिक रूप से बदलना

 Typeface typeface = getResources().getFont(R.font.lobster);
   //or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
 textView.setTypeface(typeface);

संपूर्ण App का फ़ॉन्ट बदलने के लिए AppTheme में इन दो पंक्तियों को जोड़ें

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

अधिक जानकारी के लिए प्रलेखन , Android कस्टम फ़ॉन्ट्स ट्यूटोरियल देखें

— मनोहर रेड्डी
स्रोत
7
एनबी: यह वर्तमान में केवल एंड्रॉइड स्टूडियो 3.0 पूर्वावलोकन में काम करता है। यह मेरे लिए एंड्रॉइड स्टूडियो 2.3.3 पर काम नहीं करता था। आशा है कि किसी को कुछ समय बचाता है!
— तश पेम्हिवा
2
आप एक टुकड़ा के भीतर से फ़ॉन्ट कैसे प्राप्त कर सकते हैं क्योंकि आप अभी नहीं कर सकते हैं getResources()? संपादित करें : आपके उत्तर के अंत में इस पंक्ति ने मेरे लिए काम किया: Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
— विरोधाभास
कैलीग्राफी की तुलना में किसी तरह इसने मेरे मामले में फॉन्ट को भ्रष्ट बना दिया। इसके अलावा FontWeight कुछ भी नहीं करता है
— सिंह Droidcoder
@LeoDroidcoder यह काम करता है, सुनिश्चित करें कि आपने दोनों का उपयोग किया है android:fontWeightऔरapp:fontWeight
— मनोहर रेड्डी
मैंने कई बार जाँच की। कोई असर नहीं है।
— लियो डायरोडकर 13
100

मुझे /system/etc/fonts.xmlहाल ही में एक प्रोजेक्ट में पार्स करना था । यहाँ लॉलीपॉप के रूप में वर्तमान फ़ॉन्ट परिवार हैं:

╔════╦════════════════════════════╦═════════════════════════════╗
║    ║ FONT FAMILY                ║ TTF FILE                    ║
╠════╬════════════════════════════╬═════════════════════════════╣
║  1 ║ casual                     ║ ComingSoon.ttf              ║
║  2 ║ cursive                    ║ DancingScript-Regular.ttf   ║
║  3 ║ monospace                  ║ DroidSansMono.ttf           ║
║  4 ║ sans-serif                 ║ Roboto-Regular.ttf          ║
║  5 ║ sans-serif-black           ║ Roboto-Black.ttf            ║
║  6 ║ sans-serif-condensed       ║ RobotoCondensed-Regular.ttf ║
║  7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf   ║
║  8 ║ sans-serif-light           ║ Roboto-Light.ttf            ║
║  9 ║ sans-serif-medium          ║ Roboto-Medium.ttf           ║
║ 10 ║ sans-serif-smallcaps       ║ CarroisGothicSC-Regular.ttf ║
║ 11 ║ sans-serif-thin            ║ Roboto-Thin.ttf             ║
║ 12 ║ serif                      ║ NotoSerif-Regular.ttf       ║
║ 13 ║ serif-monospace            ║ CutiveMono.ttf              ║
╚════╩════════════════════════════╩═════════════════════════════╝

यहाँ पार्सर है ( FontListParser बंद ):

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.util.Xml;

/**
 * Helper class to get the current font families on an Android device.</p>
 * 
 * Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>
 */
public final class FontListParser {

    private static final File FONTS_XML = new File("/system/etc/fonts.xml");

    private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");

    public static List<SystemFont> getSystemFonts() throws Exception {
        String fontsXml;
        if (FONTS_XML.exists()) {
            fontsXml = FONTS_XML.getAbsolutePath();
        } else if (SYSTEM_FONTS_XML.exists()) {
            fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();
        } else {
            throw new RuntimeException("fonts.xml does not exist on this system");
        }
        Config parser = parse(new FileInputStream(fontsXml));
        List<SystemFont> fonts = new ArrayList<>();

        for (Family family : parser.families) {
            if (family.name != null) {
                Font font = null;
                for (Font f : family.fonts) {
                    font = f;
                    if (f.weight == 400) {
                        break;
                    }
                }
                SystemFont systemFont = new SystemFont(family.name, font.fontName);
                if (fonts.contains(systemFont)) {
                    continue;
                }
                fonts.add(new SystemFont(family.name, font.fontName));
            }
        }

        for (Alias alias : parser.aliases) {
            if (alias.name == null || alias.toName == null || alias.weight == 0) {
                continue;
            }
            for (Family family : parser.families) {
                if (family.name == null || !family.name.equals(alias.toName)) {
                    continue;
                }
                for (Font font : family.fonts) {
                    if (font.weight == alias.weight) {
                        fonts.add(new SystemFont(alias.name, font.fontName));
                        break;
                    }
                }
            }
        }

        if (fonts.isEmpty()) {
            throw new Exception("No system fonts found.");
        }

        Collections.sort(fonts, new Comparator<SystemFont>() {

            @Override
            public int compare(SystemFont font1, SystemFont font2) {
                return font1.name.compareToIgnoreCase(font2.name);
            }

        });

        return fonts;
    }

    public static List<SystemFont> safelyGetSystemFonts() {
        try {
            return getSystemFonts();
        } catch (Exception e) {
            String[][] defaultSystemFonts = {
                    {
                            "cursive", "DancingScript-Regular.ttf"
                    }, {
                            "monospace", "DroidSansMono.ttf"
                    }, {
                            "sans-serif", "Roboto-Regular.ttf"
                    }, {
                            "sans-serif-light", "Roboto-Light.ttf"
                    }, {
                            "sans-serif-medium", "Roboto-Medium.ttf"
                    }, {
                            "sans-serif-black", "Roboto-Black.ttf"
                    }, {
                            "sans-serif-condensed", "RobotoCondensed-Regular.ttf"
                    }, {
                            "sans-serif-thin", "Roboto-Thin.ttf"
                    }, {
                            "serif", "NotoSerif-Regular.ttf"
                    }
            };
            List<SystemFont> fonts = new ArrayList<>();
            for (String[] names : defaultSystemFonts) {
                File file = new File("/system/fonts", names[1]);
                if (file.exists()) {
                    fonts.add(new SystemFont(names[0], file.getAbsolutePath()));
                }
            }
            return fonts;
        }
    }

    /* Parse fallback list (no names) */
    public static Config parse(InputStream in) throws XmlPullParserException, IOException {
        try {
            XmlPullParser parser = Xml.newPullParser();
            parser.setInput(in, null);
            parser.nextTag();
            return readFamilies(parser);
        } finally {
            in.close();
        }
    }

    private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {
        Alias alias = new Alias();
        alias.name = parser.getAttributeValue(null, "name");
        alias.toName = parser.getAttributeValue(null, "to");
        String weightStr = parser.getAttributeValue(null, "weight");
        if (weightStr == null) {
            alias.weight = 0;
        } else {
            alias.weight = Integer.parseInt(weightStr);
        }
        skip(parser); // alias tag is empty, ignore any contents and consume end tag
        return alias;
    }

    private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        Config config = new Config();
        parser.require(XmlPullParser.START_TAG, null, "familyset");
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            if (parser.getName().equals("family")) {
                config.families.add(readFamily(parser));
            } else if (parser.getName().equals("alias")) {
                config.aliases.add(readAlias(parser));
            } else {
                skip(parser);
            }
        }
        return config;
    }

    private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,
            IOException {
        String name = parser.getAttributeValue(null, "name");
        String lang = parser.getAttributeValue(null, "lang");
        String variant = parser.getAttributeValue(null, "variant");
        List<Font> fonts = new ArrayList<Font>();
        while (parser.next() != XmlPullParser.END_TAG) {
            if (parser.getEventType() != XmlPullParser.START_TAG) {
                continue;
            }
            String tag = parser.getName();
            if (tag.equals("font")) {
                String weightStr = parser.getAttributeValue(null, "weight");
                int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);
                boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));
                String filename = parser.nextText();
                String fullFilename = "/system/fonts/" + filename;
                fonts.add(new Font(fullFilename, weight, isItalic));
            } else {
                skip(parser);
            }
        }
        return new Family(name, fonts, lang, variant);
    }

    private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
        int depth = 1;
        while (depth > 0) {
            switch (parser.next()) {
            case XmlPullParser.START_TAG:
                depth++;
                break;
            case XmlPullParser.END_TAG:
                depth--;
                break;
            }
        }
    }

    private FontListParser() {

    }

    public static class Alias {

        public String name;

        public String toName;

        public int weight;
    }

    public static class Config {

        public List<Alias> aliases;

        public List<Family> families;

        Config() {
            families = new ArrayList<Family>();
            aliases = new ArrayList<Alias>();
        }

    }

    public static class Family {

        public List<Font> fonts;

        public String lang;

        public String name;

        public String variant;

        public Family(String name, List<Font> fonts, String lang, String variant) {
            this.name = name;
            this.fonts = fonts;
            this.lang = lang;
            this.variant = variant;
        }

    }

    public static class Font {

        public String fontName;

        public boolean isItalic;

        public int weight;

        Font(String fontName, int weight, boolean isItalic) {
            this.fontName = fontName;
            this.weight = weight;
            this.isItalic = isItalic;
        }

    }

    public static class SystemFont {

        public String name;

        public String path;

        public SystemFont(String name, String path) {
            this.name = name;
            this.path = path;
        }

    }
}

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

एक छोटा सा अधूरा उदाहरण:

final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();
String[] items = new String[fonts.size()];
for (int i = 0; i < fonts.size(); i++) {
    items[i] = fonts.get(i).name;
}

new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        FontListParser.SystemFont selectedFont = fonts.get(which);
        // TODO: do something with the font
        Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();
    }
}).show();
— जारेड रुम्मलर
स्रोत
क्या आप जानते हैं कि एंड्रॉइड के किस संस्करण में कौन सा फ़ॉन्ट जोड़ा गया है?
— Android डेवलपर
@androiddeveloper I नहीं। आप शायद यहां के परिवर्तनों को देखकर पता लगा सकते हैं: github.com/android/platform_frameworks_base/blob/…
— Jared Rummler
@JaredRummler, मेरी अज्ञानता को क्षमा करें। क्यों / क्या वजन == 400 है?
— शमूएल
1
@Samuel मैंने थोड़ी देर में इस कोड को नहीं देखा है, लेकिन "सामान्य" या "नियमित" फोंट के लिए 400 फ़ॉन्ट वजन का उपयोग किया जाता है। उदाहरण के लिए, रोबोटो-रेग्युलर का वजन 400 है।
— जेरेड रुम्मलर
क्या इसके लिए रूट या कुछ और चाहिए? मैंने इस कोड को एंड्रॉइड एमुलेटर (संस्करण 8.1) पर चलाया, और जब मैंने फोन किया getSystemFonts(), तो मुझे एक अपवाद मिलाorg.xmlpull.v1.XmlPullParserException: END_TAG expected (position:START_TAG (empty) <axis tag='wdth' stylevalue='100.0'>@219:51 in java.io.InputStreamReader@f001fb3)
— डेमन वेजिटेबल्स
49

Android आपको XML लेआउट से कस्टम फोंट सेट करने की अनुमति नहीं देता है। इसके बजाय, आपको अपने ऐप के संपत्ति फ़ोल्डर में विशिष्ट फ़ॉन्ट फ़ाइल को बंडल करना होगा, और इसे प्रोग्रामेटिक रूप से सेट करना होगा। कुछ इस तरह:

TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);

ध्यान दें कि आप इस कोड को setContentView () के बाद ही चला सकते हैं। इसके अलावा, केवल कुछ फोंट एंड्रॉइड द्वारा समर्थित हैं, और एक .ttf (TrueType)या .otf (OpenType)प्रारूप में होना चाहिए । फिर भी, कुछ फोंट काम नहीं कर सकते हैं।

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

Android O अपडेट: यह अब रोजर की टिप्पणी के आधार पर Android O में XML के साथ संभव है ।

— राघव सूद
स्रोत
"Android आपको XML लेआउट से कस्टम फोंट सेट करने की अनुमति नहीं देता है।" इसे Android O में बदल दिया गया है, जो आपको अनुकूलित फ़ॉन्ट परिवार बनाने और XML में उन्हें लागू करने की अनुमति देता है: developer.android.com/preview/features/working-with-fonts.html
— रोजर हुआंग
25

यह वैसा ही है android:typeface।

निर्मित फोंट हैं:

  • साधारण
  • बिना
  • सेरिफ़
  • monospace

Android देखें : टाइपफेस ।

— biegleux
स्रोत
4
मुझे नहीं लगता कि यह एक ही बात है, लेकिन ऐसा लगता है कि हम दोनों का उपयोग नहीं कर सकते। ऐसा लगता है कि अब तीन अलग-अलग विशेषताओं से कम कोई मैप नहीं है setTypeface()। अर्थात् fontFamily, typefaceऔर textStyle। लेकिन मैं अपने जीवन के लिए यह पता नहीं लगा सकता कि ठोस टाइपफेस उदाहरण को हल करने के लिए ये कैसे संयुक्त हैं। क्या किसी ने यह पता लगाया है? गूगल का डॉक्यूमेंटेशन मददगार से कम ...
— रेड हैरिंग
23

यदि आप इसे प्रोग्रामेटिक रूप से चाहते हैं, तो आप उपयोग कर सकते हैं 

label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);

जहाँ SANS_SERIFआप उपयोग कर सकते हैं:

  • DEFAULT
  • DEFAULT_BOLD
  • MONOSPACE
  • SANS_SERIF
  • SERIF

और जहाँ ITALICआप उपयोग कर सकते हैं:

  • BOLD
  • BOLD_ITALIC
  • ITALIC
  • NORMAL

सभी Android डेवलपर्स पर कहा गया है

— जोक्विन इराचुक
स्रोत
15

मैं क्रिस Jenx द्वारा उत्कृष्ट पुस्तकालय सुलेख का उपयोग कर रहा हूँ ताकि आप अपने एंड्रॉइड एप्लिकेशन में कस्टम फोंट का उपयोग कर सकें। कोशिश करो!

— gauravdott
स्रोत
हां, लेकिन उदाहरण के लिए मैं इसे फंक्शननल का उपयोग करना चाहता हूं, लेकिन सभी लाइब्रेरी को लागू नहीं करना चाहता;)
— मोरोज़ोव
12

आप जो चाहते हैं वह संभव नहीं है। आपको TypeFaceअपने कोड में सेट करना होगा ।

में XMLआप क्या कर सकते है

android:typeface="sans" | "serif" | "monospace"

अन्य तो यह आप XML में फ़ॉन्ट्स के साथ ज्यादा नहीं खेल सकते हैं। :)

इसके लिए Arialआपको अपने कोड में टाइप फेस सेट करना होगा।

— मोहसिन नईम
स्रोत
11

फोंट का प्रबंधन करने का एक आसान तरीका उन्हें संसाधनों के माध्यम से घोषित करना होगा, जैसे:

<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>

<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>

<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

यह यहाँ और यहाँ स्रोत कोड पर आधारित है

— Android डेवलपर
स्रोत
उन्हें कहां घोषित किया जाए?
— AZ_
@AZ_ कई संसाधन फ़ाइलों की तरह, आप इसे किसी भी XML फ़ाइल में रख सकते हैं, जो "res / मान / फ़ोल्डर" के अंदर है। उदाहरण के लिए, इसे "Res / मान / फोंट। Xml" में डालें। और, इसका उपयोग करने के लिए, उदाहरण के लिए इस तरह से करें: android: fontFamily = "string / fontFamily__roboto_ अनियमित"
— Android डेवलपर
धन्यवाद, मैं इस github.com/norbsoft/android-typeface-helper का उपयोग कर रहा हूं और यह वास्तव में मददगार है
— AZ_
ठीक है, लाइब्रेरी शायद इसे प्रोग्राम करने के लिए है। यहाँ यह XML के लिए है
— Android डेवलपर
9

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

For Custom font:

 TextView tv = ((TextView) v.findViewById(R.id.select_item_title));
 Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf"); 
 tv.setTypeface(face);

For Default font:

 tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));

ये डिफ़ॉल्ट फॉन्ट परिवार की सूची है , इसका उपयोग दोहरे उद्धरण स्ट्रिंग "सैंस-सेरिफ़-मीडियम" के स्थान पर करें।

FONT FAMILY                    TTF FILE                    

1  casual                      ComingSoon.ttf              
2  cursive                     DancingScript-Regular.ttf   
3  monospace                   DroidSansMono.ttf           
4  sans-serif                  Roboto-Regular.ttf          
5  sans-serif-black            Roboto-Black.ttf            
6  sans-serif-condensed        RobotoCondensed-Regular.ttf 
7  sans-serif-condensed-light  RobotoCondensed-Light.ttf   
8  sans-serif-light            Roboto-Light.ttf            
9  sans-serif-medium           Roboto-Medium.ttf           
10  sans-serif-smallcaps       CarroisGothicSC-Regular.ttf 
11  sans-serif-thin            Roboto-Thin.ttf             
12  serif                      NotoSerif-Regular.ttf       
13  serif-monospace            CutiveMono.ttf

"mycustomfont.ttf" ttf फ़ाइल है। पथ में हो जाएगा src / संपत्ति / फोंट / mycustomfont.ttf , तो आप इस में डिफ़ॉल्ट फ़ॉन्ट के बारे में अधिक उल्लेख कर सकते हैं डिफ़ॉल्ट फ़ॉन्ट परिवार

— आनंद क्रिश
स्रोत
9 
Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);

क्रमबद्ध रूप से Res> फॉन्ट डायरेक्टरी से किसी भी टेक्स्टव्यू को आसानी से फ़ॉन्ट सेट करें

— मैक्वीन
स्रोत
7

मुझे लगता है कि मुझे बहुत देर हो चुकी है लेकिन शायद यह समाधान दूसरों के लिए मददगार है। कस्टम फ़ॉन्ट का उपयोग करने के लिए अपनी फ़ॉन्ट निर्देशिका में अपनी फ़ॉन्ट फ़ाइल रखें।

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));
— रेहान सरवर
स्रोत
6

कुछ परीक्षण और त्रुटि के साथ मैंने निम्नलिखित सीखा।

* .Xml के भीतर आप स्टॉक फोंट को निम्नलिखित कार्यों के साथ जोड़ सकते हैं, न केवल टाइपफेस के साथ:

 android:fontFamily="serif" 
 android:textStyle="italic"

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

5

Android का मान्य मान: fontFamily /system/etc/system_fonts.xml(4.x) या /system/etc/fonts.xml(5.x) में परिभाषित किया गया है। लेकिन डिवाइस निर्माता इसे संशोधित कर सकता है, इसलिए फॉन्टफैमिली मान सेट करके उपयोग किया जाने वाला वास्तविक फ़ॉन्ट निर्दिष्ट डिवाइस के उपर्युक्त फ़ाइल पर निर्भर करता है।

AOSP में, एरियल फ़ॉन्ट मान्य है, लेकिन इसे "एरियल" नहीं "एरियल" का उपयोग करके परिभाषित किया जाना चाहिए, उदाहरण के लिए android: fontFamily = "arial" । किटकैट के system_fonts.xml पर एक क्विक लुक दें

    <family>
    <nameset>
        <name>sans-serif</name>
        <name>arial</name>
        <name>helvetica</name>
        <name>tahoma</name>
        <name>verdana</name>
    </nameset>
    <fileset>
        <file>Roboto-Regular.ttf</file>
        <file>Roboto-Bold.ttf</file>
        <file>Roboto-Italic.ttf</file>
        <file>Roboto-BoldItalic.ttf</file>
    </fileset>
</family>

////////////////////////////////////////////////// ////////////////////////

लेआउट में "फ़ॉन्ट" को परिभाषित करने के लिए तीन प्रासंगिक xml- विशेषताएँ हैं- android: fontFamily , android: typeface और android: textStyle । "FontFamily" और "textStyle" या "typeface" और "textStyle" के संयोजन का उपयोग पाठ में फ़ॉन्ट की उपस्थिति को बदलने के लिए किया जा सकता है, इसलिए इसका उपयोग अकेले किया जाता है। इस तरह से TextView.java में कोड स्निपेट :

    private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {
    Typeface tf = null;
    if (familyName != null) {
        tf = Typeface.create(familyName, styleIndex);
        if (tf != null) {
            setTypeface(tf);
            return;
        }
    }
    switch (typefaceIndex) {
        case SANS:
            tf = Typeface.SANS_SERIF;
            break;

        case SERIF:
            tf = Typeface.SERIF;
            break;

        case MONOSPACE:
            tf = Typeface.MONOSPACE;
            break;
    }
    setTypeface(tf, styleIndex);
}


    public void setTypeface(Typeface tf, int style) {
    if (style > 0) {
        if (tf == null) {
            tf = Typeface.defaultFromStyle(style);
        } else {
            tf = Typeface.create(tf, style);
        }

        setTypeface(tf);
        // now compute what (if any) algorithmic styling is needed
        int typefaceStyle = tf != null ? tf.getStyle() : 0;
        int need = style & ~typefaceStyle;
        mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);
        mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);
    } else {
        mTextPaint.setFakeBoldText(false);
        mTextPaint.setTextSkewX(0);
        setTypeface(tf);
    }
}

कोड से हम देख सकते हैं:

  1. यदि "fontFamily" सेट है, तो "टाइपफेस" को नजरअंदाज कर दिया जाएगा।
  2. "टाइपफेस" में मानक और सीमित वैध मूल्य हैं। वास्तव में, मान "सामान्य" "सैंस" "सेरिफ़" और "मोनोस्पेस" हैं, वे system_fonts.xml (4.x) या फोंट। Xml (5.x) में पाए जा सकते हैं। वास्तव में "सामान्य" और "संस" दोनों ही सिस्टम का डिफ़ॉल्ट फ़ॉन्ट हैं।
  3. "fontFamily" का उपयोग बिल्ड-इन फोंट के सभी फोंट को सेट करने के लिए किया जा सकता है, जबकि "टाइपफेस" केवल "सैंस-सेरिफ़" "सेरिफ़" और "मोनोस्पेस" (दुनिया में फ़ॉन्ट प्रकार की तीन मुख्य श्रेणी) के विशिष्ट फोंट प्रदान करता है। ।
  4. जब केवल "textStyle" सेट करते हैं, तो हम वास्तव में डिफ़ॉल्ट फ़ॉन्ट और निर्दिष्ट शैली सेट करते हैं। प्रभावी मूल्य "सामान्य" "बोल्ड" "इटैलिक" और "बोल्ड | इटैलिक" हैं।
— टेरी लियू
स्रोत
4

यहां एक आसान वा वाई है जो कुछ मामलों में काम कर सकता है। सिद्धांत यह है कि आपके xml लेआउट में एक दृश्यमान TextVview न जोड़ा जाए और जावा कोड में इसके प्रकार को प्राप्त किया जाए ।

Xml फ़ाइल में लेआउट:

 <TextView
        android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:fontFamily="sans-serif-thin"
        android:id="@+id/textViewDescription"/>

और जावा कोड:

myText.setTypeface(textViewSelectedDescription.getTypeface());

इसने मेरे लिए काम किया है (उदाहरण के लिए टेक्स्टस्विच के भीतर)।

— फ़्रेडरिक
स्रोत
4

इसे इस्तेमाल करे:

TextView textview = (TextView) findViewById(R.id.textview);

Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);
— मोहमद शेखी
स्रोत
4

आप इसे नीचे की तरह रेज डायरेक्टरी के तहत एक फॉन्ट फ़ोल्डर जोड़कर भी कर सकते हैं।

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

फिर, संसाधन प्रकार के रूप में फ़ॉन्ट का चयन करना। यहां छवि विवरण दर्ज करें

आप https://www.1001fonts.com/ से उपलब्ध फोंट पा सकते हैं , और फिर इस फॉन्ट डायरेक्टरी में टीटीएफ फाइलें निकाल सकते हैं ।

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

अंत में, बस XML फ़ाइल को बदलें जिसमें आपका टेक्स्ट शामिल हो रहा है android: fontFamily: "@ font / urfontfccenner"

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

— Wolfiebae
स्रोत
बहुत अच्छा, इसके लिए धन्यवाद। idk क्यों दूसरों के पास अधिक तारे हैं, लेकिन आपकी सामग्री डिजाइन पाठ दृश्य के साथ काम करने की पुष्टि की जाती है, आपको app:fontFamily=हालांकि उपयोग करना होगा , बाकी सब कुछ समान है।
— EvOlaNdLuPiZ
YOu ने मेरी जान बचाई, मैंने केवल एक फ़ोल्डर बनाया था जिसका नाम फ़ॉन्ट था और यह काम नहीं किया। वैसे भी मैंने आपके तरीके का इस्तेमाल किया और यह काम किया। धन्यवाद
— हिलाल
4

एक सरल तरीका परियोजना में वांछित फ़ॉन्ट जोड़कर है ।

फ़ाइल पर जाएँ-> नया-> नई संसाधन निर्देशिका फ़ॉन्ट का चयन करें

यह आपके संसाधनों में एक नई निर्देशिका, फ़ॉन्ट बनाएगा ।

अपना फ़ॉन्ट (.ttf) डाउनलोड करें । मैं उसी के लिए https://fonts.google.com का उपयोग करता हूं

उसे अपने फोंट फ़ोल्डर में जोड़ें फिर एक्सएमएल या प्रोग्रामेटिक रूप से उनका उपयोग करें।

XML -

<TextView 
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/your_font"/>

कार्यक्रम -

 Typeface typeface = getResources().getFont(R.font.your_font);
 textView.setTypeface(typeface);
— आकांशी श्रीवास्तव
स्रोत
8
बेहतर उपयोग ResourcesCompat.getFontविधि
— वादिम कोटोव
3 
<string name="font_family_display_4_material">sans-serif-light</string>
<string name="font_family_display_3_material">sans-serif</string>
<string name="font_family_display_2_material">sans-serif</string>
<string name="font_family_display_1_material">sans-serif</string>
<string name="font_family_headline_material">sans-serif</string>
<string name="font_family_title_material">sans-serif-medium</string>
<string name="font_family_subhead_material">sans-serif</string>
<string name="font_family_menu_material">sans-serif</string>
<string name="font_family_body_2_material">sans-serif-medium</string>
<string name="font_family_body_1_material">sans-serif</string>
<string name="font_family_caption_material">sans-serif</string>
<string name="font_family_button_material">sans-serif-medium</string>
— यांग प्योंग
स्रोत
3

यदि आप एक ही फ़ॉन्ट परिवार के साथ इतने सारे स्थानों में TextView का उपयोग करना चाहते हैं, तो TextView वर्ग का विस्तार करें और अपने फ़ॉन्ट को इस तरह सेट करें: -

public class ProximaNovaTextView extends TextView {

    public ProximaNovaTextView(Context context) {
        super(context);

        applyCustomFont(context);
    }

    public ProximaNovaTextView(Context context, AttributeSet attrs) {
        super(context, attrs);

        applyCustomFont(context);
    }

    public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {
       super(context, attrs, defStyle);

       applyCustomFont(context);
    } 

    private void applyCustomFont(Context context) {
        Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);
        setTypeface(customFont);
    }
}

और फिर इस तरह से TextView के लिए xml में इस कस्टम क्लास का उपयोग करें: -

   <com.myapp.customview.ProximaNovaTextView
        android:id="@+id/feed_list_item_name_tv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="14sp"
        />
— शुभम रायतका
स्रोत
3

यदि आप एंड्रॉइड स्टूडियो 3.5+ का उपयोग कर रहे हैं, तो फ़ॉन्ट बदलना सुपर सरल है। डिज़ाइन दृश्य पर पाठ विजेट का चयन करें और विशेषता विंडो पर फ़ॉन्टफ़िली को जांचें। मान ड्रॉपडाउन में सभी उपलब्ध फ़ॉन्ट शामिल हैं जिनसे आप एक का चयन कर सकते हैं। यदि आप Google फ़ॉन्ट्स की तलाश कर रहे हैं, तो अधिक फ़ॉन्ट्स विकल्प पर क्लिक करें।

विंडो को अट्रैक्ट करें विंडो को अट्रैक्ट करें

Google फ़ॉन्ट्स Google फ़ॉन्ट्स

— शिव
स्रोत
2

मैं केवल यह उल्लेख करना चाहता हूं कि एंड्रॉइड के अंदर फोंट के साथ नरक समाप्त होने वाला है, क्योंकि इस वर्ष Google IO पर हमें अंततः यह मिला -> https://developer.android.com/preview/features/working-with-fonts। एचटीएमएल

अब एक नया संसाधन प्रकार एक फ़ॉन्ट है और आप अपने सभी एप्लिकेशन फोंट को रिस / फोंट फ़ोल्डर के अंदर रख सकते हैं और फिर R.font.my_custom_font के साथ उपयोग कर सकते हैं, जैसे आप स्ट्रिंग रिज़ मान, ड्रॉबल रेस मान आदि का उपयोग कर सकते हैं। फ़ॉन्ट-चेहरा बनाने के लिए xml फ़ाइल , जो आपके कस्टम फोंट (इटैलिक, बोल्ड और अंडरलाइन अटर के बारे में) से सेट होने वाली है।

अधिक जानकारी के लिए ऊपर दिए गए लिंक को पढ़ें। चलो समर्थन देखते हैं।

— स्टोचो आंद्रीव
स्रोत
अफसोस की बात है कि यह अभी भी इंटेलीज के साथ काम नहीं करता है (हालांकि एंड्रॉइड स्टूडियो 3.0+ पर एक आकर्षण की तरह काम कर रहा है)।
— डोमिनिकस के।
हां, लेकिन Redmanउपर्युक्त उपयोगकर्ता का उत्तर अभी भी समाधान का एक आवश्यक हिस्सा है।
— जंगलबेदेव
2

इसके लिए एक अच्छा पुस्तकालय उपलब्ध है 

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
— शिवम यादव
स्रोत
इस लाइब्रेरी isu का उपयोग संपूर्ण एप्लिकेशन में सभी विचारों के फ़ॉन्ट बदलने के लिए किया जाता है। यह एडाप्टर दृश्य जैसे सूची दृश्य के लिए लागू नहीं है। उसके लिए हमें विशेष रूप से प्रत्येक एडेप्टर में कोड जोड़ना होगा
— सेंथिलवेल एस
2

नए फ़ॉन्ट संसाधन fontका उपयोग करके सीधे सेट करने की अनुमति देता है

android:fontFamily="@font/my_font_in_font_folder"
— अजीज
स्रोत
1

आप शैली को इस res/layout/value/style.xmlतरह सेट करते हैं:

<style name="boldText">
    <item name="android:textStyle">bold|italic</item>
    <item name="android:textColor">#FFFFFF</item>
</style>

और इस शैली को main.xmlफ़ाइल उपयोग में उपयोग करने के लिए:

style="@style/boldText"
— राजेन्द्र
स्रोत
1

एंड्रॉइड-स्टूडियो 3 और इसके बाद के लिए आप इस शैली का उपयोग कर सकते हैं और फिर सभी textView ऐप में फ़ॉन्ट बदल सकते हैं।

इस शैली को अपने में बनाएँ style.xml:

<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="android:Widget.TextView">
        <item name="android:fontFamily">@font/your_custom_font</item>
</style>

फिर इसे अपने विषय में उपयोग करें:

<!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <item name="android:textViewStyle">@style/defaultTextViewStyle</item>
    </style>
— अली खाकी
स्रोत
1

किसी पाठ दृश्य में प्रोग्राम को फ़ॉन्ट जोड़ने का सबसे आसान तरीका है , सबसे पहले, प्रोजेक्ट में अपने एसेट्स फ़ोल्डर में फ़ॉन्ट फ़ाइल जोड़ें। उदाहरण के लिए आपका फ़ॉन्ट पथ इस तरह दिख रहा है:assets/fonts/my_font.otf

और इसे TextView में जोड़ें:

Kotlin

val font_path = "fonts/my_font.otf"  

myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)

textView.typeface = myTypeface

जावा

String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);
— पांडा भालू
स्रोत
0

यहां आप सभी उपलब्ध फॉन्टामाइली मान देख सकते हैं और यह संबंधित फ़ॉन्ट फ़ाइल के नाम हैं (यह फ़ाइल एंड्रॉइड 5.0+ में उपयोग कर रही है)। मोबाइल डिवाइस में, आप इसे पा सकते हैं:

/system/etc/fonts.xml (5.0+ के लिए)

(Android 4.4 और इस संस्करण का उपयोग करने के लिए नीचे , लेकिन मुझे लगता है कि fonts.xmlइसका अधिक स्पष्ट प्रारूप है और समझने में आसान है।)

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

    <!-- first font is default -->
20    <family name="sans-serif">
21        <font weight="100" style="normal">Roboto-Thin.ttf</font>
22        <font weight="100" style="italic">Roboto-ThinItalic.ttf</font>
23        <font weight="300" style="normal">Roboto-Light.ttf</font>
24        <font weight="300" style="italic">Roboto-LightItalic.ttf</font>
25        <font weight="400" style="normal">Roboto-Regular.ttf</font>
26        <font weight="400" style="italic">Roboto-Italic.ttf</font>
27        <font weight="500" style="normal">Roboto-Medium.ttf</font>
28        <font weight="500" style="italic">Roboto-MediumItalic.ttf</font>
29        <font weight="900" style="normal">Roboto-Black.ttf</font>
30        <font weight="900" style="italic">Roboto-BlackItalic.ttf</font>
31        <font weight="700" style="normal">Roboto-Bold.ttf</font>
32        <font weight="700" style="italic">Roboto-BoldItalic.ttf</font>
33    </family>

नाम विशेषता name="sans-serif"के familyFontFamily: टैग मान आप एंड्रॉयड में उपयोग कर सकते हैं परिभाषित किया।

fontटैग corresponded फ़ॉन्ट फ़ाइलों परिभाषित करते हैं।

इस मामले में, आप स्रोत को अनदेखा कर सकते हैं <!-- fallback fonts -->, यह फोंट के फालबैक तर्क के लिए उपयोग कर रहा है।

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