Share via

App Center Distribute - Aggiornamenti di MAUI e Xamarin In-app

  • Articolo

Importante

Visual Studio App Center è previsto per il ritiro il 31 marzo 2025. Anche se è possibile continuare a usare Visual Studio App Center fino a quando non viene completamente ritirato, esistono diverse alternative consigliate che è possibile considerare la migrazione a.

Altre informazioni sulle sequenze temporali di supporto e sulle alternative.

App Center Distribute consente agli utenti di installare una nuova versione dell'app quando la si distribuisce tramite App Center. Con una nuova versione dell'app disponibile, l'SDK presenterà una finestra di dialogo di aggiornamento agli utenti per scaricare o rinviare la nuova versione. Dopo aver scelto di aggiornare, l'SDK inizierà ad aggiornare l'applicazione.

Avviso

Google Play considera il codice di aggiornamento in-app come comportamento dannoso anche se non viene usato in fase di esecuzione. Usare una variante dell'SDK di distribuzione come indicato in questa sezione prima di inviare l'app a Google Play. Non è possibile rimuovere il codice di aggiornamento in-app può causare la mancata conformità e la rimozione dell'app da Google Play.

Nota

Se si eseguono test automatizzati dell'interfaccia utente, gli aggiornamenti in-app abilitati bloccano i test automatici dell'interfaccia utente man mano che tenteranno di eseguire l'autenticazione nel back-end di App Center. È consigliabile non abilitare App Center Distribute per i test dell'interfaccia utente.

Aggiungere aggiornamenti in-app all'app

Seguire la sezione Introduzione se non è ancora stato configurato e avviato l'SDK nell'applicazione.

1. Aggiungere il modulo Distribuzione di App Center

App Center SDK è progettato con un approccio modulare: uno sviluppatore deve integrare solo i moduli dei servizi interessati.

Visual Studio per Mac

  • Aprire Visual Studio per Mac.
  • Fare clic su Apri file> e scegliere la soluzione.
  • Nel navigatore della soluzione fare clic con il pulsante destro del mouse sulla sezione Pacchetti e scegliere Aggiungi pacchetti NuGet....
  • Cercare App Center e installare App Center Distribute.
  • Fare clic su Aggiungi pacchetti.

Visual Studio per Windows

  • Aprire Visual Studio per Windows.
  • Fare clic su Apri file> e scegliere la soluzione.
  • Nel navigatore della soluzione fare clic con il pulsante destro del mouse su Riferimenti e scegliere Gestisci pacchetti NuGet.
  • Cercare App Center e installare Microsoft.AppCenter.Distribute.

Console di Gestione pacchetti

  • Aprire la console in Visual Studio. A tale scopo, scegliere Strumenti>di Gestione pacchetti NuGetPackage Manager> Console.
  • Se si lavora in Visual Studio per Mac, assicurarsi di aver installato le estensioni di gestione pacchetti NuGet. Per questo motivo, scegliere Estensioni di Visual Studio>, cercare NuGet e installare, se necessario.
  • Digitare il comando seguente nella console:
Install-Package Microsoft.AppCenter.Distribute

Nota

Se si usa App Center SDK in un progetto portatile (ad esempio Xamarin.Forms), è necessario installare i pacchetti in ognuno dei progetti: quelli portatili, Android e iOS. A tale scopo, è necessario aprire ogni sottoprogetto e seguire i passaggi corrispondenti descritti nelle sezioni Visual Studio per Mac o Visual Studio per Windows.

Nota

Android 10 o versione successiva ha restrizioni per l'attività di avvio in background. Vedere l'articolo sulle restrizioni sull'avvio di attività in background.

Nota

Le app in esecuzione in Android 10 (edizione Go) non possono ricevere l'autorizzazione di SYSTEM_ALERT_WINDOW . Vedere l'articolo relativo alle SYSTEM_ALERT_WINDOW nei dispositivi Go.

Nota

