Verificando atualizações

O título pode verificar e aplicar atualizações se for essencial que o jogo esteja atualizado. Essa condição costuma ser importante quando o jogo envolve recursos multijogador em que é fundamental que todos os jogadores que executam o jogo tenham a mesma funcionalidade. O título pode verificar atualizações usando XStoreQueryGameAndDlcPackageUpdatesAsync, conforme mostrado no código de exemplo a seguir:

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

Se um título incluir muitos itens de DLC que não exigem verificações de atualização (por exemplo, pacotes de DLC vazios usados apenas para licenciamento), o código anterior pode introduzir sobrecarga desnecessária ao verificar cada um deles. Em vez disso, use XStoreQueryPackageUpdatesAsync, filtrando pela ID do pacote do jogo atual obtida usando XPackageGetCurrentProcessPackageIdentifier ou filtrando as IDs de pacote retornadas por 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;
    }
}

Baixar e instalar atualizações

Depois de identificar o conjunto de atualizações, use XStoreDownloadAndInstallPackageUpdatesAsync para enfileirar e baixar todas as atualizações.

Nesse momento, o jogo é encerrado para aplicar a atualização. Esse processo ocorre sem aviso, portanto, forneça aviso amplo ou confirmação ao usuário antes de chamar essa função.

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

Monitorando o progresso do download

Quando um download estiver em andamento, use XPackageCreateInstallationMonitor para monitorar o progresso do download:

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

Testando atualizações

Durante o desenvolvimento, você pode testar a disponibilidade de atualizações somente usando pacotes locais.

Crie o pacote V1 com o código de verificação de atualização e de download.
Crie o pacote V2 com a mesma identidade, mas com o número de versão incrementado.
Execute xbapp/wdapp install V1.
Execute xbapp/wdapp update V2 /a.
Inicie o V1.

Verifique se a ID de conteúdo corresponde entre os pacotes. O resultado desse processo é que a chamada XStoreQueryGameAndDlcPackageUpdatesAsync ou XStoreQueryPackageUpdatesAsync do V1 encontra todas as atualizações disponíveis, e XStoreDownloadAndInstallPackageUpdatesAsync atualiza o V1 usando o pacote V2 anunciado. Quando o “download” do V2 está em andamento, esse status aparece na fila de downloads do XBOX, no aplicativo XBOX ou no aplicativo Microsoft Store como um item na fila. Quando a instalação termina, o V2 está instalado. Você pode verificar a instalação usando xbapp/wdapp list[dlc]. Usar /m em vez de /a torna a atualização “obrigatória”, o que simplesmente afeta o campo XStorePackageUpdate.isMandatory. Não é possível atualizar de um build de desenvolvimento para o pacote baixado da Store devido a diferenças de assinatura. Para obter mais informações sobre como criar atualizações eficientes e diferentes maneiras de testar, confira as páginas de atualização de conteúdo mencionadas na seção a seguir.

Documentação de referência da API

Confira também

Visão geral do comércio Habilitando o desenvolvimento e o teste do XStore Práticas recomendadas de atualização de conteúdo Criando, examinando e testando atualizações de conteúdo Referência da API XStore

Porting

Build Paths

Baixar e instalar atualizações

Monitorando o progresso do download

Testando atualizações

Documentação de referência da API

Confira também

​Baixar e instalar atualizações

​Monitorando o progresso do download

​Testando atualizações

​Documentação de referência da API

​Confira também

Baixar e instalar atualizações

Monitorando o progresso do download

Testando atualizações

Documentação de referência da API

Confira também