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

Article
01/30/2024

Le profil est la classe racine de toutes les opérations dans le kit de développement logiciel (SDK) MIP. Avant d’utiliser l’une des fonctionnalités du kit de développement logiciel (SDK) File, un FileProfile doit être créé et toutes les opérations futures seront effectuées par le profil ou par d’autres objets ajoutés au profil.

Il existe quelques prérequis concernant le code qui doivent être remplis avant de tenter d’instancier un profil :

MipContext a été créé et stocké dans un objet accessible par l’objet mip::FileProfile.
L'objet ConsentDelegateImpl implémente l'objet mip::ConsentDelegate.
L’application a été enregistrée dans Microsoft Entra ID et l’ID client est codé en dur dans les fichiers d’application ou de configuration.
Une classe qui hérite mip::FileProfile::Observer a été correctement implémentée.

Charger un profil

Avec ProfileObserver et ConsentDelegateImpl définis, mip::FileProfile peut maintenant être instancié. La création de l’objet mip::FileProfile nécessite que toutes les informations de paramètres sur le FileProfile soient disponibles par [mip::MipContext] et stockées par mip::FileProfile::Settings.

Paramètres FileProfile::Settings

Le constructeur de FileProfile::Settings accepte cinq paramètres, répertoriés ci-dessous :

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é.
std::shared_ptr<mip::ConsentDelegate> : pointeur partagé de classe mip::ConsentDelegate.
std::shared_ptr<mip::FileProfile::Observer> observer : pointeur partagé vers l’implémentation du profil Observer (dans PolicyProfile, ProtectionProfile et FileProfile).

Les exemples suivants 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);

FileProfile::Settings profileSettings(
    mMipContext,                                  // mipContext object
    mip::CacheStorageType::InMemory,              // use in memory storage
    std::make_shared<ConsentDelegateImpl>(),      // new consent delegate
    std::make_shared<FileProfileObserverImpl>()); // new protection profile observer

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

L’extrait de code suivant indique à FileProfile de stocker toutes les données d’état de l’application dans ./mip_app_data.

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

FileProfile::Settings profileSettings(
    mMipContext,                                   // mipContext object
    mip::CacheStorageType::OnDisk,                 // use on disk storage    
    std::make_shared<ConsentDelegateImpl>(),       // new consent delegate
    std::make_shared<FileProfileObserverImpl>());  // new protection profile observer

Charger le profil

En utilisant les détails de l’approche ci-dessus, utilisez maintenant le modèle promesse/avenir pour charger le FileProfile.

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

Si nous avons chargé un profil et que cette opération a réussi, ProfileObserver::OnLoadSuccess, notre implémentation de mip::FileProfile::Observer::OnLoadSuccess est appelée. L’objet résultant ou le pointeur d’exception, ainsi que le contexte, sont passés en tant que paramètres à la fonction. 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 FileProfile qui a été passé comme premier paramètre. Lorsque la fonction main utilise Future.get(), le résultat peut être stocké dans un nouvel objet.

//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@contoso.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);

    FileProfile::Settings profileSettings(
        mMipContext,                                   // MipContext object
        mip::CacheStorageType::OnDisk,                 // use on disk storage        
        std::make_shared<ConsentDelegateImpl>(),       // new consent delegate
        std::make_shared<FileProfileObserverImpl>());  // new file profile observer

        auto profilePromise = std::make_shared<promise<shared_ptr<FileProfile>>>();
        auto profileFuture = profilePromise->get_future();
        FileProfile::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 de fichier

Partager via