Recherche de mises à jour

Le titre peut rechercher et appliquer des mises à jour s’il est essentiel que le jeu soit à jour. Cette condition est souvent importante lorsque le jeu comporte des fonctionnalités multijoueurs pour lesquelles il est crucial que tous les joueurs qui exécutent le jeu disposent des mêmes fonctionnalités. Le titre peut rechercher des mises à jour à l’aide de XStoreQueryGameAndDlcPackageUpdatesAsync, comme illustré dans l’exemple de code suivant :

void CALLBACK QueryGameAndDlcPackageUpdatesCallback(XAsyncBlock* async)
{
    unsigned int numUpdates = 0;

    HRESULT hr = XStoreQueryGameAndDlcPackageUpdatesResultCount(async, &numUpdates);

    if (SUCCEEDED(hr))
    {
        if (numUpdates > 0)
        {
            std::vector<XStorePackageUpdate> packages(numUpdates);

            hr = XStoreQueryGameAndDlcPackageUpdatesResult(async, numUpdates, packages.data());

            if (SUCCEEDED(hr))
            {
                for (auto &package : packages)
                {
                    printf("Update available %s\n", package.packageIdentifier);
                }
            }
        }
        else
        {
            printf("No updates are available\n");
        }
    }

    delete async;
}

void CheckForUpdates()
{
    auto asyncBlock = new XAsyncBlock{};
    asyncBlock->queue = m_asyncQueue;
    asyncBlock->callback = QueryGameAndDlcPackageUpdatesCallback;

    if (FAILED(XStoreQueryGameAndDlcPackageUpdatesAsync(m_xStoreContext, asyncBlock)))
    {
        delete asyncBlock;
    }
}

Si un titre comprend de nombreux éléments de DLC qui ne nécessitent pas de recherche de mises à jour (par exemple, des packages de DLC vides utilisés uniquement pour les licences), le code précédent peut entraîner une surcharge inutile en vérifiant chacun d’eux. Utilisez plutôt XStoreQueryPackageUpdatesAsync, en filtrant sur l’ID de package du jeu actuel obtenu à l’aide de XPackageGetCurrentProcessPackageIdentifier ou en filtrant les ID de package renvoyés par XPackageEnumeratePackages :

void CALLBACK QueryPackageUpdatesCallback(XAsyncBlock* async)
{
    unsigned int numUpdates = 0;

    HRESULT hr = XStoreQueryPackageUpdatesResultCount(async, &numUpdates);

    if (FAILED(hr))
    {
        printf("XStoreQueryPackageUpdatesResultCount failed : 0x%x\n", hr);
        return;
    }

    printf("Number of updates: %d", numUpdates);

    if (count > 0)
    {
        std::vector<XStorePackageUpdate> packages(numUpdates);

        hr = XStoreQueryPackageUpdatesResult(async, numUpdates, packages.data());
        
        if (SUCCEEDED(hr))
        {
            for (auto &package : packages)
            {
                printf("Update available %s\n", package.packageIdentifier);
            }
        }
    }
}

void QueryPackageUpdates()
{
    std::vector<std::string> packageIds;

    HRESULT hr = XPackageEnumeratePackages(
        XPackageKind::Game,
        XPackageEnumerationScope::ThisOnly, // this will return for the base game only
        &packageIds, [](void* context, const XPackageDetails* details) -> bool
        {
            auto packageIds = reinterpret_cast<std::vector<std::string>*>(context);

            printf("Identifier: %s name: %s\n", details->packageIdentifier, details->displayName);

            packageIds->push_back(details->packageIdentifier);
        });

    // packageIds now populated with just the base game package Id

    auto asyncBlock = new XAsyncBlock();
    asyncBlock->queue = m_asyncQueue;
    asyncBlock->context = m_storeContext;
    asyncBlock->callback = QueryPackageUpdatesCallback;

    hr = XStoreQueryPackageUpdatesAsync(
        m_storeContext,
        packageIds.data(),
        packageIds.size(),
        asyncBlock);

    if (FAILED(hr))
    {
        printf("XStoreQueryPackageUpdatesAsync failed: 0x%x\n", hr);
        return;
    }
}

Télécharger et installer les mises à jour

Après avoir identifié l’ensemble des mises à jour, utilisez XStoreDownloadAndInstallPackageUpdatesAsync pour mettre en file d’attente et télécharger toutes les mises à jour.

