Szybsza dystrybucja przedpremierowych wersji systemu iOS dzięki aplikacji App Distribution i Fastlane

1. Zanim zaczniesz

4cddd34bd261cea0.png

Podczas tych ćwiczeń z programowania dowiesz się, jak używać Firebase App Distribution i jej 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, dzięki czemu będziesz mógł szybko udostępniać testerom kompilacje Ad Hoc ' ręce.

Czego się dowiesz

  • Jak przesłać i rozpowszechnić wstępną wersję aplikacji na iOS (Ad Hoc) wśród 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 udostępniania aplikacji i przesłać go ponownie do dystrybucji.

Co będziesz potrzebował

  • Konto Google
  • Komputer Apple z zainstalowanym XCode 11.7+
  • Przedpremierowa aplikacja Ad Hoc na iOS wbudowana w Xcode
  • Płatne konto programisty Apple
  • Fizyczne urządzenie iOS do testów.

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

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

2. Zacznij

Skonfiguruj szybką linię

Dystrybucja aplikacji integruje się z Fastlane , aby umożliwić automatyzację 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 „Konfiguracja ręczna”. Zobaczysz podkatalog o nazwie fastlane , który zawiera Fastfile , Appfile i Pluginfile , których będziesz używać do konfigurowania Fastlane .

Zainstaluj interfejs wiersza polecenia Firebase

Będziesz także musiał zainstalować Firebase CLI . Jeśli używasz systemu macOS lub Linux, możesz uruchomić następujące polecenie cURL:

curl -sL https://firebase.tools | bash

Jeśli używasz systemu Windows, przeczytaj instrukcje instalacji , aby uzyskać samodzielny plik binarny lub zainstalować przez npm .

Po zainstalowaniu interfejsu CLI uruchomienie firebase --version powinno zgłosić wersję 12.0.0 lub wyższą:

$ firebase --version
12.0.0

3. Zbuduj swoją aplikację za pomocą Fastlane

Zbuduj swoją aplikację

  1. Ustaw kilka zmiennych globalnych dla fastlane w swoim ./fastlane/Appfile. Dołącz identyfikator 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 build_app programu Fastlane (znanej również jako gym ), aby zbudować swoją aplikację, dodając następujące elementy do pliku ./fastlane/Fastfile :
default_platform(:ios)

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

W przypadku tych zajęć z programowania będziesz zarządzać własnym certyfikatem i profilem za pomocą get_certificates (znanej również jako cert ), która generuje lokalnie certyfikaty podpisywania 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 swojego zespołu.

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

$ fastlane produce --skip_itc

  1. Na koniec zbuduj aplikację, uruchamiając pas.

Zostaniesz poproszony o podanie identyfikatora Apple ID, hasła (przechowywanego w pęku kluczy) i 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

Po utworzeniu aplikacji możesz przesłać ją do App Distribution.

Utwórz i skonfiguruj projekt Firebase

  1. Zaloguj się do Firebase.
  2. W konsoli Firebase utwórz lub dodaj nowy projekt, a następnie nadaj mu nazwę „UDID Export Codelab”.

Dla tego projektu nie musisz włączać Google Analytics.

  1. Kliknij opcję Utwórz projekt .

Dodaj swoją aplikację na iOS do projektu

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

9c26c130a6c42212.png

  1. Pomiń kilka następnych kroków, a następnie kliknij Kontynuuj do konsoli . Później dodasz zestawy 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 opcję 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 skorzystać z wtyczki Fastlane , najpierw uwierzytelnisz swój projekt Firebase.

  1. Uruchom następujące polecenie, aby połączyć interfejs CLI z kontem Google:

$ firebase 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 udziel pozwolenia na dostęp do projektu Firebase.

Rozpowszechniaj swoją aplikację

Możesz teraz rozpocząć dystrybucję swojej aplikacji.

  1. Na górze pliku ./fastlane/Fastfile zdefiniuj zmienną o nazwie firebase_app_id . Zastąp <your_app_id> identyfikatorem aplikacji Firebase dla utworzonej aplikacji (można go znaleźć na stronie ustawień projektu ).

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

firebase_app_id = "<your_app_id>"
  1. Dodaj nowy tor o nazwie distribute , który wywołuje tor 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ć aplikację i utworzyć dystrybucję.

$ fastlane distribute

W tym momencie Twój Fastfile powinien wyglądać następująco:

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 przyjmuje zaproszenie do testowania kompilacji Ad Hoc, jest proszony o pozwolenie na udostępnienie swojego identyfikatora UDID. Jeśli wyrażą zgodę, App Distribution zbiera informacje o ich urządzeniach i powiadamia Cię e-mailem. W tej sekcji dodasz siebie jako testera, aby pobrać i przetestować dystrybuowaną przez siebie aplikację.

