Avvisa i tester sulle nuove versioni delle tue app con Firebase App Distribution iOS SDK - Codelab

1. Panoramica

Benvenuto nell'SDK Integrating the Firebase App Distribution nel codelab dell'app iOS. In questo codelab, aggiungerai l'App Distribution SDK alla tua app per mostrare avvisi in-app ai tuoi tester quando nuove build sono disponibili per il download. Imparerai come utilizzare sia una configurazione di base che una configurazione personalizzata per consentire ai tuoi tester di accedere per ricevere gli aggiornamenti. Quindi invierai una nuova versione a App Distribution e attiverai un nuovo avviso di build direttamente nell'app.

Cosa imparerai

• Come utilizzare App Distribution per distribuire un'app non definitiva ai tester live
• Come integrare l'SDK iOS di App Distribution nella tua app
• Come avvisare un tester quando è disponibile una nuova versione preliminare pronta per l'installazione
• Come personalizzare l'SDK per soddisfare le tue esigenze di test uniche

Di cosa avrai bisogno

• Xcode 12 (o superiore)
• CocoaPods 1.9.1 (o superiore)
• Un account sviluppatore Apple per la distribuzione ad hoc
• Un dispositivo iOS fisico per il test. (L' app del simulatore iOS funzionerà per la maggior parte del codelab, ma i simulatori non possono scaricare le versioni.)

2. Crea il progetto della console Firebase

Aggiungi nuovo progetto Firebase

1. Accedi a Firebase.
2. Nella console Firebase, fai clic su Aggiungi progetto, quindi assegna al progetto il nome "Firebase Codelab".

Non è necessario abilitare Google Analytics per questo progetto.

3. Fai clic su Crea progetto .

Aggiungi app a Firebase

Segui la documentazione per registrare la tua app con Firebase. Utilizza "com.google.firebase.codelab.AppDistribution.<tuo_nome>" come ID pacchetto iOS.

Quando richiesto, scarica il file GoogleService-Info.plist del tuo progetto. Ne avrai bisogno più tardi.

3. Ottieni il progetto di esempio

Scarica il codice

Inizia clonando il progetto di esempio.

git clone git@github.com:googlecodelabs/firebase-appdistribution-ios.git

Se non hai git installato, puoi anche scaricare il progetto di esempio dalla sua pagina GitHub o cliccando su questo link .

Scarica le dipendenze e apri il progetto in Xcode

1. Apri il Podfile nella stessa directory

cd firebase-appdistribution-ios/start
Open Podfile

2. Aggiungi la seguente riga al tuo podfile:

Podfile

pod 'Firebase/AppDistribution'

Esegui pod update nella directory del progetto e apri il progetto in Xcode.

pod install --repo-update
xed .

Aggiorna l'identificatore del bundle in modo che corrisponda alla tua app Firebase

Nel menu a sinistra, fai doppio clic su AppDistributionExample. Quindi, individua la scheda Generale e modifica l'identificatore del pacchetto in modo che corrisponda all'identificatore del pacchetto della tua app Firebase, che puoi trovare nelle impostazioni del progetto . Dovrebbe essere "com.google.firebase.codelab.AppDistribution.<tuo_nome>"

Aggiungi Firebase alla tua app

Individua il file GoogleService-Info.plist che hai scaricato in precedenza nel tuo file system e trascinalo nella radice del progetto Xcode. Puoi anche scaricare questo file in qualsiasi momento dalla pagina delle impostazioni del tuo progetto .

Nel tuo file AppDistributionExample/AppDelegate.swift importa Firebase nella parte superiore del file

AppDistributionExample/AppDelegate.swift

import Firebase

E nel metodo didFinishLaunchingWithOptions aggiungi una chiamata per configurare Firebase.

AppDistributionExample/AppDelegate.swift

FirebaseApp.configure()

4. Imposta avvisi di nuova build in-app con App Distribution SDK

In questo passaggio, aggiungerai l'SDK di Firebase App Distribution alla tua app e visualizzerai avvisi in-app ai tuoi tester quando saranno disponibili nuove build della tua app per l'installazione. Per fare ciò, assicurati di aver abilitato l' API Firebase App Testers per il tuo progetto "Firebase Codelab" (in Google Cloud Console). Dovrai accedere con lo stesso account e selezionare il progetto corretto dal menu a tendina in alto.

Configura avvisi in-app

L'App Distribution SDK offre due modi per configurare gli avvisi di build in-app per i tuoi tester: una configurazione di avviso di base, che viene fornita con una finestra di dialogo di accesso predefinita da mostrare ai tester, e una configurazione di avviso avanzata, che ti consente di personalizzare la propria interfaccia utente (UI).

Inizieremo con la configurazione di avviso di base. Puoi utilizzare checkForUpdate per visualizzare una finestra di dialogo di abilitazione degli avvisi predefinita ai tester che non hanno ancora abilitato gli avvisi e quindi verificare se è disponibile una nuova build. I tester abilitano gli avvisi accedendo a un account che ha accesso all'app in App Distribution. Quando viene chiamato, il metodo esegue la seguente sequenza:

1. Verifica se un tester ha abilitato gli avvisi. In caso contrario, visualizza una finestra di dialogo predefinita che richiede loro di accedere a App Distribution con il proprio account Google.

L'abilitazione degli avvisi è un processo una tantum sul dispositivo di test e persiste tra gli aggiornamenti dell'app. Gli avvisi rimangono abilitati sul dispositivo di test finché l'app non viene disinstallata o finché non viene chiamato il metodo signOutTester . Consulta la documentazione di riferimento del metodo ( Swift o Objective-C ) per ulteriori informazioni.

2. Verifica la presenza di nuove build disponibili per l'installazione da parte del tester. Restituisce un oggetto di rilascio o un errore .

Puoi includere checkForUpdate in qualsiasi punto della tua app. Ad esempio, puoi chiedere ai tester di installare le nuove build disponibili all'avvio includendo checkForUpdate in viewDidAppear di UIViewController .

Nel tuo file AppDistributionViewController.swift importa Firebase nella parte superiore del file

AppDistributionViewController.swift

import Firebase

Apri AppDistributionExample/AppDistributionViewController.swift e copia le righe nel metodo viewDidAppear in questo modo:

AppDistributionViewController.swift

 override func viewDidAppear(_ animated: Bool) {
    checkForUpdate()
 }

Ora implementiamo il metodo checkForUpdate().

AppDistributionViewController.swift

  private func checkForUpdate() {
    AppDistribution.appDistribution().checkForUpdate(completion: { [self] release, error in
      var uiAlert: UIAlertController

      if error != nil {
        uiAlert = UIAlertController(title: "Error", message: "Error Checking for update! \(error?.localizedDescription ?? "")", preferredStyle: .alert)
      } else if release == nil {
        uiAlert = UIAlertController(title: "Check for Update", message: "No releases found!!", preferredStyle: .alert)
        uiAlert.addAction(UIAlertAction(title: "Ok", style: UIAlertAction.Style.default))
      } else {
        guard let release = release else { return }

        let title = "New Version Available"
        let message = "Version \(release.displayVersion)(\(release.buildVersion)) is available."
        uiAlert = UIAlertController(title: title, message: message, preferredStyle: .alert)

        uiAlert.addAction(UIAlertAction(title: "Update", style: UIAlertAction.Style.default) {
          _ in
          UIApplication.shared.open(release.downloadURL)
        })
        uiAlert.addAction(UIAlertAction(title: "Cancel", style: UIAlertAction.Style.cancel) {
          _ in
        })
      }
      self.present(uiAlert, animated: true, completion: nil)
    })
  }

5. Crea e invita i tester a scaricare la tua app

In questa fase, creerai la tua app e testerai la tua implementazione distribuendo la build ai tester utilizzando la console Firebase.

Crea la tua app

Quando sei pronto per distribuire una versione preliminare della tua app ai tester, seleziona "Qualsiasi dispositivo iOS (arm64)" come destinazione della build e quindi Prodotto->Archivio. Una volta creato l'archivio, crea una distribuzione firmata con il profilo di distribuzione di sviluppo.

Al termine della compilazione, salva un file IPA e alcuni file di registro nella cartella specificata. Distribuisci il file IPA ai tuoi tester nei seguenti passaggi.

Se riscontri problemi durante la creazione della tua app, consulta i documenti di codifica di Apple per le procedure di risoluzione dei problemi.

Distribuisci la tua app ai tester

Per distribuire la tua app ai tester, carica il file IPA utilizzando la console Firebase:

1. Apri la pagina Distribuzione app della console Firebase. Seleziona il tuo progetto Firebase quando richiesto.
2. Premere Inizia

3. Nella pagina Release, seleziona l'app che desideri distribuire dal menu a discesa.

4. Trascina il file IPA della tua app sulla console per caricarlo.
5. Al termine del caricamento, specifica i gruppi di tester e i singoli tester a cui desideri ricevere la build. (Aggiungi la tua email per ricevere l'invito.) Quindi, aggiungi le note di rilascio per la build. Consulta Gestire i tester per ulteriori informazioni sulla creazione di gruppi di tester.

6. Fare clic su Distribuisci per rendere disponibile la build ai tester.

Aggiungi te stesso come tester alla versione

Nella console di Firebase, ora puoi vedere i tester che hai aggiunto nella versione della tua app.

Poiché hai incluso il tuo indirizzo email, riceverai un'email da Firebase App Distribution che ti invita a testare l'app. Ora sei il primo tester! Continua con la sezione seguente per configurare come tester sul tuo dispositivo di prova.

Registra il tuo dispositivo di prova

Dovrai prima registrare il tuo dispositivo di prova per scaricare e testare una versione ad hoc.

1. Sul tuo dispositivo di prova iOS, apri l'e-mail inviata da Firebase App Distribution e tocca il link Inizia. Assicurati di aprire il collegamento in Safari.
2. Nell'app Web del tester di Firebase App Distribution visualizzata, accedi con il tuo account Google e tocca Accetta invito.

Ora vedrai l'uscita a cui sei stato invitato.

3. Tocca Registra dispositivo per condividere il tuo UDID con Firebase in modo da poter aggiornare il profilo di provisioning della tua app in un secondo momento.

4. Segui le istruzioni e vai alle impostazioni per scaricare il profilo e condividere il tuo UDID.

Ora, quando torni in App Distribution, la versione è ora contrassegnata come "Dispositivo registrato":

L'UDID del tester è stato ora condiviso con lo sviluppatore. Spetta ora allo sviluppatore creare per il tester una nuova versione dell'app.

Visualizza le informazioni sul tester nella console

Tornando alla visualizzazione dello sviluppatore nella console Firebase, il tester verrà visualizzato come "Accettato" sotto la versione:

Riceverai quindi un'e-mail come sviluppatore se il dispositivo che sta utilizzando non è già incluso nel profilo di provisioning. Questo ti avviserà del nuovo UDID che devi aggiungere. Hai anche la possibilità di esportare tutti gli UDID come file di testo.

1. Per esportare tutti gli UDID, apri la scheda Tester e gruppi.

2. Fai clic su "Esporta UDID Apple".

Il file deve contenere l'UDID del dispositivo di prova.

Device ID            Device Name                            Device Platform
1234567890     tester.app.distribtuion@gmail.com - iPhone SE 2nd Gen        ios

Quando ricevi una di queste e-mail, aggiorna il tuo profilo di provisioning con l'UDID e distribuisci una nuova build ai tuoi tester seguendo questi passaggi:

1. Aggiungi i dispositivi al tuo portale per sviluppatori Apple.

• Opzione 1: importare gli UDID del dispositivo come file CSV. Nella scheda Tester e gruppi della dashboard di Distribuzione app, seleziona Tutti i tester, quindi fai clic su Esporta UDID Apple per scaricare un file CSV. Successivamente, importa il file nel tuo account sviluppatore Apple utilizzando l'opzione Registra più dispositivi. Fare riferimento alla documentazione di Apple per saperne di più. Tieni presente che il tuo account sviluppatore Apple potrebbe consentirti di importare solo un numero limitato di dispositivi all'anno.
• Opzione 2: raccogliere e inserire gli UDID via e-mail. Nella pagina Aggiungi dispositivi del portale per sviluppatori Apple, registra il nuovo UDID specificato nell'e-mail che hai ricevuto.

2. Aggiungi i dispositivi registrati al tuo profilo di provisioning .
3. Scarica il profilo di provisioning e usalo per ricostruire la tua app. Se stai ricostruendo solo per aggiornare i dispositivi registrati, non aggiornare il numero di build o la versione.
4. Ridistribuisci la tua app dalla console Firebase o dalla CLI. Se hai già distribuito una build con lo stesso numero di build e versione, solo gli utenti di dispositivi appena registrati riceveranno email di notifica.

Scarica la versione dal dispositivo di prova

Ora la versione ha l'UDID del dispositivo di prova, quindi il dispositivo di prova può scaricare e installare l'app. App Distribution invia un messaggio di posta elettronica ai tester quando il loro UDID viene aggiunto a una nuova versione.

1. Sul dispositivo di prova, torna all'app Web del tester di App Distribution utilizzando il collegamento nell'e-mail o l'icona nella schermata iniziale del dispositivo.

Quando accedi all'app codelab UDID, puoi vedere che la versione è pronta per il download.

2. Se sei su un dispositivo fisico, premi download, quindi installa ed esegui l'app!
3. Quando l'app si avvia, ti chiederà di abilitare gli avvisi di nuova build. Seleziona "Attiva"

4. Quindi ti chiederà di accedere. Fai clic su "Continua.

5. Accedi con il tuo account tester.

6. Verrai riportato all'app. Non dovrai accedere o accettare avvisi la prossima volta che esegui l'app.

Distribuisci un aggiornamento ai tuoi tester

1. Aggiorna il tuo numero di build a "2".

2. Seleziona "Qualsiasi dispositivo iOS (arm64)" come destinazione di compilazione e Prodotto->Archivio. Una volta generato l'archivio, crea una distribuzione firmata con il profilo di distribuzione di sviluppo.
3. Al termine della compilazione, salva un file IPA e alcuni file di registro nella cartella specificata. Carica questo nuovo IPA nella tua console Firebase, aggiungi di nuovo la tua email come tester e distribuisci.

Testare gli avvisi di build

1. Assicurati di aver chiuso l'app se era aperta. Riavvia l'app.
2. Quando l'app si riavvia, dovresti ricevere un avviso "Nuova versione disponibile".

3. Fare clic su "Aggiorna" per ricevere l'ultima versione.
4. Fare clic su "Installa" nella schermata successiva.

5. Congratulazioni! Sei stato in grado di aggiornare la tua app con gli avvisi integrati.

6. Personalizza l'accesso del tester

I metodi signInTester/signOutTester e isTesterSignedIn ti offrono maggiore flessibilità personalizzando l'esperienza di accesso del tuo tester, in modo che possa corrispondere meglio all'aspetto della tua app.

L'esempio seguente controlla se il tester ha già effettuato l'accesso al proprio account di tester di Firebase App Distribution, quindi puoi scegliere di visualizzare l'interfaccia utente di accesso solo per i tester che non hanno ancora effettuato l'accesso. Dopo che il tester ha effettuato l'accesso, puoi quindi chiama checkForUpdate per verificare se il tester ha accesso a una nuova build.

Disabilitiamo il controllo automatico degli aggiornamenti in viewDidAppea r commentando la chiamata checkForUpdate() .

AppDistributionViewController.swift

 override func viewDidAppear(_ animated: Bool) {
    // checkForUpdate()
 }

Invece, chiamiamo checkForUpdate() in checkForUpdateButtonClicked( ).

 @objc func checkForUpdateButtonClicked() {
    checkForUpdate()
 }

Ora, implementiamo il nostro metodo signInOutButtonClicked() che effettuerà l'accesso dell'utente se è disconnesso o disconnetterà l'utente se è già connesso.

AppDistributionViewController.swift

 @objc func signInOutButtonClicked() {
    if isTesterSignedIn() {
      AppDistribution.appDistribution().signOutTester()

      self.configureCheckForUpdateButton()
      self.configureSignInSignOutButton()
      self.configureSignInStatus()

    } else {
      AppDistribution.appDistribution().signInTester(completion: { error in
        if error == nil {
          self.configureCheckForUpdateButton()
          self.configureSignInSignOutButton()
          self.configureSignInStatus()
        } else {
          let uiAlert = UIAlertController(title: "Custom:Error", message: "Error during tester sign in! \(error?.localizedDescription ?? "")", preferredStyle: .alert)
          uiAlert.addAction(UIAlertAction(title: "Ok", style: UIAlertAction.Style.default) {
            _ in
          })

          self.present(uiAlert, animated: true, completion: nil)
        }
      })
    }
  }

Infine implementiamo il metodo isTesterSignedI n.

AppDistributionViewController.swift

 private func isTesterSignedIn() -> Bool {
    return AppDistribution.appDistribution().isTesterSignedIn
 }

Crea e testa la tua implementazione

7. Congratulazioni!

Hai integrato la funzione "Visualizzazione degli avvisi in-app" in un'app utilizzando l'SDK iOS di Firebase App Distribution.

Di cosa abbiamo parlato

• Distribuzione dell'app Firebase
• Firebase App Distribution Nuovi avvisi iOS SDK

Prossimi passi

• Utilizzo del plug-in Fastlane
• Utilizzo degli strumenti dell'interfaccia a riga di comando

Saperne di più

• Firebase.google.com
• Come Twitter utilizza il nuovo SDK iOS

Hai una domanda?

• StackOverflow 'Firebase-distribuzione-app '
• Canale slack della community di Firebase #app-distribution

Segnala problemi

• Problemi con Github