Szybciej rozpowszechniaj swoje przedpremierowe wersje iOS dzięki App Distribution i fastlane

1. Zanim zaczniesz

4cddd34bd261cea0.png

W tym laboratorium z programowania dowiesz się, jak używać Firebase App Distribution i jego wtyczki Fastlane do rozpowszechniania aplikacji na iOS wśród testerów, zbierania identyfikatorów UDID urządzeń testowych i rejestrowania ich w profilu udostępniania aplikacji, aby szybko uzyskać kompilacje ad hoc w testerach ' ręce.

Czego się nauczysz

  • Jak przesłać i rozesłać przedpremierową wersję aplikacji na iOS (ad hoc) do testerów za pomocą Firebase App Distribution i fastlane .
  • Jak zarejestrować się jako tester i pobrać dystrybuowaną aplikację na urządzenie testowe.
  • Jak szybko zarejestrować urządzenia testowe, eksportując identyfikatory UDID urządzeń testowych za pomocą wtyczki fastlane App Distribution.
  • Jak zaktualizować profil aprowizacji aplikacji i ponownie przesłać ją do dystrybucji.

Co będziesz potrzebował

  • Konto Google
  • Maszyna Apple z zainstalowanym XCode 11.7+
  • Wstępna wersja aplikacji Ad Hoc na iOS wbudowana w Xcode
  • Płatne konto Apple Developer
  • Fizyczne urządzenie iOS do testowania.

Aplikacja symulatora iOS będzie działać w większości ćwiczeń z programowania, ale symulatory nie mogą pobierać wersji.

Nadal możesz sprawdzić, czy konfiguracja zadziałała, sprawdzając, czy przycisk „Pobierz” pojawia się w aplikacji internetowej testera App Distribution.

2. Rozpocznij

Skonfiguruj Fastlane

Dystrybucja aplikacji integruje się z Fastlane , aby umożliwić zautomatyzowanie dystrybucji przedpremierowych wersji aplikacji. Dystrybucja aplikacji integruje się z konfiguracją Fastlane .

  1. Zainstaluj i skonfiguruj Fastlane .
  2. Uruchom fastlane init w katalogu głównym projektu podczas instalacji i wybierz opcję „Instalacja ręczna”. Zobaczysz podkatalog o nazwie fastlane zawierający Fastfile , Appfile i Pluginfile , których użyjesz do skonfigurowania fastlane .

3. Zbuduj swoją aplikację z Fastlane

Zbuduj swoją aplikację

  1. Ustaw kilka zmiennych globalnych dla fastlane w swoim ./fastlane/Appfile. Dołącz identyfikator swojej aplikacji i swój Apple ID:
app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")
  1. Utwórz swój pierwszy pas i użyj akcji fastlane build_app (znanej również jako gym ), aby zbudować swoją aplikację, dodając następujące elementy do ./fastlane/Fastfile :
default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end
  1. Podpisz swoją aplikację do dystrybucji.

W przypadku tego ćwiczenia z programowania będziesz zarządzać własnym certyfikatem i profilem za pomocą funkcji get_certificates (znanej również jako cert ), która generuje certyfikaty podpisywania lokalnie i przechowuje wszystko w pęku kluczy macOS. Zazwyczaj jednak będziesz chciał użyć akcji fastlane sync_code_signing action (znanej również jako match ), aby bezpiecznie zarządzać certyfikatami i profilami podpisywania kodu zespołu.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end
  1. Skonfiguruj profil aprowizacji dla swojej aplikacji za pomocą akcji get_provisioning_profile (nazywanej również sigh ). Dzięki temu możesz udostępnić swoją aplikację testerom.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end
  1. [Opcjonalnie] Jeśli Twoja aplikacja nigdy wcześniej nie była uruchamiana, uruchom następujące polecenie, aby utworzyć aplikację w konsoli programisty Apple:

$ fastlane produce --skip_itc

  1. Na koniec stwórz swoją aplikację, uruchamiając pas.

Zostaniesz poproszony o podanie swojego identyfikatora Apple ID, hasła (przechowywanego w pęku kluczy) oraz identyfikatora pakietu aplikacji.

$ fastlane build

Jeśli napotkasz jakiekolwiek problemy, zapoznaj się z przewodnikiem rozwiązywania problemów Fastlane .

4. Prześlij swoją aplikację do Firebase

