App Center – Distribuce – aktualizace v aplikaci pro Android

Důležité

Visual Studio App Center je naplánované k vyřazení na 31. března 2025. I když můžete Visual Studio App Center dál používat, dokud ho úplně nevyřadíte, existuje několik doporučených alternativ, na které můžete migraci zvážit.

Přečtěte si další informace o časových osách a alternativách podpory.

App Center Distribuovat umožní uživatelům nainstalovat novou verzi aplikace, když ji distribuujete přes App Center. Když je k dispozici nová verze aplikace, sada SDK zobrazí uživatelům dialogové okno aktualizace, které jim umožní stáhnout nebo odložit novou verzi. Jakmile se sada SDK rozhodne aktualizovat, začne aktualizovat vaši aplikaci.

Upozornění

Google Play považuje aktualizační kód v aplikaci za škodlivé chování, i když se nepoužívá za běhu. Použijte variantu sady SDK Distribuce podle pokynů v této části nebo před odesláním aplikace do Google Play úplně odeberte sadu SDK Distribute, která obsahuje aktualizační kód v aplikaci. Pokud to neuděláte, může to vést k nedodržování předpisů a odebrání aplikace z Obchodu Google Play.

Poznámka

Pokud spouštíte automatizované testy uživatelského rozhraní, povolené aktualizace v aplikaci zablokují vaše automatizované testy uživatelského rozhraní, protože se pokusí ověřit v back-endu App Center. Pro testy uživatelského rozhraní doporučujeme nepovolovat distribuci v App Center.

Přidání aktualizací v aplikaci

Pokud jste ještě sadu SDK ve své aplikaci nenastavili a nespustili, postupujte podle části Začínáme .

1. Přidání modulu Distribuce v App Center

Sada App Center SDK je navržená s modulárním přístupem – vývojáři stačí integrovat jenom moduly služeb, které ho zajímají.

  1. Otevřete soubor build.gradle na úrovni aplikace projektu (app/build.gradle) a za apply pluginpřidejte následující řádky.

    dependencies {
       def appCenterSdkVersion = '5.0.4'
       implementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
    }
    

    Poznámka

    Pokud je verze modulu plug-in Android Gradle nižší než 3.0.0, musíte implementaci nahradit kompilací.

  2. Uložte soubor build.gradle a nezapomeňte aktivovat synchronizaci Gradle v Android Studiu.

  3. DownloadManager se používá ke stahování aktualizací. Sada App Center SDK kvůli lepšímu zabezpečení vynucuje protokol TLS 1.2.

2. Spuštění distribuce v App Center

Pokud chcete používat App Center, přihlaste se k modulům, které chcete používat. Ve výchozím nastavení se nespouští žádné moduly a každý z nich musíte při spuštění sady SDK explicitně volat.

Přidejte do své metody třídu Distribute a spusťte AppCenter.start() službu App Center Distribute.

AppCenter.start(getApplication(), "{Your App Secret}", Distribute.class);
AppCenter.start(application, "{Your App Secret}", Distribute::class.java)

Ujistěte se, že jste ve výše uvedené ukázce kódu nahradili {Your App Secret} tajným kódem aplikace. Android Studio po přidání odkazu na Distribute třídu do start() metody automaticky navrhne požadovaný příkaz importu, ale pokud se zobrazí chyba, že se nerozpoznaly názvy tříd, přidejte do příkazů import ve třídě aktivity následující řádky:

import com.microsoft.appcenter.AppCenter;
import com.microsoft.appcenter.distribute.Distribute;
import com.microsoft.appcenter.AppCenter
import com.microsoft.appcenter.distribute.Distribute

Poznámka

Android 10 nebo novější má omezení pro spouštění aktivit z pozadí. Přečtěte si článek o omezeních pro spouštění aktivit na pozadí.

Poznámka

Aplikace běžící na Androidu 10 (edice Go) nemůžou získat oprávnění k SYSTEM_ALERT_WINDOW . Přečtěte si článek o zařízeních SYSTEM_ALERT_WINDOW on Go.

Poznámka

Od Androidu 11 ACTION_MANAGE_OVERLAY_PERMISSION záměry uživatele vždy přivedou na obrazovku Nastavení nejvyšší úrovně, kde může udělit nebo odvolat SYSTEM_ALERT_WINDOW oprávnění pro aplikace. Přečtěte si článek o aktualizacích oprávnění v Androidu 11.

Příprava buildu Google Play

