पाठ्य सूचना को प्रदर्शित करना संभवतः कई Android अनुप्रयोगों का सबसे बुनियादी और महत्वपूर्ण हिस्सा है। यह लेख TextView के बारे में बात करेगा। "हैलो वर्ल्ड" के साथ शुरू होने वाला प्रत्येक डेवलपर, इस यूजर इंटरफेस तत्व के साथ लगातार सामना करता है। समय-समय पर, पाठ के साथ काम करते समय, आपको स्क्रीन को प्रस्तुत करते समय विभिन्न डिज़ाइन समाधानों को लागू करने या प्रदर्शन में सुधार करने के बारे में सोचना होगा।

मैं TextView डिवाइस और इसके साथ काम करने की कुछ सूक्ष्मताओं के बारे में बात करूंगा। पिछले Google I / O की रिपोर्टों से मुख्य सुझाव लिए गए थे।

हुड के नीचे TextView

एंड्रॉइड में टेक्स्ट रेंडर करने के लिए, हुड के नीचे विभिन्न पुस्तकालयों के एक पूरे ढेर का उपयोग किया जाता है। इन्हें दो मुख्य भागों में विभाजित किया जा सकता है - जावा कोड और देशी कोड:

जावा कोड अनिवार्य रूप से एप्लिकेशन डेवलपर्स के लिए उपलब्ध एंड्रॉइड एसडीके का हिस्सा है, और इसमें से नई सुविधाओं को समर्थन पुस्तकालय में पोर्ट किया जा सकता है।

TextView कोर स्वयं C ++ में लिखा गया है, जो पोर्टिंग को ऑपरेटिंग सिस्टम के नए संस्करणों से वहां लागू नई सुविधाओं के समर्थन पुस्तकालय तक सीमित करता है। मुख्य निम्नलिखित पुस्तकालय है:

मिनिकिन का उपयोग पाठ की लंबाई, रेखा को तोड़ने और शब्दांश द्वारा शब्दों को मापने के लिए किया जाता है।
ICU यूनिकोड सहायता प्रदान करता है।
हार्फबज यूनिकोड वर्णों के लिए फोंट में संबंधित ग्राफिक तत्वों (ग्लिफ़) को ढूंढता है।
FreeType ग्लिफ़ के बिटमैप बनाता है।
Skia 2D ग्राफिक्स खींचने के लिए एक इंजन है।

पाठ की लंबाई और रेखा को मापना

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

जैसा कि आप इस उदाहरण से देख सकते हैं, ग्लिफ़ के साथ यूनिकोड वर्णों का मिलान हमेशा एक से एक नहीं होगा: यहाँ 3 वर्ण एक बार में एक ffi ग्लिफ़ के अनुरूप होंगे। इसके अलावा, यह ध्यान देने योग्य है कि आवश्यक ग्लिफ़ विभिन्न सिस्टम फोंट में पाया जा सकता है।

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

 textView.typeface = TypeFace.CustomFallbackBuilder( FontFamily.Builder( Font.Builder(assets, “lato.ttf”).build() ).build() ).addCustomFallback( FontFamily.Builder( Font.Builder(assets, “kosugi.ttf”).build() ).build() ).build()

अब, CustomFallbackBuilder का उपयोग करते CustomFallbackBuilder जब ग्लिफ़ के साथ वर्ण मिलान करते हैं, तो SDK क्रम में निर्दिष्ट फ़ॉन्ट परिवार पर CustomFallbackBuilder करेगा, और यदि यह नहीं पाया जा सकता है, तो सिस्टम फोंट में खोज जारी रहेगी (और setSystemFallback() विधि के माध्यम से आप पसंदीदा सिस्टम फ़ॉन्ट परिवार निर्दिष्ट कर सकते हैं)। CustomFallbackBuilder फ़ॉन्ट परिवार की संख्या पर एक सीमा है - आप 64 से अधिक फ़ॉन्ट नहीं जोड़ सकते हैं।

मिनिकिन पुस्तकालय शब्दों में तारों को विभाजित करता है और व्यक्तिगत शब्दों को मापता है। लॉलीपॉप (21) से काम शुरू करने के लिए, शब्दों के एक सिस्टम LRU कैश का उपयोग किया जाता है। इस तरह का कैश एक बहुत बड़ा प्रदर्शन देता है: कैश्ड शब्द के लिए Paint.measureText() को कॉल करने पर औसतन 3% समय लगेगा जब वह पहली बार अपने आकार की गणना करता है।

