खरोंच से एक कस्टम घटक बनाना। भाग 1

प्रविष्टि

बधाई, सहकर्मियों!

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

लेखों की एक श्रृंखला में मैं इस तरह के मुद्दों को उजागर करने की कोशिश करूंगा:

1. घटक प्रतिपादन
2. स्क्रॉलिंग का उपयोग करते हुए मानक स्क्रॉलबारों को जोड़ना
3. बातचीत, कुंजियों के चयनकर्ताओं का उपयोग करना
4. स्क्रीन को घुमाते समय घटक स्थिति को सहेजना
5. ओवरक्रोल के लिए बैकलाइट जोड़ना
6. एक्सएमएल को पासिंग पैरामीटर
7. चुटकी में झूमना

पहला लेख पहले तीन बिंदुओं के बारे में होगा।

यदि आप इन विषयों में रुचि रखते हैं, तो बिल्ली में आपका स्वागत है।

प्रागितिहास

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

घटक विकास

देखें या सरफेसव्यू?

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

प्रारंभिक चरण

तो, चलिए शुरू करते हैं, पहली बात जो हम करेंगे वह है एक नया वर्ग, android.view.View का उत्तराधिकारी। इसे PianoView कहते हैं।

public class PianoView extends View { public PianoView(Context context, AttributeSet attrs) { super(context, attrs); } @Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); } } 

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

कीबोर्ड रेंडरिंग। ग्राफिक संसाधन।

चाबियाँ खींचने के लिए, मैं मानक एंड्रॉइड टूल्स का उपयोग करूंगा: चयनकर्ता, नौ-पैच ड्रॉएबल।
सफेद कुंजी के लिए, मैंने निम्नलिखित 9-पैच चित्र तैयार किए। मैंने होलो के लिए मानक नीली बैकलाइट का उपयोग करके एक हाइलाइटेड राज्य बनाने का निर्णय लिया।


काले रंग के लिए:


और उनमें से प्रत्येक के लिए एक चयनकर्ता बनाया:

 <?xml version="1.0" encoding="utf-8"?> <selector xmlns:android="http://schemas.android.com/apk/res/android"> <item android:drawable="@drawable/white_key_pressed" android:state_pressed="true"></item> <item android:drawable="@drawable/white_key"></item> </selector> 

अब जो कुछ बचा है, उसे ये ड्रॉबल्स context.getResourses.getDrawable(); लिए कोड का उपयोग करके प्राप्त करना है ।getResourses.getDrawable context.getResourses.getDrawable();

कीबोर्ड रेंडरिंग। कोड

इसलिए, घटक कोड को साफ रखने के लिए, मैंने सभी कुंजीपटल रेंडरिंग को निकाल लिया और कीबोर्ड वर्ग में इसके लिए आवश्यक जानकारी संग्रहीत की। हमारे onDraw मैं बस इसकी विधि कहूंगा:

 protected void onDraw(Canvas canvas) { if (measurementChanged) { measurementChanged = false; keyboard.initializeInstrument(getMeasuredHeight(), getContext()); instrumentWidth = keyboard.getWidth(); } keyboard.draw(canvas); } 

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

पहला कदम इनिशियलाइजेशन है। प्रारंभ में कुंजियों की एक सरणी की गणना करना शामिल है।

 Key[] keysArray; 

यह हमारा मॉडल है। प्रत्येक आइटम एक कुंजी है। कुंजी इसके निर्देशांक (घटक समन्वय प्रणाली में) और आयामों को जानती है, चाहे वह काला या सफेद हो, या वर्तमान में दबाया गया है या नहीं।

 class Key { float startX; float endX; float startY; float endY; int midiCode; boolean black; boolean pressed = false; void setBounds(float startX, float endX, float startY, float endY) { this.startX = startX; this.startY = startY; this.endX = endX; this.endY = endY; } boolean containsPoint(float x, float y) { return startX <= x && endX > x && startY <= y && endY > y; } } 