Google Play považuje aktualizační kód v aplikaci za škodlivé chování, i když se nepoužívá za běhu. Použijte variantu sady SDK Distribuce podle pokynů v této části nebo před odesláním aplikace do Google Play úplně odeberte sadu SDK Distribute, která obsahuje aktualizační kód v aplikaci. Pokud to neuděláte, může to vést k nedodržování předpisů a odebrání aplikace z Obchodu Google Play. Abychom vám to usnadnili, poskytujeme verzi sady App Center Distribuce sady SDK se zadržovanými rozhraními API, takže jedinou změnou pro vás je prohození závislostí.

  1. Otevřete soubor build.gradle na úrovni aplikace projektu (app/build.gradle).

  2. Nakonfigurujte varianty sestavení přidáním příchutí produktu:

    android {
        flavorDimensions "distribute"
        productFlavors {
            appCenter {
                dimension "distribute"
            }
            googlePlay {
                dimension "distribute"
            }
        }
    }
    
  3. Upravte blok závislostí tak, aby využíval různé závislosti v závislosti na příchuti produktu:

    dependencies {
        def appCenterSdkVersion = "5.0.4"
        appCenterImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
        googlePlayImplementation "com.microsoft.appcenter:appcenter-distribute-play:${appCenterSdkVersion}"
    }
    
  4. Uložte soubor build.gradle a nezapomeňte aktivovat synchronizaci Gradle v Android Studiu.

  5. Variantu sestavení můžete změnit v rozevírací nabídce Build > Select Build Variant (Vybrat variantu sestavení ) nebo Build Variants (Varianty sestavení ) na panelu nástrojů.

Další informace o konfiguraci variant sestavení najdete v dokumentaci k Androidu.

Použití privátní distribuční skupiny

Distribuce ve výchozím nastavení používá veřejnou distribuční skupinu. Pokud chcete použít privátní distribuční skupinu, budete ji muset explicitně nastavit prostřednictvím setUpdateTrack rozhraní API.

Distribute.setUpdateTrack(UpdateTrack.PRIVATE);
Distribute.setUpdateTrack(UpdateTrack.PRIVATE)

Poznámka

Výchozí hodnota je UpdateTrack.PUBLIC. Tuto metodu lze volat pouze před voláním AppCenter.start metody. Změny ve sledování aktualizací se při restartování procesu aplikace neuchovávají, takže pokud se metoda nevolá vždy před voláním AppCenter.start , bude ve výchozím nastavení veřejná.

Když je aplikace v popředí (za Distribute.setUpdateTrack(UpdateTrack.PRIVATE); a AppCenter.start), otevře se okno prohlížeče pro ověření uživatele. Všechny následné kontroly aktualizací získají nejnovější verzi na soukromé cestě.

Pokud je uživatel na soukromé cestě, znamená to, že po úspěšném ověření získá nejnovější verzi ze všech privátních distribučních skupin, kterých je členem. Pokud je uživatel na veřejné cestě, znamená to, že získá nejnovější verzi z jakékoli veřejné distribuční skupiny.

Zakázat automatickou kontrolu aktualizací

Ve výchozím nastavení sada SDK automaticky vyhledává nové verze:

  • Při spuštění aplikace.
  • Když aplikace přejde do popředí po přechodu na pozadí.
  • Při povolování modulu Distribuovat, pokud byl dříve zakázán.

Pokud chcete nové verze vyhledat ručně, můžete zakázat automatickou kontrolu aktualizací. Chcete-li to provést, zavolejte následující metodu před spuštěním sady SDK:

Distribute.disableAutomaticCheckForUpdate();
Distribute.disableAutomaticCheckForUpdate()

Poznámka

Tato metoda musí být volána před voláním AppCenter.start metody.

Pak můžete použít checkForUpdate rozhraní API, které je popsáno v následující části.

Ruční kontrola aktualizace

Distribute.checkForUpdate();
Distribute.checkForUpdate()

Tím se odešle žádost do App Center a zobrazí se dialogové okno aktualizace pro případ, že je k dispozici nová verze.

Poznámka

Ruční kontrola pro volání aktualizace funguje i v případě, že jsou povolené automatické aktualizace. Ruční kontrola aktualizace se ignoruje, pokud už probíhá jiná kontrola. Ruční kontrola aktualizace se nezpracuje, pokud uživatel aktualizace odložil (pokud nejnovější verze není povinná aktualizace).