Teraz, gdy masz już skompilowaną aplikację, możesz przesłać ją do dystrybucji aplikacji.

Utwórz i skonfiguruj projekt Firebase

  1. Zaloguj się do Firebase.
  2. W konsoli Firebase utwórz lub dodaj nowy projekt, a następnie nazwij swój projekt „Laboratorium eksportu UDID”.

Nie musisz włączać Google Analytics w tym projekcie.

  1. Kliknij Utwórz projekt .

Dodaj swoją aplikację na iOS do projektu

  1. Kliknij ikonę iOS, aby utworzyć nową aplikację Firebase na iOS, i wpisz identyfikator pakietu swojej aplikacji.

9c26c130a6c42212.png

  1. Pomiń kilka następnych kroków, a następnie kliknij Przejdź do konsoli . Później dodasz pakiety SDK do swojej aplikacji.

Twój projekt i aplikacja są teraz dostępne na stronie Przegląd projektu .

66f79cc8a97fa8e9.png

Włącz dystrybucję aplikacji

  1. W sekcji Wydanie i monitorowanie kliknij Dystrybucja aplikacji .
  2. Po zaakceptowaniu warunków kliknij „Rozpocznij”, aby włączyć dystrybucję aplikacji dla swojej aplikacji.

460213326c2784ae.png

Skonfiguruj dystrybucję w Fastlane

  1. Uruchom następujące polecenie z katalogu głównego projektu iOS, aby dodać dystrybucję aplikacji do konfiguracji Fastlane .

Jeśli polecenie wyświetli monit z opcją, wybierz opcję 3: RubyGems.org :

$ fastlane add_plugin firebase_app_distribution

  1. Potwierdź, że wtyczka jest zainstalowana:

$ fastlane

Dane wyjściowe powinny pokazywać fastlane-plugin-firebase_app_distribution na liście zainstalowanych wtyczek.

  1. Po potwierdzeniu, że wtyczka jest zainstalowana, wybierz opcję 0, aby anulować.

Uwierzytelnij swój projekt Firebase

Aby korzystać z wtyczki Fastlane, najpierw uwierzytelnij swój projekt Firebase .

  1. Uruchom następujące polecenie:

$ fastlane run firebase_app_distribution_login

  1. Gdy polecenie wydrukuje łącze uwierzytelniające, otwórz łącze w przeglądarce.
  2. Po wyświetleniu monitu zaloguj się na swoje konto Google i przyznaj uprawnienia dostępu do projektu Firebase.

Skopiuj otrzymany kod z przeglądarki logowania i wklej go w wierszu poleceń.

  1. Akcja logowania wyświetla następnie token odświeżania, którego wtyczka App Distribution używa do uwierzytelniania w Firebase:

dbd61c40c4131158.png

  1. Przekaż token, ustawiając zmienną środowiskową FIREBASE_TOKEN :

$ export FIREBASE_TOKEN= <token>

Rozpowszechniaj swoją aplikację

Możesz teraz rozpowszechniać swoją aplikację.

  1. W górnej części ./fastlane/Fastfile zdefiniuj zmienną o nazwie firebase_app_id . Zastąp <your_app_id> dla utworzonej aplikacji (można go znaleźć na stronie ustawień projektu ).

Fastfile jest napisany w języku Ruby, więc używaj składni Rubiego do definiowania zmiennych.

firebase_app_id = "<your_app_id>"
  1. Dodaj nowy pas o nazwie distribute , który wywołuje pas kompilacji, a następnie dystrybuuje aplikację za pomocą akcji firebase_app_distribution .
lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end
  1. Uruchom nowy pas, aby zbudować swoją aplikację i utworzyć dystrybucję.

$ fastlane distribute

W tym momencie twój Fastfile powinien wyglądać tak:

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

Po odświeżeniu konsoli Firebase zobaczysz nową wersję swojej aplikacji.

c59dc1a94de3bf3c.png

5. Zaproś testerów do pobrania Twojej aplikacji

Gdy tester zaakceptuje zaproszenie do przetestowania kompilacji ad hoc, zostanie poproszony o pozwolenie na udostępnienie swojego identyfikatora UDID. Jeśli wyrażą zgodę, App Distribution gromadzi informacje o ich urządzeniach i powiadamia Cię za pośrednictwem poczty e-mail. W tej sekcji dodasz siebie jako testera, aby pobrać i przetestować dystrybuowaną aplikację.

