Lire en anglais

Partager via


Capturer l’audio, la vidéo, les captures d’écran et les métadonnées d’un jeu

Cet article explique comment capturer des vidéos, des fichiers audio et des captures d’écran de jeu et comment envoyer des métadonnées que le système incorporera dans des médias capturés et diffusés, ce qui permet à votre application et à d’autres personnes de créer des expériences dynamiques synchronisées avec des événements de jeu.

Il existe deux façons différentes de capturer le jeu dans une application UWP. L’utilisateur peut lancer la capture à l’aide de l’interface utilisateur système intégrée. Les médias capturés à l’aide de cette technique sont ingérés dans l’écosystème de jeux Microsoft, peuvent être consultés et partagés par le biais d’expériences internes telles que le application Xbox, et ne sont pas directement disponibles pour votre application ou pour les utilisateurs. Les premières sections de cet article vous montrent comment activer et désactiver la capture d’application implémentée par le système et comment recevoir des notifications lorsque la capture d’application démarre ou s’arrête.

L’autre moyen de capturer un média consiste à utiliser les API de l’espace de noms Windows.Media.AppRecording . Si la capture est activée sur l’appareil, votre application peut commencer à capturer le jeu, puis, après un certain temps, vous pouvez arrêter la capture, à quel moment le média est écrit dans un fichier. Si l’utilisateur a activé la capture historique, vous pouvez également enregistrer le jeu qui s’est déjà produit en spécifiant une heure de début dans le passé et une durée à enregistrer. Ces deux techniques produisent un fichier vidéo accessible par votre application et, selon l’emplacement où vous choisissez d’enregistrer les fichiers, par l’utilisateur. Les sections intermédiaires de cet article vous guident dans l’implémentation de ces scénarios.

L’espace de noms Windows.Media.Capture fournit des API pour créer des métadonnées qui décrivent le gameplay capturé ou diffusé. Cela peut inclure du texte ou des valeurs numériques, avec une étiquette de texte identifiant chaque élément de données. Les métadonnées peuvent représenter un « événement » qui se produit à un moment donné, par exemple lorsque l’utilisateur termine un tour dans un jeu de course, ou il peut représenter un « état » qui persiste sur une période donnée, comme la carte de jeu actuelle dans laquelle l’utilisateur joue. Les métadonnées sont écrites dans un cache alloué et géré pour votre application par le système. Les métadonnées sont incorporées dans des flux de diffusion et des fichiers vidéo capturés, y compris les techniques intégrées de capture système ou de capture d’application personnalisée. Les dernières sections de cet article vous montrent comment écrire des métadonnées de jeu.

Notes

Étant donné que les métadonnées de jeu peuvent être incorporées dans des fichiers multimédias qui peuvent potentiellement être partagés sur le réseau, hors du contrôle de l’utilisateur, vous ne devez pas inclure d’informations d’identification personnelle ou d’autres données potentiellement sensibles dans les métadonnées.

Activer et désactiver la capture d’application système

La capture d’application système est lancée par l’utilisateur avec l’interface utilisateur système intégrée. Les fichiers sont ingérés par l’écosystème de jeux Windows et ne sont pas disponibles pour votre application ou l’utilisateur, à l’exception d’expériences internes comme le application Xbox. Votre application peut désactiver et activer la capture d’application initiée par le système, ce qui vous permet d’empêcher l’utilisateur de capturer certains contenus ou jeux de jeu.

Pour activer ou désactiver la capture d’application système, appelez simplement la méthode statique AppCapture.SetAllowedAsync et transmettez false pour désactiver la capture ou true pour activer la capture.

Windows::Media::Capture::AppCapture::SetAllowedAsync(allowed);

Recevoir des notifications lorsque la capture d’application système démarre et s’arrête

Pour recevoir une notification lorsque la capture d’application système commence ou se termine, commencez par obtenir une instance de la classe AppCapture en appelant la méthode de fabrique GetForCurrentView. Ensuite, inscrivez un gestionnaire pour l’événement CapturingChanged .