यदि पाठ निर्दिष्ट चौड़ाई में फिट नहीं होता है, तो मिनिकिन पाठ में लाइन ब्रेक और शब्दों की व्यवस्था करता है। breakStrategy (23) के साथ शुरू करके , आप breakStrategy लिए breakStrategy और breakStrategy विशेष विशेषताओं को निर्दिष्ट करके इसके व्यवहार को नियंत्रित कर सकते हैं।

मूल्य के साथ breakStrategy=simple पुस्तकालय केवल पाठ के माध्यम से गुजरते हुए, क्रमिक रूप से हाइफ़न की व्यवस्था करेगा: जैसे ही लाइन फिट होना बंद हो जाती है, हाइफ़नेशन को अंतिम शब्द से पहले रखा जाता है।

balanced मूल्य में balanced लाइब्रेरी लाइन ब्रेक बनाने की कोशिश करेगी ताकि लाइनों को चौड़ाई में गठबंधन किया जाए।

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

hyphenationFrequency विशेषता hyphenationFrequency सिलेबल्स द्वारा शब्द रैपिंग के लिए रणनीति को नियंत्रित करने की अनुमति देती है। none मूल्य स्वचालित हाइफ़नेशन नहीं करेगा, normal हाइफ़नेशन की एक छोटी आवृत्ति करेगा, और full , अधिकतम शब्दों का उपयोग करेगा।

चयनित झंडे के आधार पर पाठ रेंडरिंग प्रदर्शन ( Android P (28) पर मापा जाता है):

काफी मजबूत प्रदर्शन को देखते हुए, Google डेवलपर्स, संस्करण Q (29) और AppCompat 1.1.0 के साथ शुरू करते हुए, डिफ़ॉल्ट रूप से हाइफ़नेशन को बंद करने का फैसला किया। यदि शब्द रैपिंग आवेदन में महत्वपूर्ण है, तो अब आपको इसे स्पष्ट रूप से सक्षम करने की आवश्यकता है।

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

पाठ शैली

एंड्रॉइड में टेक्स्ट को स्टाइल करने के कई तरीके हैं:

एक एकल शैली जो संपूर्ण TextView तत्व पर लागू होती है।
बहु-शैली (मल्टी स्टाइल) - एक बार में कई शैलियाँ, जो पैराग्राफ या व्यक्तिगत पात्रों के स्तर पर पाठ पर लागू की जा सकती हैं। ऐसा करने के कई तरीके हैं:
- कैनवास पर पाठ खींचना
- html टैग
- विशेष मार्कअप तत्व - स्पैन

एक एकल शैली का अर्थ है टेक्स्ट व्यू मार्कअप में XML शैलियों या XML विशेषताओं का उपयोग। इस मामले में, सिस्टम निम्नलिखित क्रम में संसाधनों से मूल्यों को लागू करेगा: टेक्स्टएपैरेंस, थीम (थीम), डिफ़ॉल्ट शैली (डिफ़ॉल्ट शैली), आवेदन से शैली, और सर्वोच्च प्राथमिकता व्यू विशेषताओं का मान है।

संसाधनों का उपयोग करना एक काफी सरल उपाय है, लेकिन, दुर्भाग्य से, यह आपको पाठ के कुछ हिस्सों में शैली लागू करने की अनुमति नहीं देता है।

HTML टैग एक और सरल समाधान है जो व्यक्तिगत शब्दों को बोल्ड, इटैलिक बनाने या यहां तक कि पाठ में डॉट्स के साथ सूचियों को हाइलाइट करने जैसी सुविधाएँ प्रदान करता है। सभी डेवलपर को Html.fromHtml() विधि के लिए एक कॉल करना है, जो कि पाठ को टैग किए गए पाठ को स्पैन द्वारा चिह्नित कर देगा। लेकिन इस समाधान में सीमित क्षमताएं हैं, क्योंकि यह HTML टैग्स के केवल एक हिस्से को पहचानता है और सीएसएस शैलियों का समर्थन नहीं करता है।

 val text = "My text <ul><li>bullet one</li><li>bullet two</li></ul>" myTextView.text = Html.fromHtml(text)

