> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Verificando atualizações

> Verifique e aplique atualizações de pacotes de jogos e DLC do XBOX no seu título usando XStoreQueryGameAndDlcPackageUpdatesAsync para paridade multijogador.

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](/pt-BR/reference/system/xstore/xstore_members), conforme mostrado no código de exemplo a seguir:

```cpp theme={null}
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](/pt-BR/reference/system/xstore/xstore_members), filtrando pela ID do pacote do jogo atual obtida usando [XPackageGetCurrentProcessPackageIdentifier](/pt-BR/reference/system/xstore/xstore_members) ou filtrando as IDs de pacote retornadas por [XPackageEnumeratePackages](/pt-BR/reference/system/xstore/xstore_members):

```cpp theme={null}
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](/pt-BR/reference/system/xstore/xstore_members) para enfileirar e baixar todas as atualizações.

<Note />

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.

```cpp theme={null}
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](/pt-BR/reference/system/xstore/xstore_members) para monitorar o progresso do download:

```cpp theme={null}
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.

1. Crie o pacote V1 com o código de verificação de atualização e de download.
2. Crie o pacote V2 com a mesma identidade, mas com o número de versão incrementado.
3. Execute `xbapp/wdapp install` V1.
4. Execute `xbapp/wdapp update` V2 `/a`.
5. 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](/pt-BR/reference/system/xstore/xstore_members)`.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

* [XStore (conteúdo da API)](/pt-BR/reference/system/xstore/xstore_members)
  * Funções
    * [XStoreQueryGameAndDlcPackageUpdatesAsync](/pt-BR/reference/system/xstore/xstore_members)
    * [XStoreQueryPackageUpdatesAsync](/pt-BR/reference/system/xstore/xstore_members)
    * [XStoreDownloadAndInstallPackageUpdatesAsync](/pt-BR/reference/system/xstore/xstore_members)
  * Estruturas
    * [XStorePackageUpdate](/pt-BR/reference/system/xstore/xstore_members)
* [XPackage (conteúdo da API)](/pt-BR/reference/system/xstore/xstore_members)
  * Funções
    * [XPackageGetCurrentProcessPackageIdentifier](/pt-BR/reference/system/xstore/xstore_members)
    * [XPackageEnumeratePackages](/pt-BR/reference/system/xstore/xstore_members)
    * [XPackageCreateInstallationMonitor](/pt-BR/reference/system/xstore/xstore_members)

## Confira também

[Visão geral do comércio](/pt-BR/publishing/xstore-commerce/xstore-commerce-overview)

[Habilitando o desenvolvimento e o teste do XStore](/pt-BR/publishing/xstore-commerce/xstore-product-testing-setup)

Práticas recomendadas de atualização de conteúdo

Criando, examinando e testando atualizações de conteúdo

[Referência da API XStore](/pt-BR/reference/system/xstore/xstore_members)


## Related topics

- [XBOX Rapid Updates](/pt-BR/publishing/game-publishing/concepts/certification/xbox-rapid-updates.md)
- [Terminologia](/pt-BR/publishing/certification/console-cert-terminology.md)
- [Inicio rápido de mensajería por correo electrónico](/es/services/playfab/live-service-management/game-configuration/title-communications/emails/quickstart.md)
- [Requisitos do XBOX para jogos do XBOX](/pt-BR/publishing/certification/xbox-requirements.md)
- [Requisitos XBOX testados na certificação para jogos de console XBOX](/pt-BR/publishing/certification/console-cert-tested-requirements.md)