Windows::Media::Capture::AppCapture^ appCapture = Windows::Media::Capture::AppCapture::GetForCurrentView();
appCapture->CapturingChanged +=
    ref new TypedEventHandler<Windows::Media::Capture::AppCapture^, Platform::Object^>(this, &App::OnCapturingChanged);

Dans le gestionnaire de l’événement CapturingChanged, vous pouvez vérifier les propriétés IsCapturingAudio et IsCapturingVideo pour déterminer si l’audio ou la vidéo sont capturés respectivement. Vous pouvez mettre à jour l’interface utilisateur de votre application pour indiquer l’état de capture actuel.

void App::OnCapturingChanged(Windows::Media::Capture::AppCapture^ sender, Platform::Object^ args)
{
    Platform::String^ captureStatusText = "";
    if (sender->IsCapturingAudio)
    {
        captureStatusText += "Capturing audio.";
    }
    if (sender->IsCapturingVideo)
    {
        captureStatusText += "Capturing video.";
    }
    UpdateStatusText(captureStatusText);
}

Ajouter les extensions de bureau Windows pour UWP à votre application

Les API d’enregistrement audio et vidéo et de capture d’écran directement à partir de votre application, trouvées dans l’espace de noms Windows.Media.AppRecording , ne sont pas incluses dans le contrat d’API universelle. Pour accéder aux API, vous devez ajouter une référence aux extensions de bureau Windows pour L’UWP à votre application en procédant comme suit.

  1. Dans Visual Studio, dans Explorateur de solutions, développez votre projet UWP et cliquez avec le bouton droit sur Références, puis sélectionnez Ajouter une référence....
  2. Développez le nœud Windows universel et sélectionnez Extensions.
  3. Dans la liste des extensions, cochez la case en regard des extensions de bureau Windows pour l’entrée UWP qui correspond à la build cible de votre projet. Pour les fonctionnalités de diffusion d’application, la version doit être 1709 ou ultérieure.
  4. Cliquez sur OK.

Obtenir une instance d’AppRecordingManager

La classe AppRecordingManager est l’API centrale que vous allez utiliser pour gérer l’enregistrement d’application. Obtenez une instance de cette classe en appelant la méthode de fabrique GetDefault. Avant d’utiliser l’une des API de l’espace de noms Windows.Media.AppRecording , vous devez vérifier leur présence sur l’appareil actuel. Les API ne sont pas disponibles sur les appareils exécutant une version du système d’exploitation antérieure à Windows 10, version 1709. Au lieu de rechercher une version spécifique du système d’exploitation, utilisez la méthode ApiInformation.IsApiContractPresent pour rechercher windows.Media.AppBroadcasting.AppRecordingContract version 1.0. Si ce contrat est présent, les API d’enregistrement sont disponibles sur l’appareil. L’exemple de code de cet article vérifie les API une seule fois, puis vérifie si AppRecordingManager a la valeur Null avant les opérations suivantes.

if (Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent(
    "Windows.Media.AppRecording.AppRecordingContract", 1, 0))
{
    m_appRecordingManager = AppRecordingManager::GetDefault();
}

Déterminer si votre application peut enregistrer actuellement

Il existe plusieurs raisons pour lesquelles votre application peut actuellement ne pas être en mesure de capturer du contenu audio ou vidéo, notamment si l’appareil actuel ne répond pas à la configuration matérielle requise pour l’enregistrement ou si une autre application est en cours de diffusion. Avant de lancer un enregistrement, vous pouvez vérifier si votre application est actuellement en mesure d’enregistrer. Appelez la méthode GetStatus de l’objet AppRecordingManager, puis vérifiez la propriété CanRecord de l’objet AppRecordingStatus retourné. Si CanRecord retourne false, ce qui signifie que votre application ne peut pas enregistrer actuellement, vous pouvez vérifier la propriété Details pour déterminer la raison. Selon la raison, vous pouvez afficher l’état à l’utilisateur ou afficher des instructions pour activer l’enregistrement de l’application.