A partire da Android 11, ACTION_MANAGE_OVERLAY_PERMISSION le finalità portano sempre l'utente alla schermata Impostazioni di primo livello, in cui l'utente può concedere o revocare le SYSTEM_ALERT_WINDOW autorizzazioni per le app. Vedere l'articolo sugli aggiornamenti delle autorizzazioni in Android 11.

2. Avviare App Center Distribute

Configurare App Center SDK chiamando AppCenter.Start(...) come descritto nella Guida introduttiva.

Per l'applicazione iOS aprire e AppDelegate.cs aggiungere la riga seguente prima della chiamata a LoadApplication:

Distribute.DontCheckForUpdatesInDebug();

Questo passaggio non è necessario in Android in cui la configurazione di debug viene rilevata automaticamente in fase di esecuzione.

Per abilitare gli aggiornamenti in-app per le build di debug in Android, chiamare il metodo seguente nel file di MainActivity.cs del progetto, nel OnCreate metodo e prima LoadApplicationdi .

Distribute.SetEnabledForDebuggableBuild(true);

Nota

Questo metodo influisce solo sulle build di debug e non ha alcun impatto sulle build di versione.

2.3 [Solo per iOS] Modificare l'info.plist del progetto

App Center SDK controlla il reindirizzamento degli URL all'applicazione per evitare il sideload, quindi per poter gestire correttamente gli aggiornamenti distribuiti tramite il portale, è necessario specificare CFBundleURLSchemes nella CFBundleURLTypes sezione del Info.plist file:

Nota

Info.plisto un file di elenco di proprietà informazioni è un file di testo strutturato che contiene informazioni di configurazione essenziali per un eseguibile in bundle. Per altre informazioni, vedere la documentazione per sviluppatori Apple.

  1. Aggiungere una nuova chiave per URL types o CFBundleURLTypes nel file Info.plist (nel caso in cui Xcode visualizzi info.plist come codice sorgente).
  2. Modificare la chiave del primo elemento figlio in URL Schemes o CFBundleURLSchemes.
  3. Immettere appcenter-${APP_SECRET} come schema URL e sostituire ${APP_SECRET} con il segreto app dell'app.

Suggerimento

Se si vuole verificare che l'info.plist sia stato modificato correttamente, aprirlo come codice sorgente. Deve contenere la voce seguente con il segreto dell'app anziché ${APP_SECRET}:

<key>CFBundleURLTypes</key>
  <array>
      <dict>
          <key>CFBundleURLSchemes</key>
          <array>
              <string>appcenter-${APP_SECRET}</string>
          </array>
      </dict>
  </array>

Rimuovere gli aggiornamenti in-app per le compilazioni di Google Play

Google Play considera il codice di aggiornamento in-app come comportamento dannoso anche se non viene usato in fase di esecuzione. Non è possibile rimuovere il codice di aggiornamento in-app può causare la mancata conformità e la rimozione dell'app da Google Play. Per semplificare, è possibile fornire la versione di App Center Distribute SDK con API sbbed, quindi l'unica modifica per l'utente è uno scambio di dipendenze.

  1. Aggiungere una nuova configurazione di compilazione denominata GooglePlay per i progetti Xamarin.Android e condivisi. Assicurarsi che la configurazione della compilazione dei progetti sia mappata correttamente alla configurazione della soluzione appropriata. Per altre informazioni, vedere Visual Studio o Visual Studio per Mac istruzioni.

  2. Aprire Xamarin.Android e progetti condivisi in .csproj qualsiasi editor di testo e spostare i riferimenti distribuiti nel gruppo di elementi condizionali:

    <ItemGroup Condition=" '$(Configuration)' != 'GooglePlay' ">
    <PackageReference Include="Microsoft.AppCenter.Distribute" Version="3.3.0" />
</ItemGroup>
<ItemGroup Condition=" '$(Configuration)' == 'GooglePlay' ">
    <PackageReference Include="Microsoft.AppCenter.DistributePlay" Version="3.3.0" />
