SDK de Microsoft Information Protection: Observadores del SDK de protección

El SDK de protección contiene tres clases de observador. Los miembros del observador son virtuales y se pueden invalidar para controlar las devoluciones de llamada de las operaciones asincrónicas.

• Perfil de protección: mip::ProtectionProfile::Observer
• Motor de protección: mip::ProtectionEngine::Observer
• Controlador de protección: mip::ProtectionHandler::Observer

Cuando finaliza una operación asincrónica, se llama a la función miembro de OnXxx() correspondiente para obtener el resultado. Algunos ejemplos de ello son OnLoadSuccess(), OnLoadFailure() y OnAddEngineSuccess() para mip::ProtectionProfile::Observer.

Los ejemplos siguientes muestran el patrón de promesa/futuro, que también se usa en los ejemplos del SDK, y se puede ampliar para implementar el comportamiento de devolución de llamada deseado.

Implementación del observador protectionProfile

En el ejemplo siguiente, hemos creado una clase, ProtectionProfileObserverImpl, que se deriva de mip::ProtectionProfile::Observer. Las funciones miembro se han invalidado para usar el patrón promesa/futuro usado en los ejemplos.

Declaración de la clase ProtectionProfileObserverImpl

En el encabezado, definimos ProtectionProfileObserverImpl, que deriva de mip::ProtectionProfile::Observer, y, a continuación, invalidamos cada una de las funciones miembro.

//ProtectionProfileObserverImpl.h
class ProtectionProfileObserverImpl final : public mip::ProtectionProfile::Observer {
public:
  ProtectionProfileObserverImpl() { }
  void OnLoadSuccess(const shared_ptr<mip::ProtectionProfile>& profile, const shared_ptr<void>& context) override;
  void OnLoadFailure(const exception_ptr& error, const shared_ptr<void>& context) override;
  void OnAddEngineSuccess(const shared_ptr<mip::ProtectionEngine>& engine, const shared_ptr<void>& context) override;
  void OnAddEngineError(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implementación de ProtectionProfileObserverImpl

En la propia implementación, simplemente definimos la acción que se debe realizar para cada función miembro del observador.

Cada miembro acepta dos parámetros. El primero es un puntero compartido a la clase que controlamos en la función. ProtectionObserver::OnLoadSuccess esperaría recibir mip::ProtectionProtection y ProtectionObserver::OnAddEngineSuccess esperaría mip::ProtectionEngine.

El segundo es un puntero compartido al contexto. En nuestra implementación, el contexto es una referencia a std::promise que se ha enviado como shared_ptr<void>. La primera línea de la función convierte todo esto en std::promise y, a continuación, se almacena en un objeto denominado promise.

Por último, se prepara el futuro estableciendo el valor de promise->set_value() y pasando el objeto mip::ProtectionProtection.

//protection_observers.cpp

void ProtectionProfileObserverImpl::OnLoadSuccess(
  const shared_ptr<mip::ProtectionProfile>& profile,
  const shared_ptr<void>& context) {
  auto loadPromise = static_cast<promise<shared_ptr<mip::ProtectionProfile>>*>(context.get());
  loadPromise->set_value(profile);
};

void ProtectionProfileObserverImpl::OnLoadFailure(const exception_ptr& error, const shared_ptr<void>& context) {
  auto loadPromise = static_cast<promise<shared_ptr<mip::ProtectionProfile>>*>(context.get());
  loadPromise->set_exception(error);
};

void ProtectionProfileObserverImpl::OnAddEngineSuccess(
  const shared_ptr<mip::ProtectionEngine>& engine,
  const shared_ptr<void>& context) {
  auto addEnginePromise = static_cast<promise<shared_ptr<mip::ProtectionEngine>>*>(context.get());
  addEnginePromise->set_value(engine);
};

void ProtectionProfileObserverImpl::OnAddEngineError(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto addEnginePromise = static_cast<promise<shared_ptr<mip::ProtectionEngine>>*>(context.get());
  addEnginePromise->set_exception(error);
};

Cuando creemos instancias de cualquier clase de SDK o usemos una función que realice operaciones asincrónicas, pasaremos la implementación del observador al constructor de configuración o a la propia función asincrónica. Al crear una instancia del objeto mip::ProtectionProfile::Settings, el constructor incorpora mip::ProtectionProfile::Observer como uno de los parámetros. En el ejemplo siguiente se muestra el valor de ProtectionProfileObserverImpl personalizado que se usa en un constructor mip::ProtectionProfile::Settings.

Implementación del observador protectionHandler

De forma similar al observador de protección, mip::ProtectionHandler implementa una clase mip::ProtectionHandler::Observer para controlar las notificaciones de eventos asincrónicas durante las operaciones de protección. La implementación es similar a la que detallamos anteriormente. A continuación, se define parcialmente ProtectionHandlerObserverImpl. La implementación completa está disponible en nuestro repositorio de ejemplo de GitHub.

Declaración de la clase ProtectionHandlerObserverImpl

//protection_observers.h

class ProtectionHandlerObserverImpl final : public mip::ProtectionHandler::Observer {
public:
  ProtectionHandlerObserverImpl() { }
  void OnCreateProtectionHandlerSuccess(const shared_ptr<mip::ProtectionHandler>& protectionHandler, const shared_ptr<void>& context) override;
  void OnCreateProtectionHandlerError(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implementación parcial de ProtectionHandlerObserverImpl

Este ejemplo solo hace referencia a las dos primeras funciones, pero las funciones restantes usan un patrón similar a estos y a ProtectionObserver.

//protection_observers.cpp

void ProtectionHandlerObserverImpl::OnCreateProtectionHandlerSuccess(
  const shared_ptr<mip::ProtectionHandler>& protectionHandler,
  const shared_ptr<void>& context) {
  auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
  createProtectionHandlerPromise->set_value(protectionHandler);
};

void ProtectionHandlerObserverImpl::OnCreateProtectionHandlerError(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
  createProtectionHandlerPromise->set_exception(error);
};