Partager via

Kit de développement logiciel (SDK) - Observateurs du kit de développement logiciel ( SDK) Policy

  • Article

Le SDK Policy contient une classe d’observateur. Les membres observateurs sont virtuels et doivent être remplacés pour gérer les rappels pour les opérations asynchrones.

Quand une opération asynchrone se termine, la fonction du membre OnXxx() correspondant au résultat est appelée. Des exemples sont OnLoadSuccess(), OnLoadFailure() et OnAddEngineSuccess() pour mip::Profile::Observer.

Les exemples ci-dessous illustrent le modèle de promesse/avenir, qui est également utilisé par les exemples du kit de développement logiciel (SDK) et peut être étendu pour implémenter le comportement de rappel souhaité.

Implémentation de l’observateur de profil

Dans l’exemple suivant, nous avons créé une classe, ProfileObserver, dérivée de mip::Profile::Observer. Les fonctions membres ont été remplacées pour utiliser le modèle avenir/promesse utilisé dans les exemples.

Remarque : Les exemples ci-dessous ne sont implémentés que partiellement et n’incluent pas de remplacements pour les observateurs associés au mip::ProfileEngine.

profile_observer.h

Dans l’en-tête, nous définissons ProfileObserver, dérivant de mip::Profile::Observer, puis remplaçons chacune des fonctions membres.

class ProfileObserver final : public mip::Profile::Observer {
public:
ProfileObserver() { }
  void OnLoadSuccess(const std::shared_ptr<mip::Profile>& profile, const std::shared_ptr<void>& context) override;
  void OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
  //TODO: Implement remaining members
};

profile_observer.cpp

Dans l’implémentation elle-même, nous définissons une action à entreprendre pour chaque fonction membre de l’observateur.

Chaque membre accepte deux paramètres. Le premier est un pointeur partagé vers la classe gérée par la fonction. ProfileObserver::OnLoadSuccess s’attendrait à recevoir un mip::Profile. ProfileObserver::OnAddEngineSuccess s’attendrait à mip::ProfileEngine.

Le deuxième est un pointeur partagé vers le contexte. Dans notre implémentation, le contexte est une référence à un std::promise, passé en tant que shared_ptr<void>. La première ligne de la fonction le convertit en std::promise, puis est stockée dans un objet appelé promise.

Enfin, l’avenir est prêt en définissant la fonction promise->set_value() et en la passant dans l’objet mip::Profile.

#include "profile_observer.h"
#include <future>

//Called when Profile is successfully loaded
void ProfileObserver::OnLoadSuccess(const std::shared_ptr<mip::Profile>& profile, const std::shared_ptr<void>& context) {
  //cast context to promise
  auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::Profile>>>(context);
  //set promise value to profile
  promise->set_value(profile);
}

//Called when Profile fails to load
void ProfileObserver::OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
  auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::Profile>>>(context);
  promise->set_exception(error);
}

//TODO: Implement remaining observer members

Lors de l’exécution d’une opération asynchrone, l’implémentation de l’observateur est passée au constructeur des paramètres ou à la fonction asynchrone elle-même.