Csomagfrissítések letöltése és telepítése az Áruházból

A Windows 10 1607-es verziójától kezdve a Windows.Services.Store névtér StoreContext osztályának metódusaival programozott módon ellenőrizheti az aktuális alkalmazás csomagfrissítéseit a Microsoft Store-ból, és letöltheti és telepítheti a frissített csomagokat. A Partnerközpontban kötelezőként megjelölt csomagokat is lekérdezheti, és letilthatja az alkalmazás funkcióit a kötelező frissítés telepítéséig.

A Windows 10 1803-as verziójában bevezetett további StoreContext metódusok lehetővé teszik a csomagfrissítések csendes letöltését és telepítését (anélkül, hogy értesítési felhasználói felületet jelenítenének meg a felhasználónak), eltávolíthat egy választható csomag, és információkat kaphat az alkalmazás letöltési és telepítési várólistájában lévő csomagokról.

Ezek a funkciók segítenek automatikusan naprakészen tartani a felhasználói bázist az alkalmazás legújabb verziójával, az opcionális csomagokkal és a kapcsolódó szolgáltatásokkal az Áruházban.

Csomagfrissítések letöltése és telepítése a felhasználó engedélyével

Ez a példakód bemutatja, hogyan használhatja a GetAppAndOptionalStorePackageUpdatesAsync metódust az Áruházból elérhető összes csomagfrissítés felderítéséhez, majd a RequestDownloadAndInstallStorePackageUpdatesAsync metódust a frissítések letöltéséhez és telepítéséhez. Ha ezzel a módszerrel tölti le és telepíti a frissítéseket, az operációs rendszer megjelenít egy párbeszédpanelt, amely megkérdezi a felhasználó engedélyét, mielőtt letöltené a frissítéseket.

Jegyzet

Ezek a módszerek támogatják a szükséges és az alkalmazáshoz választható csomagokat. Az opcionális csomagok hasznosak letölthető tartalmak (DLC) bővítményekhez, a nagyméretű alkalmazás méretkorlátozások szerinti osztásához vagy az alapalkalmazástól eltérő további tartalmak szállításához. Az opcionális csomagokat (köztük DLC-bővítményeket) használó alkalmazások Áruházba való beküldésére vonatkozó engedélyért tekintse meg Windows fejlesztői támogatásicímű témakört.

Ez a példakód a következőket feltételezi:

• A kód egy lapkörnyezetében fut.
• A lap tartalmaz egy folyamatjelzőt, amelyet downloadProgressBar-nek neveznek, a letöltési művelet állapotának megadásához.
• A kódfájl rendelkezik egy a Windows.Services.Store, a Windows.Threading.Tasks és a Windows.UI.Popups névterek utasítással.
• Az alkalmazás egy egyfelhasználós alkalmazás, amely csak az alkalmazást elindító felhasználó kontextusában fut. Többfelhasználós GetForUser metódussal StoreContext objektumot kérhet le a GetDefault metódus helyett.

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

Jegyzet

Ha csak az elérhető csomagfrissítéseket szeretné letölteni (de nem telepíteni), használja a RequestDownloadStorePackageUpdatesAsync metódust.

Letöltési és telepítési folyamat adatainak megjelenítése

Amikor meghívja a RequestDownloadStorePackageUpdatesAsync vagy RequestDownloadAndInstallStorePackageUpdatesAsync metódust, hozzárendelhet egy Progress kezelőt, amelyet a kérés minden egyes csomagjának letöltési (vagy letöltési és telepítési) folyamatában egyszer hívunk meg. A kezelő kap egy StorePackageUpdateStatus objektumot, amely információt nyújt az állapotértesítést generáló frissítési csomagról. Az előző példa a StorePackageUpdateStatus objektum PackageDownloadProgress mezőjét használja a letöltési és telepítési folyamat előrehaladásának megjelenítéséhez.

