Event Handling in Android using Interface Type

Event Handling in Android using Interface Type – Java में हम किसी Interface को एक Type या Class की तरह Use कर सकते हैं और इसमें उस Class के किसी Instance यानी Object का Reference Hold कर सकते हैं, जिसमें उस Interface को Implement किया गया हो। Java Interface की यही Functionality हमें किसी Event Source को उसके Event Listener के साथ Register करने की सुविधा प्रदान करता है।

इस तरीके के अन्‍तर्गत हम एक Anonymous Event Listener Class Create करते हैं जिसका कोई नाम नहीं होता और उस Unnamed या Noname Class का Reference एक Appropriate Listener Interface Type के Variable में Assign कर देते हैं। फिर उस Variable के माध्‍यम से Event Source को Anonymous Listener Class के साथ Register कर देते हैं।

इस तरीके में भी Event Handling की सारी प्रक्रियाएं Internally तो बिलकुल वैसी ही होती हैं जैसी पिछले Section में Discuss किए गए तरीके में होती हैं, लेकिन बाहर से देखने पर दोनों तरीकों में अन्‍तर दिखाई देता है।

Anonymous Event Listener Class Create करने और Event Source को उसके साथ Register करने की प्रक्रिया के अलावा Callback Event Handler Method को Implement करने के तरीके में कोई अन्‍तर नहीं है और Interface Type के अन्‍तर्गत भी इस Callback Method को Exactly उसी तरीके से Define किया जाता है जिस तरीके से पिछले Section में Define किए गए Nested Listener Class के अन्‍तर्गत किया था।

जब हम Member Method के रूप में ऐसी Event Listener Class को Define करते हैं जिसमें Appropriate Listener Interface को Implement किया गया होता है और फिर Event Source को उस Event Listener Class के साथ Register करने के लिए हमें निम्‍न Statement में Highlight किए अनुसार Event Listener Class का एक Anonymous Object Create करते हैं जो कि Event Source को Event Listener Class के साथ Bind कर देता है-

findViewById(R.id.btnAdd).setOnClickListener(new ClickHandler());
findViewById(R.id.btnSub).setOnClickListener(new ClickHandler());
findViewById(R.id.btnMul).setOnClickListener(new ClickHandler());
findViewById(R.id.btnDiv).setOnClickListener(new ClickHandler());
findViewById(R.id.btnRem).setOnClickListener(new ClickHandler());

इस तरीके में भी Create होने वाला Event Listener Object केवल One Time Use के लिए ही Create किया जाना होता है, जिसका कुल काम इतना ही होता है कि वह Event Source को Event Listener Class के साथ Register कर सके ताकि Event Source द्वारा Fire होने वाले Events से Listner Class Notify हो सके और Response के रूप में Callback Event Handler Method को Execute कर सके और इसीलिए इस Object को किसी Named Object के रूप में Saved नहीं रखा जाता।

लेकिन जब हम Interface Type का प्रयोग करते हुए Event Listener Class पर Event Source को Register करना चाहते हैं, तब हम Event Listener Class का Anonymous Object Create नहीं करते बल्कि Event Listener Class को ही एक Anonymous Class की तरह Create कर लेते हैं और इस Anonymous Event Listener Class में Appropriate Event Listener Interface के Callback Event Handler Method को Define कर लेने के परिणामस्‍वरूप उसमें Event Listener Interface Implement हो जाता है।

इसलिए अब हम इस Anonymous Event Listener Class के Reference को उस Event Listener Interface Type के Variable में Assign कर सकते हैं, जिसे उस Anonymous Event Listener Class में Implement किया गया है। क्‍योंकि Interface Type का Variable तभी किसी Class के Reference को Hold कर सकता है, जबकि उसके सभी Abstract Methods को उस Class में Implement कर दिया गया हो और हमारे Example में View.OnClickListener नाम के Interface में onClick() नाम का केवल एक ही Abstract Method है, जिसे Anonymous Event Listener Class में Implement कर दिया जाता है।

