1. Prima di iniziare
In questo codelab imparerai come utilizzare Firebase App Distribution e il suo plug- in fastlane per distribuire un'app iOS ai tester, raccogliere gli UDID dei dispositivi di test e registrarli nel profilo di provisioning della tua app, in modo da poter ottenere rapidamente build ad hoc nei tester ' mani.
Cosa imparerai
- Come caricare e distribuire un'app iOS pre-release (ad hoc) ai tester utilizzando Firebase App Distribution e fastlane .
- Come registrarsi come tester e scaricare l'app distribuita su un dispositivo di prova.
- Come registrare rapidamente i dispositivi di test esportando gli UDID dei dispositivi di test con il plug-in fastlane di App Distribution.
- Come aggiornare il profilo di provisioning dell'app e ricaricarlo per la distribuzione.
Di cosa avrai bisogno
- Un account Google
- Una macchina Apple con XCode 11.7+ installato
- Un'app iOS pre-release di Ad Hoc integrata in Xcode
- Un account sviluppatore Apple a pagamento
- 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.
Puoi comunque verificare che la configurazione abbia funzionato verificando che il pulsante "Download" venga visualizzato nell'app Web del tester di App Distribution.
2. Inizia
Imposta la corsia preferenziale
App Distribution si integra con fastlane per consentirti di automatizzare la distribuzione delle versioni preliminari della tua app. App Distribution si integra con la tua configurazione fastlane .
- Installa e configura fastlane .
- Esegui
fastlane init
nella directory principale del tuo progetto durante l'installazione e scegli "Installazione manuale". Vedrai una sottodirectory chiamatafastlane
che contieneFastfile
,Appfile
ePluginfile
, che utilizzerai per configurare fastlane .
Installa l'interfaccia a riga di comando di Firebase
Dovrai anche installare l' interfaccia a riga di comando di Firebase . Se utilizzi macOS o Linux, puoi eseguire il seguente comando cURL:
curl -sL https://firebase.tools | bash
Se utilizzi Windows, leggi le istruzioni di installazione per ottenere un file binario autonomo o per l'installazione tramite npm
.
Una volta installata la CLI, l'esecuzione firebase --version
dovrebbe riportare una versione 12.0.0
o successiva:
$ firebase --version 12.0.0
3. Crea la tua app con fastlane
Crea la tua app
- Imposta alcune variabili globali per fastlane nel tuo
./fastlane/Appfile.
Includi l'ID della tua app e il tuo ID Apple:
app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")
- Crea la tua prima corsia e usa l'azione
build_app
di fastlane (nota anche comegym
) per costruire la tua app aggiungendo quanto segue al tuo./fastlane/Fastfile
:
default_platform(:ios)
lane :build do
build_app(export_method: "ad-hoc")
end
- Firma la tua app per la distribuzione.
Per questo codelab, gestirai la tua certificazione e il tuo profilo utilizzando get_certificates
(noto anche come cert
), che genera i certificati di firma in locale e memorizza tutto nel tuo portachiavi macOS. In genere, tuttavia, ti consigliamo di utilizzare l'azione fastlane sync_code_signing action
(nota anche come match
) per gestire in modo sicuro i certificati e i profili di firma del codice del tuo team.
lane :build do
get_certificates()
build_app(export_method: "ad-hoc")
end
- Imposta un profilo di provisioning per la tua app utilizzando l'azione
get_provisioning_profile
(nota anche comesigh
). Ciò ti consente di condividere la tua app con i tester.
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true)
build_app(export_method: "ad-hoc")
end
- [Facoltativo] Se non hai mai eseguito la tua app prima, esegui il seguente comando per creare la tua app nella console per sviluppatori Apple:
$ fastlane produce --skip_itc
- Infine, crea la tua app eseguendo la corsia.
Ti verrà richiesto il tuo ID Apple, la password (che è memorizzata nel tuo portachiavi) e l'ID bundle della tua app.
$ fastlane build
Se riscontri problemi, consulta la guida alla risoluzione dei problemi Fastlane .
4. Carica la tua app su Firebase
Ora che hai creato la tua app, sei pronto per caricarla su App Distribution.
Crea e configura un progetto Firebase
- Accedi a Firebase.
- Nella console Firebase, crea o aggiungi un nuovo progetto, quindi assegna al progetto il nome "UDID Export Codelab".
Non è necessario abilitare Google Analytics per questo progetto.
- Fai clic su Crea progetto .
Aggiungi la tua app iOS al progetto
- Fai clic sull'icona iOS per creare una nuova app iOS Firebase e inserisci l'ID bundle della tua app.
- Saltare i passaggi successivi, quindi fare clic su Continua alla console . Successivamente aggiungerai gli SDK alla tua app.
Il tuo progetto e la tua app sono ora disponibili nella pagina Panoramica del progetto .
Abilita la distribuzione delle app
- Nella sezione Rilascio e monitoraggio, fai clic su Distribuzione app .
- Dopo aver accettato i termini, fai clic su "Inizia" per abilitare App Distribution per la tua app.
Imposta una distribuzione in fastlane
- Esegui il seguente comando dalla radice del tuo progetto iOS per aggiungere App Distribution alla tua configurazione fastlane .
Se il comando ti richiede un'opzione, seleziona Opzione 3: RubyGems.org :
$ fastlane add_plugin firebase_app_distribution
- Conferma che il plug-in è installato:
$ fastlane
L'output dovrebbe mostrare fastlane-plugin-firebase_app_distribution
nell'elenco dei plugin installati.
- Dopo aver confermato che il plug-in è installato, scegli l'opzione 0 per annullare.
Autentica il tuo progetto Firebase
Per utilizzare il plug-in fastlane , devi prima autenticare il tuo progetto Firebase.
- Esegui il seguente comando per connettere la CLI al tuo account Google:
$ firebase login
- Quando il comando stampa un collegamento di autenticazione, aprire il collegamento in un browser.
- Quando richiesto, accedi al tuo Account Google e concedi l'autorizzazione per accedere al tuo progetto Firebase.
Distribuisci la tua app
Ora sei pronto per distribuire la tua app.
- Nella parte superiore del tuo
./fastlane/Fastfile
, definisci una variabile chiamatafirebase_app_id
. Sostituisci<your_app_id>
con l'ID app Firebase per l'app che hai creato (disponibile nella pagina delle impostazioni del progetto ).
Il Fastfile
è scritto in Ruby, quindi usa la sintassi di Ruby per definire le variabili.
firebase_app_id = "<your_app_id>"
- Aggiungi una nuova corsia chiamata
distribute
che chiama la corsia di compilazione, quindi distribuisce la tua app utilizzando l'operazionefirebase_app_distribution
.
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
)
end
- Esegui la nuova corsia per creare la tua app e creare una distribuzione.
$ fastlane distribute
A questo punto, il tuo Fastfile dovrebbe essere simile al seguente:
firebase_app_id = "<your Firebase app ID>"
default_platform(:ios)
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true)
build_app(export_method: "ad-hoc")
end
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
)
end
Dopo aver aggiornato la console Firebase, vedrai la nuova versione per la tua app.
5. Invita i tester a scaricare la tua app
Quando un tester accetta un invito a testare una build ad hoc, gli viene richiesta l'autorizzazione a condividere il proprio UDID. Se sono d'accordo, App Distribution raccoglie le informazioni sul loro dispositivo e ti avvisa via e-mail. In questa sezione ti aggiungerai come tester per scaricare e testare l'app che hai distribuito.
Aggiungi te stesso come tester alla versione
- Sotto
firebase_app_id
nella parte superiore del tuo Fastfile, crea una variabile per contenere i tester e includi il tuo indirizzo email, così come altri indirizzi email facoltativi che vorresti provare.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
- Applica il metodo Array#join di Ruby per trasformare l'array
app_testers
in una stringa separata da virgole, come previsto dal parametrotesters
. Quindi, passa il risultato al parametrotesters
difirebase_app_distribution.
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!"
testers: app_testers.join(","),
)
end
A questo punto, il tuo Fastfile dovrebbe assomigliare a questo:
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
default_platform(:ios)
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true)
build_app(export_method: "ad-hoc")
end
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
testers: app_testers.join(","),
)
end
- Percorri di nuovo la corsia.
$ fastlane distribute
Una volta eseguita la corsia, i tester che hai aggiunto riceveranno un'e-mail di invito da App Distribution che li informa della nuova versione disponibile. 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
In qualità di tester, dovrai accedere a Google sul tuo dispositivo di prova per accedere alle versioni dell'app che sei stato invitato a testare. Poiché la build di test è una versione ad hoc, dovrai anche registrare il dispositivo di test installando il profilo Firebase. Successivamente, è possibile accedere alle versioni che diventano disponibili dall'app Web del tester di App Distribution, utilizzando il clip Web aggiunto alla schermata iniziale del dispositivo.
- 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.
- Ora sei nell'app Web del tester di App Distribution. Nella pagina visualizzata, accedi con il tuo account Google e tocca Accetta invito.
- Ora puoi vedere le uscite a cui sei stato invitato. Tocca Registra dispositivo sotto una delle versioni.
- Quando richiesto, scarica il profilo Firebase, quindi installa il profilo nell'app Impostazioni.
L'installazione del profilo autorizza Firebase a:
- Registra il dispositivo di prova raccogliendo l'ID dispositivo univoco (UDID) del dispositivo.
Firebase invia a tutti i proprietari e gli editor del progetto Firebase un'e-mail che include l'UDID del dispositivo di prova.
- Installa un web clip nella schermata iniziale del dispositivo di prova. Il clip Web apre l'app Web del tester di App Distribution, che consente di installare e accedere a tutte le app di test.
Nell'app Web tester di App Distribution, il tuo dispositivo di test è ora registrato per la versione dell'app.
Ora che hai condiviso l'UDID del tuo dispositivo di prova con Firebase, puoi riprendere il ruolo di sviluppatore. Nella scheda Tester della dashboard di App Distribution , le informazioni sul tester ora vengono visualizzate sotto la versione dell'app con lo stato "Accettata":
Nella sezione successiva, aggiungerai l'UDID del dispositivo al profilo di provisioning della tua app e quindi creerai una versione della tua app che funzioni con il tuo dispositivo di prova.
Esporta gli UDID del dispositivo del tester
In qualità di sviluppatore, riceverai un'email da Firebase contenente l'UDID del dispositivo di prova. Come opzione, App Distribution semplifica la raccolta di più UDID di nuovi dispositivi contemporaneamente consentendo di esportarli direttamente dalla console Firebase come file di testo non elaborato.
- Per esportare tutti gli UDID, apri la scheda Tester e gruppi .
- Fai clic su Esporta UDID Apple .
Il file deve contenere l'UDID del dispositivo di prova.
Device ID Device Name Device Platform
1234567890 udid.codelab.tester@gmail.com - iPhone SE 2nd Gen ios
Gli UDID possono anche essere esportati dalla riga di comando utilizzando fastlane , cosa che farai nella prossima sezione.
6. Aggiorna il profilo di provisioning della tua app e ricostruiscilo
Ora aggiungerai l'UDID del tuo dispositivo di prova al profilo di provisioning della tua app, ricostruirai una versione della tua app che funzioni per il tuo dispositivo e distribuirai la nuova versione.
Aggiungi corsia di esportazione UDID
- Aggiungi un'altra variabile nella parte superiore del tuo Fastfile e impostala su un percorso di file in cui verranno scaricati gli UDID del dispositivo dei tuoi tester.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
tester_udids_file = "tester_udids.txt"
- Imposta una nuova corsia che utilizzi l'azione di esportazione UDID del plug-in App Distribution per scaricare gli UDID del tester, proprio come hai fatto dalla console.
lane :download_udids do
firebase_app_distribution_get_udids(
app: firebase_app_id,
output_file: tester_udids_file,
)
end
- Eseguire la corsia seguente per scaricare gli UDID.
$ fastlane download_udids
- Stampare il file scaricato, che dovrebbe contenere gli UDID del dispositivo di prova.
$ cat tester_udids.txt
Aggiunta di dispositivi alla console per sviluppatori Apple
- Crea la seguente corsia per aggiungere gli UDID all'elenco dei tuoi dispositivi nella console per sviluppatori Apple, in modo da poterli aggiungere al tuo profilo di provisioning utilizzando l'azione
register_devices
di fastlane :
lane :add_new_devices do
register_devices(devices_file: tester_udids_file)
end
- Quindi, esegui la corsia:
$ fastlane add_new_devices
Dovresti quindi vedere i nuovi dispositivi nell'elenco dei dispositivi della tua console per sviluppatori .
Aggiungi dispositivi al tuo profilo di provisioning
- Aggiungi l'argomento
force
al passaggio del profilo di provisioning nella tua corsiabuild
, per forzarlo a raccogliere nuovi dispositivi ogni volta che crei.
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true, force: true)
build_app(export_method: "ad-hoc")
end
Riesegui la corsia per costruire e caricare
Ora aggiornerai la corsia distribute
con le nuove corsie per aggiungere i dispositivi al profilo di provisioning, ricostruire l'app e quindi distribuirla.
- Chiama le nuove corsie da
distribute
:
lane :distribute do
download_udids
add_new_devices
build
firebase_app_distribution(
app: "1:123456789:ios:abcd1234",
release_notes: "Try out this app!"
testers: app_testers.join(","),
)
end
- Esegui la corsia
distribute
:
$ fastlane distribute
A questo punto, il tuo Fastfile dovrebbe assomigliare a questo:
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
tester_udids_file = "tester_udids.txt"
default_platform(:ios)
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true, force: true)
build_app(export_method: "ad-hoc")
end
lane :distribute do
download_udids
add_new_devices
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
testers: app_testers.join(","),
)
end
lane :download_udids do
firebase_app_distribution_get_udids(
app: firebase_app_id,
output_file: tester_udids_file,
)
end
lane :add_new_devices do
register_devices(devices_file: tester_udids_file)
end
Scarica la versione dal dispositivo di prova
Ora che la tua app include gli UDID del dispositivo di test, questi possono essere installati sui dispositivi di test.
- 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.
- Se sei su un dispositivo fisico, premi download, quindi installa ed esegui l'app!
7. Congratulazioni
Ora hai configurato App Distribution e Fastlane per automatizzare il processo di test pre-rilascio. Ora, quando vuoi invitare altri tester o aggiungere i loro UDID alla tua app, devi solo eseguire un comando: fastlane distribute
.
Quindi non è più necessario raccogliere individualmente UDID dai tester o accedere alla console per sviluppatori Apple per aggiornare elenchi di dispositivi o profili di provisioning. Non hai nemmeno bisogno di aprire XCode!
Questo flusso di lavoro è facile da configurare per essere eseguito su base oraria o giornaliera nel tuo ambiente di integrazione continua.
Ulteriori letture
- Esplora le funzionalità di Firebase App Distribution , incluso il nostro SDK in-app per iOS
- Scopri di più su fastlane
- Gestisci la firma del codice del tuo team con
match
- Integra fastlane nel tuo CI