À ce stade, le jeu se ferme pour appliquer la mise à jour. Ce processus se produit sans avertissement ; prévoyez donc une notification ou une confirmation suffisante pour l’utilisateur avant d’appeler cette fonction.

void DownloadUpdates()
{
    std::vector<const char*> packageIds;

    for (XStorePackageUpdate package : m_updates)
    {
        // m_updates populated from the update check
        packageIds.push_back(package.packageIdentifier);
    }

    if (!packageIds.empty())
    {
        auto asyncBlock = new XAsyncBlock{};
        asyncBlock->context = this;
        asyncBlock->queue = m_asyncQueue;
        asyncBlock->callback = [](XAsyncBlock* asyncBlockInner)
        {
            // Called when update is complete
            auto pThis = reinterpret_cast<Sample*>(asyncBlockInner->context);
            HRESULT hr = XStoreDownloadAndInstallPackageUpdatesResult(asyncBlockInner);

            delete asyncBlockInner;
        };

        HRESULT hr = XStoreDownloadAndInstallPackageUpdatesAsync(m_xStoreContext, packageIds.data(), packageIds.size(), asyncBlock);
    }
}

Surveillance de la progression du téléchargement

Lorsqu’un téléchargement est en cours, utilisez XPackageCreateInstallationMonitor pour en surveiller la progression :

void CreateInstallationMonitor(const char* packageId)
{
    XPackageInstallationMonitorHandle pimHandle;

    HRESULT hr = XPackageCreateInstallationMonitor(packageId, 0, nullptr, 1000, m_asyncQueue, &pimHandle);

    if(SUCCEEDED(hr))
    {
        XTaskQueueRegistrationToken callbackToken;

        XPackageRegisterInstallationProgressChanged(
            m_pimHandle,
            this,
            [](void* context, XPackageInstallationMonitorHandle pimHandle)
            {
                XPackageInstallationProgress progress;
                XPackageGetInstallationProgress(pimHandle, &progress);

                if(!progress.completed)
                {
                    printf("%llu%% installed\n", static_cast<double>(progress.installedBytes) / static_cast<double>(progress.totalBytes);
                }
                else
                {
                    XPackageCloseInstallationMonitorHandle(pimHandle);
                }
            }, &callbackToken);
    }
}

Test des mises à jour

Pendant le développement, vous pouvez tester la disponibilité des mises à jour uniquement à l’aide de packages locaux.

Créez un package V1 contenant le code de recherche et de téléchargement des mises à jour.
Créez un package V2 avec la même identité, mais un numéro de version incrémenté.
Exécutez xbapp/wdapp install V1.
Exécutez xbapp/wdapp update V2 /a.
Lancez V1.

Assurez-vous que l’ID de contenu correspond entre les packages. À l’issue de ce processus, l’appel XStoreQueryGameAndDlcPackageUpdatesAsync ou XStoreQueryPackageUpdatesAsync de V1 détecte les mises à jour disponibles, et XStoreDownloadAndInstallPackageUpdatesAsync met à jour V1 à l’aide du package V2 annoncé. Pendant le « téléchargement » de V2, cet état apparaît sous forme d’élément dans la file d’attente de téléchargement XBOX, l’application XBOX ou l’application Microsoft Store. Une fois l’installation terminée, V2 est installé. Vous pouvez vérifier l’installation à l’aide de xbapp/wdapp list[dlc]. L’utilisation de /m au lieu de /a rend la mise à jour « obligatoire », ce qui affecte simplement le champ XStorePackageUpdate.isMandatory. Vous ne pouvez pas effectuer la mise à jour d’une build de développement vers le package téléchargé à partir du Store en raison de différences de signature. Pour plus d’informations sur la création de mises à jour efficaces et les différentes méthodes de test, consultez les pages sur les mises à jour de contenu référencées dans la section suivante.

Documentation de référence des API

Voir aussi

Vue d’ensemble du commerce Activation du développement et des tests XStore Bonnes pratiques relatives aux mises à jour de contenu Création, examen et test des mises à jour de contenu Référence de l’API XStore

Introduction

Onboarding & Access

Setup & Install

Build Your First Title

Télécharger et installer les mises à jour

Surveillance de la progression du téléchargement

Test des mises à jour

Documentation de référence des API

Voir aussi

​Télécharger et installer les mises à jour

​Surveillance de la progression du téléchargement

​Test des mises à jour

​Documentation de référence des API

​Voir aussi

Télécharger et installer les mises à jour

Surveillance de la progression du téléchargement

Test des mises à jour

Documentation de référence des API

Voir aussi