Vegye figyelembe, hogy amikor meghívja RequestDownloadAndInstallStorePackageUpdatesAsync, hogy egyetlen műveletben töltse le és telepítse a csomagfrissítéseket, a PackageDownloadProgress mező 0,0-ról 0,8-ra nő a csomag letöltési folyamata során, majd a telepítés során 0,8-ról 1,0-ra nő. Ezért ha az egyéni folyamat felhasználói felületén látható százalékos arányt közvetlenül a PackageDownloadProgress mező értékéhez rendeli, a felhasználói felület 80% jelenik meg, amikor a csomag letöltése befejeződött, és az operációs rendszer megjeleníti a telepítési párbeszédpanelt. Ha azt szeretné, hogy az egyéni folyamatjelző kijelző 100% értéket mutasson, amikor a csomag letöltésre kerül és készen áll a telepítésre, módosíthatja a kódját úgy, hogy 100% értéket rendel az előrehaladási felületéhez, amikor a PackageDownloadProgress mező eléri a 0,8 értéket.

Csomagfrissítések csendes letöltése és telepítése

A Windows 10 1803-as verziójától kezdve használhatja a TrySilentDownloadStorePackageUpdatesAsync és TrySilentDownloadAndInstallStorePackageUpdatesAsync metódusokat a csomagfrissítések csendes letöltéséhez és telepítéséhez anélkül, hogy megjelenítené a felhasználó értesítési felhasználói felületét. Ez a művelet csak akkor lesz sikeres, ha a felhasználó engedélyezte a Az alkalmazások automatikus frissítése beállítást az Áruházban, és nem forgalomkorlátozott hálózaton van. A metódusok meghívása előtt először ellenőrizheti a CanSilentlyDownloadStorePackageUpdates tulajdonságot annak megállapításához, hogy ezek a feltételek jelenleg teljesülnek-e.

Ez a példakód bemutatja, hogyan használhatja a GetAppAndOptionalStorePackageUpdatesAsync metódust az összes elérhető csomagfrissítés felderítéséhez, majd meghívhatja a TrySilentDownloadStorePackageUpdatesAsync és TrySilentDownloadAndInstallStorePackageUpdatesAsync metódusokat a frissítések csendes letöltéséhez és telepítéséhez.

Ez a példakód a következőket feltételezi:

• A kódfájl utasítást használ a Windows.Services.Store és System.Threading.Tasks névterekhez.
• Az alkalmazás egy egyfelhasználós alkalmazás, amely csak az alkalmazást elindító felhasználó kontextusában fut. Többfelhasználós GetForUser metódussal StoreContext objektumot kérhet le a GetDefault metódus helyett.

Jegyzet

Az IsNowAGoodTimeToRestartApp, RetryDownloadAndInstallLaterés RetryInstallLater metódusok a jelen példában szereplő kód által meghívott helyőrző metódusok, amelyek a saját alkalmazástervnek megfelelően szükség szerint implementálhatók.

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

Kötelező csomagfrissítések

Amikor létrehoz egy csomagküldést a Partnerközpontban egy olyan alkalmazáshoz, amely a Windows 10 1607-es vagy újabb verzióját célozza, megjelölheti a csomagot kötelező, valamint a kötelezővé válás dátumát és időpontját. Ha ez a tulajdonság be van állítva, és az alkalmazás felfedezi, hogy a csomagfrissítés elérhető, az alkalmazás meghatározhatja, hogy a frissítési csomag kötelező-e, és a frissítés telepítéséig módosíthatja annak viselkedését (például az alkalmazás letilthatja a funkciókat).

Jegyzet

A Microsoft nem kényszeríti a csomagfrissítések kötelező állapotát, és az operációs rendszer nem biztosít felhasználói felületet, amely jelzi a felhasználóknak, hogy telepíteni kell egy kötelező alkalmazásfrissítést. A fejlesztők a kötelező beállítással kívánják kikényszeríteni a kötelező alkalmazásfrissítéseket a saját kódjukban.

Csomagküldés kötelezőként való megjelölése:

1. Jelentkezzen be Partnerközpont, és keresse meg az alkalmazás áttekintő oldalát.
2. Kattintson annak a beküldésnek a nevére, amely tartalmazza a kötelezővé tenni kívánt csomagfrissítést.
3. Lépjen a Csomagok oldalra a beküldéshez. Az oldal alja közelében válassza a Frissítés kötelezővé tétele lehetőséget, majd válassza ki azt a napot és időpontot, amikor a csomagfrissítés kötelezővé válik. Ez a beállítás a beküldésben szereplő összes UWP-csomagra vonatkozik.

