Sdílet prostřednictvím

Stažení a instalace aktualizací balíčků ze Storu

Počínaje Windows 10 verze 1607 můžete pomocí metod třídy StoreContext v oboru názvů Windows.Services.Store programově zkontrolovat aktualizace balíčků pro aktuální aplikaci z Microsoft Storu a stáhnout a nainstalovat aktualizované balíčky. Můžete také zadat dotaz na balíčky, které jste v Partnerském centru označili jako povinné, a zakázat funkce v aplikaci, dokud nebude nainstalovaná povinná aktualizace.

Další metody StoreContext zavedené ve Windows 10 verze 1803 umožňují stahovat a instalovat aktualizace balíčků bezobslužně (bez zobrazení uživatelského rozhraní oznámení pro uživatele), odinstalovat volitelný balíček a získat informace o balíčcích ve stažení a instalaci fronty pro vaši aplikaci.

Tyto funkce vám pomůžou automaticky udržovat uživatelskou základnu v aktualizovaném stavu s nejnovější verzí aplikace, volitelnými balíčky a souvisejícími službami ve Storu.

Stažení a instalace aktualizací balíčků s oprávněním uživatele

Tento příklad kódu ukazuje, jak použít metodu GetAppAndOptionalStorePackageUpdatesAsync ke zjištění všech dostupných aktualizací balíčků ze Storu a potom volat metodu RequestDownloadAndInstallStorePackageUpdatesAsync ke stažení a instalaci aktualizací. Při použití této metody ke stažení a instalaci aktualizací zobrazí operační systém dialogové okno, které před stažením aktualizací požádá uživatele o oprávnění.

Poznámka

Tyto metody podporují požadované a volitelné balíčky pro vaši aplikaci. Volitelné balíčky jsou užitečné pro doplňky DLC (downloadable content), rozdělení velké aplikace pro omezení velikosti nebo pro expedici dalšího obsahu odděleného od základní aplikace. Pokud chcete získat oprávnění k odeslání aplikace, která používá volitelné balíčky (včetně doplňků DLC) do Storu, podívejte se na podporu vývojářů pro Windows.

Tento příklad kódu předpokládá:

  • Kód se spouští v kontextu stránky .
  • Stránka obsahuje indikátor průběhu s názvemdownloadProgressBar, který poskytuje stav operace stahování.
  • Soubor kódu obsahuje příkaz using pro obory názvů Windows.Services.Store, Windows.Threading.Tasks a Windows.UI.Popups .
  • Aplikace je aplikace s jedním uživatelem, která běží jenom v kontextu uživatele, který aplikaci spustil. Pro víceuživatelovou aplikaci použijte metodu GetForUser k získání objektu StoreContext místo Metody GetDefault .
private StoreContext context = null;

public async Task DownloadAndInstallAllUpdatesAsync()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    // Get the updates that are available.
    IReadOnlyList<StorePackageUpdate> updates =
        await context.GetAppAndOptionalStorePackageUpdatesAsync();

    if (updates.Count > 0)
    {
        // Alert the user that updates are available and ask for their consent
        // to start the updates.
        MessageDialog dialog = new MessageDialog(
            "Download and install updates now? This may cause the application to exit.", "Download and Install?");
        dialog.Commands.Add(new UICommand("Yes"));
        dialog.Commands.Add(new UICommand("No"));
        IUICommand command = await dialog.ShowAsync();

        if (command.Label.Equals("Yes", StringComparison.CurrentCultureIgnoreCase))
        {
            // Download and install the updates.
            IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> downloadOperation =
                context.RequestDownloadAndInstallStorePackageUpdatesAsync(updates);

            // The Progress async method is called one time for each step in the download
            // and installation process for each package in this request.
            downloadOperation.Progress = async (asyncInfo, progress) =>
            {
                await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
                () =>
                {
                    downloadProgressBar.Value = progress.PackageDownloadProgress;
                });
            };

            StorePackageUpdateResult result = await downloadOperation.AsTask();
        }
    }
}

Poznámka

Pokud chcete stáhnout (ale neinstalovat) dostupné aktualizace balíčků, použijte metodu RequestDownloadStorePackageUpdatesAsync .

Zobrazení informací o průběhu stahování a instalace