Dodaj siebie jako testera do wydania

  1. W obszarze firebase_app_id u góry Fastfile utwórz zmienną do przechowywania testerów i dołącz własny adres e-mail, a także inne opcjonalne adresy e-mail, które chcesz wypróbować.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
  1. Zastosuj metodę Array#join firmy Ruby, aby przekształcić tablicę app_testers w ciąg znaków oddzielonych przecinkami, którego oczekuje parametr testers . Następnie przekaż wynik do parametru testers w firebase_app_distribution.
lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!"
        testers: app_testers.join(","),
    )
end

W tym momencie twój Fastfile powinien wyglądać tak:

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
  1. Uruchom ponownie pas.

$ fastlane distribute

Gdy uruchomisz linię, dodani testerzy otrzymają wiadomość e-mail z zaproszeniem od App Distribution z powiadomieniem o nowej wersji. W konsoli Firebase możesz teraz zobaczyć testerów dodanych w wersji aplikacji.

2e0fc9603b868af8.png

Ponieważ podałeś swój adres e-mail, otrzymasz e-maila od Firebase App Distribution z zaproszeniem do przetestowania aplikacji. Jesteś teraz pierwszym testerem! Kontynuuj poniższą sekcję, aby skonfigurować się jako tester na swoim urządzeniu testowym.

Zarejestruj swoje urządzenie testowe

Jako tester musisz zalogować się w Google na swoim urządzeniu testowym, aby uzyskać dostęp do wersji aplikacji, do testowania których Cię zaproszono. Ponieważ kompilacja testowa jest wersją ad hoc, musisz również zarejestrować swoje urządzenie testowe, instalując profil Firebase. Następnie wersje, które staną się dostępne, można uzyskać z aplikacji internetowej testera App Distribution, korzystając z klipu internetowego dodanego do ekranu głównego urządzenia.

  1. Na urządzeniu testowym z systemem iOS otwórz wiadomość e-mail wysłaną z usługi Firebase App Distribution i kliknij łącze Rozpocznij . Pamiętaj, aby otworzyć link w Safari.
  2. Jesteś teraz w aplikacji internetowej testera dystrybucji aplikacji. Na wyświetlonej stronie zaloguj się na swoje konto Google i dotknij Zaakceptuj zaproszenie.

d833407de251b89f.png

  1. Teraz możesz zobaczyć wydania, na które Cię zaproszono. Dotknij Zarejestruj urządzenie w jednej z wersji.

fd141215e54a938d.png

  1. Po wyświetleniu monitu pobierz profil Firebase, a następnie zainstaluj profil w aplikacji Ustawienia.

Zainstalowanie profilu daje Firebase uprawnienia do:

  • Zarejestruj urządzenie testowe, zbierając unikalny identyfikator urządzenia (UDID).

Firebase wysyła wszystkim właścicielom i redaktorom projektu Firebase wiadomość e-mail zawierającą identyfikator UDID urządzenia testowego.

  • Zainstaluj wycinek z sieci na ekranie głównym urządzenia testowego. Klip internetowy otwiera aplikację internetową testera dystrybucji aplikacji, która umożliwia zainstalowanie i dostęp do wszystkich aplikacji testowych.

W aplikacji internetowej testera dystrybucji aplikacji Twoje urządzenie testowe jest teraz zarejestrowane w celu wydania aplikacji.

fe93d649dfa25877.png

Teraz, gdy udostępniłeś Firebase identyfikator UDID swojego urządzenia testowego, możesz wznowić pracę jako programista. Na karcie Testerzy panelu Dystrybucja aplikacji , informacje o testerze są teraz wyświetlane pod wersją aplikacji ze stanem „Zaakceptowana”:

7b9f665a63a384cf.png

W następnej sekcji dodasz identyfikator UDID urządzenia do profilu aprowizacji aplikacji, a następnie utworzysz wersję aplikacji, która będzie współpracować z urządzeniem testowym.

Wyeksportuj identyfikatory UDID urządzenia testowego