További információért lásd: Alkalmazáscsomagok feltöltése.

Jegyzet

Ha létrehoz egy csomagrepülést, a csomagokat kötelezőként megjelölheti a csomagok oldalon található hasonló felület segítségével. Ebben az esetben a kötelező csomagfrissítés csak a repülési csoporthoz tartozó ügyfelekre vonatkozik.

Példakód kötelező csomagokhoz

Az alábbi példakód bemutatja, hogyan állapítható meg, hogy a frissítési csomagok kötelezőek-e. Amennyiben egy kötelező csomagfrissítés letöltése vagy telepítése sikertelen, rendszerint zökkenőmentesen csökkenteni kell az alkalmazás felhasználói élményének szintjét a felhasználó számára.

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()
{
}

Választható csomagok eltávolítása

A Windows 10 1803-es verziójától kezdve a RequestUninstallStorePackageAsync vagy RequestUninstallStorePackageByStoreIdAsync metódusokkal eltávolíthat egy opcionális csomag (beleértve egy DLC-csomagot) az aktuális alkalmazáshoz. Ha például olyan alkalmazással rendelkezik, amely nem kötelező csomagokon keresztül telepített tartalommal rendelkezik, érdemes lehet olyan felhasználói felületet biztosítani, amellyel a felhasználók eltávolíthatják az opcionális csomagokat a lemezterület felszabadításához.

Az alábbi példakód bemutatja, hogyan hívható meg RequestUninstallStorePackageAsync. Ez a példa a következőket feltételezi:

• A kódfájl utasítást használ a Windows.Services.Store és System.Threading.Tasks névterekhez.
• Az alkalmazás egy egyfelhasználós alkalmazás, amely csak az alkalmazást elindító felhasználó kontextusában fut. Többfelhasználós GetForUser metódussal StoreContext objektumot kérhet le a GetDefault metódus helyett.

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

Letöltési várólista adatainak lekérése

A Windows 10 1803-as verziójától kezdve használhatja a GetAssociatedStoreQueueItemsAsync és GetStoreQueueItemsAsync metódusokat, hogy információkat kapjon az aktuális letöltési és telepítési várólistában lévő csomagokról az Áruházból. Ezek a módszerek akkor hasznosak, ha az alkalmazás vagy a játék támogatja a nagy opcionális csomagokat (beleértve a DPC-ket is), amelyek letöltése és telepítése órákat vagy napokat vehet igénybe, és érdemes türelmesen kezelni azt az esetet, amikor az ügyfél bezárja az alkalmazást vagy a játékot a letöltési és telepítési folyamat befejezése előtt. Amikor az ügyfél újra elindítja az alkalmazást vagy a játékot, a kód ezekkel a módszerekkel információkat kaphat a letöltési és telepítési várólistában lévő csomagok állapotáról, így megjelenítheti az egyes csomagok állapotát az ügyfél számára.

Az alábbi példakód bemutatja, hogyan hívhatja meg GetAssociatedStoreQueueItemsAsync az aktuális alkalmazás folyamatban lévő csomagfrissítéseinek listájának lekéréséhez és az egyes csomagok állapotadatainak lekéréséhez. Ez a példa a következőket feltételezi:

• A kódfájl utasítást használ a Windows.Services.Store és System.Threading.Tasks névterekhez.
• Az alkalmazás egy egyfelhasználós alkalmazás, amely csak az alkalmazást elindító felhasználó kontextusában fut. Többfelhasználós GetForUser metódussal StoreContext objektumot kérhet le a GetDefault metódus helyett.

Jegyzet

A MarkUpdateInProgressInUI, RemoveItemFromUI, MarkInstallCompleteInUI, MarkInstallErrorInUIés MarkInstallPausedInUI metódusok, amelyeket a jelen példában szereplő kód hív meg, olyan helyőrző metódusok, amelyek a saját alkalmazástervnek megfelelően szükség szerint implementálhatók.

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

Kapcsolódó témakörök

• Választható csomagok és kapcsolódó készletszerkesztés