</ItemGroup>

    Nota

    Se si usa un formato di packages.config precedente per gestire i riferimenti NuGet, è possibile eseguire la migrazione a un formato PackageReference , seguire l'istruzione di migrazione.

  3. Salvare le modifiche e ripristinare i pacchetti NuGet.

  4. È possibile modificare la configurazione nella barra dei comandi nella parte superiore dell'IDE.

Usare il gruppo di distribuzione privato

Per impostazione predefinita, Distribute usa un gruppo di distribuzione pubblico. Se si vuole usare un gruppo di distribuzione privato, è necessario impostarlo in modo esplicito tramite UpdateTrack la proprietà.

Distribute.UpdateTrack = UpdateTrack.Private;

Nota

Il valore predefinito è UpdateTrack.Public. Questa proprietà può essere aggiornata solo prima della chiamata al AppCenter.Start metodo. Le modifiche apportate alla traccia di aggiornamento non vengono mantenute quando il processo dell'applicazione viene riavviato e quindi se la proprietà non viene sempre aggiornata prima della AppCenter.Start chiamata, sarà pubblica, per impostazione predefinita.

Dopo questa chiamata, verrà aperta una finestra del browser per autenticare l'utente. Tutti i controlli di aggiornamento successivi otterranno la versione più recente sulla traccia privata. La traccia di aggiornamento non viene mantenuta nell'SDK tra i lanci dell'app.

Se un utente si trova sulla traccia privata, significa che dopo l'autenticazione completata, otterranno la versione più recente da tutti i gruppi di distribuzione privati di cui sono membri. Se un utente si trova sulla traccia pubblica, significa che otterrà la versione più recente da qualsiasi gruppo di distribuzione pubblico.

Disabilita controllo automatico per l'aggiornamento

Per impostazione predefinita, l'SDK controlla automaticamente le nuove versioni:

  • All'avvio dell'applicazione.
  • Quando l'applicazione entra in background, in primo piano di nuovo.
  • Quando si abilita il modulo Distribuisci se in precedenza è disabilitato.

Se si vuole verificare manualmente la disponibilità di nuove versioni, è possibile disabilitare il controllo automatico per l'aggiornamento. A tale scopo, chiamare il metodo seguente prima dell'avvio dell'SDK:

Distribute.DisableAutomaticCheckForUpdate();

Nota

Questo metodo deve essere chiamato prima della chiamata al AppCenter.Start metodo.

È quindi possibile usare l'API CheckForUpdate descritta nella sezione seguente.

Controllare manualmente la disponibilità di aggiornamenti

Distribute.CheckForUpdate();

Nota

Un controllo manuale della chiamata di aggiornamento funziona anche quando sono abilitati gli aggiornamenti automatici. Un controllo manuale per l'aggiornamento viene ignorato se è già in corso un altro controllo. Il controllo manuale per l'aggiornamento non verrà elaborato se l'utente ha posticipato gli aggiornamenti (a meno che la versione più recente non sia un aggiornamento obbligatorio).

Personalizzare o localizzare la finestra di dialogo di aggiornamento in-app

1. Personalizzare o localizzare il testo

È possibile specificare facilmente stringhe di risorse personalizzate se si vuole localizzare il testo visualizzato nella finestra di dialogo di aggiornamento. Esaminare i file di stringa per iOS in questo file di risorse e quelli per Android in questo file di risorse. Usare la stessa stringa nome/chiave e specificare il valore localizzato da riflettere nella finestra di dialogo nei propri file di risorse dell'app.

2. Personalizzare la finestra di dialogo di aggiornamento

È possibile personalizzare l'aspetto della finestra di dialogo di aggiornamento predefinita implementando il ReleaseAvailable callback. È necessario registrare il callback prima di chiamare AppCenter.Start come illustrato nell'esempio seguente:

// In this example OnReleaseAvailable is a method name in same class
Distribute.ReleaseAvailable = OnReleaseAvailable;
AppCenter.Start(...);