TextView को स्टाइल करने के विभिन्न तरीकों को जोड़ा जा सकता है, लेकिन यह किसी विशेष विधि की प्राथमिकता को याद रखने योग्य है, जो अंतिम परिणाम को प्रभावित करेगा:

एक और तरीका - कैनवास पर पाठ खींचना - डेवलपर को पाठ आउटपुट पर पूर्ण नियंत्रण देता है: उदाहरण के लिए, आप एक घुमावदार रेखा के साथ पाठ आकर्षित कर सकते हैं। लेकिन आवश्यकताओं के आधार पर इस तरह के समाधान को लागू करना काफी मुश्किल हो सकता है और इस लेख के दायरे से परे है।

spans

TextView ठीक धुन शैलियों के लिए स्पैन का उपयोग करता है। स्पैन का उपयोग करके, आप वर्णों की श्रेणी का रंग बदल सकते हैं, पाठ का हिस्सा लिंक के रूप में बना सकते हैं, पाठ का आकार बदल सकते हैं, पैराग्राफ के सामने एक बिंदु खींच सकते हैं, आदि।

स्पैन की निम्नलिखित श्रेणियां प्रतिष्ठित की जा सकती हैं:

चरित्र स्पैन - एक स्ट्रिंग के चरित्र स्तर पर लागू होते हैं।
- दिखावट प्रभावित - पाठ का आकार न बदलें।
- मैट्रिक प्रभावित - पाठ का आकार बदलें।
पैराग्राफ स्पैन - पैराग्राफ स्तर पर लागू किया जाता है।

एंड्रॉइड फ्रेमवर्क में इंटरफेस और एब्स्ट्रैक्ट क्लासेस हैं, जिन्हें onMeasure() और onMeasure() रेंडरिंग के दौरान बुलाया जाता है, ये तरीके TextPaint और Canvas जैसी TextPaint -लेवल ऑब्जेक्ट्स तक पहुँच प्रदान करते हैं। स्पैन का उपयोग करते हुए, एंड्रॉइड फ्रेमवर्क यह जांचता है कि इस ऑब्जेक्ट को लागू करने के लिए आवश्यक तरीकों को लागू करने के लिए कौन-सा इंटरफेस है।

एंड्रॉइड फ्रेमवर्क लगभग 20+ स्पैन को परिभाषित करता है, इसलिए इससे पहले कि आप अपना बना लें, यह जांचना बेहतर है कि क्या एसडीके उपयुक्त है।

स्पैन को प्रभावित करने वाले मेट्रिक की उपस्थिति

स्पैन की पहली श्रेणी प्रभावित करती है कि स्ट्रिंग में वर्ण कैसे दिखेंगे: चरित्र का रंग, पृष्ठभूमि का रंग, रेखांकित या पार किए गए वर्ण, आदि। ये स्पैन UpdateAppearance इंटरफेस को लागू करते हैं और CharacterStyle क्लास से इनहेरिट करते हैं, जो TextPaint ऑब्जेक्ट तक पहुंच प्रदान करता है।

मैट्रिक प्रभावित स्पैन टेक्स्ट और लेआउट के आकार को प्रभावित करता है, इसलिए, इस तरह के स्पैन के उपयोग के लिए न केवल onMeasure() , बल्कि कॉल onMeasure() / onLayout() । ये MetricAffectingSpan आमतौर पर MetricAffectingSpan वर्ग से विरासत में प्राप्त होते हैं, जो ऊपर बताए गए MetricAffectingSpan से विरासत में मिले हैं।

वर्ण बनाम पैराग्राफ प्रभावित करने वाले स्पैन

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

Android पर, पैराग्राफ को newlines ( \n ) द्वारा अलग किए गए पाठ का हिस्सा माना जाता है।

आपका विस्तार लेखन

अपने स्वयं के स्पैन लिखते समय, आपको यह तय करने की आवश्यकता है कि किस वर्ग को प्रभावित करने के लिए किस वर्ग को प्रभावित करना है:

