Microsoft Information Protection SDK - Observateurs du SDK de fichiers

Le Kit de développement logiciel (SDK) File contient deux classes d’observateur. Les membres observateurs sont virtuels et peuvent être remplacés pour gérer les rappels d’événements.

Lorsqu’une opération asynchrone se termine, la OnXxx() fonction membre correspondant au résultat est appelée. Voici des exemples : OnLoadSuccess(), OnLoadFailure()et OnAddEngineSuccess() pour mip::FileProfile::Observer.

Ces exemples illustrent le modèle de promesse/futur, 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 de fichier

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

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

profile_observer.h

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

class ProfileObserver final : public mip::FileProfile::Observer {
public:
ProfileObserver() { }
  void OnLoadSuccess(const std::shared_ptr<mip::FileProfile>& profile, const std::shared_ptr<void>& context) override;
  void OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
  //TODO: Implement mip::FileEngine related observers.
};

profile_observer.cpp

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

Chaque membre accepte deux paramètres. Le premier est un pointeur partagé vers la classe que nous gérons dans la fonction. ProfileObserver::OnLoadSuccess s’attendrait à recevoir un mip::FileProfile. ProfileObserver::OnAddEngineSuccess s’attendrait à mip::FileEngine.

Le deuxième est un pointeur partagé vers le contexte. Dans notre implémentation, le contexte est une référence à un std::promise, transmise par référence sous la forme de std::shared_ptr<void>. La première ligne de la fonction convertit ceci en std::promise, puis le stocke dans un objet appelé promise.

Enfin, le future est préparé en définissant le promise->set_value() et en passant l’objet mip::FileProfile.

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

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

//Called when FileProfile 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::FileProfile>>>(context);
  promise->set_exception(error);
}

//TODO: Implement mip::FileEngine related observers.

Lorsque nous instancions une classe sdk ou utilisons une fonction qui effectue des opérations asynchrones, nous transmettons l’implémentation de l’observateur au constructeur de paramètres ou à la fonction asynchrone elle-même. Lors de l’instanciation de l’objet mip::FileProfile::Settings, le constructeur prend mip::FileProfile::Observer comme l’un des paramètres. Cet exemple montre notre ProfileObserver personnalisé, utilisé dans un constructeur mip::FileProfile::Settings.

Implémentation de l’observateur de FileHandler

Comme l’observateur du profil, mip::FileHandler implémente une classe mip::FileHandler::Observers pour gérer les notifications d’événements asynchrones lors des opérations sur les fichiers. L’implémentation est similaire à celle décrite ci-dessus. FileHandlerObserver est partiellement défini ci-dessous.

file_handler_observer.h

#include "mip/file/file_handler.h"

class FileHandlerObserver final : public mip::FileHandler::Observer {
public:
  void OnCreateFileHandlerSuccess(
      const std::shared_ptr<mip::FileHandler>& fileHandler,
      const std::shared_ptr<void>& context) override;

  void OnCreateFileHandlerFailure(
      const std::exception_ptr& error,
      const std::shared_ptr<void>& context) override;

  //TODO: override remaining member functions inherited from mip::FileHandler::Observer
};

file_handler_observer.cpp

Cet exemple n’est que les deux premières fonctions, mais les autres fonctions utilisent un modèle similaire à ceux-ci et à ProfileObserver.

#include "file_handler_observer.h"

void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
    promise->set_value(fileHandler);
}

void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
    promise->set_exception(error);
}

//TODO: override remaining member functions inherited from mip::FileHandler::Observer
  • Last updated on