इस प्रकार से अब यदि हम Interface Type तरीके को Use करते हुए Event Source को Anonymous Event Listener Class पर Register करना चाहें, तो हमें निम्‍न Statement में Highlight किए अनुसार उस Listener Interface Type के Variable को Specify करना होता है जिसमें Anonymous Event Listener Class का Reference Stored है-

findViewById(R.id.btnAdd).setOnClickListener(clickHandler);
findViewById(R.id.btnSub).setOnClickListener(clickHandler);
findViewById(R.id.btnMul).setOnClickListener(clickHandler);
findViewById(R.id.btnDiv).setOnClickListener(clickHandler);
findViewById(R.id.btnRem).setOnClickListener(clickHandler);

जबकि Anonymous Event Listener Class को हम निम्‍नानुसार तरीके से Define कर सकते हैं जिसमें View.OnClickListener Interface का onClick() Callback Event Handler Method Implemented है, जो कि Event Source द्वारा Fire होने वाले Events से Notify होकर Response के रूप में Execute हो जाता है-

    private View.OnClickListener clickHandler = new View.OnClickListener (){

        public void onClick(View btnClicked) {

             . . .

        }

    };

इस Code की शुरूआत में ही हमने private Keyword को Use किया है क्‍योंकि ये एक Event Handler है और Event Handler केवल Current Activity के Layouts द्वारा Fire होने वाले Events को Handle करने के लिए ही उपयोगी होता है। इसलिए इसे public या default Access Specifier के साथ Specify करने का कोई मतलब ही नहीं है।

क्‍योंकि हम clickHandler नाम का एक View.OnClickListener Interface Type का Variable Create कर रहे हैं, इसलिए इसमें Value के रूप में केवल उसी Class के Instance का Reference Assign किया जा सकता है, जिसमें View.OnClickListener Interface में Declared सभी Abstract Methods को Implement यानी Define किया गया हो।

चूंकि अभी तक हमने कोई ऐसी Class Create नहीं की है, इसलिए या तो हम एक ऐसी Class Create करें जिसमें View.OnClickListener Interface Implemented हो और फिर उसके किसी Instance से clickHandler Variable को Assign करें, जैसाकि Member Listener Class के रूप में पिछले Section में किया था, या फिर हम एक Anonymous Class Create करें जिसमें View.OnClickListener Interface के onClick() Abstract Method को Implement किया गया हो और इसी समय उस Created Class का एक नया Instance Create करके उसके Reference को clickHandler Variable में Assign कर दें, जैसाकि उपरोक्‍त Code Fragement में किया गया है।

जब हम इस दूसरे तरीके को Use करते हैं, तो उपरोक्‍त Code Fragement में सबसे पहले Assignment Operator के Right Side में Specified View.OnClickListener() Constructor के माध्‍यम से निम्‍नानुसार Highlighted Program Code Execute होता है और एक Unnamed या Anonymous Event Listener Class Create होता है क्‍योंकि Assignment Operator का Priority सबसे कम व View.OnClickListener() Constructor के साथ Specified Parenthesis की Priority सबसे ज्‍यादा होती है-

    private View.OnClickListener clickHandler = new View.OnClickListener (){
         public void onClick(View btnClicked) {

             . . .

        }

    };

चूंकि इस Anonymous Event Listener Class का कोई नाम नहीं है, इसलिए जैसे ही ये Class Create होती है, इसका एक Instance Create करना जरूरी होता है, अन्‍यथा जैसे ही ये Highlighted Code Block Execute करके Program Control आगे बढ़ेगा, Compiler के लिए ये Newly Defined Anonymous Class Inaccessible हो जाएगा। परिणामस्‍वरूप Java का Garbage Collector इसे Destroy करके इसके Resources को Free देगा क्‍योंकि Java Compiler द्वारा किसी Class को Memory में तब तक कोई Space Allocate नहीं किया जाता जब तक कि उसका कोई Instance Create न हो।