यह प्रक्रिया हमारे घटक के भौतिक आकार में हर परिवर्तन के साथ होती है, हमारा कीबोर्ड आरंभीकृत होता है (इसके लिए मापक ध्वज ध्वज उत्तरदायी होता है, जिसे हम ऑन-ऑन विधि में सत्य पर सेट करते हैं)। इस प्रकार, हम हर बार आकर्षित होने वाले प्रमुख पदों की गणना नहीं करेंगे।



यहां हम घटक की ऊंचाई के आधार पर कुंजियों की चौड़ाई की गणना करते हैं और चाबियों का एक सरणी बनाते हैं। सबसे पहले, पहले सप्तक का निर्माण किया जाता है, फिर इसे एक्स अक्ष के साथ क्लोन किया जाता है और शेष ऑक्टेव्स को प्राप्त करने के लिए आवश्यक संख्या में स्थानांतरित किया जाता है। साथ ही, प्रत्येक कुंजी में एक MIDI कोड होगा, जिसके अनुसार ध्वनि चलाना संभव होगा। मिडी कोड में एंड-टू-एंड नंबरिंग है। हमारा पहला मुख्य कोड START_MIDI_CODE होगा। किसी भी कुंजी के कोड की गणना प्रारंभ कोड और सरणी में कुंजी के सूचकांक को जोड़कर की जाती है।

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

 private void drawSingleKey(Canvas canvas, Key key, int firstVisibleKey, int lastVisibleKey) { Drawable drawable = key.black ? blackKeyDrawable : whiteKeyDrawable; drawable.setState(new int[] { key.pressed ? android.R.attr.state_pressed : -android.R.attr.state_pressed }); drawable.setBounds((int) key.startX, (int) key.startY, (int) key.endX, (int) key.endY); drawable.draw(canvas); } 

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

हो गया, हमारा टूल सफलतापूर्वक तैयार हो गया है:



बुरा नहीं है। बेशक, जब आप कुंजियों पर क्लिक करते हैं तो कुछ भी नहीं होता है। चलो इसे ठीक करते हैं।

मुख्य बातचीत

उपयोगकर्ता क्लिकों के साथ बातचीत के लिए, ऑन-टच विधि को आमतौर पर पुनर्परिभाषित किया जाता है और यह निर्धारित करता है कि उपयोगकर्ता ने क्या किया है - एक उंगली को स्पर्श करें, एक इशारा करें, दोहरा स्पर्श करें, लंबा स्पर्श करें, आदि सौभाग्य से, ज्यादातर मामलों में आप और मैं ऐसी परेशानियों से मुक्त हैं।
हम GestureDetector वर्ग का उपयोग करेंगे, कृपया अपने पहले दिनों से मंच द्वारा प्रदान किया गया।

चलिए हमारे टूल में private GestureDetector gestureDetector; फ़ील्ड private GestureDetector gestureDetector; और इसे इनिशियलाइज़ करें

 private void init() { if (!isInEditMode()) { gestureDetector = new GestureDetector(getContext(), gestureListener); } } 

हम निर्माणकर्ता को श्रोता जेस्चरलिस्ट को पास करते हैं, यह वह स्थान है जहां हम डिटेक्टर से कॉलबैक प्राप्त करते हैं जब किसी भी इशारों का पता लगाया जाता है।

  private OnGestureListener gestureListener = new GestureDetector.SimpleOnGestureListener() { public boolean onDown(MotionEvent e) { if (keyboard.touchItem(e.getX(), e.getY())) { invalidate(); } return true; } public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { resetTouchFeedback(); return true; } public boolean onSingleTapUp(MotionEvent e) { resetTouchFeedback(); return super.onSingleTapUp(e); } }; 

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

 public boolean onTouchEvent(MotionEvent event) { int action = event.getAction(); if (action == MotionEvent.ACTION_CANCEL) { resetTouchFeedback(); } return super.onTouchEvent(event) || gestureDetector.onTouchEvent(event); } 

कृपया ध्यान दें कि हम यह भी ACTION_CANCEL कि क्या कार्रवाई ACTION_CANCEL , और इस मामले में, चयन को भी रीसेट करें, क्योंकि GestureDetector किसी भी तरह से इस पर प्रतिक्रिया नहीं करता है, और अगर यह अचानक हुआ, तो हम हमेशा के लिए चयनित कुंजी के साथ शेष रहते हैं।