bool App::CanRecord()
{

    if (m_appRecordingManager == nullptr)
    {
        return false;
    }

    AppRecordingStatus^ recordingStatus = m_appRecordingManager->GetStatus();

    if (!recordingStatus->CanRecord)
    {
        AppRecordingStatusDetails^ details = recordingStatus->Details;
    
        if (details->IsAnyAppBroadcasting)
        {
            UpdateStatusText("Another app is currently broadcasting.");
            return false;
        }

        if (details->IsCaptureResourceUnavailable)
        {
            UpdateStatusText("The capture resource is currently unavailable.");
            return false;
        }

        if (details->IsGameStreamInProgress)
        {
            UpdateStatusText("A game stream is currently in progress.");
            return false;
        }

        if (details->IsGpuConstrained)
        {
            // Typically, this means that the GPU software does not include an H264 encoder
            UpdateStatusText("The GPU does not support app recording.");
            return false;
        }

        
        if (details->IsAppInactive)
        {
            // Broadcasting can only be started when the application's window is the active window.
            UpdateStatusText("The app window to be recorded is not active.");
            return false;
        }

        if (details->IsBlockedForApp)
        {
            UpdateStatusText("Recording is blocked for this app.");
            return false;
        }

        if (details->IsDisabledByUser)
        {
            UpdateStatusText("The user has disabled GameBar in Windows Settings.");
            return false;
        }

        if (details->IsDisabledBySystem)
        {
            UpdateStatusText("Recording is disabled by the system.");
            return false;
        }

        
        return false;
    }


    return true;
}

Démarrer et arrêter manuellement l’enregistrement de votre application dans un fichier

Après avoir vérifié que votre application est en mesure d’enregistrer, vous pouvez démarrer un nouvel enregistrement en appelant la méthode StartRecordingToFileAsync de l’objet AppRecordingManager.

Dans l’exemple suivant, le premier bloc s’exécute lorsque la tâche asynchrone échoue. Le deuxième bloc tente ensuite d’accéder au résultat de la tâche et, si le résultat est null, la tâche est terminée. Dans les deux cas, la méthode d’assistance OnRecordingComplete , illustrée ci-dessous, est appelée pour gérer le résultat.

void App::StartRecordToFile(Windows::Storage::StorageFile^ file)
{

    if (m_appRecordingManager == nullptr)
    {
        return;
    }

    if (!CanRecord())
    {
        return;
    }


    // Start a recording operation to record starting from 
    // now until the operation fails or is cancelled. 
    m_recordOperation = m_appRecordingManager->StartRecordingToFileAsync(file);

    create_task(m_recordOperation).then(
        [this](AppRecordingResult^ result)
    {
        OnRecordingComplete();
    }).then([this](task<void> t)
    {
        try
        {
            t.get();
        }
        catch (const task_canceled&)
        {
            OnRecordingComplete();
        }
    });
}

Une fois l’opération d’enregistrement terminée, vérifiez la propriété Succeeded de l’objet AppRecordingResult retourné pour déterminer si l’opération d’enregistrement a réussi. Dans ce cas, vous pouvez vérifier la propriété IsFileTruncated pour déterminer si, pour des raisons de stockage, le système a été forcé de tronquer le fichier capturé. Vous pouvez vérifier la propriété Duration pour découvrir la durée réelle du fichier enregistré qui, si le fichier est tronqué, peut être plus court que la durée de l’opération d’enregistrement.

void App::OnRecordingComplete()
{
    if (m_recordOperation)
    {
        auto result = m_recordOperation->GetResults();

        if (result->Succeeded)
        {
            Windows::Foundation::TimeSpan duration = result->Duration;
            boolean isTruncated = result->IsFileTruncated;

            UpdateStatusText("Recording completed.");
        }
        else
        {
            // If the recording failed, ExtendedError 
            // can be retrieved and used for diagnostic purposes 
            HResult extendedError = result->ExtendedError;
            LogTelemetryMessage("Error during recording: " + extendedError);
        }

        m_recordOperation = nullptr;
    }
}