इसीलिए उपरोक्‍त Highlighted Code द्वारा Anonymous Class Create होते ही “new” Operator अपना काम करता है और इस Newly Created Anonymous Class का एक Instance Create कर देता है।

चूंकि “new” Operator की Priority, Parenthesis से कम होती है इसलिए View.OnClickListener() Constructor के Execute होने के Response में Anonymous Class Create होने के बाद ही new Operator अपना काम शुरू करता है और Newly Defined Anonymous Event Listener Class का एक Unnamed Instance Create करके उसका Reference Return कर देता है जो कि View.OnClickListener Interface Type के clickHandler Variable में Assign हो जाता है।

यहां एक और बात ध्‍यान रखने वाली ये है कि इस Code में हम यद्धपि एक Anonymous Class Define कर रहे हैं लेकिन ये पूरी Class एक Single Statement के रूप में Define हो रही है और जावा में प्रत्‍येक Statement का अन्‍त एक Semicolon से होता है। इसीलिए एक Anonymous Class का Description Specify करने के बावजूद Anonymous Class के Closing Curly Brace के बाद हमने Semicolon का प्रयोग करते हुए Statement का अन्‍त किया है जबकि Normal Java Class Create करते समय कभी भी Closing Curly Brace के बाद Semicolon का प्रयोग नहीं किया जाता।

अब यदि हम Interface Type के माध्‍यम से Event Handling Mechanism के दूसरे तरीके का प्रयोग करते हुए अपने पिछले Example को ही Modify करें, तो हमारी Modified Java File के Code कुछ निम्‍नानुसार होंगे-

File Name: MainActivity.java

package com.bccfalna.arithmetic;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //Register Event Source Using View.OnClickListener Interface Type clickHandler variable
        findViewById(R.id.btnAdd).setOnClickListener( clickHandler );
        findViewById(R.id.btnSub).setOnClickListener( clickHandler );
        findViewById(R.id.btnMul).setOnClickListener( clickHandler );
        findViewById(R.id.btnDiv).setOnClickListener( clickHandler );
        findViewById(R.id.btnRem).setOnClickListener( clickHandler );
    }

    private View.OnClickListener clickHandler = new View.OnClickListener (){
        public void onClick(View btnClicked) {
            // Get a reference to the etFN EditText of Layout
            EditText etFN = (EditText) findViewById(R.id.etFN);

            // Get a reference to the etSN EditText of Layout
            EditText etSN = (EditText) findViewById(R.id.etSN);

            // Get a reference to the tvResult TextView of Layout
            TextView tvResult = (TextView) findViewById(R.id.tvResult);

            // Type Cast etFN and etSN Text into String and then into Value
            double fn = Double.parseDouble(etFN.getText().toString());
            double sn = Double.parseDouble(etSN.getText().toString());

            switch (btnClicked.getId()) {
                case R.id.btnAdd:
                    // tvResult = etFN + etSN
                    tvResult.setText(String.valueOf(fn + sn));
                    break;

                case R.id.btnSub:
                    // tvResult = etFN - etSN
                    tvResult.setText(String.valueOf(fn - sn));
                    break;

                case R.id.btnMul:
                    // tvResult = etFN x etSN
                    tvResult.setText(String.valueOf(fn * sn));
                    break;

                case R.id.btnDiv:
                    // tvResult = etFN / etSN
                    tvResult.setText(String.valueOf(fn / sn));
                    break;

                case R.id.btnRem:
                    // tvResult = etFN % etSN
                    tvResult.setText(String.valueOf(fn % sn));
                    break;

                default:
            }
        }
    };
}

जब हम इस Modified Event Handler Code वाले Android App को Run करते हैं, तब भी हमें Exactly वैसा ही Output प्राप्‍त होता है जैसा पिछले Section में Create किए गए Nested Event Listener Class द्वारा प्राप्‍त हो रहा था। इसलिए हम इन दोनों में से जिसे चाहें उस तरीके को Use करते हुए अपने Event Handler को Specify कर सकते हैं।