Kit de développement logiciel (SDK) Microsoft Information Protection - Concepts du profil du kit de développement logiciel (SDK) Policy

Article
01/30/2024

Le mip::Profile doit être chargé avant que toutes les opérations du SDK Policy puissent être effectuées.

Les deux exemples ci-dessous montrent comment créer l’objet profileSettings à l’aide du stockage local pour le stockage d’état, ainsi que dans la mémoire uniquement.

Charger un profil

Maintenant que les MipContext et ProfileObserver sont définis, nous allons les utiliser pour instancier mip::PolicyProfile. La création de l’objet mip::PolicyProfile nécessite mip::PolicyProfile::Settings et mip::MipContext.

Paramètres Profile::Settings

Le constructeur PolicyProfile::Settings accepte quatre paramètres, répertoriés ci-dessous :

const std::shared_ptr<MipContext>: L’objet mip::MipContext initialisé pour stocker les informations de l’application, le chemin d’état, etc.
mip::CacheStorageType: Définit comment stocker l’état : en mémoire, sur le disque ou sur le disque et chiffré. Pour plus d’informations, consultez les concepts de stockage du cache.
std::shared_ptr<mip::PolicyProfile::Observer> observer : pointeur partagé vers l’implémentation du profil Observer (dans PolicyProfile, ProtectionProfile et FileProfile).

Les deux exemples ci-dessous montrent comment créer l’objet profileSettings à l’aide du stockage local pour le stockage d’état, ainsi que dans la mémoire uniquement.

Stocker l’état en mémoire uniquement

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

Paramètres de profil en lecture/écriture à partir du chemin d’accès du stockage sur le disque

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

Ensuite, utilisez le modèle promesse/avenir pour charger le Profile.

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

Si un profil est correctement chargé, ProfileObserver::OnLoadSuccess, notre implémentation de mip::Profile::Observer::OnLoadSuccess est notifiée. L’objet résultant, dans ce cas, un mip::Profile, ainsi que le contexte, sont passés en tant que paramètres à la fonction d’observateur.

Le contexte est un pointeur vers la std::promise que nous avons créé pour gérer l’opération asynchrone. La fonction définit simplement la valeur de la promesse à l’objet Profile qui a été passée comme premier paramètre. Lorsque la fonction main utilise Future.get(), le résultat peut être stocké dans un nouvel objet dans le thread appelant.

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

Synthèse

Après avoir entièrement implémenté les observateurs et le délégué de l’authentification, il est désormais possible de charger entièrement un profil. L’extrait de code ci-dessous suppose que tous les en-têtes nécessaires sont déjà inclus.

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();
}

Le résultat final est que nous avons correctement chargé le profil et l’avons stocké dans l’objet appelé profile.

Étapes suivantes

Maintenant que le profil a été ajouté, l’étape suivante consiste à ajouter un moteur au profil.

Concepts du moteur Policy

Partager via