“Nella programmazione per computer, un callback è un riferimento al codice eseguibile, o un pezzo di codice eseguibile, che viene passato come argomento ad altro codice. Ciò consente a un livello software di livello inferiore di chiamare una subroutine (o funzione) definita in un livello di livello superiore. " - Wikipedia
Richiamata in C usando il puntatore a funzione
In C, il callback viene implementato utilizzando il puntatore a funzione. Puntatore a funzione - come suggerisce il nome, è un puntatore a una funzione.
Ad esempio, int (* ptrFunc) ();
Qui, ptrFunc è un puntatore a una funzione che non accetta argomenti e restituisce un numero intero. NON dimenticare di inserire la parentesi, altrimenti il compilatore supporrà che ptrFunc sia un normale nome di funzione, che non accetta nulla e restituisce un puntatore a un numero intero.
Ecco un po 'di codice per dimostrare il puntatore alla funzione.
#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;
}
Ora proviamo a capire il concetto di Callback in C usando il puntatore a funzione.
Il programma completo ha tre file: callback.c, reg_callback.h e 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)();
}
Se eseguiamo questo programma, l'output sarà
Questo è un programma che mostra la funzione di callback all'interno di register_callback all'interno di my_callback e torna all'interno del programma principale
La funzione di livello superiore chiama una funzione di livello inferiore come una normale chiamata e il meccanismo di richiamata consente alla funzione di livello inferiore di chiamare la funzione di livello superiore tramite un puntatore a una funzione di richiamata.
Richiamata in Java tramite l'interfaccia
Java non ha il concetto di puntatore a funzione Implementa il meccanismo di callback attraverso il suo meccanismo di interfaccia Qui invece di un puntatore a funzione, dichiariamo un'interfaccia con un metodo che verrà chiamato quando la chiamata termina il suo compito
Vorrei dimostrarlo con un esempio:
L'interfaccia di callback
public interface Callback
{
public void notify(Result result);
}
Il chiamante o la classe di livello superiore
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
}
}
La funzione Chiamata o livello inferiore
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
}
}
Richiamata mediante il modello EventListener
Questo modello viene utilizzato per notificare da 0 a n numeri di osservatori / ascoltatori che una determinata attività è terminata
La differenza tra il meccanismo Callback e il meccanismo EventListener / Observer è che nel callback, il chiamante avvisa il singolo chiamante, mentre in Eventlisener / Observer, il chiamante può avvisare chiunque sia interessato a quell'evento (la notifica può andare ad alcune altre parti del applicazione che non ha attivato l'attività)
Lasciami spiegare con un esempio.
L'interfaccia dell'evento
public interface Events {
public void clickEvent();
public void longClickEvent();
}
Widget di classe
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);
}
}
Pulsante di classe
public class Button extends Widget{
private String mButtonText;
public Button (){
}
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}
Casella di controllo della classe
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;
}
}
Classe di attività
pacchetto 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();
}
}
Altra classe
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...");
}
}
Classe principale
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);
}
}
Come puoi vedere dal codice sopra, che abbiamo un'interfaccia chiamata eventi che sostanzialmente elenca tutti gli eventi che possono accadere per la nostra applicazione. La classe Widget è la classe base per tutti i componenti dell'interfaccia utente come Button, Checkbox. Questi componenti dell'interfaccia utente sono gli oggetti che ricevono effettivamente gli eventi dal codice del framework. La classe Widget implementa l'interfaccia Eventi e inoltre ha due interfacce nidificate, vale a dire OnClickEventListener & OnLongClickEventListener
Queste due interfacce sono responsabili dell'ascolto di eventi che possono verificarsi sui componenti dell'interfaccia utente derivati dal Widget come Button o Checkbox. Quindi, se confrontiamo questo esempio con il precedente esempio di Callback usando l'interfaccia Java, queste due interfacce funzionano come l'interfaccia di Callback. Quindi il codice di livello superiore (Here Activity) implementa queste due interfacce. E ogni volta che si verifica un evento su un widget, verrà chiamato il codice di livello superiore (o il metodo di queste interfacce implementato nel codice di livello superiore, che è qui Attività).
Ora lasciami discutere la differenza di base tra il modello Callback e Eventlistener. Come abbiamo detto che utilizzando Callback, Callee può notificare solo un singolo chiamante. Ma nel caso del modello EventListener, qualsiasi altra parte o classe dell'applicazione può registrarsi per gli eventi che possono verificarsi sul pulsante o sulla casella di controllo. L'esempio di questo tipo di classe è OtherClass. Se vedi il codice di OtherClass, scoprirai che si è registrato come listener di ClickEvent che può verificarsi nel pulsante definito nell'attività. La parte interessante è che, oltre all'attività (il chiamante), questa OtherClass verrà anche avvisata ogni volta che si verifica l'evento click sul pulsante.
