Android पर SurfaceView के साथ काम करना

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

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

भूतल दृश्य वर्ग

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

पूरा कार्यान्वयन दो मुख्य बिंदुओं पर आता है:

1. SurfaceView से विरासत में मिली एक क्लास बनाना और SurfaceHolder.Callback इंटरफ़ेस को लागू करना
2. एक स्ट्रीम बनाएं जो रेंडरिंग को नियंत्रित करेगा।

वर्ग निर्माण

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

public class MySurfaceView extends SurfaceView implements SurfaceHolder.Callback { public MySurfaceView(Context context) { super(context); getHolder().addCallback(this); } @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { } @Override public void surfaceCreated(SurfaceHolder holder) { } @Override public void surfaceDestroyed(SurfaceHolder holder) { } } 

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

रेंडरिंग स्ट्रीम का कार्यान्वयन

थ्रेड से विरासत में मिली एक क्लास बनाएं। निर्माणकर्ता में, दो मापदंडों को ले जाएगा: सतहहार्ड और संसाधन उस छवि को लोड करने के लिए जिसे हम स्क्रीन पर आकर्षित करेंगे। इसके अलावा कक्षा में हमें एक ध्वज चर की आवश्यकता होगी जो यह दर्शाता है कि ड्राइंग प्रगति पर है और इस चर को स्थापित करने के लिए एक विधि है। ठीक है, निश्चित रूप से, आपको रन () विधि को ओवरराइड करना होगा।
परिणामस्वरूप, हमें निम्न वर्ग मिलता है:

 class DrawThread extends Thread{ private boolean runFlag = false; private SurfaceHolder surfaceHolder; private Bitmap picture; private Matrix matrix; private long prevTime; public DrawThread(SurfaceHolder surfaceHolder, Resources resources){ this.surfaceHolder = surfaceHolder; //  ,    picture = BitmapFactory.decodeResource(resources, R.drawable.icon); //      matrix = new Matrix(); matrix.postScale(3.0f, 3.0f); matrix.postTranslate(100.0f, 100.0f); //    prevTime = System.currentTimeMillis(); } public void setRunning(boolean run) { runFlag = run; } @Override public void run() { Canvas canvas; while (runFlag) { //         //    long now = System.currentTimeMillis(); long elapsedTime = now - prevTime; if (elapsedTime > 30){ //    30  -    //     2 . //   -   prevTime = now; matrix.preRotate(2.0f, picture.getWidth() / 2, picture.getHeight() / 2); } canvas = null; try { //   Canvas    canvas = surfaceHolder.lockCanvas(null); synchronized (surfaceHolder) { canvas.drawColor(Color.BLACK); canvas.drawBitmap(picture, matrix, null); } } finally { if (canvas != null) { //  .     surfaceHolder.unlockCanvasAndPost(canvas); } } } } } 

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

ड्राइंग शुरू और समाप्त करें

अब, जब हमने रेंडरिंग को नियंत्रित करने वाले थ्रेड को लिखा, तो हम अपने सरफेस व्यू क्लास के संपादन पर वापस जाएँ। सरफेसटेड () विधि में, एक स्ट्रीम बनाएं और इसे शुरू करें। और मेथड सरफेसड्रोयड () में हम इसका काम पूरा करेंगे। परिणामस्वरूप, MySurfaceView वर्ग निम्न रूप लेगा:

 public class MySurfaceView extends SurfaceView implements SurfaceHolder.Callback { private DrawThread drawThread; public MySurfaceView(Context context) { super(context); getHolder().addCallback(this); } @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { } @Override public void surfaceCreated(SurfaceHolder holder) { drawThread = new DrawThread(getHolder(), getResources()); drawThread.setRunning(true); drawThread.start(); } @Override public void surfaceDestroyed(SurfaceHolder holder) { boolean retry = true; //    drawThread.setRunning(false); while (retry) { try { drawThread.join(); retry = false; } catch (InterruptedException e) { //   ,       } } } } 

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

एक अनुप्रयोग गतिविधि इस तरह दिख सकती है:

 public class SurfaceViewActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(new MySurfaceView(this)); } } 

कार्यक्रम का परिणाम इस तरह दिखता है (रोटेशन के कारण, छवि थोड़ी धुंधली है, लेकिन डिवाइस पर यह काफी स्वीकार्य दिखता है):

निष्कर्ष

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

1. आधिकारिक प्रलेखन से खेल LunarLander का एक उदाहरण
   
2. सरफेस व्यू के उपयोग का वर्णन करने वाला लेख