Dans le développement d'applications modernes, le développement piloté par les événements gagne en popularité. De nos jours, les développeurs utilisent largement les callbacks synchrones et asynchrones dans leurs applications pour obtenir une certaine flexibilité. Alors que ce concept est connu sous le nom de Callbacks dans la communauté Java, il est appelé Delegates dans le monde .NET. Aujourd'hui, nous allons expliquer les méthodes Callback de manière claire, à l'aide de trois exemples simples

Qu'est-ce qu'un rappel ?

Les rappels sont un mécanisme de programmation orientée objet qui permet à une application de traiter des événements souscrits, survenant au moment de l'exécution, par le biais d'une interface d'écoute. Les abonnés devront fournir une implémentation concrète des méthodes abstraites de l'interface. Ainsi, chaque fois que l'événement spécifié est déclenché, les actions prédéfinies qui lui sont associées s'exécutent dans l'ordre où elles ont été définies.

Exemples :

Instance de base :

Dans cet exemple, nous allons expliquer le concept de la création d'un callback en quatre étapes :
Tout d'abord, créez une interface de callback et déclarez à l'intérieur les méthodes à rappeler. Ces méthodes abstraites représentent les événements qui déclencheront les méthodes de rappel dans la classe principale.

Appelons l'interface ActionListenerCallback, avec les méthodes abstraites onActionSuccess et onActionFailure , qui seront passées avec une implémentation concrète comme argument à la setActionListener , par une instance anonyme de l'ActionListenerCallback.

 public interface ActionListenerCallback { public void onActionSuccess(String successMessage ; public void onActionFailure(Throwable throwableError) ; }

Créez la WorkerClass, c'est la classe qui va produire l'événement et déclencher les méthodes de rappel appropriées en fonction des conditions prédéfinies. La WorkerClass contient la méthode setActionListener, qui permettra aux objets abonnés d'envoyer leurs rappels en tant qu'argument, par le biais d'une interface anonyme ActionListenerCallback.

 

public class Worker { ActionListenerCallback callBack ; public Worker() { //initialisation de l'objet callback à partir du constructeur this.callBack = null ; } public void setActionListener(ActionListenerCallback callBack) { this.callBack = callBack ; System.out.println("Exécution d'une tâche, avant d'invoquer le callback") ; if (this.callBack!= null) { callBack.onActionSuccess (successMessage) ; else callBack.onActionFailure (throwableError) ; } } 

Fournissez la réponse souhaitée à l'événement en définissant les méthodes de rappel dans la classe SubscriberActivity. Dans le code ci-dessous, la méthode setActionListenermethodattachera l'ActionListenerCallback anonyme à l'objet worker, le rendant prêt à répondre lorsque l'événement spécifié est déclenché.

public class SubscriberActivity extends Activity { @Overrideprotected void onCreate(Bundle savedInstanceState) { Worker worker = new Worker () ; worker.setActionListener(new ActionListenerCallback () { @Overridepublic void onActionSuccess(StringsuccessMessage) { System.out.println("L'événement a été déclenché avec succès") ; } @Overridepublic void onActionFailure(Throwable throwableError) { System.err.println("Error : " + throwableError.getMessage()) ; } } } ; }

Exemple d'écouteurs de rappel Android :

Nous avons choisi de fournir le deuxième exemple à partir du cadre Android en raison de sa popularité. Android maintient l'interaction entre l'utilisateur final et l'application en utilisant le modèle de conception d'écouteur largement utilisé. Tous les composants de l'interface utilisateur, comme un bouton, héritent de la classe View, qui à son tour met en œuvre l'interface Callback du paquet android.graphics.drawable . La classe View contient tous les écouteurs d'événements pour intercepter les différents événements de l'interface utilisateur. Chacun de ces listeners ne contient qu'une seule méthode de rappel.

Jetons un coup d'oeil à l'un des callbacks les plus utilisés dans Android, onClick(), il est déclaré dans View.OnClickListenerinterfacecomme indiqué ci-dessous . Lorsque l'événement de clic se produit sur l'élément respectif de l'interface utilisateur, la méthode OnClick() sera déclenchée et exécutera les opérations définies par les objets souscripteurs

interface statique publique OnClickListener() { void onClick(View view) ; }

Ensuite, le code de rappel est défini et attaché au bouton à l'aide de l'interface OnClickListener, en attendant que l'événement de clic soit déclenché. L'élément d'interface utilisateur, qui est un bouton dans cet exemple, utilise la méthode setOnClickListener de sa superclasse View pour s'abonner à l'événement et fournir sa propre mise en œuvre de la fonction de rappel.

Button button = (Button) findViewById(R.id.button) ; button.setOnClickListener(new View.OnClickListener() { @Overridepublic void onClick(View view) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE) ; imm.hideSoftInputFromWindow(view.getWindowToken(), 0) ; startRegistration() ; }) ;)

Pour une référence complète, voici le setOnClickListener de la classe View.

public void setOnClickListener(@Nullable View.OnClickListener l) {lancer une nouvelle RuntimeException("Stub !") ;

} 

Exemple de rappel du SDK d'orchestration :

Pour maintenir la réactivité de l'application intégrée, le SDK d'orchestration utilise une approche asynchrone, dans laquelle l'intégrateur devra fournir des implémentations concrètes des méthodes de rappel pour les différentes activités fournies par le SDK d'orchestration. De cette façon, l'objet intégrateur est enregistré auprès d'un auditeur, et il pourrait poursuivre son exécution avec une autre opération. Chaque fois qu'un événement se produit, le SDK d'orchestration exécute le code lié à cet événement, y compris les méthodes de rappel définies par le développeur intégrateur.

REMARQUE : les méthodes de rappel sont appelées à partir du fil d'exécution de l'interface utilisateur sur Android, et à partir du fil d'exécution principal sur iOS.

Un exemple d'utilisation des méthodes de rappel du SDK Orchestration se trouve dans l'activité principale de l' application d'exemple. La méthode sendCommandToServermethodinstancie un objet CommandSender avec un objet anonyme de l'interface CommandSenderCallback. Cet anonyme portera l'implémentation concrète de onCommandSendingFailure et de onCommandSendingSuccess. En outre, le contexte de l'application sera fourni comme argument à l'objet CommandSender.
En suivant cette configuration, chaque fois que la méthode d'exécution asynchrone est exécutée sur l'objet CommandSender
, les méthodes de rappel seront appelées dans l'ordre déterminé

private void sendCommandToServer(String command) { CommandSender commandSender = new CommandSender(getApplicationContext(), new CommandSenderCallback() { @Overridepublic void onCommandSendingFailure() { UIUtils.hideProgress(progressDialog) ; UIUtils.displayAlert(MainActivity.this, getString(R.string.dialog_error_title), getString(R.string.dialog_error_content_sending)) ; } @Overridepublic void onCommandSendingSuccess(String serverCommand) { orchestrator.execute(serverCommand) ; } }) ; commandSender.execute(command) ;

Ce tutoriel était un point d'entrée pour le concept des méthodes Callback, destiné à fournir une compréhension de base du flux entre les différentes activités de la suite OneSpan Mobile Security. Nous nous appuierons sur ce concept de base pour approfondir ce sujet dans les prochains blogs. En attendant, si vous avez des questions, n'hésitez pas à nous contacter sur les forums du portail communautaire OneSpan.