Dodaj siebie jako testera do wydania

  1. W obszarze firebase_app_id na górze pliku Fastfile utwórz zmienną do przechowywania testerów i podaj swój 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 Ruby, aby zamienić tablicę app_testers na ciąg znaków rozdzielany przecinkami, czego 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ć następująco:

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

Po uruchomieniu ścieżki dodani przez Ciebie testerzy otrzymają wiadomość e-mail z zaproszeniem od App Distribution powiadamiającą ich o nowo dostępnej wersji. W konsoli Firebase możesz teraz zobaczyć testerów dodanych w ramach wersji aplikacji.

2e0fc9603b868af8.png

Ponieważ podałeś swój adres e-mail, otrzymasz wiadomość e-mail z Firebase App Distribution zapraszającą do przetestowania aplikacji. Jesteś teraz pierwszym testerem! Kontynuuj poniższą sekcję, aby skonfigurować 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 zaproszono Cię. Ponieważ Twoja wersja testowa jest wersją Ad Hoc, musisz także zarejestrować urządzenie testowe, instalując profil Firebase. Później dostęp do udostępnionych Ci wydań będzie można uzyskać w aplikacji internetowej testera dystrybucji aplikacji, korzystając z klipu internetowego dodanego do ekranu głównego urządzenia.

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

d833407de251b89f.png

  1. Możesz teraz zobaczyć premiery, na które Cię zaproszono. Kliknij opcję Zarejestruj urządzenie pod jedną 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 klip internetowy na ekranie głównym urządzenia testowego. Klip internetowy otwiera aplikację internetową testera dystrybucji aplikacji, która umożliwia instalację wszystkich aplikacji testowych i uzyskiwanie do nich dostępu.

W aplikacji internetowej testera dystrybucji aplikacji Twoje urządzenie testowe jest teraz zarejestrowane na potrzeby wydania Twojej aplikacji.

fe93d649dfa25877.png

Teraz, gdy udostępniłeś identyfikator UDID swojego urządzenia testowego w Firebase, możesz wznowić pracę jako programista. Na karcie Testerzy w panelu dystrybucji aplikacji informacje o testerze pojawiają się teraz pod wersją aplikacji i mają status „Zaakceptowano”:

7b9f665a63a384cf.png

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

Wyeksportuj identyfikatory UDID urządzenia testowego

Jako programista otrzymasz e-mail z Firebase zawierający identyfikator UDID urządzenia testowego. Opcjonalnie usługa App Distribution ułatwia gromadzenie wielu nowych identyfikatorów UDID urządzeń jednocześnie, umożliwiając ich eksport bezpośrednio z konsoli Firebase w postaci nieprzetworzonego pliku tekstowego.

  1. Aby wyeksportować wszystkie identyfikatory UDID, otwórz zakładkę 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ą programu 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 udostępniania aplikacji, odbudujesz wersję aplikacji, która będzie działać na Twoim urządzeniu, i rozpowszechnisz nową wersję.

Dodaj pas eksportu UDID

  1. Dodaj kolejną zmienną na górze pliku Fastfile i ustaw ją na ścieżkę pliku, z której zostaną pobrane 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 korzysta z akcji eksportu UDID wtyczki App Distribution do pobierania identyfikatorów UDID testerów, tak jak robiłeś to z 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ądzeń testowych.

$ cat tester_udids.txt

Dodaj urządzenia do konsoli programisty Apple

  1. Utwórz następujący pas, aby dodać identyfikatory UDID do listy urządzeń w konsoli programisty Apple, aby móc dodać je do swojego profilu udostępniania za pomocą akcji register_devices Fastlane :
lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end
  1. Następnie uruchom pas:

$ fastlane add_new_devices

Powinieneś wtedy zobaczyć nowe urządzenia na liście urządzeń w konsoli programisty.

Dodaj urządzenia do swojego profilu udostępniania

  1. Dodaj argument force do kroku profilu udostępniania na ścieżce build , aby wymusić pobieranie nowych urządzeń za każdym razem, gdy budujesz.
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 ścieżkę distribute o nowe ścieżki, aby dodać urządzenia do profilu udostępniania, ponownie skompilować aplikację, a następnie ją rozpowszechnić.

  1. Wywołaj nowe pasy 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ć następująco:

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 aplikacja zawiera identyfikatory UDID urządzeń testowych, 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 UDID codelab zobaczysz, że wersja jest gotowa do pobrania.

tata6d03b6ad78746.png

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

7. Gratulacje

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

Dzięki temu nie musisz już indywidualnie zbierać identyfikatorów UDID od testerów ani korzystać z konsoli programisty Apple w celu aktualizacji list urządzeń lub profili udostępniania. Nie musisz nawet otwierać XCode!

Ten przepływ pracy można łatwo skonfigurować tak, aby działał co godzinę lub codziennie w środowisku ciągłej integracji.

Dalsza lektura