Les exemples suivants montrent du code de base pour démarrer et arrêter l’opération d’enregistrement indiquée dans l’exemple précédent.

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
concurrency::create_task(storageFolder->CreateFileAsync("recordtofile_example.mp4", CreationCollisionOption::ReplaceExisting)).then(
    [this](StorageFile^ file)
{
    StartRecordToFile(file);
});
void App::FinishRecordToFile()
{
    m_recordOperation->Cancel();
}

Enregistrer un intervalle de temps historique dans un fichier

Si l’utilisateur a activé l’enregistrement historique de votre application dans les paramètres système, vous pouvez enregistrer un intervalle de temps de jeu qui s’est déjà produit. Un exemple précédent de cet article a montré comment confirmer que votre application peut enregistrer le jeu. Il existe une vérification supplémentaire pour déterminer si la capture historique est activée. Une fois de plus, appelez GetStatus et vérifiez la propriété CanRecordTimeSpan de l’objet AppRecordingStatus retourné. Cet exemple retourne également la propriété HistoricalBufferDuration de l’AppRecordingStatus qui sera utilisée pour déterminer une heure de début valide pour l’opération d’enregistrement.

bool App::CanRecordTimeSpan(TimeSpan &historicalDurationBuffer)
{

    if (m_appRecordingManager == nullptr)
    {
        return false;
    }

    AppRecordingStatus^ recordingStatus = m_appRecordingManager->GetStatus();
    if (recordingStatus->Details->IsTimeSpanRecordingDisabled)
    {
        UpdateStatusText("Historical time span recording is disabled by the system.");
        return false;
    }

    historicalDurationBuffer = recordingStatus->HistoricalBufferDuration;

    return true;
}

Pour capturer un intervalle de temps historique, vous devez spécifier une heure de début pour l’enregistrement et une durée. L’heure de début est fournie en tant que struct DateTime . L’heure de début doit être une heure avant l’heure actuelle, dans la durée de la mémoire tampon d’enregistrement historique. Pour cet exemple, la longueur de la mémoire tampon est récupérée dans le cadre de la vérification pour voir si l’enregistrement historique est activé, qui est illustré dans l’exemple de code précédent. La durée de l’enregistrement historique est fournie en tant que struct TimeSpan , qui doit également être égal ou inférieur à la durée de la mémoire tampon historique. Une fois que vous avez déterminé l’heure de début et la durée souhaitées, appelez RecordTimeSpanToFileAsync pour démarrer l’opération d’enregistrement.

Comme l’enregistrement avec démarrage et arrêt manuels, lorsqu’un enregistrement historique est terminé, vous pouvez vérifier la propriété Succeeded de l’objet AppRecordingResult retourné pour déterminer si l’opération d’enregistrement a réussi, et vous pouvez vérifier la propriété IsFileTruncated et Duration pour découvrir la durée réelle du fichier enregistré qui, si le fichier est tronqué, peut être plus court que la durée demandée. fenêtre.

void App::RecordTimeSpanToFile(Windows::Storage::StorageFile^ file)
{


    if (m_appRecordingManager == nullptr)
    {
        return;
    }

    if (!CanRecord())
    {
        return;
    }

    Windows::Foundation::TimeSpan historicalBufferDuration;
    if (!CanRecordTimeSpan(historicalBufferDuration))
    {
        return;
    }
    

    AppRecordingStatus^ recordingStatus = m_appRecordingManager->GetStatus();
    
    Windows::Globalization::Calendar^ calendar = ref new Windows::Globalization::Calendar();
    calendar->SetToNow();

    Windows::Foundation::DateTime nowTime = calendar->GetDateTime();

    int secondsToRecord = min(30, historicalBufferDuration.Duration / 10000000);
    calendar->AddSeconds(-1 * secondsToRecord);

    Windows::Foundation::DateTime  startTime = calendar->GetDateTime();

    Windows::Foundation::TimeSpan duration;

    duration.Duration = nowTime.UniversalTime - startTime.UniversalTime;

    create_task(m_appRecordingManager->RecordTimeSpanToFileAsync(startTime, duration, file)).then(
        [this](AppRecordingResult^ result)
    {
        if (result->Succeeded)
        {
            Windows::Foundation::TimeSpan duration = result->Duration;
            boolean isTruncated = result->IsFileTruncated;
            UpdateStatusText("Recording completed.");
        }
        else
        {
            // If the recording failed, ExtendedError
            // can be retrieved and used for diagnostic purposes
            HResult extendedError = result->ExtendedError;
            LogTelemetryMessage("Error during recording: " + extendedError);
        }
    });

}