Di seguito è riportato un esempio dell'implementazione del callback che sostituisce la finestra di dialogo SDK con una versione personalizzata:

bool OnReleaseAvailable(ReleaseDetails releaseDetails)
{
    // Look at releaseDetails public properties to get version information, release notes text or release notes URL
    string versionName = releaseDetails.ShortVersion;
    string versionCodeOrBuildNumber = releaseDetails.Version;
    string releaseNotes = releaseDetails.ReleaseNotes;
    Uri releaseNotesUrl = releaseDetails.ReleaseNotesUrl;

    // custom dialog
    var title = "Version " + versionName + " available!";
    Task answer;

    // On mandatory update, user can't postpone
    if (releaseDetails.MandatoryUpdate)
    {
        answer = Current.MainPage.DisplayAlert(title, releaseNotes, "Download and Install");
    }
    else
    {
        answer = Current.MainPage.DisplayAlert(title, releaseNotes, "Download and Install", "Maybe tomorrow...");
    }
    answer.ContinueWith((task) =>
    {
        // If mandatory or if answer was positive
        if (releaseDetails.MandatoryUpdate || (task as Task<bool>).Result)
        {
            // Notify SDK that user selected update
            Distribute.NotifyUpdateAction(UpdateAction.Update);
        }
        else
        {
            // Notify SDK that user selected postpone (for 1 day)
            // This method call is ignored by the SDK if the update is mandatory
            Distribute.NotifyUpdateAction(UpdateAction.Postpone);
        }
    });

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

Note sull'implementazione per Xamarin.Android:

Come illustrato nell'esempio, è necessario chiamare Distribute.NotifyUpdateAction(UpdateAction.UPDATE); o Distribute.NotifyUpdateAction(UpdateAction.POSTPONE); se il callback restituisce true.

Se non si chiama NotifyUpdateAction, il callback verrà ripetuto in ogni modifica dell'attività.

Il callback può essere chiamato di nuovo con la stessa versione se l'attività cambia prima che l'azione dell'utente venga notificata all'SDK.

Questo comportamento è necessario per coprire gli scenari seguenti:

  • L'applicazione viene inviata in background (ad esempio premendo HOME) e quindi ripresa in un'attività diversa.
  • L'attività è coperta da un'altra senza uscire dall'applicazione (ad esempio facendo clic su alcune notifiche).
  • Altri scenari simili.

In tal caso, l'attività che ospita il dialogo potrebbe essere sostituita senza l'interazione dell'utente. L'SDK chiama di nuovo il listener in modo da poter ripristinare la finestra di dialogo personalizzata.

3. Eseguire il codice se non vengono trovati aggiornamenti

Nei casi in cui l'SDK controlla la disponibilità di aggiornamenti e non trova aggiornamenti disponibili più recenti di quelli attualmente usati, viene richiamato un NoReleaseAvailable callback. In questo modo è possibile eseguire codice personalizzato in tali scenari. È necessario registrare il callback prima di chiamare AppCenter.Start come illustrato nell'esempio seguente:

// In this example OnNoReleaseAvailable is a method name in same class
Distribute.NoReleaseAvailable = OnNoReleaseAvailable;
AppCenter.Start(...);

void OnNoReleaseAvailable()
{
    AppCenterLog.Info(LogTag, "No release available callback invoked.");
}

Abilitare o disabilitare App Center Distribute in fase di esecuzione

È possibile abilitare e disabilitare App Center Distribute in fase di esecuzione. Se la si disabilita, l'SDK non fornirà alcuna funzionalità di aggiornamento in-app, ma è comunque possibile usare il servizio Distribuisci nel portale di App Center.

Distribute.SetEnabledAsync(false);

Per abilitare di nuovo App Center Distribute, usare la stessa API ma passare true come parametro.

Distribute.SetEnabledAsync(true);

Non è necessario attendere questa chiamata per rendere coerenti altre chiamate API ( ad esempio IsEnabledAsync).

Lo stato viene salvato in modo permanente nella risorsa di archiviazione del dispositivo tra i lanci dell'applicazione.

Nota

Questo metodo deve essere utilizzato solo dopo Distribute l'avvio.

Controllare se App Center Distribute è abilitato

È anche possibile controllare se App Center Distribute è abilitato o meno:

bool enabled = await Distribute.IsEnabledAsync();

Nota

Questo metodo deve essere utilizzato solo dopo Distribute l'avvio, ma restituirà false sempre prima dell'avvio.

Eseguire la pulizia subito prima della chiusura dell'app per l'aggiornamento (solo iOS)

Registrare il callback come illustrato nell'esempio seguente:

// In this example, OnWillExitApp is a method name in same class
Distribute.WillExitApp = OnWillExitApp;

void OnWillExitApp()
{
    // Perform clean up here
}

A questo scopo, OnWillExitApp() verrà richiamato quando Distribute sta per chiudersi.

Come funzionano gli aggiornamenti in-app?

Nota

Per il funzionamento degli aggiornamenti in-app, è necessario scaricare una compilazione dell'app dal collegamento. Non funzionerà se installato da un IDE o manualmente.

La funzionalità aggiornamenti in-app funziona come segue:

  1. Questa funzionalità funziona solo con le build RELEASE (per impostazione predefinita) distribuite con il servizio App Center Distribute . Non funzionerà se la funzionalità accesso guidato iOS è attivata.

  2. Dopo aver integrato l'SDK, la versione di rilascio della build dell'app e il caricamento in App Center, gli utenti del gruppo di distribuzione riceveranno una notifica per la nuova versione tramite un messaggio di posta elettronica.

  3. Quando ogni utente apre il collegamento nel messaggio di posta elettronica, l'applicazione verrà installata nel dispositivo. È importante che usino il collegamento di posta elettronica per l'installazione. Non è supportato il sideload. Quando un'applicazione viene scaricata dal collegamento, l'SDK salva informazioni importanti dai cookie per verificare la disponibilità di aggiornamenti in un secondo momento, altrimenti l'SDK non dispone di tali informazioni chiave.

  4. Se l'applicazione imposta la traccia su privata, verrà aperto un browser per autenticare l'utente e abilitare gli aggiornamenti in-app. Il browser non si riaprirà finché le informazioni di autenticazione rimangono valide anche quando si torna alla traccia pubblica e si torna nuovamente a privato in un secondo momento. Se l'autenticazione del browser ha esito positivo, l'utente viene reindirizzato automaticamente all'applicazione. Se la traccia è pubblica (ovvero l'impostazione predefinita), il passaggio successivo viene eseguito direttamente.

    • In iOS 9 e 10, un'istanza di SFSafariViewController verrà aperta all'interno dell'app per autenticare l'utente. Si chiuderà automaticamente dopo l'esito positivo dell'autenticazione.
    • In iOS 11 l'esperienza utente è simile a iOS 10, ma iOS 11 chiederà all'utente l'autorizzazione per accedere alle informazioni di accesso. Si tratta di una finestra di dialogo a livello di sistema che non può essere personalizzata. Se l'utente annulla la finestra di dialogo, può continuare a usare la versione che sta testando, ma non otterrà gli aggiornamenti in-app. Verrà chiesto di accedere di nuovo alle informazioni di accesso quando avviano l'app la volta successiva.

  5. Una nuova versione dell'app mostra la finestra di dialogo di aggiornamento in-app che chiede agli utenti di aggiornare l'applicazione se è:

    • iOS:

      • un valore superiore di CFBundleShortVersionString o
      • un valore uguale di CFBundleShortVersionString ma un valore superiore di CFBundleVersion.
      • le versioni sono uguali, ma l'identificatore univoco della compilazione è diverso.

    • Android:

      • un valore superiore di versionCode o
      • un valore uguale a versionCode ma un valore diverso di versionName.

