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

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.

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

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

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:

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.

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

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

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

Controllare manualmente la disponibilità di aggiornamenti

Distribute.CheckForUpdate();

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.

Controllare se App Center Distribute è abilitato

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

bool enabled = await Distribute.IsEnabledAsync();

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?

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.

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.

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