Přizpůsobení nebo lokalizace dialogového okna aktualizace v aplikaci

1. Přizpůsobení nebo lokalizace textu

Pokud chcete změnit nebo lokalizovat text zobrazený v dialogovém okně aktualizace, můžete snadno zadat vlastní řetězce prostředků. Podívejte se na soubory řetězců v tomto souboru prostředků. Použijte stejný název řetězce nebo klíč a zadejte lokalizovanou hodnotu, která se má v dialogovém okně projevit ve vlastních souborech prostředků aplikace.

2. Přizpůsobení dialogového okna aktualizace

Vzhled výchozího dialogového okna aktualizace můžete přizpůsobit implementací DistributeListener rozhraní. Před voláním AppCenter.start musíte zaregistrovat naslouchací proces, jak je znázorněno v následujícím příkladu:

Distribute.setListener(new MyDistributeListener());
AppCenter.start(...);
Distribute.setListener(MyDistributeListener())
AppCenter.start(...)

Tady je příklad implementace naslouchacího procesu, která nahrazuje dialogové okno sady SDK vlastním dialogem:

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.net.Uri;

import com.microsoft.appcenter.distribute.Distribute;
import com.microsoft.appcenter.distribute.DistributeListener;
import com.microsoft.appcenter.distribute.ReleaseDetails;
import com.microsoft.appcenter.distribute.UpdateAction;

public class MyDistributeListener implements DistributeListener {

    @Override
    public boolean onReleaseAvailable(Activity activity, ReleaseDetails releaseDetails) {

        // Look at releaseDetails public methods to get version information, release notes text or release notes URL
        String versionName = releaseDetails.getShortVersion();
        int versionCode = releaseDetails.getVersion();
        String releaseNotes = releaseDetails.getReleaseNotes();
        Uri releaseNotesUrl = releaseDetails.getReleaseNotesUrl();

        // Build our own dialog title and message
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(activity);
        dialogBuilder.setTitle("Version " + versionName + " available!"); // you should use a string resource instead, this is just a simple example
        dialogBuilder.setMessage(releaseNotes);

        // Mimic default SDK buttons
        dialogBuilder.setPositiveButton(com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_download, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {

                // This method is used to tell the SDK what button was clicked
                Distribute.notifyUpdateAction(UpdateAction.UPDATE);
            }
        });

        // We can postpone the release only if the update isn't mandatory
        if (!releaseDetails.isMandatoryUpdate()) {
            dialogBuilder.setNegativeButton(com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_postpone, new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {

                    // This method is used to tell the SDK what button was clicked
                    Distribute.notifyUpdateAction(UpdateAction.POSTPONE);
                }
            });
        }
        dialogBuilder.setCancelable(false); // if it's cancelable you should map cancel to postpone, but only for optional updates
        dialogBuilder.create().show();

        // Return true if you're using your own dialog, false otherwise
        return true;
    }
    
    @Override
    public void onNoReleaseAvailable(Activity activity) {
        Toast.makeText(activity, activity.getString(R.string.no_updates_available), Toast.LENGTH_LONG).show();
    }
}
import android.app.Activity
import android.app.AlertDialog
import com.microsoft.appcenter.distribute.Distribute
import com.microsoft.appcenter.distribute.DistributeListener
import com.microsoft.appcenter.distribute.ReleaseDetails
import com.microsoft.appcenter.distribute.UpdateAction

class MyDistributeListener : DistributeListener {

    override fun onReleaseAvailable(activity: Activity, releaseDetails: ReleaseDetails): Boolean {

        // Look at releaseDetails public methods to get version information, release notes text or release notes URL
        val versionName = releaseDetails.shortVersion
        val versionCode = releaseDetails.version
        val releaseNotes = releaseDetails.releaseNotes
        val releaseNotesUrl = releaseDetails.releaseNotesUrl

        // Build our own dialog title and message
        val dialogBuilder = AlertDialog.Builder(activity)
        dialogBuilder.setTitle("Version $versionName available!") // you should use a string resource instead, this is just a simple example
        dialogBuilder.setMessage(releaseNotes)

        // Mimic default SDK buttons
        dialogBuilder.setPositiveButton(
            com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_download
        ) { dialog, which ->
            // This method is used to tell the SDK what button was clicked
            Distribute.notifyUpdateAction(UpdateAction.UPDATE)
        }

        // We can postpone the release only if the update isn't mandatory
        if (!releaseDetails.isMandatoryUpdate) {
            dialogBuilder.setNegativeButton(
                com.microsoft.appcenter.distribute.R.string.appcenter_distribute_update_dialog_postpone
            ) { dialog, which ->
                // This method is used to tell the SDK what button was clicked
                Distribute.notifyUpdateAction(UpdateAction.POSTPONE)
            }
        }
        dialogBuilder.setCancelable(false) // if it's cancelable you should map cancel to postpone, but only for optional updates
        dialogBuilder.create().show()

        // Return true if you're using your own dialog, false otherwise
        return true
    }

    override fun onNoReleaseAvailable(activity: Activity) {
        Toast.makeText(activity, activity.getString(R.string.no_updates_available), Toast.LENGTH_LONG).show()
    }
}

Jak je znázorněno v příkladu, musíte buď volat Distribute.notifyUpdateAction(UpdateAction.UPDATE); , nebo Distribute.notifyUpdateAction(UpdateAction.POSTPONE); pokud váš naslouchací proces vrátí true.

Pokud nezavoláte notifyUpdateAction, zpětné volání se bude opakovat při každé změně aktivity.

Naslouchací proces lze znovu volat se stejnou verzí, pokud se aktivita změní předtím, než se akce uživatele oznámí sadě SDK.

Toto chování je potřeba k pokrytí následujících scénářů:

  • Vaše aplikace se odešle na pozadí (například stisknutím klávesy HOME) a pak se obnoví v jiné aktivitě.
  • Vaše aktivita je pokryta jinou aktivitou, aniž byste opustili aplikaci (například kliknutím na některá oznámení).
  • Další podobné scénáře.

V takovém případě může být aktivita hostující dialogové okno nahrazena bez zásahu uživatele. Sada SDK proto znovu zavolá naslouchací proces, abyste mohli obnovit vlastní dialogové okno.

V případech, kdy sada SDK vyhledá aktualizace a nenajde žádné aktualizace, které jsou k dispozici novější, než je aktuálně používaná, onNoReleaseAvailable se vyvolá zpětné volání z DistributeListener rozhraní. To vám umožní spouštět vlastní kód v takových scénářích. Výše uvedený příklad ukazuje, jak zobrazit informační zprávu, když nejsou nalezeny žádné aktualizace.

Povolení nebo zakázání distribuce app Center za běhu

App Center můžete povolit a zakázat distribuci za běhu. Pokud ho zakážete, sada SDK nebude poskytovat žádné funkce aktualizace v aplikaci, ale přesto můžete použít službu Distribuovat na portálu App Center.

Distribute.setEnabled(false);
Distribute.setEnabled(false)

Pokud chcete app Center distribuovat znovu, použijte stejné rozhraní API, ale předejte true ho jako parametr.

Distribute.setEnabled(true);
Distribute.setEnabled(true)

Stav se v úložišti zařízení během spouštění aplikací udržuje.

Toto rozhraní API je asynchronní. Další informace si o tom můžete přečíst v naší příručce k asynchronním rozhraním API app center .

Poznámka

Tuto metodu je možné použít pouze po Distribute spuštění.

Kontrola, jestli je povolená distribuce v App Centeru

Můžete také zkontrolovat, jestli je distribuce App Center povolená nebo ne:

Distribute.isEnabled();
Distribute.isEnabled()

Toto rozhraní API je asynchronní. Další informace si o tom můžete přečíst v naší příručce k asynchronním rozhraním API app center .

Poznámka

Tuto metodu je možné použít pouze po Distribute spuštění, vždy se vrátí false před spuštěním.

Povolení aktualizací v aplikaci pro sestavení ladění

App Center ve výchozím nastavení povoluje aktualizace v aplikacích jenom pro buildy vydaných verzí.

Pokud chcete povolit aktualizace v aplikaci v buildech ladění, před voláním následující metody AppCenter.start:

Distribute.setEnabledForDebuggableBuild(true);
Distribute.setEnabledForDebuggableBuild(true)

Poznámka

Tato metoda ovlivňuje pouze sestavení ladění a nemá žádný vliv na sestavení vydaných verzí. Ladění sestavení znamená, že android:debuggable příznak je nastavený na true (který je obvykle automaticky nastaven gradle předdefinovanými variantami sestavení ladění). V opačném případě se jedná o build vydané verze.

Jak fungují aktualizace v aplikaci?

Poznámka

Aby aktualizace v aplikaci fungovaly, je potřeba stáhnout build aplikace z odkazu. Nebude fungovat, pokud se nainstaluje z integrovaného vývojového prostředí (IDE) nebo ručně.

Funkce aktualizací v aplikaci funguje takto:

  1. Tato funkce funguje jenom s buildy RELEASE (ve výchozím nastavení), které se distribuují pomocí služby App Center Distribute .

  2. Jakmile integrujete sadu SDK, sestavíte vydanou verzi aplikace a nahrajete ji do App Center, budou uživatelé v této distribuční skupině upozorněni na novou verzi e-mailem.

  3. Když každý uživatel otevře odkaz ve svém e-mailu, aplikace se nainstaluje na jeho zařízení. Je důležité, aby k instalaci použili e-mailový odkaz – nepodporujeme načítání bokem. Když se aplikace stáhne z odkazu, sada SDK uloží důležité informace ze souborů cookie, aby později zkontrolovala aktualizace, jinak sada SDK tyto klíčové informace neobsahuje.

  4. Pokud aplikace nastaví trasu na privátní, otevře se prohlížeč pro ověření uživatele a povolení aktualizací v aplikaci. Prohlížeč se znovu neotevře, dokud ověřovací informace zůstanou platné, i když se později znovu přepnete na veřejnou trasu a znovu na privátní. Pokud je ověření prohlížeče úspěšné, uživatel se automaticky přesměruje zpět do aplikace. Pokud je trasa veřejná (což je výchozí), provede se další krok přímo.

  5. V nové verzi aplikace se zobrazí dialogové okno aktualizace v aplikaci s výzvou uživatelům, aby aplikaci aktualizovali, pokud je to:

    • vyšší hodnotu versionCode nebo
    • stejnou hodnotu, versionCode ale jinou hodnotu versionName.

Tip

Pokud nahrajete stejný soubor APK podruhé, dialogové okno se nezobrazí , protože verze jsou identické.

Návody testovat aktualizace v aplikaci?

Abyste mohli otestovat aktualizace v aplikaci, musíte nahrát buildy vydaných verzí (které používají modul Distribuovat v sadě App Center SDK) na portál App Center a pokaždé zvýšit počet verzí.

  1. Pokud jste to ještě neudělali, vytvořte aplikaci na portálu App Center.
  2. Vytvořte novou distribuční skupinu a pojmenujte ji, abyste poznali, že je určená k testování funkce aktualizace v aplikaci.
  3. Přidejte sebe (nebo všechny lidi, které chcete zahrnout do testu funkce aktualizace v aplikaci). Použijte k tomu novou nebo vyhozenou e-mailovou adresu, která se pro danou aplikaci v App Center nepoužila. Tím zajistíte, že se vaše prostředí bude blížit zkušenostem skutečných testerů.
  4. Vytvořte nové sestavení vaší aplikace, které zahrnuje App Center Distribute a obsahuje logiku nastavení, jak je popsáno výše. Pokud je skupina soukromá, nezapomeňte nastavit privátní trasu aktualizace v aplikaci, než začnete používat rozhraní API setUpdateTrack.
  5. Na portálu klikněte na tlačítko Distribuovat novou verzi a nahrajte svůj build aplikace.
  6. Po dokončení nahrávání klikněte na Další a vyberte distribuční skupinu , kterou jste vytvořili jako cíl dané distribuce aplikace.
  7. Projděte si téma Distribuce a distribuujte sestavení do testovací skupiny v aplikaci.
  8. Lidé v této skupině obdrží pozvánku k testování aplikace. Jakmile pozvánku přijme, může si aplikaci stáhnout z portálu App Center ze svého mobilního zařízení. Jakmile budou mít nainstalované aktualizace v aplikaci, můžete je otestovat.
  9. Vyrovnejte versionCode svou aplikaci.
  10. Sestavte vydanou verzi aplikace a nahrajte nový build aplikace, jako jste to udělali v předchozím kroku, a distribuujte ho do distribuční skupiny , kterou jste vytvořili dříve. Při příštím spuštění aplikace se členům distribuční skupiny zobrazí výzva k zadání nové verze.

Tip

Podrobnější informace o distribučních skupinách atd. najdete v tématu Věnovaném využití distribuce app center. I když je možné distribuovat novou verzi aplikace pomocí App Center Distribuovat bez přidání kódu, přidáním app Center Distribuovat do kódu aplikace zajistíte pro testery a uživatele plynulejší prostředí, jakmile získají prostředí aktualizace v aplikaci.