L’exemple suivant montre un code de base pour lancer l’opération d’enregistrement historique illustrée dans l’exemple précédent.

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
concurrency::create_task(storageFolder->CreateFileAsync("recordtimespantofile_example.mp4", CreationCollisionOption::ReplaceExisting)).then(
    [this](StorageFile^ file)
{
    RecordTimeSpanToFile(file);
});

Enregistrer des images de capture d’écran dans des fichiers

Votre application peut lancer une capture d’écran qui enregistre le contenu actuel de la fenêtre de l’application dans un fichier image ou dans plusieurs fichiers image avec différents encodages d’image. Pour spécifier les encodages d’image que vous souhaitez utiliser, créez une liste de chaînes où chacun représente un type d’image. Les propriétés d’ImageEncodingSubtypes fournissent la chaîne correcte pour chaque type d’image pris en charge, comme MediaEncodingSubtypes.Png ou MediaEncodingSubtypes.JpegXr.

Lancez la capture d’écran en appelant la méthode SaveScreenshotToFilesAsync de l’objet AppRecordingManager. Le premier paramètre de cette méthode est un StorageFolder dans lequel les fichiers image seront enregistrés. Le deuxième paramètre est un préfixe de nom de fichier auquel le système ajoute l’extension pour chaque type d’image enregistré, tel que « .png ».

Le troisième paramètre de SaveScreenshotToFilesAsync est nécessaire pour que le système puisse effectuer la conversion d’espace de couleurs appropriée si la fenêtre actuelle à capturer affiche du contenu HDR. Si le contenu HDR est présent, ce paramètre doit être défini sur AppRecordingSaveScreenshotOption.HdrContentVisible. Sinon, utilisez AppRecordingSaveScreenshotOption.None. Le paramètre final de la méthode est la liste des formats d’image auxquels l’écran doit être capturé.

Lorsque l’appel asynchrone à SaveScreenshotToFilesAsync se termine, il retourne un objet AppRecordingSavedScreenshotInfo qui fournit la valeur StorageFile et MediaEncodingSubtypes associé indiquant le type d’image pour chaque image enregistrée.

void App::SaveScreenShotToFiles(Windows::Storage::StorageFolder^ folder, Platform::String^ filenamePrefix)
{

    if (m_appRecordingManager == nullptr)
    {
        return;
    }


    Windows::Foundation::Collections::IVectorView<Platform::String^>^ supportedFormats = 
        m_appRecordingManager->SupportedScreenshotMediaEncodingSubtypes;

    
    Platform::Collections::Vector<Platform::String^>^ requestedFormats = 
        ref new Platform::Collections::Vector<Platform::String^>();

    for (Platform::String^ format : requestedFormats)
    {
        if (format == Windows::Media::MediaProperties::MediaEncodingSubtypes::Png)
        {
            requestedFormats->Append(format);
        }
        else if (format == Windows::Media::MediaProperties::MediaEncodingSubtypes::JpegXr)
        {
            requestedFormats->Append(format);
        }
    }


    create_task(m_appRecordingManager->SaveScreenshotToFilesAsync(folder, filenamePrefix, AppRecordingSaveScreenshotOption::None,
        requestedFormats->GetView())).then(
            [this](AppRecordingSaveScreenshotResult^ result)
    {
        if (result->Succeeded)
        {
            Windows::Foundation::Collections::IVectorView<AppRecordingSavedScreenshotInfo^>^ returnedScreenshots = result->SavedScreenshotInfos;

            for (AppRecordingSavedScreenshotInfo^ screenshotInfo : returnedScreenshots)
            {
                Windows::Storage::StorageFile^ file = screenshotInfo->File;
                Platform::String^ type = screenshotInfo->MediaEncodingSubtype;
            }
        }
        else
        {
            // If the recording failed, ExtendedError 
            // can be retrieved and used for diagnostic purposes 
            HResult extendedError = result->ExtendedError;
            LogTelemetryMessage("Error during screenshot: " + extendedError);
        }
    });
}

