Microsoft Information Protection SDK - Concetti relativi al profilo di Policy SDK

Deve essere caricato mip::Profile prima che sia possibile eseguire qualsiasi operazione dell'SDK di Policy.

I due esempi seguenti illustrano come creare l'oggetto profileSettings usando l'archiviazione locale per l'archiviazione stato e solo in memoria.

Caricare un profilo

Ora che MipContext e ProfileObserver sono definiti, verranno usati per istanziare mip::PolicyProfile. La creazione dell'oggetto mip::PolicyProfile richiede mip::PolicyProfile::Settings e mip::MipContext.

Parametri del Profilo::Impostazioni

Il PolicyProfile::Settings costruttore accetta quattro parametri, elencati di seguito:

• const std::shared_ptr<MipContext> mip::MipContext: oggetto inizializzato per archiviare le informazioni sull'applicazione, il percorso dello stato e così via.
• mip::CacheStorageType: definisce come archiviare lo stato: in memoria, su disco o su disco e crittografato. Per altri dettagli, vedere i concetti relativi all'archiviazione della cache.
• std::shared_ptr<mip::PolicyProfile::Observer> observer: puntatore condiviso all'implementazione del profilo Observer (in PolicyProfile, ProtectionProfilee FileProfile).

I due esempi seguenti illustrano come creare l'oggetto profileSettings usando l'archiviazione locale per l'archiviazione stato e solo in memoria.

Archiviare lo stato solo in memoria

mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };

std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
				                                                                                  "mip_data",
                                                                                        		  mip::LogLevel::Trace,
                                                                                                  false);

std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

PolicyProfile::Settings profileSettings(
    mMipContext,                                  // mipContext object
    mip::CacheStorageType::InMemory,              // use in memory storage
    std::make_shared<PolicyProfileObserverImpl>()); // new protection profile observer

Impostazioni del profilo di lettura/scrittura dal percorso di archiviazione su disco

mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };

std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
			                                                                                      "mip_data",
                                                                                       			  mip::LogLevel::Trace,
                                                                                                  false);

std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

PolicyProfile::Settings profileSettings(
    mipContext,                                    // mipContext object
    mip::CacheStorageType::OnDisk,                 // use on disk storage
    std::make_shared<PolicyProfileObserverImpl>());  // new protection profile observer

Usa quindi il modello promise/future per caricare il Profile.

auto profilePromise = std::make_shared<std::promise<std::shared_ptr<Profile>>>();
auto profileFuture = profilePromise->get_future();
Profile::LoadAsync(profileSettings, profilePromise);

Se un profilo viene caricato correttamente, ProfileObserver::OnLoadSuccess, l'implementazione di mip::Profile::Observer::OnLoadSuccess riceve una notifica. L'oggetto risultante, in questo caso , mip::Profilenonché il contesto, vengono passati come parametri alla funzione observer.

Il contesto è un puntatore all'oggetto std::promise che abbiamo creato per gestire l'operazione asincrona. La funzione imposta semplicemente il valore della promessa sull'oggetto Profile passato per il primo parametro. Quando la funzione main usa Future.get(), il risultato può essere archiviato in un nuovo oggetto nel thread chiamante.

//get the future value and store in profile.
auto profile = profileFuture.get();

Assemblare i componenti

Dopo aver implementato completamente gli osservatori e il delegato di autenticazione, è ora possibile caricare completamente un profilo. Lo snippet di codice seguente presuppone che tutti i header necessari siano già inclusi.

int main()
{
    const string userName = "MyTestUser@consoto.com";
    const string password = "P@ssw0rd!";
    const string clientId = "MyClientId";

    mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };
 
    std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
				                                                                                       "mip_data",
                                                                                        			   mip::LogLevel::Trace,
                                                                                                       false);

    std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

    PolicyProfile::Settings profileSettings(
        mMipContext,                                    // mipContext object
        mip::CacheStorageType::OnDisk,                 // use on disk storage
        std::make_shared<PolicyProfileObserverImpl>());  // new protection profile observer

    auto profilePromise = std::make_shared<promise<shared_ptr<PolicyProfile>>>();
    auto profileFuture = profilePromise->get_future();
    Profile::LoadAsync(profileSettings, profilePromise);
    auto profile = profileFuture.get();
}

Il risultato finale è che il profilo è stato caricato correttamente e archiviato nell'oggetto denominato profile.

Passaggi successivi

Ora che il profilo è stato aggiunto, il passaggio successivo consiste nell'aggiungere un motore al profilo.

Concetti relativi al motore di policy