चरित्र स्तर पर पाठ को प्रभावित करता है -> CharacterStyle
पैराग्राफ स्तर पर पाठ को प्रभावित करता है -> ParagraphStyle
पाठ दृश्य को प्रभावित करता है → UpdateAppearance
पाठ का आकार प्रभावित करता है - UpdateLayout

यहाँ फ़ॉन्ट बदलने के लिए एक अवधि का एक उदाहरण है:

 class CustomTypefaceSpan(private val font: Typeface?) : MetricAffectingSpan() { override fun updateMeasureState(textPaint: TextPaint) = update(textPaint) override fun updateDrawState(textPaint: TextPaint) = update(textPaint) fun update(textPaint: TextPaint) { textPaint.apply { val old = typeface val oldStyle = old?.style ?: 0 val font = Typeface.create(font, oldStyle) typeface = font //    } } }

कल्पना करें कि हम कोड के हाइलाइटिंग ब्लॉक के लिए अपना खुद का स्पैन बनाना चाहते हैं, इसके लिए हम अपने पिछले स्पैन को एडिट करेंगे - फॉन्ट सेट करने के बाद, हम टेक्स्ट के बैकग्राउंड कलर में बदलाव करेंगे:

 class CodeBlockSpan(private val font: Typeface?) : MetricAffectingSpan() { … fun update(textPaint: TextPaint) { textPaint.apply { //    … bgColor = lightGray //    } } }

पाठ पर अवधि लागू करें:

 //    span spannable.setSpan(CodeBlockSpan(typeface), ...)

लेकिन आप दो स्पैन के संयोजन से ठीक वैसा ही परिणाम प्राप्त कर सकते हैं: Android फ्रेमवर्क से हमारे पिछले CustomTypefaceSpan और BackgroundColorSpan को लें:

 //    spannable.setSpan(BackgroundColorSpan(lightGray), ...) //   spannable.setSpan(CustomTypefaceSpan(typeface), ...)

इन दोनों समाधानों में अंतर होगा। तथ्य यह है कि स्व-लिखित स्पैन सिस्टम के विपरीत Parcelable इंटरफ़ेस को लागू नहीं कर सकते हैं।

जब स्व-लिखित मार्कअप की अवधि के मामले में इंटेंट या क्लिपबोर्ड के माध्यम से एक स्टाइल लाइन को प्रेषित नहीं किया जाएगा। फ्रेमवर्क से स्पैन का उपयोग करते समय, मार्कअप रहेगा।

पाठ में स्पैन का उपयोग करना

फ्रेमवर्क में स्टाइल किए गए टेक्स्ट के लिए दो इंटरफेस हैं: Spannable और Spannable (क्रमशः अपरिवर्तित और परिवर्तनशील मार्कअप के साथ) और तीन कार्यान्वयन: SpannedString (अपरिवर्तित टेक्स्ट), SpannableString (अपरिवर्तित टेक्स्ट) और SpannableStringBuilder ( SpannableStringBuilder पाठ)।

	परस्पर पाठ	परिवर्तनशील मार्कअप
फैला हुआ तार	नहीं	नहीं
स्पैन करने योग्य तार	नहीं	हां
Spannablestring बिल्डर	हां	हां

SpannableStringBuilder , उदाहरण के लिए, एक EditText अंदर उपयोग किया जाता है जिसे पाठ को बदलने की आवश्यकता होती है।

आप विधि का उपयोग करके एक नई अवधि जोड़ सकते हैं:

setSpan(Object what, int start, int end, int flags)

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

ऊपर सूचीबद्ध कक्षाएं न केवल शब्दार्थ रूप से भिन्न होती हैं, बल्कि यह भी कि वे आंतरिक रूप से कैसे व्यवस्थित की जाती हैं: SpannedString और SpannableString स्पैन को स्टोर करने के लिए सरणियों का उपयोग करते हैं, और SpannableStringBuilder एक अंतराल पेड़ का उपयोग करते हैं ।

यदि आप स्पैन की संख्या के आधार पर टेक्स्ट को रेंडर करने की गति के लिए परीक्षण करते हैं, तो आपको निम्न परिणाम मिलेंगे: एक पंक्ति में ~ 250 स्पैन तक का उपयोग करते हुए, SpannableString और SpannableStringBuilder लगभग समान गति से काम करते हैं, लेकिन यदि मार्कअप तत्व 250 से अधिक हो जाते हैं, तो SpannableString शुरू हो जाती है। हारना। इस प्रकार, यदि कार्य किसी पाठ में एक शैली को लागू करना है, तो कक्षा का चयन करते समय, किसी व्यक्ति को शब्दार्थ आवश्यकताओं द्वारा निर्देशित किया जाना चाहिए: क्या पंक्ति और शैली परस्पर भिन्न होंगी। लेकिन अगर मार्कअप के लिए 250 से अधिक स्पैन की आवश्यकता होती है, तो आपको हमेशा SpannableStringBuilder को SpannableStringBuilder देनी चाहिए।

पाठ में अवधि के लिए जाँच करें

कार्य समय-समय पर यह जांचने के लिए उठता है कि क्या एक स्पैन लाइन की एक विशिष्ट अवधि है। और Stackoverflow पर आप यह कोड पा सकते हैं:

 fun <T> hasSpan(spanned: Spanned, clazz: Class<T>): Boolean { val spans: Array<out T> = spanned.getSpans(0, spanned.length, clazz) return spans.isNotEmpty() }

ऐसा समाधान काम करेगा, लेकिन यह अक्षम है: आपको सभी स्पैन से गुजरना होगा, जांचें कि क्या उनमें से प्रत्येक पारित प्रकार से संबंधित है, परिणाम को एक सरणी में इकट्ठा करें, और अंत में यह जांचें कि सरणी खाली नहीं है।

एक और अधिक प्रभावी समाधान होगा nextSpanTransition() विधि का उपयोग करने के लिए:

 fun <T> hasSpan(spanned: Spanned, clazz: Class<T>): Boolean { val limit = spanned.length return spanned.nextSpanTransition(0, limit, clazz) < limit }

विभिन्न भाषा संसाधनों में पाठ मार्कअप

ऐसा कार्य तब उत्पन्न हो सकता है जब आप किसी विशिष्ट शब्द को विभिन्न स्ट्रिंग संसाधनों में मार्कअप की मदद से उजागर करना चाहते हैं। उदाहरण के लिए, हमें अंग्रेजी संस्करण में "टेक्स्ट" शब्द और स्पेनिश में "टेक्स्टो" शब्द को उजागर करने की आवश्यकता है:

 <!-- values-en/strings.xml --> <string name="title">Best practices for text in Android</string> <!-- values-es/strings.xml --> <string name=”title”>Texto en Android: mejores prácticas</string>

यदि आपको कुछ सरल की आवश्यकता है, उदाहरण के लिए, शब्द को बोल्ड में उजागर करने के लिए, तो आप सामान्य HTML टैग ( <b> ) का उपयोग कर सकते हैं। UI में, आपको बस TextView में स्ट्रिंग संसाधन सेट करने की आवश्यकता है:

 textView.setText(R.string.title)

लेकिन अगर आपको कुछ और जटिल चाहिए, उदाहरण के लिए, फ़ॉन्ट बदलना, तो html का अब उपयोग नहीं किया जा सकता है। समाधान विशेष <annotation> का उपयोग करना है। यह टैग आपको xml फ़ाइल में किसी भी कुंजी-मान युग्म को परिभाषित करने की अनुमति देता है। जब हम संसाधनों से एक स्ट्रिंग खींचते हैं, तो ये टैग स्वचालित रूप से Annotation स्पैन में परिवर्तित हो जाते हैं, पाठ में संबंधित कुंजियों और मूल्यों के साथ व्यवस्थित होते हैं। उसके बाद, आप पाठ में एनोटेशन की सूची को पार्स कर सकते हैं और आवश्यक स्पैन लागू कर सकते हैं।

मान लें कि हमें CustomTypefaceSpan का उपयोग करके फ़ॉन्ट बदलने की आवश्यकता है।

एक टैग जोड़ें और इसे "फ़ॉन्ट" कुंजी और मान के लिए परिभाषित करें - जिस प्रकार का फ़ॉन्ट हम उपयोग करना चाहते हैं वह है "title_emphasha" :

 <!-- values-en/strings.xml --> <string name="title">Best practices for <annotation font=”title_emphasis”>text</annotation> in Android</string> <!-- values-es/strings.xml --> <string name=”title”><annotation font=”title_emphasis”>Texto</annotation> en Android: mejores prácticas</string>

संसाधनों से स्ट्रिंग खींचो, एनोटेशन को "फ़ॉन्ट" कुंजी के साथ खोजें और स्पैन की व्यवस्था करें:

 //      SpannedString,     span' val titleText = getText(R.string.title) as SpannedString //    val annotations = titleText.getSpans(0, titleText.length, Annotation::class.java) //     SpannableString //      val spannableString = SpannableString(titleText) //     for (annotation in annotations) { //     "font" if (annotation.key == "font") { val fontName = annotation.value //   ,     if (fontName == "title_emphasis") { val typeface = getFontCompat(R.font.permanent_marker) //  span    ,    spannableString.setSpan( CustomTypefaceSpan(typeface), titleText.getSpanStart(annotation), titleText.getSpanEnd(annotation), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE ) } } } styledText.text = spannableString

यह ऊपर उल्लेख किया गया था कि एंड्रॉइड फ्रेमवर्क के बाहर के स्पैन Parcelable लागू नहीं कर सकते हैं और इंटेंट के माध्यम से प्रेषित होते हैं। लेकिन यह उन एनोटेशन पर लागू नहीं होता है जो Parcelable लागू Parcelable । तो आप एनोटेंट स्ट्रिंग को इंट्रेंट और पार्स के माध्यम से ठीक उसी तरह से पारित कर सकते हैं जैसे अपने स्पैन की व्यवस्था करके।

टेक्स्ट टेक्स्ट में कैसे टेक्स्ट रखा जाता है

TextView न केवल पाठ, बल्कि चित्र भी प्रदर्शित कर सकता है। आप पाठ के सामने विभिन्न संकेत भी सेट कर सकते हैं। हुड के तहत, यह काम करता है ताकि TextView एक बच्चा वर्ग, लेआउट बनाता है, जो सीधे पाठ प्रदर्शित करने के लिए जिम्मेदार है। यह एक सार वर्ग है जिसमें तीन कार्यान्वयन हैं; आमतौर पर जब तक आप अपना नियंत्रण नहीं लिखते हैं, तब तक आपको सीधे उनके साथ काम नहीं करना होगा:

बोरिंगलैट का उपयोग सरल ग्रंथों के लिए किया जाता है , लाइन ब्रेक , आरटीएल और अन्य चीजों का समर्थन नहीं करता है, लेकिन यह सबसे हल्का है। यदि पाठ सभी प्रतिबंधों को पूरा करता है, तो TextView इसका उपयोग करता है।
StaticLayout का उपयोग अन्य मामलों के लिए TextView में किया जाता है।
एक एडिटटेक्स्ट में म्यूटेबल टेक्स्ट के लिए डायनेमिकलाईट का उपयोग किया जाता है।

लेआउट में कई विधियां हैं जो आपको प्रदर्शित पाठ के विभिन्न मापदंडों को जानने देती हैं: लाइनों के निर्देशांक, आधार रेखा, पाठ के आरंभ और अंत के निर्देशांक आदि। (अधिक विवरण प्रलेखन में पाया जा सकता है)

इस तरह के तरीके बहुत उपयोगी हो सकते हैं। उदाहरण के लिए, कुछ डेवलपर्स को पाठ के भाग को गोल आयतों में निकालने के कार्य के साथ सामना किया जाता है, और इस समस्या को हल करने में लागू नहीं होने वाले स्पैन के माध्यम से इसका समाधान खोजने की कोशिश की जाती है।

लेकिन लेआउट वर्ग के तरीके बचाव में आ सकते हैं। यहाँ एक नमूना समाधान है:

एनोटेशन का उपयोग करते हुए, हम उन शब्दों का चयन करते हैं जिन्हें आयतों में परिचालित किया जाना चाहिए।

फिर पाठ रैपिंग के सभी मामलों के लिए 4 आकर्षित करने योग्य संसाधन बनाएं, जिन्हें आयतों में संलग्न किया जाना चाहिए:

इसके बाद, हम पाठ में जिन एनोटेशन की आवश्यकता है, वे ऊपर वर्णित हैं। अब हमारे पास इस तरह के एनोटेशन की शुरुआत और अंत के सूचकांक हैं। लेआउट विधियों के माध्यम से, आप उस पंक्ति की संख्या का पता लगा सकते हैं जिस पर एनोटेट पाठ शुरू होता है, और जिस पर यह समाप्त होता है:

 val startLine = layout.getLineForOffset(spanStartIndex) val endLine = layout.getLineForOffset(spanEndIndex)

इसके बाद, आपको एक या एक से अधिक आयतें खींचनी होंगी। साधारण मामले पर विचार करें जब पाठ का एनोटेट भाग एक पंक्ति में दिखाई देता है, तो हमें चार गोल कोनों के साथ केवल एक आयत की आवश्यकता होती है। इसके निर्देशांक निर्धारित करें और ड्रा करें:

 ... if (startLine == endLine) { val lineTop = layout.getLineTop(startLine) //    val lineBottom = layout.getLineBottom(startLine) //    val startCoor = layout.getPrimaryHorizontal(spanStartIndex).toInt() //    val endCoor = layout.getPrimaryHorizontal(spanEndIndex).toInt() //    //   drawable.setBounds(startCoor, lineTop, endCoor, lineBottom) drawable.draw(canvas) ...

जैसा कि आप इस उदाहरण से देख सकते हैं, लेआउट प्रदर्शित पाठ पर बहुत उपयोगी जानकारी संग्रहीत करता है, जो विभिन्न गैर-मानक कार्यों के कार्यान्वयन में मदद कर सकता है।

TextView प्रदर्शन

onMeasure() व्यू, किसी भी दृश्य की तरह, प्रदर्शित होने पर तीन चरणों से onMeasure() : onMeasure() , onLayout() और onLayout() onDraw() । उसी समय, onMeasure() को अन्य दो विधियों के विपरीत, सबसे अधिक समय लगता है: इस समय, लेआउट वर्ग को फिर से बनाया जाता है और पाठ आकार की गणना की जाती है। इसलिए पाठ का आकार बदलना (उदाहरण के लिए, फ़ॉन्ट बदलना) बहुत काम करता है। पाठ का रंग बदलना अधिक हल्का होगा क्योंकि इसमें केवल onDraw() कॉलिंग की आवश्यकता होती है। जैसा कि ऊपर उल्लेख किया गया है, सिस्टम में गणना आकार के साथ एक वैश्विक शब्द कैश है। यदि शब्द पहले से ही कैश में है, तो इसके लिए onMeasure() कॉल करने पर उस समय का 11-16% लगेगा जो एक पूर्ण गणना के लिए आवश्यक था।

पाठ त्वरण

2015 में, इंस्टाग्राम डेवलपर्स ने वैश्विक कैश का उपयोग करते हुए तस्वीरों पर टिप्पणियों के प्रदर्शन को तेज किया। यह विचार वस्तुतः पाठ को स्क्रीन पर दिखाने से पहले खींचना था, इस प्रकार सिस्टम कैश को "वार्मिंग अप" करता है। जब यह पाठ दिखाने का समय था, तो उपयोगकर्ता ने इसे बहुत तेजी से देखा, क्योंकि पाठ पहले से ही मापा गया था और कैश में था।

एंड्रॉइड पी (28) के साथ शुरू, Google डेवलपर्स ने एपीआई को पृष्ठभूमि के धागे में अग्रिम में टेक्स्ट आकार को मापने के चरण को करने की क्षमता में जोड़ा है - PrecomputedText (और Android I (14) - PrecomputedTextCompat साथ शुरू होने वाले एपीआई के लिए बैकपोर्ट)। नई एपीआई का उपयोग करते हुए, 90% काम पृष्ठभूमि थ्रेड में किया जाएगा।

एक उदाहरण:

 // UI thread val params: PrecomputedText.Params = textView.getTextMetricsParams() val ref = WeakReference(textView) executor.execute { // background thread val text = PrecomputedText.create("Hello", params) val textView = ref.get() textView?.post { // UI thread val textView = ref.get() textView?.text = text } }

बड़ा पाठ दिखाओ

यदि आपको बड़ा पाठ दिखाने की आवश्यकता है, तो उसे तुरंत एक TextView में स्थानांतरित न करें। अन्यथा, एप्लिकेशन सुचारू रूप से या पूरी तरह से काम करना बंद कर सकता है, क्योंकि यह विशाल पाठ को दिखाने के लिए मुख्य थ्रेड पर बहुत काम करेगा जिसे उपयोगकर्ता अंत तक स्क्रॉल भी नहीं कर सकता है। समाधान पाठ को भागों में विभाजित करना है (जैसे पैराग्राफ) और RecyclerView में व्यक्तिगत भागों को प्रदर्शित करना है। और भी अधिक स्पीडअप के लिए, आप PrecomputedText का उपयोग करके टेक्स्ट ब्लॉक के आकार की पूर्व-गणना कर सकते हैं।

RecyclerView में PrecomputedText की एम्बेडिंग की सुविधा के लिए, Google डेवलपर्स ने PrecomputedTextCompat.getTextFuture() और AppCompatTextView.setTextFuture() लिए विशेष तरीके बनाए।

 fun onBindViewHolder(vh: ViewHolder, position: Int) { val data = getData(position) vh.textView.setTextSize(...) vh.textView.setFontVariationSettings(...) //    val future = PrecomputedTextCompat.getTextFuture( data.text, vh.textView.getTextMetricsParamsCompat(), myExecutor ) //  future  TextView,      onMeasure() vh.textView.setTextFuture(future) }

RecyclerView , , , .

, getTextFuture() (, ), , , getTextFuture() , , TextView.

, TextView

TextView.setText() :

 if (type == SPANNABLE || movementMethod != null) { text = spannableFactory.newSpannable(spannable) //  } else { text = new SpannedString(spannable) //  }

span' TextView, setText() , .

, . TextView , -, . , . , , TextView spannableFactory :

 class MySpannableFactory : Spannable.Factory() { override fun newSpannable(source: CharSequence): Spannable { return source as? Spannable ?: super.newSpannable(source) } } textView.spannableFactory = MySpannableFactory()

textView.setText(spannable, BufferType.SPANNABLE) , .

Google span' RecyclerView, .

TextView, span, setText() . TextView span. TextView spannable- span', :

 val spannable = textView.getText() as Spannable val span = CustomTypefaceSpan(span) spannable.setSpan(span, ...)

span, TextView, TextView . , invalidate() , – requestLayout() :

 val spannable = textView.getText() as Spannable val span = CustomTypefaceSpan(span) spannable.setSpan(span, ...) span.setTypeface(anotherTypeface) textView.requestLayout() // re-measure and re-draw // or textView.invalidate() // re-draw

autoLink

TextView . autoLink . autoLink=”web” TextView URL URLSpan . , SDK setText() :

 spannable = new SpannableString(string); Matcher m = pattern.matcher(text); while (...) { //      String utl = … URLSpan span = new URLSpan(url); spannable.setSpan(span, ...); }

UI , autoLink=”web” RecyclerView. . LinkifyCompat :

 //  ,       background thread val spannable = SpannableString(string) LinkifyCompat.addLinks(spannable, Linkify.WEB_URLS) //   RecyclerView override fun onBindViewHolder(holder: ViewHolder, position: Int) { holder.textView.setText(spannable, BufferType.SPANNABLE) // ... }

autoLink map – ( all ). . , WebView, ! SDK Linkify.gatherMapLinks() , :

 while ((address = WebView.findAddress(string)) != null) { ... }

WebView TODO SDK:

 public static String findAddress(String addr) { // TODO: Rewrite this in Java so it is not needed to start up chromium // Could also be deprecated return getFactory().getStatics().findAddress(addr); }

? Smart Linkify, Android P (28) , , . :

 // UI thread val text: Spannable = … val request = TextLinks.Request.Builder(text) val ref = WeakReference(textView) executor.execute { // background thread TextClassifier.generateLinks(request).apply(text) val textView = ref.get() textView?.post { // UI thread val textView = ref.get() textView?.text = text } }

Linkify, . toolbar , Google .

Smart Linkify : , .

Magnifier

Android P (28) , – Magnifier, . .

TextView, EditText WebView, : API .

निष्कर्ष

Android , , :

, TextView (, EditText)

- , Google I/O'19 “Best Practices for Using Text in Android” .

Android पाठ प्रदर्शन