L’exemple suivant montre un code de base pour lancer l’opération de capture d’écran illustrée dans l’exemple précédent.

StorageFolder^ storageFolder = ApplicationData::Current->LocalFolder;
SaveScreenShotToFiles(storageFolder, "screen_capture");

Ajouter des métadonnées de jeu pour la capture initiée par le système et l’application

Les sections suivantes de cet article décrivent comment fournir des métadonnées que le système incorporera dans le flux MP4 du jeu capturé ou diffusé. Les métadonnées peuvent être incorporées dans un média capturé à l’aide de l’interface utilisateur système intégrée et du média capturés par l’application avec AppRecordingManager. Ces métadonnées peuvent être extraites par votre application et d’autres applications pendant la lecture multimédia afin de fournir des expériences contextuelles qui sont synchronisées avec le jeu capturé ou diffusé.

Obtenir une instance d’AppCaptureMetadataWriter

La classe principale pour la gestion des métadonnées de capture d’application est AppCaptureMetadataWriter. Avant d’initialiser une instance de cette classe, utilisez la méthode ApiInformation.IsApiContractPresent pour interroger windows.Media.Capture.AppCaptureMetadataContract version 1.0 pour vérifier que l’API est disponible sur l’appareil actuel.

if (Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent("Windows.Media.Capture.AppCaptureMetadataContract", 1, 0))
{
    m_appCaptureMetadataWriter = ref new AppCaptureMetadataWriter();
}

Écrire des métadonnées dans le cache système de votre application

Chaque élément de métadonnées a une étiquette de chaîne, identifiant l’élément de métadonnées, une valeur de données associée qui peut être une chaîne, un entier ou une valeur double, et une valeur de l’énumération AppCaptureMetadataPriority indiquant la priorité relative de l’élément de données. Un élément de métadonnées peut être considéré comme un « événement », qui se produit à un point unique dans le temps, ou un « état » qui conserve une valeur dans une fenêtre de temps. Les métadonnées sont écrites dans un cache de mémoire alloué et géré pour votre application par le système. Le système applique une limite de taille au cache de mémoire des métadonnées et, lorsque la limite est atteinte, purge les données en fonction de la priorité avec laquelle chaque élément de métadonnées a été écrit. La section suivante de cet article montre comment gérer l’allocation de mémoire des métadonnées de votre application.

Une application classique peut choisir d’écrire des métadonnées au début de la session de capture pour fournir un contexte pour les données suivantes. Pour ce scénario, il est recommandé d’utiliser des données « événement » instantanées. Cet exemple appelle AddStringEvent, AddDoubleEvent et AddInt32Event pour définir des valeurs instantanées pour chaque type de données.

void App::StartSession(Platform::String^ sessionId, double averageFps, int resolutionWidth, int resolutionHeight)
{
    if (m_appCaptureMetadataWriter != nullptr)
    {
        m_appCaptureMetadataWriter->AddStringEvent("sessionId", sessionId, AppCaptureMetadataPriority::Informational);
        m_appCaptureMetadataWriter->AddDoubleEvent("averageFps", averageFps, AppCaptureMetadataPriority::Informational);
        m_appCaptureMetadataWriter->AddInt32Event("resolutionWidth", resolutionWidth, AppCaptureMetadataPriority::Informational);
        m_appCaptureMetadataWriter->AddInt32Event("resolutionHeight", resolutionHeight, AppCaptureMetadataPriority::Informational);
    }
}