Suggerimento

Se si carica lo stesso apk/ipa una seconda volta, la finestra di dialogo NON verrà visualizzata come i file binari sono identici. In iOS, se si carica una nuova build con le stesse proprietà della versione, verrà visualizzata la finestra di dialogo di aggiornamento. Il motivo è che si tratta di un file binario diverso . In Android i file binari vengono considerati uguali se entrambe le proprietà della versione sono uguali.

Ricerca per categorie testare gli aggiornamenti in-app?

È necessario caricare le build di versione (che usano il modulo Distribuisci di App Center SDK) nel portale di App Center per testare gli aggiornamenti in-app, aumentando i numeri di versione ogni volta.

  1. Creare l'app nel portale di App Center, se non è già stato fatto.
  2. Creare un nuovo gruppo di distribuzione e denominarlo, in modo da poterlo riconoscere per testare la funzionalità di aggiornamento in-app.
  3. Aggiungi te stesso (o tutte le persone che vuoi includere nel test della funzionalità di aggiornamento in-app). Usare un indirizzo di posta elettronica nuovo o eliminato per questo, che non è stato usato per l'app in App Center. Ciò garantisce che l'esperienza sia vicina all'esperienza dei tester reali.
  4. Creare una nuova build dell'app che include App Center Distribute e contiene la logica di configurazione, come descritto di seguito. Se il gruppo è privato, non dimenticare di impostare la traccia di aggiornamento in-app privata prima di iniziare a usare la UpdateTrack proprietà .
  5. Fare clic sul pulsante Distribuisci nuova versione nel portale e caricare la compilazione dell'app.
  6. Al termine del caricamento, fare clic su Avanti e selezionare il gruppo di distribuzione creato come Destinazione della distribuzione dell'app.
  7. Esaminare la distribuzione e distribuire la compilazione nel gruppo di test in-app.
  8. Persone in tale gruppo riceverà un invito a essere tester dell'app. Dopo aver accettato l'invito, può scaricare l'app dal portale di App Center dal dispositivo mobile. Dopo aver installato gli aggiornamenti in-app, si è pronti per testare gli aggiornamenti in-app.
  9. Aggiornare la versione dell'app (CFBundleShortVersionString o CFBundleVersion per iOS, versionCode per Android)
  10. Compilare la versione di rilascio dell'app e caricare una nuova build dell'app come nel passaggio precedente e distribuirla al gruppo di distribuzione creato in precedenza. I membri del gruppo di distribuzione verranno richiesti per una nuova versione al successivo avvio dell'app.

