SDK de protección de la información de Microsoft: observadores del SDK de protección

El SDK de protección contiene tres clases de observador. Puede sobrescribir los miembros virtuales del observador para manejar las llamadas de retorno de las operaciones asíncronas.

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

En los ejemplos siguientes se muestra el patrón de promesa y futuro. Los ejemplos del SDK también usan este patrón y puede ampliarlo para implementar el comportamiento de devolución de llamada deseado.

Implementación del observador de perfil de protección

En el ejemplo siguiente se crea una clase , ProtectionProfileObserverImpl, que deriva de mip::ProtectionProfile::Observer. Las funciones miembro sobrescriben las de la clase base para utilizar el patrón promesa/futuro empleado en todos los ejemplos.

Declaración de clase ProtectionProfileObserverImpl

El encabezado define ProtectionProfileObserverImpl, lo deriva de mip::ProtectionProfile::Observery, a continuación, invalida 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 OnAddEngineFailure(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implementación de ProtectionProfileObserverImpl

La implementación define una acción que se va a realizar para cada función miembro del observador.

Cada miembro acepta dos parámetros. El primero es un puntero compartido a la clase que administra la función. ProtectionObserver::OnLoadSuccess espera recibir un mip::ProtectionProfile. ProtectionObserver::OnAddEngineSuccess espera mip::ProtectionEngine.

El segundo es un puntero compartido al contexto. En esta implementación, el contexto es una referencia a std::promise, pasada como shared_ptr<void>. La primera línea de la función convierte este valor std::promiseen y, a continuación, la almacena en un objeto denominado promise.

Por último, el código deja preparado el futuro estableciendo promise->set_value() y pasando el objeto mip::ProtectionProfile.

//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::OnAddEngineFailure(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto addEnginePromise = static_cast<promise<shared_ptr<mip::ProtectionEngine>>*>(context.get());
  addEnginePromise->set_exception(error);
};

Al crear instancias de cualquier clase de SDK o usar una función que realiza operaciones asincrónicas, pase la implementación del observador al constructor de configuración o a la propia función asincrónica. Al crear una instancia del mip::ProtectionProfile::Settings objeto, el constructor acepta mip::ProtectionProfile::Observer como uno de los parámetros. En el siguiente ejemplo se muestra el elemento personalizado ProtectionProfileObserverImpl, utilizado 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 implementación anterior. En el ejemplo siguiente se define ProtectionHandlerObserverImplparcialmente . La implementación completa está en el repositorio de GitHub ejemplo.

Declaración de 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 OnCreateProtectionHandlerFailure(const exception_ptr& error, const shared_ptr<void>& context) override;
};

Implementación parcial de ProtectionHandlerObserverImpl

Este ejemplo incluye solo las dos primeras funciones, pero las funciones restantes usan un patrón similar a estas funciones 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::OnCreateProtectionHandlerFailure(
  const exception_ptr& error,
  const shared_ptr<void>& context) {
  auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
  createProtectionHandlerPromise->set_exception(error);
};

Pasos siguientes

  • Se actualizó por última vez el