Když voláte metodu RequestDownloadStorePackageUpdatesAsync nebo RequestDownloadAndInstallStorePackageUpdatesAsync , můžete přiřadit obslužnou rutinu Progress , která se volá jednou pro každý krok procesu stahování (nebo stahování a instalace) pro každý balíček v tomto požadavku. Obslužná rutina obdrží StorePackageUpdateStatus objekt, který poskytuje informace o balíčku aktualizace, který vyvolal oznámení o průběhu. Předchozí příklad používá Pole PackageDownloadProgressobjektu StorePackageUpdateStatus k zobrazení průběhu procesu stahování a instalace.

Mějte na paměti, že když zavoláte RequestDownloadAndInstallStorePackageUpdatesAsync ke stažení a instalaci aktualizací balíčků v jedné operaci, pole PackageDownloadProgress se během procesu stahování balíčku zvýší z 0.0 na 0.8 a pak se během instalace zvýší z 0.8 na 1.0. Proto pokud namapujete procento zobrazené v uživatelském rozhraní vlastního průběhu přímo na hodnotu pole PackageDownloadProgress , uživatelské rozhraní zobrazí 80% po dokončení stahování balíčku a operační systém zobrazí dialogové okno instalace. Pokud chcete, aby uživatelské rozhraní vlastního průběhu zobrazovalo 100% při stažení balíčku a je připraven k instalaci, můžete kód upravit tak, aby přiřadil 100% k uživatelskému rozhraní průběhu, když pole PackageDownloadProgress dosáhne hodnoty 0.8.

Bezobslužné stahování a instalace aktualizací balíčků

Počínaje Windows 10 verze 1803 můžete použít metody TrySilentDownloadStorePackageUpdatesAsync a TrySilentDownloadAndInstallStorePackageUpdatesAsync ke stažení a instalaci aktualizací balíčků bezobslužně bez zobrazení uživatelského rozhraní oznámení pro uživatele. Tato operace bude úspěšná jenom v případě, že uživatel povolil automatické nastavení aplikací pro aktualizaci ve Storu a uživatel není v síti účtované podle měrného metru. Před voláním těchto metod můžete nejprve zkontrolovat CanSilentlyDownloadStorePackageUpdates vlastnost určit, zda tyto podmínky jsou aktuálně splněny.

Tento příklad kódu ukazuje, jak použít metodu GetAppAndOptionalStorePackageUpdatesAsync ke zjištění všech dostupných aktualizací balíčku a potom volat metody TrySilentDownloadStorePackageUpdatesAsync a TrySilentDownloadAndInstallStorePackageUpdatesAsync k bezobslužnému stažení a instalaci aktualizací.

Tento příklad kódu předpokládá:

  • Soubor kódu obsahuje příkaz using pro obory názvů Windows.Services.Store a System.Threading.Tasks .
  • Aplikace je aplikace s jedním uživatelem, která běží jenom v kontextu uživatele, který aplikaci spustil. Pro víceuživatelovou aplikaci použijte metodu GetForUser k získání objektu StoreContext místo Metody GetDefault .

Poznámka

Metody IsNowAGoodTimeToRestartApp, RetryDownloadAndInstallLater a RetryInstallLater volané kódem v tomto příkladu jsou zástupné metody, které mají být implementovány podle potřeby podle návrhu vlastní aplikace.

private StoreContext context = null;

public async Task DownloadAndInstallAllUpdatesInBackgroundAsync()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    // Get the updates that are available.
    IReadOnlyList<StorePackageUpdate> storePackageUpdates =
        await context.GetAppAndOptionalStorePackageUpdatesAsync();

    if (storePackageUpdates.Count > 0)
    {

        if (!context.CanSilentlyDownloadStorePackageUpdates)
        {
            return;
        }

        // Start the silent downloads and wait for the downloads to complete.
        StorePackageUpdateResult downloadResult =
            await context.TrySilentDownloadStorePackageUpdatesAsync(storePackageUpdates);

        switch (downloadResult.OverallState)
        {
            case StorePackageUpdateState.Completed:
                // The download has completed successfully. At this point, confirm whether your app
                // can restart now and then install the updates (for example, you might only install
                // packages silently if your app has been idle for a certain period of time). The
                // IsNowAGoodTimeToRestartApp method is not implemented in this example, you should
                // implement it as needed for your own app.
                if (IsNowAGoodTimeToRestartApp())
                {
                    await InstallUpdate(storePackageUpdates);
                }
                else
                {
                    // Retry/reschedule the installation later. The RetryInstallLater method is not  
                    // implemented in this example, you should implement it as needed for your own app.
                    RetryInstallLater();
                    return;
                }
                break;
            // If the user cancelled the download or you can't perform the download for some other
            // reason (for example, Wi-Fi might have been turned off and the device is now on
            // a metered network) try again later. The RetryDownloadAndInstallLater method is not  
            // implemented in this example, you should implement it as needed for your own app.
            case StorePackageUpdateState.Canceled:
            case StorePackageUpdateState.ErrorLowBattery:
            case StorePackageUpdateState.ErrorWiFiRecommended:
            case StorePackageUpdateState.ErrorWiFiRequired:
            case StorePackageUpdateState.OtherError:
                RetryDownloadAndInstallLater();
                return;
            default:
                break;
        }
    }
}