Suggerimento

Esaminare le informazioni su come usare App Center Distribute per informazioni più dettagliate sui gruppi di distribuzione e così via. Anche se è possibile usare App Center Distribute per distribuire una nuova versione dell'app senza aggiungere codice, l'aggiunta di App Center Distribute al codice dell'app comporterà un'esperienza più semplice per i tester e gli utenti man mano che ottengono l'esperienza di aggiornamento in-app.

Disabilitare l'inoltro automatico dei metodi del delegato dell'applicazione ai servizi di App Center

App Center usa swizzling per inoltrare automaticamente i metodi del delegato dell'applicazione ai servizi di App Center per migliorare l'integrazione dell'SDK. Esiste una possibilità di conflitti con altre librerie di terze parti o il delegato dell'applicazione stesso. In questo caso, è possibile disabilitare l'inoltro del delegato dell'applicazione app Center per tutti i servizi di App Center seguendo la procedura seguente:

  1. Aprire il file Info.plist del progetto.
  2. Aggiungere AppCenterAppDelegateForwarderEnabled la chiave e impostare il valore su 0. Ciò disabilita l'inoltro del delegato dell'applicazione per tutti i servizi di App Center.
  3. Aggiungere OpenUrl il callback nel AppDelegate.cs file.
public override bool OpenUrl(UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
{
    Distribute.OpenUrl(url);
    return true;
}