एंड्रॉइड पर कोड हाइलाइटिंग। मेरा अनुभव

अपने अंतिम अनुप्रयोग के विकास के दौरान, मुझे EditText में स्पैन रखने के लिए अलग-अलग तरीकों के साथ प्रयोग करने में काफी समय बिताना पड़ा। इस पोस्ट में, मैं कुछ इस शगल को संक्षेप में प्रस्तुत करना चाहूंगा, साथ ही उन लोगों के लिए समय की बचत करेगा जो भविष्य में ऐसी समस्याओं का समाधान करेंगे।

थोड़ा कोड होगा, केवल मुख्य बिंदु।

शुरुआत करने के लिए, मैं पाठकों को अद्यतित करने के लिए तथ्यों की एक छोटी सूची देना चाहता हूं:

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

इसलिए, मेरे निर्णय का अधिकार, जो, शायद, सबसे इष्टतम से दूर है। इस मामले में, मुझे सलाह देने में खुशी होगी।

प्रस्तावित समाधान की संरचना का सामान्य विवरण

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

सामान्य योजना इस प्रकार है। अब विवरण के लिए कि मैं एक प्रश्न और उत्तर के रूप में रेखांकित करूंगा।

स्क्रॉलिंग के अंत के क्षण को कैसे पकड़ें?

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

private Thread timerThread; protected void onScrollChanged(int x, int y, int oldx, int oldy) { super.onScrollChanged(x, y, oldx, oldy); timer = 500; if (timerThread == null || !timerThread.isAlive()) { timerThread = new Thread(lastScrollTime); timerThread.start(); } } Runnable lastScrollTime = new Runnable() { @Override public void run() { while (timer != 0) { timer -= 10; try { Thread.sleep(10); } catch (InterruptedException e) { } } CustomScrollView.this.post(new Runnable() { @Override public void run() { if (onScrollStoppedListener != null) { onScrollStoppedListener.onScrollStopped(CustomScrollView.this.getScrollY()); } } }); } }; public interface OnScrollStoppedListener { void onScrollStopped(int scrollY); } 

यही है, हर बार जब विधि को बुलाया जाता है, तो हम टाइमर को 500 एमएस पर सेट करते हैं और, अगर इस समय के दौरान विधि को नहीं बुलाया जाता है, तो हम ऑनस्क्राकॉलस्टॉप्लीस्टनर को सूचित करते हैं कि स्क्रॉलिंग बंद हो गई है। मेरे मामले में, OnScrollStnectListener इंटरफ़ेस मेरे EditText को लागू करता है।

प्रत्येक वर्ण में प्रवेश करने के बाद पार्सर स्ट्रीम कैसे शुरू करें?

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

कैसे समझें कि पाठ दृश्य क्षेत्र में क्या आता है?

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

 List<Integer> charsCountPerLine = new ArrayList<>(); public void fillArrayWithCharsCountPerLine(String text) { charsCountPerLine.clear(); charsCountPerLine.add(0); BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(text.getBytes()))); int currentLineLength = 0; char current; try { while (true) { int c = br.read(); if (c == -1) { charsCountPerLine.add(currentLineLength); break; } current = (char) c; currentLineLength++; if (current == '\n') { charsCountPerLine.add(currentLineLength); } } } catch (IOException e) { Log.e(TAG, "", e); } } 

यही है, मुझे प्रत्येक पंक्ति की शुरुआत का चरित्र संख्या मिलती है। फिर, पिक्सेल में स्क्रीन की ऊँचाई को जानते हुए, हम आसानी से पहली और अंतिम दृश्य रेखा की संख्या की गणना करते हैं:

  int lineHeight = mEditText.getLineHeight(); int startLine = scrollY / lineHeight; // scrollY -     ScrollView int endLine = mEditText.startLine + viewHeight / lineHeight + 1; // viewHeight     

इस डेटा के होने पर, आप आसानी से पहला और अंतिम दृश्यमान चरित्र पा सकते हैं।

मुझे स्पैन सूची भरने की आवश्यकता क्यों है? इसे बनाने के ठीक बाद हैंडलर को हर स्पैन क्यों न भेजें?

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

हमें लगातार नींद की धारा की आवश्यकता क्यों है? क्यों नहीं थ्रेडपोल का उपयोग करें?

सिद्धांत रूप में, यह थोड़ा बेहतर होना चाहिए, लेकिन मैंने कोशिश नहीं की।

मैंने समाधान की सामान्य संरचना और, मेरी राय में, गैर-स्पष्ट बिंदुओं पर प्रकाश डाला। मुझे उम्मीद है कि यह किसी के लिए उपयोगी है। आपका धन्यवाद