इस पेज का अनुवाद Cloud Translation API से किया गया है.

स्ट्रिंग रिसॉर्स

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

String: एक्सएमएल संसाधन, जो सिंगल स्ट्रिंग देता है.
स्ट्रिंग अरे: स्ट्रिंग का कलेक्शन देने वाला एक्सएमएल रिसॉर्स.
संख्या वाली स्ट्रिंग (बहुवचन): एक्सएमएल रिसॉर्स, जिसमें बहुवचन के लिए अलग-अलग स्ट्रिंग इस्तेमाल की गई हैं.

सभी स्ट्रिंग में कुछ स्टाइलिंग मार्कअप और फ़ॉर्मैटिंग आर्ग्युमेंट का इस्तेमाल किया जा सकता है. इसके लिए स्ट्रिंग की स्टाइल और फ़ॉर्मैटिंग के बारे में जानने के लिए, फ़ॉर्मैटिंग और स्टाइलिंग वाला सेक्शन देखें.

स्ट्रिंग

एक ऐसी स्ट्रिंग जिसे ऐप्लिकेशन या दूसरी संसाधन फ़ाइलों (जैसे कि (एक्सएमएल लेआउट के तौर पर).

ध्यान दें: स्ट्रिंग एक सामान्य रिसॉर्स होता है, जिसका रेफ़रंस दिया जाता है name एट्रिब्यूट में दी गई वैल्यू का इस्तेमाल करके (एक्सएमएल फ़ाइल का नाम नहीं). इसलिए, आप एक एक्सएमएल फ़ाइल में स्ट्रिंग रिसॉर्स को दूसरे सामान्य रिसॉर्स के साथ मिलाता है, एक <resources> एलिमेंट के तहत.

फ़ाइल की जगह:

res/values/filename.xml
फ़ाइल नाम आर्बिट्रेरी है. <string> एलिमेंट के name का इस्तेमाल इस तरह किया जाता है: संसाधन आईडी का इस्तेमाल करें.

कंपाइल किए गए संसाधन डेटा टाइप:

String के लिए रिसॉर्स पॉइंटर.

संसाधन का रेफ़रंस:

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है Java में: R.string.string_name
एक्सएमएल में:@string/string_name

सिंटैक्स:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string
        name="string_name"
        >text_string</string>
</resources>

एलिमेंट:

उदाहरण:

एक्सएमएल फ़ाइल res/values/strings.xml पर सेव की गई:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello!</string>
</resources>

यह लेआउट एक्सएमएल किसी व्यू पर स्ट्रिंग लागू करता है:

<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello" />

यह ऐप्लिकेशन कोड फिर से स्ट्रिंग हासिल करता है:

Kotlin

val string: String = getString(R.string.hello)

Java

String string = getString(R.string.hello);

getString(int) या स्ट्रिंग वापस पाने के लिए getText(int). getText(int), स्ट्रिंग पर लागू की गई रिच टेक्स्ट स्टाइल को बनाए रखता है.

स्ट्रिंग अरे

स्ट्रिंग का कलेक्शन, जिसे ऐप्लिकेशन से रेफ़रंस लिया जा सकता है.

ध्यान दें: स्ट्रिंग अरे एक सामान्य रिसॉर्स होता है, जिसका रेफ़रंस दिया जाता है name एट्रिब्यूट में दी गई वैल्यू का इस्तेमाल करके (एक्सएमएल फ़ाइल का नाम नहीं). जैसे इसका मतलब है कि एक एक्सएमएल फ़ाइल में, स्ट्रिंग अरे के रिसॉर्स को दूसरे सामान्य रिसॉर्स के साथ जोड़ा जा सकता है, एक <resources> एलिमेंट के तहत.

फ़ाइल की जगह:

res/values/filename.xml
फ़ाइल नाम आर्बिट्रेरी है. <string-array> एलिमेंट के name का इस्तेमाल इस तरह किया जाता है: संसाधन आईडी का इस्तेमाल करें.

कंपाइल किए गए संसाधन डेटा टाइप:

String की कलेक्शन के लिए रिसॉर्स पॉइंटर.

संसाधन का रेफ़रंस:

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है Java में: R.array.string_array_name
एक्सएमएल में: @[package:]array/string_array_name

सिंटैक्स:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array
        name="string_array_name">
        <item
            >text_string</item>
    </string-array>
</resources>

एलिमेंट:

उदाहरण:

एक्सएमएल फ़ाइल res/values/strings.xml पर सेव की गई:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="planets_array">
        <item>Mercury</item>
        <item>Venus</item>
        <item>Earth</item>
        <item>Mars</item>
    </string-array>
</resources>

यह ऐप्लिकेशन कोड स्ट्रिंग अरे को फिर से हासिल करता है:

Kotlin

val array: Array<String> = resources.getStringArray(R.array.planets_array)

Java

Resources res = getResources();
String[] planets = res.getStringArray(R.array.planets_array);

संख्या वाली स्ट्रिंग (बहुवचन)

अलग-अलग भाषाओं में मात्रा के साथ व्याकरण के अनुबंध के लिए अलग-अलग नियम हैं. अंग्रेज़ी में, उदाहरण के लिए, संख्या 1 एक खास मामला है. हम "1 पुस्तक" लिखते हैं, लेकिन किसी अन्य मात्रा के लिए "n Books" लिखें. एकवचन और बहुवचन के बीच यह फ़र्क़ बहुत आम है, लेकिन कुछ और भाषाओं के बीच का अंतर ज़्यादा बारीकी से नज़र आता है. Android पर काम करने वाला पूरा सेट zero है, one, two, few, many, और other.

किसी भाषा और संख्या के लिए कौनसा केस इस्तेमाल करना है, यह तय करने के नियम बहुत जटिल हो सकते हैं. इसलिए Android आपको ऐसे तरीके उपलब्ध कराता है चुनने के लिए getQuantityString() आपके लिए सही संसाधन चुनें.

हालांकि, इसे ऐतिहासिक तौर पर "संख्या स्ट्रिंग" कहा जाता था (और इसे अब भी एपीआई में कहा जाता है), संख्या स्ट्रिंग का इस्तेमाल सिर्फ़ बहुवचन के लिए किया जाना चाहिए. संख्या वाली स्ट्रिंग का इस्तेमाल करना गलत होगा Gmail के "इनबॉक्स" जैसा कुछ लागू करें बनाम "इनबॉक्स (12)" अगर नहीं पढ़े गए मैसेज हों, तो उदाहरण के लिए. if स्टेटमेंट के बजाय, संख्या वाली स्ट्रिंग का इस्तेमाल करना ज़्यादा आसान लग सकता है, लेकिन यह ध्यान रखना ज़रूरी है कि कुछ भाषाएं (जैसे चीनी) अंतर की पहचान करता है, इसलिए आपको हमेशा other स्ट्रिंग मिलेगी.

इस्तेमाल करने के लिए स्ट्रिंग को पूरी तरह से व्याकरण की ज़रूरी शर्त के आधार पर चुना जाता है. अंग्रेज़ी में, zero के लिए स्ट्रिंग को अनदेखा कर दिया जाता है, भले ही संख्या 0 हो, क्योंकि 0 व्याकरण के हिसाब से 2 से अलग न हो या 1 को छोड़कर किसी भी अन्य संख्या ("शून्य किताबें", "एक किताब", "दो किताबें" वगैरह). इसके उलट, कोरियन में सिर्फ़ other स्ट्रिंग जिनका कभी इस्तेमाल किया गया है.

इस तथ्य से भी गुमराह न हों कि two ऐसा लगता है जो सिर्फ़ इस पर लागू हो सकता है मात्रा 2: किसी भाषा के लिए यह ज़रूरी हो सकता है कि 2, 12, 102 (जैसे कि ऐसे ही अन्य सभी) को एक जैसा समझा जाए दूसरा, लेकिन दूसरी मात्राओं से अलग. अपनी भाषा के बारे में जानने के लिए, अपने अनुवादक पर भरोसा करें उनकी भाषा वास्तव में जोर देती है.

यदि आपके संदेश में मात्रा संख्या नहीं है, तो संभवतः यह एक अच्छा उम्मीदवार नहीं है बहुवचन. उदाहरण के लिए, लिथुआनियन में 1 और 101, दोनों के लिए एकवचन का इस्तेमाल होता है, इसलिए "1 किताब" इससे मेल खाता है "1 knyga" और "101 किताबें" का अनुवाद किया गया है का अनुवाद "101 knyga" के तौर पर किया जाता है. इस बीच, "एक किताब" "निगा" है और "कई किताबें" यह "daug knygø" है. अगर अंग्रेज़ी के बहुवचन वाले मैसेज में "एक किताब" शामिल है (एकवचन) और "कई किताबें" (बहुवचन) बिना तो इसका मतलब "knyga" के रूप में किया जा सकता है (किताब)/"daug knyg $" (कई किताबें), लेकिन लिथुआनियाई नियम, यह "knyga" दिखाएगा (एक किताब), जब संख्या 101 होती है.

मात्रा में न्यूट्रल फ़ॉर्मूला इस्तेमाल करके, अक्सर संख्या वाली स्ट्रिंग से बचा जा सकता है "किताबें: 1". ऐसा करने से आपका और आपके अनुवादकों का अगर यह आपके ऐप्लिकेशन के लिए स्वीकार्य शैली है, तो यह आसान रहता है.

एपीआई 24 या इसके बाद के वर्शन पर, ज़्यादा दमदार ICU MessageFormat का इस्तेमाल किया जा सकता है क्लास का इस्तेमाल करें.

ध्यान दें: बहुवचन वाला कलेक्शन एक आसान संसाधन है, जो name एट्रिब्यूट में दिए गए मान का इस्तेमाल करके रेफ़रंस दिया गया है (एक्सएमएल का नाम नहीं फ़ाइल से लिया जाता है). इसका मतलब है कि बहुवचन वाले संसाधनों को दूसरे आसान संसाधनों के साथ मिलाया जा सकता है एक्सएमएल फ़ाइल, एक <resources> एलिमेंट के नीचे.

फ़ाइल की जगह:

res/values/filename.xml
फ़ाइल नाम आर्बिट्रेरी है. <plurals> एलिमेंट के name का इस्तेमाल इस तरह किया जाता है: संसाधन आईडी का इस्तेमाल करें.

संसाधन का रेफ़रंस:

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है Java में: R.plurals.plural_name

सिंटैक्स:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals
        name="plural_name">
        <item
            quantity=["zero" | "one" | "two" | "few" | "many" | "other"]
            >text_string</item>
    </plurals>
</resources>

एलिमेंट:

<resources>

ज़रूरी है. यह रूट नोड होना चाहिए.

कोई एट्रिब्यूट मौजूद नहीं है.

<plurals>

स्ट्रिंग का कलेक्शन, जिसमें से एक स्ट्रिंग दी जाती है. यह इस बात पर निर्भर करता है कि कितने कुछ. एक या ज़्यादा <item> एलिमेंट शामिल हैं.

विशेषताएं:

name: स्ट्रिंग. स्ट्रिंग के जोड़े का नाम. इस नाम का इस्तेमाल संसाधन आईडी का इस्तेमाल करें.

<item>

कोई बहुवचन या एकवचन स्ट्रिंग. वैल्यू, किसी दूसरी वैल्यू का रेफ़रंस हो सकती है स्ट्रिंग संसाधन. <plurals> एलिमेंट का चाइल्ड होना चाहिए. ध्यान रहे कि आपको से बचें. देखें फ़ॉर्मैटिंग और आपकी स्ट्रिंग को सही तरीके से स्टाइल और फ़ॉर्मैट करने के बारे में जानकारी के लिए, नीचे को स्टाइल किया जा रहा है.

विशेषताएं:

quantity

कीवर्ड. इस स्ट्रिंग का इस्तेमाल कब किया जाना चाहिए, इसके बारे में बताने वाली वैल्यू. मान्य ब्रैकेट में इनके उदाहरण दिए गए हैं:

वैल्यू	ब्यौरा
`zero`	जब भाषा में संख्या 0 पर खास ध्यान देने की ज़रूरत होती है (जैसे कि अरबी).
`one`	जब भाषा के लिए, किसी एक जैसी संख्याओं पर खास ध्यान देने की ज़रूरत हो (जैसा कि अंग्रेज़ी में और ज़्यादातर दूसरी भाषाओं में नंबर 1 के साथ होता है; रशियन में, 1 से खत्म होने वाली कोई भी संख्या 11 पर खत्म नहीं होने वाली कोई भी संख्या इस क्लास में होती है).
`two`	जब भाषा में संख्याओं पर खास ध्यान देने की ज़रूरत हो, जैसे कि दो (जैसे कि वेल्श में 2 या स्लोवेनियाई में 102).
`few`	जब भाषा में "छोटी" का इस्तेमाल करने की ज़रूरत हो नंबर (जैसे कि चेक में 2, 3 और 4 होता है; या वह नंबर जिसके आखिर में 2, 3 या 4 होता है, लेकिन पोलिश में 12, 13 या 14 नहीं).
`many`	जब भाषा में "बड़ा" का खास ध्यान रखने की ज़रूरत हो (जैसे कि माल्टा में 11-99 तक के अंक वाले)
`other`	जब भाषा में दी गई संख्या के लिए खास ध्यान देने की ज़रूरत न हो (जैसा कि चीनी में सभी संख्याओं के साथ या अंग्रेज़ी में 42 के साथ होता है).

उदाहरण:

एक्सएमएल फ़ाइल res/values/strings.xml पर सेव की गई:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals name="numberOfSongsAvailable">
        <!--
             As a developer, you should always supply "one" and "other"
             strings. Your translators will know which strings are actually
             needed for their language. Always include %d in "one" because
             translators will need to use %d for languages where "one"
             doesn't mean 1 (as explained above).
          -->
        <item quantity="one">%d song found.</item>
        <item quantity="other">%d songs found.</item>
    </plurals>
</resources>

एक्सएमएल फ़ाइल को res/values-pl/strings.xml पर सेव किया गया:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals name="numberOfSongsAvailable">
        <item quantity="one">Znaleziono %d piosenkę.</item>
        <item quantity="few">Znaleziono %d piosenki.</item>
        <item quantity="other">Znaleziono %d piosenek.</item>
    </plurals>
</resources>

इस्तेमाल:

Kotlin

val count = getNumberOfSongsAvailable()
val songsFound = resources.getQuantityString(R.plurals.numberOfSongsAvailable, count, count)

Java

int count = getNumberOfSongsAvailable();
Resources res = getResources();
String songsFound = res.getQuantityString(R.plurals.numberOfSongsAvailable, count, count);

getQuantityString() तरीके का इस्तेमाल करते समय, आपको count को दो बार पास करना होगा, अगर आपकी स्ट्रिंग में संख्या के साथ स्ट्रिंग फ़ॉर्मैटिंग. उदाहरण के लिए, %d songs found, पहला count पैरामीटर सही बहुवचन स्ट्रिंग चुनता है और दूसरा count पैरामीटर, %d प्लेसहोल्डर में डाला जाता है. अगर आपका बहुवचन है स्ट्रिंग में स्ट्रिंग फ़ॉर्मैटिंग शामिल नहीं होती है. आपको getQuantityString को तीसरा पैरामीटर पास करने की ज़रूरत नहीं होती है.

फ़ॉर्मैट और स्टाइल

यहां कुछ ज़रूरी बातें दी गई हैं, जो आपको सही तरीके से पता होनी चाहिए फ़ॉर्मैट और स्टाइल में बदलाव कर सकते हैं.

खास वर्णों को हैंडल करना

जब किसी स्ट्रिंग में ऐसे वर्ण हों जिनका एक्सएमएल में खास इस्तेमाल किया गया हो, तो आपको वर्णों को स्टैंडर्ड एक्सएमएल/एचटीएमएल एस्केपिंग नियमों के मुताबिक बनाएं. अगर आपको किसी वर्ण से बचना है जिसका Android में विशेष अर्थ है, आपको पहले बैकस्लैश का उपयोग करना चाहिए.

डिफ़ॉल्ट रूप से Android, खाली सफ़ेद जगह वाले वर्णों के क्रम को एक ही स्पेस में छोटा कर देगा. इससे बचने के लिए, अपनी स्ट्रिंग के काम के हिस्से को डबल कोट में रखें. इस मामले में सभी खाली सफ़ेद जगह वाले वर्ण (नई लाइनें शामिल हैं) कोट किए गए इलाके में सेव कर लिए जाएंगे. डबल कोट की मदद से, सामान्य सिंगल अनएस्केप्ड कोट का भी इस्तेमाल किया जा सकता है.

वर्ण	एस्केप्ड फ़ॉर्म
@	`\@`
?	`\?`
नई लाइन	`\n`
टैब	`\t`
U+XXXX यूनिकोड वर्ण	`\uXXXX`
सिंगल कोट (`'`)	इनमें से कोई भी: `\'` पूरी स्ट्रिंग को डबल कोट में रखें (उदाहरण के लिए, `"This'll work"`)
डबल कोट (`"`)	`\"` ध्यान रखें कि स्ट्रिंग के आस-पास सिंगल कोट काम नहीं करते हैं.

आपके बाद व्हाइटस्पेस छोटा हो जाता है और Android एस्केपिंग होता है रिसॉर्स फ़ाइल को एक्सएमएल के तौर पर पार्स किया जाता है. इसका मतलब है कि <string>    </string> अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है (स्पेस, विराम चिह्न, यूनिकोड एम स्पेस) सभी छोटे होकर एक ही स्पेस में आ जाते हैं (" "), क्योंकि फ़ाइल को एक्सएमएल के तौर पर पार्स करने के बाद, ये सभी यूनिकोड स्पेस हैं. उन स्पेस को वैसा ही सेव रखने के लिए, आपके पास उन्हें कोट करने का विकल्प होता है <string>"    "</string> या Android एस्केपिंग का इस्तेमाल करें (<string> \u0032 \u8200 \u8195</string>).

ध्यान दें: एक्सएमएल पार्सर के हिसाब से, इनमें कोई अंतर नहीं है <string>"Test this"</string> और <string>"Test this"</string> कुछ भी. दोनों रूप कोई कोट नहीं दिखाएगा, लेकिन Android की खाली जगह वाले कोट को ट्रिगर करेगा (इसमें कोई कोट नहीं होगा व्यावहारिक असर होगा).

स्ट्रिंग फ़ॉर्मैट करना

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

<string name="welcome_messages">Hello, %1$s! You have %2$d new messages.</string>

इस उदाहरण में, फ़ॉर्मैट स्ट्रिंग में दो आर्ग्युमेंट हैं: %1$s एक स्ट्रिंग है और %2$d एक दशमलव संख्या है. इसके बाद, getString(int, Object...) पर कॉल करके स्ट्रिंग को फ़ॉर्मैट करें. उदाहरण के लिए:

Kotlin

var text = getString(R.string.welcome_messages, username, mailCount)

Java

String text = getString(R.string.welcome_messages, username, mailCount);

एचटीएमएल मार्कअप की मदद से स्टाइल बनाना

एचटीएमएल मार्कअप की मदद से, अपनी स्ट्रिंग में स्टाइल जोड़ी जा सकती है. उदाहरण के लिए:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="welcome">Welcome to <b>Android</b>!</string>
</resources>

इन एचटीएमएल एलिमेंट का इस्तेमाल किया जा सकता है:

बोल्ड:
इटैलिक: , <citation>, <dfn>,
25% बड़ा टेक्स्ट: <big>
20% छोटा टेक्स्ट:
फ़ॉन्ट प्रॉपर्टी सेट की जा रही हैं: . के उदाहरण संभावित फ़ॉन्ट फ़ैमिली में monospace, serif, और sans_serif.
मोनोस्पेस फ़ॉन्ट फ़ैमिली सेट करना: <tt>
स्ट्राइकथ्रू: <s>, <strike>, <del>
अंडरलाइन:
सुपरस्क्रिप्ट:
सबस्क्रिप्ट:
बुलेट पॉइंट: <ul>, <li>
लाइन ब्रेक:
विभाजन: <div>
सीएसएस स्टाइल:
पैराग्राफ़:

अगर फ़ॉर्मैटिंग लागू नहीं की जा रही है, तो सीधे कॉल करके TextView टेक्स्ट सेट किया जा सकता है setText(java.lang.CharSequence). हालांकि, कुछ मामलों में आपको एक स्टाइल टेक्स्ट संसाधन बनाना चाहते हैं जिसका उपयोग फ़ॉर्मैट स्ट्रिंग के रूप में भी किया जा सके. आम तौर पर, यह काम नहीं करता है, क्योंकि format(String, Object...) और getString(int, Object...) तरीकों से पूरा स्टाइल हट जाता है . इसका समाधान यह है कि एचटीएमएल टैग को एस्केप किए गए तरीके से लिखें इकाइयों को fromHtml(String) की मदद से वापस लाया जाता है. तो उन्हें फ़ॉर्मैट किया जा सकता है. उदाहरण के लिए:

अपने स्टाइल वाले टेक्स्ट रिसॉर्स को एचटीएमएल-एस्केप स्ट्रिंग के तौर पर सेव करें:
```
<resources>
 <string name="welcome_messages">Hello, %1$s! You have &lt;b>%2$d new messages&lt;/b>.</string>
</resources>
```
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
फ़ॉर्मैट की गई इस स्ट्रिंग में, एक  एलिमेंट जोड़ा गया है. ध्यान दें कि ओपनिंग ब्रैकेट < नोटेशन का इस्तेमाल करके, एचटीएमएल-एस्केप किया गया.
इसके बाद, स्ट्रिंग को हमेशा की तरह फ़ॉर्मैट करें. हालाँकि, fromHtml(String) को भी कॉल करें एचटीएमएल टेक्स्ट को स्टाइल वाले टेक्स्ट में बदलें:
Kotlin
```
val text: String = getString(R.string.welcome_messages, username, mailCount)
val styledText: Spanned = Html.fromHtml(text, FROM_HTML_MODE_LEGACY)
```
Java
```
String text = getString(R.string.welcome_messages, username, mailCount);
Spanned styledText = Html.fromHtml(text, FROM_HTML_MODE_LEGACY);
```

fromHtml(String) तरीका सभी एचटीएमएल इकाइयों को फ़ॉर्मैट करता है. इसलिए, पक्का करें कि उन स्ट्रिंग में मौजूद किसी भी संभावित एचटीएमएल वर्ण को एस्केप करने के लिए जिनका इस्तेमाल आप फ़ॉर्मैट किए गए टेक्स्ट के साथ करते हैं htmlEncode(String). उदाहरण के लिए, यदि आप कोई ऐसी स्ट्रिंग प्रारूपित कर रहे हैं जिसमें "<" या "&" है, तो उन्हें फ़ॉर्मैट करने से पहले एस्केप किया जाना चाहिए, ताकि फ़ॉर्मैट की गई स्ट्रिंग में को fromHtml(String) से पास कर दिया जाता है, तो वर्ण उसी तरह से बाहर आते हैं जैसे वे थे मूल रूप से लिखा गया. उदाहरण के लिए:

Kotlin

val escapedUsername: String = TextUtils.htmlEncode(username)

val text: String = getString(R.string.welcome_messages, escapedUsername, mailCount)
val styledText: Spanned = Html.fromHtml(text, FROM_HTML_MODE_LEGACY)

Java

String escapedUsername = TextUtils.htmlEncode(username);

String text = getString(R.string.welcome_messages, escapedUsername, mailCount);
Spanned styledText = Html.fromHtml(text);

स्पैनेबल की मदद से स्टाइल करना

Spannable एक टेक्स्ट ऑब्जेक्ट है, जिसकी मदद से स्टाइल बदली जा सकती है टाइपफ़ेस प्रॉपर्टी, जैसे कि रंग और फ़ॉन्ट की मोटाई. आप उपयोग करते हैं बनाने के लिए SpannableStringBuilder अपना टेक्स्ट डालें और फिर android.text.style में तय की गई स्टाइल लागू करें टेक्स्ट में पैकेज जोड़ना.

नीचे दिए गए हेल्पर तरीकों का इस्तेमाल करके, ज़्यादातर काम सेट अप किए जा सकते हैं. स्पैनेबल टेक्स्ट बनाने की प्रोसेस:

Kotlin

/**
 * Returns a CharSequence that concatenates the specified array of CharSequence
 * objects and then applies a list of zero or more tags to the entire range.
 *
 * @param content an array of character sequences to apply a style to
 * @param tags the styled span objects to apply to the content
 *        such as android.text.style.StyleSpan
 */
private fun apply(content: Array<out CharSequence>, vararg tags: Any): CharSequence {
    return SpannableStringBuilder().apply {
        openTags(tags)
        content.forEach { charSequence ->
            append(charSequence)
        }
        closeTags(tags)
    }
}

/**
 * Iterates over an array of tags and applies them to the beginning of the specified
 * Spannable object so that future text appended to the text will have the styling
 * applied to it. Do not call this method directly.
 */
private fun Spannable.openTags(tags: Array<out Any>) {
    tags.forEach { tag ->
        setSpan(tag, 0, 0, Spannable.SPAN_MARK_MARK)
    }
}

/**
 * "Closes" the specified tags on a Spannable by updating the spans to be
 * endpoint-exclusive so that future text appended to the end will not take
 * on the same styling. Do not call this method directly.
 */
private fun Spannable.closeTags(tags: Array<out Any>) {
    tags.forEach { tag ->
    if (length > 0) {
            setSpan(tag, 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
        } else {
            removeSpan(tag)
        }
    }
}

Java

/**
 * Returns a CharSequence that concatenates the specified array of CharSequence
 * objects and then applies a list of zero or more tags to the entire range.
 *
 * @param content an array of character sequences to apply a style to
 * @param tags the styled span objects to apply to the content
 *        such as android.text.style.StyleSpan
 *
 */
private static CharSequence applyStyles(CharSequence[] content, Object[] tags) {
    SpannableStringBuilder text = new SpannableStringBuilder();
    openTags(text, tags);
    for (CharSequence item : content) {
        text.append(item);
    }
    closeTags(text, tags);
    return text;
}

/**
 * Iterates over an array of tags and applies them to the beginning of the specified
 * Spannable object so that future text appended to the text will have the styling
 * applied to it. Do not call this method directly.
 */
private static void openTags(Spannable text, Object[] tags) {
    for (Object tag : tags) {
        text.setSpan(tag, 0, 0, Spannable.SPAN_MARK_MARK);
    }
}

/**
 * "Closes" the specified tags on a Spannable by updating the spans to be
 * endpoint-exclusive so that future text appended to the end will not take
 * on the same styling. Do not call this method directly.
 */
private static void closeTags(Spannable text, Object[] tags) {
    int len = text.length();
    for (Object tag : tags) {
        if (len > 0) {
            text.setSpan(tag, 0, len, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        } else {
            text.removeSpan(tag);
        }
    }
}

bold, italic, और color तरीकों में, ऊपर बताए गए हेल्पर तरीकों को रैप किया जाता है और लागू करने के खास उदाहरण दिखाए जाते हैं android.text.style पैकेज में परिभाषित स्टाइल. आपने लोगों तक पहुंचाया मुफ़्त में की मदद से, दूसरी तरह की टेक्स्ट स्टाइलिंग के लिए मिलते-जुलते तरीके बनाए जा सकते हैं.

Kotlin

/**
 * Returns a CharSequence that applies boldface to the concatenation
 * of the specified CharSequence objects.
 */
fun bold(vararg content: CharSequence): CharSequence = apply(content, StyleSpan(Typeface.BOLD))

/**
 * Returns a CharSequence that applies italics to the concatenation
 * of the specified CharSequence objects.
 */
fun italic(vararg content: CharSequence): CharSequence = apply(content, StyleSpan(Typeface.ITALIC))

/**
 * Returns a CharSequence that applies a foreground color to the
 * concatenation of the specified CharSequence objects.
 */
fun color(color: Int, vararg content: CharSequence): CharSequence =
        apply(content, ForegroundColorSpan(color))

Java

/**
 * Returns a CharSequence that applies boldface to the concatenation
 * of the specified CharSequence objects.
 */
public static CharSequence bold(CharSequence... content) {
    return apply(content, new StyleSpan(Typeface.BOLD));
}

/**
 * Returns a CharSequence that applies italics to the concatenation
 * of the specified CharSequence objects.
 */
public static CharSequence italic(CharSequence... content) {
    return apply(content, new StyleSpan(Typeface.ITALIC));
}

/**
 * Returns a CharSequence that applies a foreground color to the
 * concatenation of the specified CharSequence objects.
 */
public static CharSequence color(int color, CharSequence... content) {
    return apply(content, new ForegroundColorSpan(color));
}

यहां एक उदाहरण दिया गया है कि अलग-अलग स्टाइल को एक साथ लागू करने के लिए, इन तरीकों को एक साथ कैसे चेन करें वाक्यांश में शब्द:

Kotlin

// Create an italic "hello, " a red "world",
// and bold the entire sequence.
val text: CharSequence = bold(italic(getString(R.string.hello)),
        color(Color.RED, getString(R.string.world)))

Java

// Create an italic "hello, " a red "world",
// and bold the entire sequence.
CharSequence text = bold(italic(getString(R.string.hello)),
    color(Color.RED, getString(R.string.world)));

Core-ktx Kotlin मॉड्यूल में एक्सटेंशन फ़ंक्शन भी होते हैं जो स्पैन के साथ भी काम करते हैं और भी आसान हो गया है. ज़्यादा जानकारी के लिए, ज़्यादा जानने के लिए, GitHub पर android.text पैकेज दस्तावेज़ देखें.

स्पैन के साथ काम करने के बारे में ज़्यादा जानकारी के लिए, ये लिंक देखें:

एनोटेशन की मदद से स्टाइल बनाना

जटिल या कस्टम स्टाइलिंग लागू करने के लिए, Annotation क्लास के साथ-साथ आपकीstring.xml संसाधन फ़ाइलों में <annotation> टैग होता है. यह एनोटेशन टैग एक्सएमएल में कस्टम की-वैल्यू पेयर तय करके, स्ट्रिंग के हिस्सों को कस्टम स्टाइलिंग के लिए मार्क करें जिसे फिर फ़्रेमवर्क Annotation स्पैन में बदल जाता है. इसके बाद, इन सेगमेंट को वापस पाया जा सकता है एनोटेशन और स्टाइल लागू करने के लिए, कुंजी और वैल्यू का इस्तेमाल करें.

एनोटेशन बनाते समय, <annotation> जोड़ना न भूलें हर स्ट्रिंग.xml फ़ाइल में स्ट्रिंग के सभी अनुवादों के लिए टैग डालें.

सभी भाषाओं में, “टेक्स्ट” शब्द के लिए कस्टम टाइपफ़ेस लागू करना

उदाहरण - पसंद के मुताबिक टाइपफ़ेस जोड़ना

<annotation> टैग जोड़ें और की-वैल्यू पेयर तय करें. इस मामले में, कुंजी font है और मान उस फ़ॉन्ट का प्रकार है जिसे हम इस्तेमाल करना चाहते हैं: title_emphasis
```
// values/strings.xml
<string name="title">Best practices for <annotation font="title_emphasis">text</annotation> on Android</string>

// values-es/strings.xml
<string name="title"><annotation font="title_emphasis">Texto</annotation> en Android: mejores prácticas</string>
```

स्ट्रिंग रिसॉर्स लोड करें और फ़ॉन्ट कुंजी के साथ एनोटेशन ढूंढें. इसके बाद, को अपने हिसाब से स्पैन करने और मौजूदा स्पैन को बदलने के लिए कहा जाता है.

Kotlin

// get the text as SpannedString so we can get the spans attached to the text
val titleText = getText(R.string.title) as SpannedString

// get all the annotation spans from the text
val annotations = titleText.getSpans(0, titleText.length, Annotation::class.java)

// create a copy of the title text as a SpannableString.
// the constructor copies both the text and the spans. so we can add and remove spans
val spannableString = SpannableString(titleText)

// iterate through all the annotation spans
for (annotation in annotations) {
   // look for the span with the key font
   if (annotation.key == "font") {
      val fontName = annotation.value
      // check the value associated to the annotation key
      if (fontName == "title_emphasis") {
         // create the typeface
         val typeface = getFontCompat(R.font.permanent_marker)
         // set the span at the same indices as the annotation
         spannableString.setSpan(CustomTypefaceSpan(typeface),
            titleText.getSpanStart(annotation),
            titleText.getSpanEnd(annotation),
            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
      }
   }
}

// now, the spannableString contains both the annotation spans and the CustomTypefaceSpan
styledText.text = spannableString

Java

// get the text as SpannedString so we can get the spans attached to the text
SpannedString titleText = (SpannedString) getText(R.string.title);

// get all the annotation spans from the text
Annotation[] annotations = titleText.getSpans(0, titleText.length(), Annotation.class);

// create a copy of the title text as a SpannableString.
// the constructor copies both the text and the spans. so we can add and remove spans
SpannableString spannableString = new SpannableString(titleText);

// iterate through all the annotation spans
for (Annotation annotation: annotations) {
  // look for the span with the key font
  if (annotation.getKey().equals("font")) {
    String fontName = annotation.getValue();
    // check the value associated to the annotation key
    if (fontName.equals("title_emphasis")) {
    // create the typeface
    Typeface typeface = ResourcesCompat.getFont(this, R.font.roboto_mono);
    // set the span at the same indices as the annotation
    spannableString.setSpan(new CustomTypefaceSpan(typeface),
      titleText.getSpanStart(annotation),
      titleText.getSpanEnd(annotation),
      Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    }
  }
}

// now, the spannableString contains both the annotation spans and the CustomTypefaceSpan
styledText.text = spannableString;

अगर एक ही टेक्स्ट का कई बार इस्तेमाल किया जा रहा है, तो आपको SpannableString ऑब्जेक्ट को एक बार और ज़रूरत के मुताबिक फिर से इस्तेमाल करें, ताकि संभावित परफ़ॉर्मेंस और मेमोरी से बचा जा सके समस्याएं.

एनोटेशन के इस्तेमाल से जुड़े और उदाहरण देखने के लिए, यहां जाएं Android में अंतरराष्ट्रीय टेक्स्ट को बेहतर बनाना

एनोटेशन स्पैन और टेक्स्ट पार्सल

क्योंकि Annotation स्पैन ParcelableSpans भी हैं, इसलिए की-वैल्यू पेयर पार्स किए गए और पार्स नहीं किए गए होते हैं. अगर पार्सल पाने वाला व्यक्ति, अनुवाद करने का तरीका जानता है, तो एनोटेशन के लिए, आप Annotation स्पैन का इस्तेमाल करके पार्स किया गया टेक्स्ट.

टेक्स्ट को किसी इंटेंट बंडल में पास करते समय, अपनी कस्टम स्टाइलिंग बनाए रखने के लिए, आपको सबसे पहले Annotation आपके टेक्स्ट तक फैला होता है. ऐसा करने के लिए, एक्सएमएल संसाधनों में <एनोटेशन> टैग, जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है, या Annotation और इसे अवधि के रूप में सेट कर रहा है, जैसा कि नीचे दिखाया गया है:

Kotlin

val spannableString = SpannableString("My spantastic text")
val annotation = Annotation("font", "title_emphasis")
spannableString.setSpan(annotation, 3, 7, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)

// start Activity with text with spans
val intent = Intent(this, MainActivity::class.java)
intent.putExtra(TEXT_EXTRA, spannableString)
startActivity(intent)

Java

SpannableString spannableString = new SpannableString("My spantastic text");
Annotation annotation = new Annotation("font", "title_emphasis");
spannableString.setSpan(annotation, 3, 7, 33);

// start Activity with text with spans
Intent intent = new Intent(this, MainActivity.class);
intent.putExtra(TEXT_EXTRA, spannableString);
this.startActivity(intent);

Bundle से टेक्स्ट को SpannableString के तौर पर वापस पाएं और पार्स करें जोड़ें, जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है.

Kotlin

// read text with Spans
val intentCharSequence = intent.getCharSequenceExtra(TEXT_EXTRA) as SpannableString

Java

// read text with Spans
SpannableString intentCharSequence = (SpannableString)intent.getCharSequenceExtra(TEXT_EXTRA);

टेक्स्ट स्टाइलिंग के बारे में ज़्यादा जानकारी के लिए, ये लिंक देखें: