App Center Distribueren - Android-updates in de app

Met App Center Distribueren kunnen uw gebruikers een nieuwe versie van de app installeren wanneer u deze distribueert via App Center. Met een nieuwe versie van de app die beschikbaar is, geeft de SDK een updatedialoogvenster aan de gebruikers om de nieuwe versie te downloaden of uit te stellen. Zodra ze ervoor hebben gekozen om bij te werken, wordt uw toepassing bijgewerkt met de SDK.

In-app updates aan uw app toevoegen

Volg de sectie Aan de slag als u de SDK nog niet hebt ingesteld en gestart in uw toepassing.

1. De module App Center Distribute toevoegen

De App Center SDK is ontworpen met een modulaire benadering. Een ontwikkelaar hoeft alleen de modules te integreren van de services waarin ze geïnteresseerd zijn.

1. Open het build.gradle-bestand op app-niveau van het project (app/build.gradle) en voeg de volgende regels toe na apply plugin.

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

   Opmerking

   Als de versie van uw Android Gradle-invoegtoepassing lager is dan 3.0.0, moet u de implementatie vervangen door compileren.

2. Sla uw build.gradle-bestand op en zorg ervoor dat u een Gradle-synchronisatie activeert in Android Studio.

3. DownloadManager wordt gebruikt om updates te downloaden. De App Center SDK dwingt TLS 1.2 af om de beveiliging te verbeteren.

2. App Center distribueren starten

Als u App Center wilt gebruiken, meldt u zich aan bij de module(s) die u wilt gebruiken. Standaard worden er geen modules gestart en moet u deze expliciet aanroepen bij het starten van de SDK.

Voeg de klasse Distribute toe aan uw AppCenter.start() methode om de App Center Distribute-service te starten.

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

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

Zorg ervoor dat u {Your App Secret} in het bovenstaande codevoorbeeld hebt vervangen door uw App Secret. Android Studio stelt automatisch de vereiste importinstructie voor wanneer u een verwijzing naar de klasse aan de Distributestart() methode toevoegt, maar als er een fout wordt weergegeven dat de klassenamen niet worden herkend, voegt u de volgende regels toe aan de importinstructies in uw activiteitsklasse:

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

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

Uw Google Play-build voorbereiden

Google Play beschouwt de in-app-updatecode als schadelijk gedrag, zelfs als deze tijdens runtime niet wordt gebruikt. Gebruik een variant van de Distributie-SDK zoals beschreven in deze sectie of verwijder de Distributie-SDK die in-app-updatecode bevat voordat u uw app indient bij Google Play. Als u dit niet doet, kan dit leiden tot niet-naleving en verwijdering van de app uit Google Play. Om het eenvoudiger te maken, bieden we de versie van App Center Distribute SDK met stubbed API's, dus de enige wijziging voor u is een afhankelijkheidswisseling.

1. Open het build.gradle-bestand op app-niveau van het project (app/build.gradle).

2. Configureer buildvarianten door productvarianten toe te voegen:

   android {
       flavorDimensions "distribute"
       productFlavors {
           appCenter {
               dimension "distribute"
           }
           googlePlay {
               dimension "distribute"
           }
       }
   }
   

3. Wijzig het afhankelijkhedenblok om verschillende afhankelijkheden te gebruiken op basis van de productvariant.

   dependencies {
       def appCenterSdkVersion = "5.0.6"
       appCenterImplementation "com.microsoft.appcenter:appcenter-distribute:${appCenterSdkVersion}"
       googlePlayImplementation "com.microsoft.appcenter:appcenter-distribute-play:${appCenterSdkVersion}"
   }
   

4. Sla uw build.gradle-bestand op en zorg ervoor dat u een Gradle-synchronisatie activeert in Android Studio.

5. U kunt de buildvariant wijzigen in de vervolgkeuzelijst Build > Select Build Variant of Build Variants in de vensterbalk van het hulpprogramma.

Meer informatie over het configureren van buildvarianten vindt u in de Android-documentatie.

Privédistributiegroep gebruiken

Distributie maakt standaard gebruik van een openbare distributiegroep. Als u een privédistributiegroep wilt gebruiken, moet u deze expliciet instellen via setUpdateTrack DE API.

Distribute.setUpdateTrack(UpdateTrack.PRIVATE);

Distribute.setUpdateTrack(UpdateTrack.PRIVATE)

Wanneer de app zich op de voorgrond bevindt (na Distribute.setUpdateTrack(UpdateTrack.PRIVATE); en AppCenter.start), wordt er een browservenster geopend om de gebruiker te verifiëren. Alle volgende updatecontroles zullen de meest recente release op de privétrack bekomen.

Als een gebruiker zich op het privéspoor bevindt, betekent dit dat ze na de geslaagde verificatie de meest recente versie krijgen van alle privédistributiegroepen waarvan ze lid zijn. Als een gebruiker zich op het openbare circuit bevindt, betekent dit dat deze de meest recente versie van een openbare distributiegroep ontvangt.

Automatische controle op update uitschakelen

Standaard controleert de SDK automatisch op nieuwe releases:

• Wanneer de toepassing wordt gestart.
• Wanneer de toepassing naar de voorgrond gaat nadat deze naar de achtergrond is gegaan.
• Bij het inschakelen van de module Distribueren als deze eerder is uitgeschakeld.

Als u handmatig op nieuwe releases wilt controleren, kunt u automatische controle op updates uitschakelen. U doet dit door de volgende methode aan te roepen voordat de SDK wordt gestart:

Distribute.disableAutomaticCheckForUpdate();

Distribute.disableAutomaticCheckForUpdate()

Vervolgens kunt u de checkForUpdate API gebruiken, die in de volgende sectie wordt beschreven.

Handmatig controleren op update

Distribute.checkForUpdate();

Distribute.checkForUpdate()

Hiermee wordt een aanvraag verzonden naar App Center en wordt een updatedialoogvenster weergegeven voor het geval er een nieuwe release beschikbaar is.

Het dialoogvenster voor het bijwerken van apps aanpassen of lokaliseren

1. Tekst aanpassen of lokaliseren

U kunt eenvoudig uw eigen resource-strings opgeven als u de tekst wilt wijzigen of lokaliseren die wordt weergegeven in het bijwerkdialoogvenster. Bekijk de bestandsreeksen in dit resourcebestand. Gebruik dezelfde tekenreeksnaam/-sleutel en geef de gelokaliseerde waarde op die moet worden weergegeven in het dialoogvenster in uw eigen app-resourcebestanden.

2. Het dialoogvenster voor bijwerken aanpassen

U kunt het uiterlijk van het standaarddialoogvenster aanpassen door de DistributeListener interface te implementeren. U moet de listener registreren voordat u belt AppCenter.start , zoals wordt weergegeven in het volgende voorbeeld:

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

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

Hier volgt een voorbeeld van de listener-implementatie die het SDK-dialoogvenster vervangt door een aangepast dialoogvenster:

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

Zoals in het voorbeeld wordt weergegeven, moet u ofwel Distribute.notifyUpdateAction(UpdateAction.UPDATE); of Distribute.notifyUpdateAction(UpdateAction.POSTPONE); aanroepen als uw listener true retourneert.

Als u niet belt notifyUpdateAction, wordt de callback herhaald bij elke activiteitswijziging.

De listener kan opnieuw worden aangeroepen met dezelfde release als de activiteit verandert voordat de gebruikersactie wordt gemeld aan de SDK.

Dit gedrag is nodig voor de volgende scenario's:

• Uw toepassing wordt verzonden naar de achtergrond (zoals drukken op HOME) en vervolgens hervat in een andere activiteit.
• Uw activiteit wordt gedekt door een andere activiteit zonder de toepassing te verlaten (zoals klikken op bepaalde meldingen).
• Andere vergelijkbare scenario's.

In dat geval kan de activiteit die als host fungeert voor het dialoogvenster, worden vervangen zonder tussenkomst van de gebruiker. De SDK roept de listener dus opnieuw aan, zodat u het aangepaste dialoogvenster kunt herstellen.

In gevallen waarin de SDK controleert op updates en geen updates vindt die nieuwer beschikbaar zijn dan de updates die momenteel worden gebruikt, wordt een onNoReleaseAvailable callback van DistributeListener de interface aangeroepen. Hiermee kunt u aangepaste code uitvoeren in dergelijke scenario's. In het bovenstaande voorbeeld ziet u hoe u het toastbericht toont wanneer er geen updates worden gevonden.

App Center Distributie tijdens uitvoering in- of uitschakelen

U kunt App Center Distribute in- en uitschakelen tijdens runtime. Als u deze functie uitschakelt, biedt de SDK geen functionaliteit voor updates in de app, maar kunt u de service Distribueren nog steeds gebruiken in de App Center-portal.

Distribute.setEnabled(false);

Distribute.setEnabled(false)

Als u App Center Distribute opnieuw wilt inschakelen, gebruikt u dezelfde API, maar geeft u deze door true als een parameter.

Distribute.setEnabled(true);

Distribute.setEnabled(true)

De status blijft behouden in de opslag van het apparaat tijdens het starten van de toepassing.

Deze API is asynchroon. In onze Handleiding voor Asynchrone API's van App Center vindt u hier meer informatie over.

Controleren of App Center Distribueren is ingeschakeld

U kunt ook controleren of App Center Distribute is ingeschakeld of niet:

Distribute.isEnabled();

Distribute.isEnabled()

Deze API is asynchroon. In onze Handleiding voor Asynchrone API's van App Center vindt u hier meer informatie over.

In-app updates inschakelen voor debug-builds

Standaard schakelt App Center alleen updates in de app in voor release-builds.

Om app-updates in debug builds mogelijk te maken, roept u de volgende methode aan voor AppCenter.start.

Distribute.setEnabledForDebuggableBuild(true);

Distribute.setEnabledForDebuggableBuild(true)

Hoe werken updates in apps?

De functie updates in de app werkt als volgt:

1. Deze functie werkt alleen met RELEASE-builds (standaard) die worden gedistribueerd met behulp van de App Center Distribute-service .

2. Zodra u de SDK hebt geïntegreerd, build release-versie van uw app en uploadt naar App Center, ontvangen gebruikers in die distributiegroep een melding voor de nieuwe release via een e-mail.

3. Wanneer elke gebruiker de koppeling in zijn e-mail opent, wordt de toepassing op het apparaat geïnstalleerd. Het is belangrijk dat ze via de e-mailkoppeling installeren - sideloading wordt niet ondersteund. Wanneer een toepassing wordt gedownload via de koppeling, slaat de SDK belangrijke informatie van cookies op om later op updates te controleren, anders beschikt de SDK niet over die belangrijke informatie.

4. Als de toepassing de track op privé instelt, wordt een browser geopend om de gebruiker te verifiëren en updates in de app in te schakelen. De browser wordt niet opnieuw geopend zolang de verificatiegegevens geldig blijven, zelfs niet wanneer u later terugschakelt naar het openbare spoor en weer teruggaat naar privé. Als de browserverificatie is geslaagd, wordt de gebruiker automatisch teruggeleid naar de toepassing. Als het nummer openbaar is (dit is de standaardinstelling), wordt de volgende stap rechtstreeks uitgevoerd.

5. In een nieuwe release van de app wordt het dialoogvenster voor het bijwerken van apps weergegeven waarin gebruikers worden gevraagd uw toepassing bij te werken als dit het volgende is:

   • een hogere waarde van versionCode of
   • een gelijke waarde van versionCode maar een andere waarde van versionName.

Hoe test ik updates in apps?

U moet releaseversies uploaden (die gebruikmaken van de module Distribueren van de App Center SDK) naar de App Center-portal om updates in de app te testen, waardoor de versienummers steeds worden verhoogd.

1. Maak uw app in de App Center-portal als u dat nog niet hebt gedaan.
2. Maak een nieuwe distributiegroep en geef deze een naam, zodat u kunt herkennen dat deze is bedoeld voor het testen van de functie voor in-app-updates.
3. Voeg uzelf toe (of alle personen die u wilt opnemen in uw test van de functie voor in-app-updates). Gebruik hiervoor een nieuw of weggooiend e-mailadres dat niet is gebruikt voor die app in App Center. Dit zorgt ervoor dat uw ervaring dicht bij de ervaring van uw echte testers ligt.
4. Maak een nieuwe build van uw app met App Center Distribueren en bevat de installatielogica zoals hierboven beschreven. Als de groep privé is, vergeet dan niet om het persoonlijke updatespoor in de app in te stellen voordat u de setUpdateTrack-API gaat gebruiken.
5. Klik op de knop Nieuwe release distribueren in de portal en upload uw build van de app.
6. Zodra het uploaden is voltooid, klikt u op Volgende en selecteert u de distributiegroep die u hebt gemaakt als de bestemming van die app-distributie.
7. Controleer de distributie en distribueer de build naar uw testgroep in uw app.
8. Personen in die groep ontvangen een uitnodiging om testers van de app te zijn. Zodra ze de uitnodiging accepteren, kunnen ze de app downloaden vanuit de App Center-portal vanaf hun mobiele apparaat. Zodra er updates in de app zijn geïnstalleerd, kunt u updates in de app testen.
9. Update de versionCode van je app.
10. Bouw de releaseversie van uw app en upload een nieuwe build van uw app, zoals u in de vorige stap hebt gedaan en distribueer deze naar de distributiegroep die u eerder hebt gemaakt. Leden van de distributiegroep worden gevraagd om een nieuwe versie wanneer de app de volgende keer wordt gestart.