Un scénario courant pour l’utilisation de données « state » qui persiste au fil du temps consiste à suivre la carte de jeu dans laquelle le joueur est actuellement à l’intérieur. Cet exemple appelle StartStringState pour définir la valeur d’état.

void App::StartMap(Platform::String^ mapName)
{
    m_appCaptureMetadataWriter->StartStringState("map", mapName, AppCaptureMetadataPriority::Important);
}

Appelez StopState pour enregistrer qu’un état particulier a pris fin.

void App::EndMap(Platform::String^ mapName)
{
    m_appCaptureMetadataWriter->StopState("map");
}

Vous pouvez remplacer un état en définissant une nouvelle valeur avec une étiquette d’état existante.

void App::LevelUp(int newLevel)
{
    m_appCaptureMetadataWriter->StartInt32State("currentLevel", newLevel, AppCaptureMetadataPriority::Important);
}

Vous pouvez mettre fin à tous les états actuellement ouverts en appelant StopAllStates.

void App::RaceComplete()
{
    m_appCaptureMetadataWriter->StopAllStates();
}

Gérer la limite de stockage du cache de métadonnées

Les métadonnées que vous écrivez avec AppCaptureMetadataWriter sont mises en cache par le système jusqu’à ce qu’elle soit écrite dans le flux multimédia associé. Le système définit une limite de taille pour le cache de métadonnées de chaque application. Une fois la limite de taille du cache atteinte, le système commence à purger les métadonnées mises en cache. Le système supprime les métadonnées écrites avec la valeur de priorité AppCaptureMetadataPriority.Informational avant de supprimer les métadonnées avec la priorité AppCaptureMetadataPriority.Important.

À tout moment, vous pouvez vérifier le nombre d’octets disponibles dans le cache de métadonnées de votre application en appelant RemainingStorageBytesAvailable. Vous pouvez choisir de définir votre propre seuil défini par l’application après quoi vous pouvez choisir de réduire la quantité de métadonnées que vous écrivez dans le cache. L’exemple suivant montre une implémentation simple de ce modèle.

void App::CheckMetadataStorage()
{
    INT64 storageRemaining = m_appCaptureMetadataWriter->RemainingStorageBytesAvailable;

    if (storageRemaining < m_myLowStorageLevelInBytes)
    {
        m_writeLowPriorityMetadata = false;
    }
}
void App::ComboExecuted(Platform::String^ comboName)
{
    if (m_writeLowPriorityMetadata)
    {
        m_appCaptureMetadataWriter->AddStringEvent("combo", comboName, AppCaptureMetadataPriority::Informational);
    }
}

Recevoir des notifications lorsque le système vide les métadonnées

Vous pouvez vous inscrire pour recevoir une notification lorsque le système commence à purger les métadonnées de votre application en inscrivant un gestionnaire pour l’événement MetadataPurged .

if (m_appCaptureMetadataWriter != nullptr)
{
    m_appCaptureMetadataWriter->MetadataPurged += 
        ref new TypedEventHandler<AppCaptureMetadataWriter^, Platform::Object^>(this, &App::OnMetadataPurged);

}

Dans le gestionnaire de l’événement MetadataPurged , vous pouvez effacer une pièce dans le cache de métadonnées en terminant les états de priorité inférieure, vous pouvez implémenter la logique définie par l’application pour réduire la quantité de métadonnées que vous écrivez dans le cache, ou vous ne pouvez rien faire et laisser le système continuer à vider le cache en fonction de la priorité avec laquelle il a été écrit.

void App::OnMetadataPurged(Windows::Media::Capture::AppCaptureMetadataWriter^ sender, Platform::Object^ args)
{
    // Reduce metadata by stopping a low-priority state.
    //m_appCaptureMetadataWriter->StopState("map");

    // Reduce metadata by stopping all states.
    //m_appCaptureMetadataWriter->StopAllStates();

    // Change app-specific behavior to write less metadata.
    //m_writeLowPriorityMetadata = false;

    // Take no action. Let the system purge data as needed. Record event for telemetry.
    OutputDebugString(TEXT("Low-priority metadata purged."));

}