private async Task InstallUpdate(IReadOnlyList<StorePackageUpdate> storePackageUpdates)
{
    // Start the silent installation of the packages. Because the packages have already
    // been downloaded in the previous method, the following line of code just installs
    // the downloaded packages.
    StorePackageUpdateResult downloadResult =
        await context.TrySilentDownloadAndInstallStorePackageUpdatesAsync(storePackageUpdates);

    switch (downloadResult.OverallState)
    {
        // If the user cancelled the installation or you can't perform the installation  
        // for some other reason, try again later. The RetryInstallLater method is not  
        // implemented in this example, you should implement it as needed for your own app.
        case StorePackageUpdateState.Canceled:
        case StorePackageUpdateState.ErrorLowBattery:
        case StorePackageUpdateState.OtherError:
            RetryInstallLater();
            return;
        default:
            break;
    }
}

Povinné aktualizace balíčků

Když vytvoříte odeslání balíčku v Partnerském centru pro aplikaci, která cílí na Windows 10 verze 1607 nebo novější, můžete balíček označit jako povinný a datum a čas, kdy se stane povinným. Když je tato vlastnost nastavená a vaše aplikace zjistí, že je aktualizace balíčku dostupná, může aplikace určit, jestli je balíček aktualizace povinný, a změnit jeho chování, dokud se aktualizace nenainstaluje (například aplikace může zakázat funkce).

Poznámka

Microsoft nevynucuje povinný stav aktualizace balíčku a operační systém neposkytuje uživatelské rozhraní, které uživatelům oznámí, že musí být nainstalovaná povinná aktualizace aplikace. Vývojáři mají použít povinné nastavení k vynucení povinných aktualizací aplikace ve vlastním kódu.

Označení odeslání balíčku jako povinného:

  1. Přihlaste se k partnerskému centru a přejděte na stránku s přehledem aplikace.
  2. Klikněte na název odeslání, který obsahuje aktualizaci balíčku, kterou chcete nastavit jako povinnou.
  3. Přejděte na stránku Balíčky pro odeslání. V dolní části této stránky vyberte Nastavit tuto aktualizaci jako povinnou a pak zvolte den a čas, kdy se aktualizace balíčku stane povinnou. Tato možnost se vztahuje na všechny balíčky UWP v podání.

Další informace najdete v tématu Nahrání balíčků aplikací.

Poznámka

Pokud vytvoříte testovací verzi balíčku, můžete balíčky označit jako povinné pomocí podobného uživatelského rozhraní na stránce Balíčky pro testovací verzi. V tomto případě se povinná aktualizace balíčku vztahuje pouze na zákazníky, kteří jsou součástí letové skupiny.

Příklad kódu pro povinné balíčky

Následující příklad kódu ukazuje, jak určit, zda jsou některé balíčky aktualizací povinné. Pokud se povinná aktualizace balíčku úspěšně nestahuje nebo nenainstaluje, měli byste snadno snížit úroveň uživatelského prostředí aplikace.

private StoreContext context = null;

// Downloads and installs package updates in separate steps.
public async Task DownloadAndInstallAllUpdatesAsync()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }  

    // Get the updates that are available.
    IReadOnlyList<StorePackageUpdate> updates =
        await context.GetAppAndOptionalStorePackageUpdatesAsync();

    if (updates.Count != 0)
    {
        // Download the packages.
        bool downloaded = await DownloadPackageUpdatesAsync(updates);

        if (downloaded)
        {
            // Install the packages.
            await InstallPackageUpdatesAsync(updates);
        }
    }
}