Jako programista otrzymasz od Firebase wiadomość e-mail zawierającą identyfikator UDID urządzenia testowego. Opcjonalnie App Distribution ułatwia jednoczesne zbieranie wielu nowych identyfikatorów UDID urządzeń, umożliwiając ich eksport bezpośrednio z konsoli Firebase jako nieprzetworzony plik tekstowy.

  1. Aby wyeksportować wszystkie identyfikatory UDID, otwórz kartę Testerzy i grupy .

241a9936898a2fc0.png

  1. Kliknij opcję Eksportuj identyfikatory UDID firmy Apple .

bcf0c26c522d9b4e.png

Plik powinien zawierać identyfikator UDID urządzenia testowego.

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

Identyfikatory UDID można również wyeksportować z wiersza poleceń za pomocą fastlane , co zrobisz w następnej sekcji.

6. Zaktualizuj profil udostępniania aplikacji i odbuduj go

Teraz dodasz identyfikator UDID urządzenia testowego do profilu aprowizacji aplikacji, odbudujesz wersję aplikacji, która działa na Twoim urządzeniu, i rozpowszechnisz nową wersję.

Dodaj ścieżkę eksportu UDID

  1. Dodaj kolejną zmienną na górze swojego Fastfile i ustaw ją na ścieżkę pliku, z której będą pobierane identyfikatory UDID urządzeń testerów.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "your@email.com",
  "another@email.com",
]
tester_udids_file = "tester_udids.txt"
  1. Skonfiguruj nowy pas, który używa akcji eksportu UDID wtyczki App Distribution, aby pobrać identyfikatory UDID testera, tak jak w przypadku konsoli.
lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end
  1. Uruchom następujący pas, aby pobrać identyfikatory UDID.

$ fastlane download_udids

  1. Wydrukuj pobrany plik, który powinien zawierać identyfikatory UDID urządzenia testowego.

$ cat tester_udids.txt

Dodaj urządzenia do konsoli programisty Apple

  1. Utwórz następującą ścieżkę, aby dodać identyfikatory UDID do listy urządzeń w konsoli programisty Apple, aby móc dodać je do swojego profilu aprowizacji za pomocą akcji register_devices w Fastlane :
lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end
  1. Następnie biegnij po pasie:

$ fastlane add_new_devices

Powinny pojawić się nowe urządzenia na liście urządzeń w konsoli programisty .

Dodaj urządzenia do swojego profilu aprowizacji

  1. Dodaj argument force do kroku profilu aprowizacji w linii build , aby wymusić pobieranie nowych urządzeń za każdym razem, gdy tworzysz.
lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Uruchom ponownie pas, aby zbudować i przesłać

Teraz zaktualizujesz swój pas distribute nowymi pasami, aby dodać urządzenia do profilu aprowizacji, ponownie skompilować aplikację, a następnie ją rozpowszechnić.

  1. Zadzwoń do nowych pasów z 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
  1. Uruchom pas distribute :

$ fastlane distribute

W tym momencie twój Fastfile powinien wyglądać tak:

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

Pobierz wersję z urządzenia testowego

Teraz, gdy Twoja aplikacja zawiera identyfikatory UDID urządzenia testowego, można je zainstalować na urządzeniach testowych.

e275f73d57cc8fb1.png

  1. Na urządzeniu testowym wróć do aplikacji internetowej testera dystrybucji aplikacji, korzystając z łącza w wiadomości e-mail lub ikony na ekranie głównym urządzenia.

Po przejściu do aplikacji do ćwiczeń z kodowania UDID zobaczysz, że wydanie jest gotowe do pobrania.

tata6d03b6ad78746.png

  1. Jeśli korzystasz z urządzenia fizycznego, naciśnij pobierz, a następnie zainstaluj i uruchom aplikację!

7. Gratulacje

Skonfigurowałeś teraz dystrybucję aplikacji i Fastlane , aby zautomatyzować proces testowania przed wydaniem. Teraz, gdy chcesz zaprosić dodatkowych testerów lub dodać ich identyfikatory UDID do swojej aplikacji, wystarczy uruchomić jedno polecenie: fastlane distribute .

Koniec z indywidualnym zbieraniem identyfikatorów UDID od testerów lub przechodzeniem do konsoli programisty Apple w celu aktualizacji list urządzeń lub profili aprowizacji. Nie musisz nawet otwierać XCode!

Ten przepływ pracy jest łatwy do skonfigurowania do uruchamiania co godzinę lub codziennie w środowisku ciągłej integracji.

Dalsza lektura