हम जाँच करते हैं:



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

 private int xOffset; 

हमारी कक्षा के लिए।

अब हम इस तरह से एक निर्माण के साथ अपने onDraw विधि का विस्तार करेंगे:

 protected void onDraw(Canvas canvas) { if (measurementChanged) { measurementChanged = false; keyboard.initializeInstrument(getMeasuredHeight(), getContext()); instrumentWidth = keyboard.getWidth(); } canvas.save(); canvas.translate(-xOffset, 0); keyboard.updateBounds(xOffset, canvasWidth + xOffset); keyboard.draw(canvas); canvas.restore(); } 

आइए देखें कि हमने क्या किया:

• कैनवस.सेवे () - कैनवास की वर्तमान स्थिति को याद करता है। एक तरह का ब्रेकपॉइंट बनाता है
• कैनवस.ट्रांसलेट () - कैनवस को एक निर्धारित दूरी से स्थानांतरित करता है
• कैनवास। श्रेष्ठ () - कैनवास को उसकी मूल स्थिति में पुनर्स्थापित करें।

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

अब जब हमने ड्राइंग चरण पर स्क्रॉल करने के लिए समर्थन जोड़ा है, तो हम इसे उपयोगकर्ता के इंटरैक्शन में जोड़ देंगे - GestureDetector। OnScroll को संशोधित करें:

 public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { resetTouchFeedback(); xOffset += distanceX; if (xOffset < 0) { xOffset = 0; } if (xOffset > instrumentWidth - getMeasuredWidth()) { xOffset = instrumentWidth - getMeasuredWidth(); } invalidate(); return true; } 

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

 private OverScroller scroller; 

और घटक निर्माता में इसे इनिशियलाइज़ करें।