// Helper method for downloading package updates.
private async Task<bool> DownloadPackageUpdatesAsync(IEnumerable<StorePackageUpdate> updates)
{
    bool downloadedSuccessfully = false;

    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> downloadOperation =
        this.context.RequestDownloadStorePackageUpdatesAsync(updates);

    // The Progress async method is called one time for each step in the download process for each
    // package in this request.
    downloadOperation.Progress = async (asyncInfo, progress) =>
    {
        await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
        () =>
        {
            downloadProgressBar.Value = progress.PackageDownloadProgress;
        });
    };

    StorePackageUpdateResult result = await downloadOperation.AsTask();

    switch (result.OverallState)
    {
        case StorePackageUpdateState.Completed:
            downloadedSuccessfully = true;
            break;
        default:
            // Get the failed updates.
            var failedUpdates = result.StorePackageUpdateStatuses.Where(
                status => status.PackageUpdateState != StorePackageUpdateState.Completed);

            // See if any failed updates were mandatory
            if (updates.Any(u => u.Mandatory && failedUpdates.Any(
                failed => failed.PackageFamilyName == u.Package.Id.FamilyName)))
            {
                // At least one of the updates is mandatory. Perform whatever actions you
                // want to take for your app: for example, notify the user and disable
                // features in your app.
                HandleMandatoryPackageError();
            }
            break;
    }

    return downloadedSuccessfully;
}

// Helper method for installing package updates.
private async Task InstallPackageUpdatesAsync(IEnumerable<StorePackageUpdate> updates)
{
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> installOperation =
        this.context.RequestDownloadAndInstallStorePackageUpdatesAsync(updates);

    // The package updates were already downloaded separately, so this method skips the download
    // operation and only installs the updates; no download progress notifications are provided.
    StorePackageUpdateResult result = await installOperation.AsTask();

    switch (result.OverallState)
    {
        case StorePackageUpdateState.Completed:
            break;
        default:
            // Get the failed updates.
            var failedUpdates = result.StorePackageUpdateStatuses.Where(
                status => status.PackageUpdateState != StorePackageUpdateState.Completed);

            // See if any failed updates were mandatory
            if (updates.Any(u => u.Mandatory && failedUpdates.Any(failed => failed.PackageFamilyName == u.Package.Id.FamilyName)))
            {
                // At least one of the updates is mandatory, so tell the user.
                HandleMandatoryPackageError();
            }
            break;
    }
}

// Helper method for handling the scenario where a mandatory package update fails to
// download or install. Add code to this method to perform whatever actions you want
// to take, such as notifying the user and disabling features in your app.
private void HandleMandatoryPackageError()
{
}

Odinstalace volitelných balíčků

Počínaje Windows 10 verze 1803 můžete použít metody RequestUninstallStorePackageAsync nebo RequestUninstallStorePackageByStoreIdAsync k odinstalaci volitelného balíčku (včetně balíčku DLC) pro aktuální aplikaci. Pokud máte například aplikaci s obsahem nainstalovaným prostřednictvím volitelných balíčků, můžete chtít poskytnout uživatelské rozhraní, které uživatelům umožní odinstalovat volitelné balíčky, aby uvolnily místo na disku.

Následující příklad kódu ukazuje, jak volat RequestUninstallStorePackageAsync. Tento příklad předpokládá:

  • Soubor kódu obsahuje příkaz using pro obory názvů Windows.Services.Store a System.Threading.Tasks .
  • Aplikace je aplikace s jedním uživatelem, která běží jenom v kontextu uživatele, který aplikaci spustil. Pro víceuživatelovou aplikaci použijte metodu GetForUser k získání objektu StoreContext místo Metody GetDefault .
public async Task UninstallPackage(Windows.ApplicationModel.Package package)
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    var storeContext = StoreContext.GetDefault();
    IAsyncOperation<StoreUninstallStorePackageResult> uninstallOperation =
        storeContext.RequestUninstallStorePackageAsync(package);

    // At this point, you can update your app UI to show that the package
    // is installing.

    uninstallOperation.Completed += (asyncInfo, status) =>
    {
        StoreUninstallStorePackageResult result = uninstallOperation.GetResults();
        switch (result.Status)
        {
            case StoreUninstallStorePackageStatus.Succeeded:
                {
                    // Update your app UI to show the package as uninstalled.
                    break;
                }
            default:
                {
                    // Update your app UI to show that the package uninstall failed.
                    break;
                }
        }
    };
}

Získání informací o frontě stahování

