“कंप्यूटर प्रोग्रामिंग में, कॉलबैक निष्पादन योग्य कोड, या निष्पादन योग्य कोड का एक टुकड़ा है, जो अन्य कोड के तर्क के रूप में पारित किया जाता है। यह निम्न-स्तरीय सॉफ़्टवेयर परत को उच्च-स्तरीय परत में परिभाषित उप-रेखा (या फ़ंक्शन) को कॉल करने की अनुमति देता है। " - विकिपीडिया
फ़ंक्शन सूचक का उपयोग करके C में कॉलबैक
C में, फ़ंक्शन पॉइंटर का उपयोग करके कॉलबैक लागू किया जाता है। फ़ंक्शन पॉइंटर - जैसा कि नाम से पता चलता है, एक फ़ंक्शन के लिए एक संकेतक है।
उदाहरण के लिए, int (* ptrFunc) ();
यहां, ptrFunc एक फ़ंक्शन का एक संकेतक है जो कोई तर्क नहीं लेता है और पूर्णांक देता है। कोष्ठक में रखना मत भूलना, अन्यथा संकलक मान लेंगे कि ptrFunc एक सामान्य फ़ंक्शन नाम है, जो कुछ भी नहीं लेता है और एक पूर्णांक के लिए एक संकेतक लौटाता है।
फ़ंक्शन पॉइंटर को प्रदर्शित करने के लिए यहां कुछ कोड दिए गए हैं।
#include<stdio.h>
int func(int, int);
int main(void)
{
int result1,result2;
/* declaring a pointer to a function which takes
two int arguments and returns an integer as result */
int (*ptrFunc)(int,int);
/* assigning ptrFunc to func's address */
ptrFunc=func;
/* calling func() through explicit dereference */
result1 = (*ptrFunc)(10,20);
/* calling func() through implicit dereference */
result2 = ptrFunc(10,20);
printf("result1 = %d result2 = %d\n",result1,result2);
return 0;
}
int func(int x, int y)
{
return x+y;
}
अब हम फ़ंक्शन पॉइंटर का उपयोग करके C में कॉलबैक की अवधारणा को समझने का प्रयास करते हैं।
पूर्ण कार्यक्रम में तीन फाइलें हैं: callback.c, reg_callback.h और reg_callback.c।
/* callback.c */
#include<stdio.h>
#include"reg_callback.h"
/* callback function definition goes here */
void my_callback(void)
{
printf("inside my_callback\n");
}
int main(void)
{
/* initialize function pointer to
my_callback */
callback ptr_my_callback=my_callback;
printf("This is a program demonstrating function callback\n");
/* register our callback function */
register_callback(ptr_my_callback);
printf("back inside main program\n");
return 0;
}
/* reg_callback.h */
typedef void (*callback)(void);
void register_callback(callback ptr_reg_callback);
/* reg_callback.c */
#include<stdio.h>
#include"reg_callback.h"
/* registration goes here */
void register_callback(callback ptr_reg_callback)
{
printf("inside register_callback\n");
/* calling our callback function my_callback */
(*ptr_reg_callback)();
}
यदि हम इस प्रोग्राम को चलाते हैं, तो आउटपुट होगा
यह मुख्य कार्यक्रम के अंदर my_callback के अंदर register_callback के अंदर फ़ंक्शन कॉलबैक प्रदर्शित करने वाला एक प्रोग्राम है
उच्च परत फ़ंक्शन सामान्य कॉल के रूप में एक निचली परत फ़ंक्शन को कॉल करता है और कॉलबैक तंत्र किसी कॉलबैक फ़ंक्शन के लिए पॉइंटर के माध्यम से उच्च परत फ़ंक्शन को कॉल करने की अनुमति देता है।
इंटरफ़ेस का उपयोग करके जावा में कॉलबैक
जावा में फंक्शन पॉइंटर की अवधारणा नहीं है। यह अपने इंटरफेस तंत्र के माध्यम से कॉलबैक तंत्र को लागू करता है। यहां फ़ंक्शन पॉइंटर के बजाय, हम एक इंटरफ़ेस की घोषणा करते हैं जिसमें एक विधि होती है जिसे कॉल किया जाता है जब कैली अपने कार्य को पूरा करता है।
मुझे एक उदाहरण के माध्यम से इसे प्रदर्शित करने दें:
कॉलबैक इंटरफ़ेस
public interface Callback
{
public void notify(Result result);
}
कॉलर या उच्च स्तर की कक्षा
public Class Caller implements Callback
{
Callee ce = new Callee(this); //pass self to the callee
//Other functionality
//Call the Asynctask
ce.doAsynctask();
public void notify(Result result){
//Got the result after the callee has finished the task
//Can do whatever i want with the result
}
}
कैली या निचली परत का कार्य
public Class Callee {
Callback cb;
Callee(Callback cb){
this.cb = cb;
}
doAsynctask(){
//do the long running task
//get the result
cb.notify(result);//after the task is completed, notify the caller
}
}
EventListener पैटर्न का उपयोग कर कॉलबैक
इस पैटर्न का उपयोग पर्यवेक्षकों / श्रोताओं की 0 से n संख्याओं को सूचित करने के लिए किया जाता है जो एक विशेष कार्य समाप्त हो गया है
कॉलबैक तंत्र और EventListener / ऑब्जर्वर तंत्र के बीच का अंतर यह है कि कॉलबैक में, कॉलली एकल कॉलर को सूचित करता है, जबकि Eventlisener / ऑब्जर्वर में, कैलि उस व्यक्ति को सूचित कर सकता है जो उस ईवेंट में रुचि रखता है (अधिसूचना कुछ अन्य भागों में जा सकती है) अनुप्रयोग जिसने कार्य को ट्रिगर नहीं किया है)
इसे एक उदाहरण के माध्यम से समझाता हूं।
इवेंट इंटरफ़ेस
public interface Events {
public void clickEvent();
public void longClickEvent();
}
वर्ग विजेट
package com.som_itsolutions.training.java.exampleeventlistener;
import java.util.ArrayList;
import java.util.Iterator;
public class Widget implements Events{
ArrayList<OnClickEventListener> mClickEventListener = new ArrayList<OnClickEventListener>();
ArrayList<OnLongClickEventListener> mLongClickEventListener = new ArrayList<OnLongClickEventListener>();
@Override
public void clickEvent() {
// TODO Auto-generated method stub
Iterator<OnClickEventListener> it = mClickEventListener.iterator();
while(it.hasNext()){
OnClickEventListener li = it.next();
li.onClick(this);
}
}
@Override
public void longClickEvent() {
// TODO Auto-generated method stub
Iterator<OnLongClickEventListener> it = mLongClickEventListener.iterator();
while(it.hasNext()){
OnLongClickEventListener li = it.next();
li.onLongClick(this);
}
}
public interface OnClickEventListener
{
public void onClick (Widget source);
}
public interface OnLongClickEventListener
{
public void onLongClick (Widget source);
}
public void setOnClickEventListner(OnClickEventListener li){
mClickEventListener.add(li);
}
public void setOnLongClickEventListner(OnLongClickEventListener li){
mLongClickEventListener.add(li);
}
}
कक्षा बटन
public class Button extends Widget{
private String mButtonText;
public Button (){
}
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}
कक्षा चेकबॉक्स
public class CheckBox extends Widget{
private boolean checked;
public CheckBox() {
checked = false;
}
public boolean isChecked(){
return (checked == true);
}
public void setCheck(boolean checked){
this.checked = checked;
}
}
गतिविधि वर्ग
पैकेज com.som_itsolutions.training.java.exampleeventlistener;
public class Activity implements Widget.OnClickEventListener
{
public Button mButton;
public CheckBox mCheckBox;
private static Activity mActivityHandler;
public static Activity getActivityHandle(){
return mActivityHandler;
}
public Activity ()
{
mActivityHandler = this;
mButton = new Button();
mButton.setOnClickEventListner(this);
mCheckBox = new CheckBox();
mCheckBox.setOnClickEventListner(this);
}
public void onClick (Widget source)
{
if(source == mButton){
mButton.setButtonText("Thank you for clicking me...");
System.out.println(((Button) mButton).getButtonText());
}
if(source == mCheckBox){
if(mCheckBox.isChecked()==false){
mCheckBox.setCheck(true);
System.out.println("The checkbox is checked...");
}
else{
mCheckBox.setCheck(false);
System.out.println("The checkbox is not checked...");
}
}
}
public void doSomeWork(Widget source){
source.clickEvent();
}
}
अन्य वर्ग
public class OtherClass implements Widget.OnClickEventListener{
Button mButton;
public OtherClass(){
mButton = Activity.getActivityHandle().mButton;
mButton.setOnClickEventListner(this);//interested in the click event //of the button
}
@Override
public void onClick(Widget source) {
if(source == mButton){
System.out.println("Other Class has also received the event notification...");
}
}
मुख्य वर्ग
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Activity a = new Activity();
OtherClass o = new OtherClass();
a.doSomeWork(a.mButton);
a.doSomeWork(a.mCheckBox);
}
}
जैसा कि आप उपरोक्त कोड से देख सकते हैं, कि हमारे पास एक इंटरफ़ेस है, जिसे इवेंट कहा जाता है, जो मूल रूप से उन सभी घटनाओं को सूचीबद्ध करता है जो हमारे एप्लिकेशन के लिए हो सकती हैं। विजेट वर्ग बटन, चेकबॉक्स जैसे सभी UI घटकों के लिए आधार वर्ग है। ये यूआई घटक ऑब्जेक्ट हैं जो वास्तव में फ्रेमवर्क कोड से घटनाओं को प्राप्त करते हैं। विजेट वर्ग ईवेंट इंटरफ़ेस को लागू करता है और इसमें दो नेस्टेड इंटरफेस भी होते हैं जिनका नाम OnClickEventListener और OnLongClickEventListener है
ये दो इंटरफेस बटन या चेकबॉक्स जैसे विजेट व्युत्पन्न यूआई घटकों पर होने वाली घटनाओं को सुनने के लिए जिम्मेदार हैं। इसलिए यदि हम इस उदाहरण की तुलना जावा इंटरफेस का उपयोग करके पहले के कॉलबैक उदाहरण से करते हैं, तो ये दो इंटरफेस कॉलबैक इंटरफेस के रूप में काम करते हैं। तो उच्च स्तर का कोड (यहां गतिविधि) इन दो इंटरफेस को लागू करता है। और जब भी कोई घटना विजेट में घटित होती है, तो उच्च स्तरीय कोड (या उच्च स्तर कोड में लागू इन इंटरफेस की विधि, जो यहां गतिविधि है) को कहा जाएगा।
अब मुझे कॉलबैक और इवेंटलिस्टर पैटर्न के बीच बुनियादी अंतर पर चर्चा करने दें। जैसा कि हमने उल्लेख किया है कि कॉलबैक का उपयोग करते हुए, कैलली केवल एक ही कॉलर को सूचित कर सकता है। लेकिन EventListener पैटर्न के मामले में, एप्लिकेशन का कोई अन्य भाग या वर्ग बटन या चेकबॉक्स पर होने वाली घटनाओं के लिए पंजीकरण कर सकता है। इस तरह के वर्ग का उदाहरण अन्य क्लैक्सेस है। यदि आप OtherClass का कोड देखते हैं, तो आप पाएंगे कि इसने खुद को ClickEvent में एक श्रोता के रूप में पंजीकृत किया है जो गतिविधि में परिभाषित बटन में हो सकता है। दिलचस्प हिस्सा यह है कि, गतिविधि (कॉलर) के अलावा, यह अन्यक्लास को भी सूचित किया जाएगा जब भी बटन पर क्लिक करने की घटना होती है।