इसके बाद, GestureDetector को निम्नानुसार संशोधित करें:

 private OnGestureListener gestureListener = new GestureDetector.SimpleOnGestureListener() { public boolean onDown(MotionEvent e) { scroller.forceFinished(true); if (keyboard.touchItem(e.getX() / scaleX + xOffset, e.getY())) { invalidate(); } return true; } public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { scroller.fling(xOffset, 0, (int) -velocityX, 0, 0, instrumentWidth - getMeasuredWidth(), 0, 0); return true; } // ... }; 

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

अगला कदम ऑनड्रॉ है

 protected void onDraw(Canvas canvas) { if (scroller.computeScrollOffset()) { xOffset = scroller.getCurrX(); } if (measurementChanged) { measurementChanged = false; keyboard.initializeInstrument(getMeasuredHeight(), getContext()); instrumentWidth = keyboard.getWidth(); } canvas.save(); canvas.scale(scaleX, 1.0f); canvas.translate(xOffset , 0); keyboard.updateBounds(xOffset , canvasWidth + xOffset ); keyboard.draw(canvas); canvas.restore(); if (!scroller.isFinished()) { ViewCompat.postInvalidateOnAnimation(this); } } 

यहाँ क्या बदल गया है? एनीमेशन के प्रत्येक फ्रेम के लिए जिसे हम scroller.computeScrollOffset () कहते हैं, यह विधि सही है यदि स्कोरर एनिमेटेड है, तो हमें xOffset वैरिएबल का वर्तमान मान मिलता है।
चूँकि एनीमेशन में रिड्रेस की एक श्रृंखला शामिल है - इस पद्धति के अंत में हम जाँचते हैं कि क्या स्कोरर ऐनिमेटिंग समाप्त हो गया है, और यदि नहीं, तो एनीमेशन के अगले फ्रेम को असाइन करें। इस प्रकार, जब तक कि स्कोरर अपना काम पूरा नहीं करता, या बल द्वारा रोक दिया जाता है, तब तक ऑनड्राव विधि को जितनी बार संभव हो कहा जाएगा और अपने घटक को आकर्षित करेगा।

अब हमारा घटक अच्छी तरह से स्क्रॉल करेगा और फ्लिंग का समर्थन करेगा। लेकिन कुछ याद आ रहा है, है ना? नीचे पर्याप्त मानक स्क्रॉलबार नहीं हैं। समस्या नहीं है।

मानक कॉलबार जोड़ना

मानक स्क्रॉलबार जोड़ना एक जादू की तरह है, कोई विशेष रहस्य नहीं हैं, बस क्रियाओं का एक क्रम है।
सबसे पहले, हमें अपने घटक को बताने की आवश्यकता है कि यह सभी मानक स्क्रॉलिंग विशेषताओं का समर्थन करता है। ऐसा करने के लिए, हमारी मान निर्देशिका में attrs.xml फ़ाइल बनाएँ, जिसमें निम्नलिखित परिभाषा जोड़ें:

 <declare-styleable name="View"> <attr name="android:fadeScrollbars" /> <attr name="android:scrollbarAlwaysDrawHorizontalTrack" /> <attr name="android:scrollbarAlwaysDrawVerticalTrack" /> <attr name="android:scrollbarDefaultDelayBeforeFade" /> <attr name="android:scrollbarFadeDuration" /> <attr name="android:scrollbarSize" /> <attr name="android:scrollbarStyle" /> <attr name="android:scrollbarThumbHorizontal" /> <attr name="android:scrollbarThumbVertical" /> <attr name="android:scrollbarTrackHorizontal" /> <attr name="android:scrollbarTrackVertical" /> <attr name="android:scrollbars" /> </declare-styleable> 

अब, कंस्ट्रक्टर में जोड़ें:

 setVerticalScrollBarEnabled(false); setHorizontalScrollBarEnabled(true); TypedArray a = context.obtainStyledAttributes(R.styleable.View); initializeScrollbars(a); a.recycle(); 

अगला कदम तीन सरल तरीकों को फिर से परिभाषित करना है जिसमें हम स्क्रॉलबार के आकार और स्थिति को नियंत्रित करेंगे:

  protected int computeHorizontalScrollExtent() { return canvasWidth; } @Override protected int computeHorizontalScrollOffset() { return xOffset; } @Override protected int computeHorizontalScrollRange() { return instrumentWidth; } 

कोड खुद के लिए बोलता है - पहली विधि में हम अपने घटक की चौड़ाई का संकेत देते हैं, दूसरे में, स्क्रॉलिंग की वर्तमान ऑफसेट, तीसरे में पूरे कीबोर्ड का आकार (जो स्क्रीन की सीमाओं से परे जाता है)। अब यह जरूरत पड़ने पर इन स्क्रॉलबार को "वेक अप" करने के लिए रहता है। बेस व्यू क्लास इसके लिए एक विशेष awakenScrollBars () विधि प्रदान करता है। निम्नलिखित पंक्तियाँ जोड़ें:

 if (!awakenScrollBars()) { invalidate(); } 

हमारे GestureDetectorListener के onScroll और onFling तरीकों पर।

परिणाम - मानक स्क्रॉलबार हमारी आँखों को प्रसन्न करते हैं।

निष्कर्ष

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

लेख काफी लंबा था, इसलिए मैंने इसे कई हिस्सों में तोड़ने का फैसला किया।

अगले भाग में मैं बात करूंगा:

1. स्क्रीन को घुमाते समय घटक स्थिति को सहेजना
2. ओवरक्रोल के लिए बैकलाइट जोड़ना
3. XML में पासिंग पैरामीटर
4. चुटकी में झूमना

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

लेखों की इस श्रृंखला के लिए तैयार परियोजना का स्रोत कोड मेरे github पर goo.gl/VDeuw पर पाया जा सकता है। मैं तुरंत ध्यान देना चाहता हूं कि ये विकसित की जा रही परियोजना से क्लिपिंग हैं, और यदि आपको कुछ कोड मिलते हैं, तो ऐसा प्रतीत होता है, इसकी आवश्यकता नहीं है, मैं संभवतः इसे नोटिस नहीं करता और इसे काट देना भूल गया।