Počínaje Windows 10 verze 1803 můžete pomocí metod GetAssociatedStoreQueueItemsAsync a GetStoreQueueItemsAsync získat informace o balíčcích, které jsou v aktuální frontě stahování a instalace ze Storu. Tyto metody jsou užitečné, pokud vaše aplikace nebo hra podporuje velké volitelné balíčky (včetně dlc), které mohou trvat hodiny nebo dny ke stažení a instalaci, a chcete elegantně zpracovat případ, kdy zákazník zavře vaši aplikaci nebo hru před dokončením stahování a instalace. Když zákazník aplikaci nebo hru spustí znovu, může váš kód pomocí těchto metod získat informace o stavu balíčků, které jsou stále ve frontě pro stahování a instalaci, abyste zákazníkovi mohli zobrazit stav jednotlivých balíčků.

Následující příklad kódu ukazuje, jak volat GetAssociatedStoreQueueItemsAsync získat seznam probíhajících aktualizací balíčků pro aktuální aplikaci a načíst informace o stavu pro každý balíček. Tento příklad předpokládá:

  • Soubor kódu obsahuje příkaz using pro obory názvů Windows.Services.Store a System.Threading.Tasks .
  • Aplikace je aplikace s jedním uživatelem, která běží jenom v kontextu uživatele, který aplikaci spustil. Pro víceuživatelovou aplikaci použijte metodu GetForUser k získání objektu StoreContext místo Metody GetDefault .

Poznámka

Metody MarkUpdateInProgressInUI, RemoveItemFromUI, MarkInstallCompleteInUI, MarkInstallErrorInUI a MarkInstallPausedInUI volané kódem v tomto příkladu jsou zástupné metody, které mají být implementovány podle potřeby podle návrhu vlastní aplikace.

private StoreContext context = null;

private async Task GetQueuedInstallItemsAndBuildInitialStoreUI()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    // Get the Store packages in the install queue.
    IReadOnlyList<StoreQueueItem> storeUpdateItems = await context.GetAssociatedStoreQueueItemsAsync();

    foreach (StoreQueueItem storeItem in storeUpdateItems)
    {
        // In this example we only care about package updates.
        if (storeItem.InstallKind != StoreQueueItemKind.Update)
            continue;

        StoreQueueItemStatus currentStatus = storeItem.GetCurrentStatus();
        StoreQueueItemState installState = currentStatus.PackageInstallState;
        StoreQueueItemExtendedState extendedInstallState =
            currentStatus.PackageInstallExtendedState;

        // Handle the StatusChanged event to display current status to the customer.
        storeItem.StatusChanged += StoreItem_StatusChanged;

        switch (installState)
        {
            // Download and install are still in progress, so update the status for this  
            // item and provide the extended state info. The following methods are not
            // implemented in this example; you should implement them as needed for your
            // app's UI.
            case StoreQueueItemState.Active:
                MarkUpdateInProgressInUI(storeItem, extendedInstallState);
                break;
            case StoreQueueItemState.Canceled:
                RemoveItemFromUI(storeItem);
                break;
            case StoreQueueItemState.Completed:
                MarkInstallCompleteInUI(storeItem);
                break;
            case StoreQueueItemState.Error:
                MarkInstallErrorInUI(storeItem);
                break;
            case StoreQueueItemState.Paused:
                MarkInstallPausedInUI(storeItem, installState, extendedInstallState);
                break;
        }
    }
}

private void StoreItem_StatusChanged(StoreQueueItem sender, object args)
{
    StoreQueueItemStatus currentStatus = sender.GetCurrentStatus();
    StoreQueueItemState installState = currentStatus.PackageInstallState;
    StoreQueueItemExtendedState extendedInstallState = currentStatus.PackageInstallExtendedState;

    switch (installState)
    {
        // Download and install are still in progress, so update the status for this  
        // item and provide the extended state info. The following methods are not
        // implemented in this example; you should implement them as needed for your
        // app's UI.
        case StoreQueueItemState.Active:
            MarkUpdateInProgressInUI(sender, extendedInstallState);
            break;
        case StoreQueueItemState.Canceled:
            RemoveItemFromUI(sender);
            break;
        case StoreQueueItemState.Completed:
            MarkInstallCompleteInUI(sender);
            break;
        case StoreQueueItemState.Error:
            MarkInstallErrorInUI(sender);
            break;
        case StoreQueueItemState.Paused:
            MarkInstallPausedInUI(sender, installState, extendedInstallState);
            break;
    }
}
  • Last updated on