Szybciej rozpowszechniaj przedpremierowe kompilacje na iOS dzięki Rozpowszechnianiu aplikacji i szybkim pasowi do działania

1. Zanim zaczniesz

Z tego ćwiczenia w Codelabs dowiesz się, jak używać usługi Firebase App Distribution i jej wtyczki fastlane do udostępniania aplikacji na iOS testerom, zbierania identyfikatorów UDID urządzeń testowych i rejestrowania ich w profilu udostępniania aplikacji, aby szybko tworzyć kompilacje Ad Hoc na potrzeby testerów ręce.

Czego się nauczysz

• Jak przesłać i rozpowszechnić przedpremierową aplikację na iOS (Ad Hoc) testerom za pomocą funkcji Rozpowszechniania aplikacji przez Firebase i szybkiej linii.
• Jak zarejestrować się jako tester i pobrać dystrybuowaną aplikację na urządzenie testowe.
• Jak szybko zarejestrować urządzenia testowe przez eksportowanie identyfikatorów UDID urządzeń testowych za pomocą wtyczki fastlane do App Distribution.
• Jak zaktualizować profil udostępniania aplikacji i ponownie przesłać ją do dystrybucji.

Czego potrzebujesz

• konto Google,
• komputer Apple z zainstalowanym XCode w wersji 11.7 lub nowszej,
• Nieopublikowana przedpremierowa aplikacja na iOS utworzona w Xcode
• płatne konto dewelopera Apple,
• Fizyczne urządzenie z iOS do testowania.

W przypadku większości ćwiczeń z programowania sprawdzi się symulator iOS, ale symulatory nie mogą pobierać wersji.

Aby upewnić się, że konfiguracja się udała, sprawdź, czy przycisk „Pobierz” w aplikacji internetowej testera usługi Rozpowszechniania aplikacji

2. Rozpocznij

Skonfiguruj szybki pas.

Rozpowszechnianie aplikacji integruje się z usługą fastlane, co umożliwia automatyzację rozpowszechniania przedpremierowych kompilacji aplikacji. Rozpowszechnianie aplikacji integruje się z konfiguracją szybkiej linii.

1. Zainstaluj i skonfiguruj fastlane.
2. Podczas konfiguracji uruchom polecenie fastlane init w katalogu głównym projektu i wybierz opcję „Konfiguracja ręczna”. Zobaczysz podkatalog fastlane zawierający elementy Fastfile, Appfile i Pluginfile, których użyjesz do skonfigurowania szybkiej linii.

Instalowanie interfejsu wiersza poleceń Firebase

Musisz też zainstalować interfejs wiersza poleceń Firebase. 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, by pobrać samodzielny plik binarny lub zainstalować go za pomocą npm.

Po zainstalowaniu interfejsu wiersza poleceń uruchomienie interfejsu firebase --version powinno zgłosić wersję 12.0.0 lub nowszą:

$ firebase --version
12.0.0

3. Utwórz aplikację w Fastlane

Tworzenie aplikacji

1. Ustaw pewne zmienne globalne dla fastlane (szybkiej linii) w: ./fastlane/Appfile. podaj identyfikator aplikacji oraz identyfikator Apple ID:

app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")

2. Utwórz pierwszy pas i użyj działania fastlane build_app (znanej też jako gym), aby stworzyć aplikację, dodając do ./fastlane/Fastfile:

default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end

3. Podpisz aplikację do dystrybucji.

W ramach tych ćwiczeń w Codelabs będziesz zarządzać własnym certyfikatem i profilem za pomocą narzędzia get_certificates (nazywanego też cert), które generuje lokalnie certyfikaty podpisywania i przechowuje wszystko w pęku kluczy macOS. Zazwyczaj jednak lepiej jest używać szybkiej ścieżki sync_code_signing action (znanej też jako match), aby bezpiecznie zarządzać certyfikatami i profilami podpisywania kodu w zespole.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end

4. Skonfiguruj profil obsługi administracyjnej aplikacji za pomocą działania get_provisioning_profile (nazywanego też sigh). Pozwoli Ci to udostępnić aplikację testerom.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

5. [Opcjonalnie] Jeśli Twoja aplikacja nie była jeszcze uruchamiana po raz pierwszy, uruchom to polecenie, aby utworzyć aplikację w konsoli Apple dla deweloperów:

$ fastlane produce --skip_itc

6. Na koniec stwórz swoją aplikację i poruszaj się po niej.

Wyświetli się prośba o podanie identyfikatora Apple ID, hasła (przechowywanego w pęku kluczy) i identyfikatora pakietu aplikacji.

$ fastlane build

W razie jakichkolwiek problemów zapoznaj się z przewodnikiem rozwiązywania problemów z szybką trasą.

4. Prześlij aplikację do Firebase

Gdy masz już aplikację, możesz przesłać ją do usługi Rozpowszechnianie aplikacji.

Tworzenie i konfigurowanie projektu Firebase

1. Zaloguj się w Firebase.
2. W konsoli Firebase utwórz lub dodaj nowy projekt, a potem nazwij go „Ćwiczenie z programowania dotyczące eksportowania danych UDID”.

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

3. Kliknij Utwórz projekt.

Dodawanie do projektu aplikacji na iOS

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

2. Pomiń kilka następnych kroków i kliknij Przejdź do konsoli. Pakiety SDK dodasz do aplikacji później.

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

Włącz Rozpowszechnianie aplikacji

1. W sekcji dotyczącej premiery W sekcji Monitorowanie kliknij Rozpowszechnianie aplikacji.
2. Po zaakceptowaniu warunków kliknij „Rozpocznij”. aby włączyć Rozpowszechnianie aplikacji dla Twojej aplikacji.

Konfigurowanie dystrybucji w fastlane

1. Aby dodać Rozpowszechnianie aplikacji do konfiguracji fastlane, uruchom następujące polecenie w katalogu głównym projektu na iOS.

Jeśli w poleceniu pojawi się opcja, wybierz Opcja 3. RubyGems.org:

$ fastlane add_plugin firebase_app_distribution

2. Sprawdź, czy wtyczka została zainstalowana:

$ fastlane

W danych wyjściowych na liście zainstalowanych wtyczek powinien pojawić się fastlane-plugin-firebase_app_distribution.

3. Po potwierdzeniu instalacji wtyczki wybierz opcję 0, aby anulować.

Uwierzytelnianie projektu Firebase

Aby korzystać z wtyczki fastlane, musisz najpierw uwierzytelnić swój projekt Firebase.

1. Uruchom to polecenie, aby połączyć interfejs wiersza poleceń z kontem Google:

$ firebase login

2. Gdy polecenie wygeneruje link uwierzytelniania, otwórz go w przeglądarce.
3. Gdy pojawi się taka prośba, zaloguj się na swoje konto Google i przyznaj uprawnienia dostępu do projektu Firebase.

Dystrybucja aplikacji

Możesz teraz rozpowszechniać aplikację.

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

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

firebase_app_id = "<your_app_id>"

2. Dodaj nowy pas o nazwie distribute, który wywołuje pas ruchu, a następnie rozpowszechnia aplikację za pomocą działania firebase_app_distribution.

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end

3. Wyznacz nowy pas, aby stworzyć aplikację i stworzyć rozpowszechnianie.

$ fastlane distribute

Plik 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ę aplikacji.

5. Zaproś testerów do pobrania aplikacji

Gdy tester otrzyma zaproszenie do testowania kompilacji ad hoc, pojawi się prośba o zgodę na udostępnianie jego identyfikatora UDID. Jeśli wyrażą na to zgodę, Rozpowszechnianie aplikacji będzie zbierać informacje z urządzenia i wysyłać Ci e-maile z powiadomieniem. W tej sekcji dodasz siebie jako testera, który pozwoli Ci pobrać i przetestować rozpowszechnioną przez Ciebie aplikację.

Dodawanie siebie jako testera wersji

1. W sekcji firebase_app_id u góry pliku Fastfile utwórz zmienną do przechowywania danych o testerach. Podaj też swój adres e-mail i inne opcjonalne adresy e-mail, które chcesz wypróbować.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

2. Zastosuj metodę Array#join 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 dla 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

Plik Fastfile powinien wyglądać teraz tak:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

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

3. Ponownie przejedź pasem.

$ fastlane distribute

Gdy wyznaczysz ten pas, dodani testerzy otrzymają e-maila z zaproszeniem z usługi Rozpowszechniania aplikacji z powiadomieniem o nowej wersji. W konsoli Firebase zobaczysz teraz dodanych testerów w sekcji wersji aplikacji.

Ponieważ został przez Ciebie podany adres e-mail, otrzymasz e-maila z usługi Rozpowszechniania aplikacji przez Firebase z zaproszeniem do przetestowania aplikacji. Jesteś teraz pierwszym testerem. Przejdź do sekcji poniżej, aby skonfigurować urządzenie testowe jako tester.

Rejestrowanie urządzenia testowego

Aby uzyskać dostęp do wersji aplikacji, do testowania których Cię zaproszono, jako tester musisz zalogować się w Google na urządzeniu testowym. Twoja kompilacja testowa jest wersją doraźną, więc musisz też zarejestrować urządzenie testowe, instalując profil Firebase. Późniejsze wersje będą dostępne w aplikacji internetowej testera Rozpowszechniania aplikacji za pomocą klipu z internetu dodanego do ekranu głównego urządzenia.

1. Na urządzeniu testowym iOS otwórz e-maila wysłanego z Rozpowszechniania aplikacji przez Firebase i kliknij link Rozpocznij. Pamiętaj, aby otworzyć link w przeglądarce Safari.
2. Jesteś teraz w aplikacji internetowej testera usługi Rozpowszechniania aplikacji. Na stronie, która się wyświetli, zaloguj się na swoje konto Google i kliknij Zaakceptuj zaproszenie.

3. Teraz możesz przeglądać wersje, do których Cię zaproszono. Pod jedną z wersji kliknij Zarejestruj urządzenie.

4. Gdy pojawi się prośba, pobierz profil Firebase, a potem zainstaluj go w aplikacji Ustawienia.

Zainstalowanie profilu daje Firebase uprawnienia do:

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

Firebase wysyła wszystkim właścicielom i edytorom projektu Firebase e-maila z identyfikatorem UDID urządzenia testowego.

• Zainstaluj wycinek internetowy na ekranie głównym urządzenia testowego. Klip internetowy otwiera aplikację internetową testera w usłudze Rozpowszechniania aplikacji, dzięki której możesz zainstalować wszystkie aplikacje testowe i uzyskać do nich dostęp.

W aplikacji internetowej testera usługi Rozpowszechniania aplikacji urządzenie testowe jest teraz zarejestrowane na potrzeby wersji aplikacji.

Uwaga: jeśli w przeszłości dodałeś to urządzenie do konta dewelopera, mogło już być uwzględnione w profilu obsługi administracyjnej. W sekcji „Pobierz” jest już widoczna opcja „Pobierz”. tutaj.

Po udostępnieniu Firebase identyfikatora UDID urządzenia testowego możesz wznowić działanie jako deweloper. Na karcie Testerzy w panelu dystrybucji aplikacji informacje o testerach pojawią się w sekcji aplikacji ze stanem „Zaakceptowano”:

W następnej sekcji dodasz identyfikator UDID urządzenia do profilu udostępniania aplikacji, a potem utworzysz wersję aplikacji współpracującą z urządzeniem testowym.

Eksportowanie identyfikatorów UDID urządzeń testowych

Jako deweloper otrzymasz z Firebase e-maila z identyfikatorem UDID urządzenia testowego. Opcjonalnie aplikacja Rozpowszechnianie aplikacji ułatwia zbieranie wielu nowych identyfikatorów UDID urządzeń naraz, ponieważ umożliwia ich eksportowanie bezpośrednio z konsoli Firebase do nieprzetworzonych plików tekstowych.

1. Aby wyeksportować wszystkie identyfikatory UDID, otwórz menu Testers & Grupy.

2. Kliknij Eksportuj identyfikatory UDID Apple.

Plik powinien zawierać identyfikator UDID urządzenia testowego.

Device ID            Device Name                            Device Platform
1234567890     [e-mail] - iPhone SE 2nd Gen        ios

Identyfikatory UDID można też eksportować z wiersza poleceń, używając szybkiej linii, co zrobisz w następnej sekcji.

6. Zaktualizuj profil obsługi administracyjnej aplikacji i skompiluj ją od nowa

Teraz dodaj identyfikator UDID urządzenia testowego do profilu udostępniania aplikacji, ponownie skompiluj wersję aplikacji, która współpracuje z Twoim urządzeniem, i rozpowszechnij nową wersję.

Dodaj pasek eksportu UDID

1. Dodaj kolejną zmienną na górze pliku Fastfile i ustaw ją na ścieżkę pliku, w której znajdują się testerzy zostaną pobrane identyfikatory UDID urządzeń.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

2. Skonfiguruj nowy pas, który będzie korzystać z działania eksportu UDID wtyczki do dystrybucji aplikacji, aby pobrać identyfikatory UDID testerów – tak jak w konsoli.

lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end

3. Aby pobrać identyfikatory UDID, pojedź tym pasem.

$ fastlane download_udids

4. Wydrukuj pobrany plik, który powinien zawierać identyfikatory UDID urządzeń testowych.

$ cat tester_udids.txt

Dodawanie urządzeń do konsoli Apple dla deweloperów

1. Utwórz następujący pas, aby dodać identyfikatory UDID do listy urządzeń w konsoli programisty Apple i dodać je do profilu obsługi administracyjnej przy użyciu czynności fastlane register_devices:

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

2. Następnie wyznacz pas:

$ fastlane add_new_devices

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

Dodawanie urządzeń do profilu obsługi administracyjnej

1. Dodaj argument force do kroku profilu obsługi administracyjnej na pasie build, aby wymuszać odbieranie nowych urządzeń za każdym razem, gdy tworzysz nowe urządzenia.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Wykonaj ponownie ścieżkę, aby utworzyć i przesłać

Uaktualnij pas distribute o nowe pasy, aby dodać urządzenia do profilu obsługi administracyjnej, ponownie skompilować aplikację i ją rozpowszechniać.

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

2. Przejdź pasem distribute:

$ fastlane distribute

Plik Fastfile powinien wyglądać teraz tak:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
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

Pobieranie wersji z urządzenia testowego

Gdy aplikacja zawiera identyfikatory UDID urządzeń testowych, możesz je zainstalować na urządzeniach testowych.

1. Na urządzeniu testowym wróć do aplikacji internetowej testera w usłudze Rozpowszechnianie aplikacji, korzystając z linku w e-mailu lub ikony na ekranie głównym urządzenia.

Po przejściu do aplikacji z programowaniem UDID zobaczysz, że wersja jest gotowa do pobrania.

2. Jeśli używasz urządzenia fizycznego, naciśnij Pobierz, a potem zainstaluj i uruchom aplikację.

Uwaga: pobieranie wersji działa tylko na urządzeniach fizycznych. Jeśli korzystasz z symulatora, pobieranie nie zadziała, ale nadal możesz sprawdzić, czy konfiguracja się udała, sprawdzając, czy przycisk „Pobierz” w aplikacji internetowej testera usługi Rozpowszechniania aplikacji

7. Gratulacje

Masz teraz skonfigurowaną funkcję Rozpowszechniania aplikacji i fastlane (szybkość) w celu zautomatyzowania procesu testowania przedpremierowych wersji aplikacji. Teraz, gdy chcesz zaprosić kolejnych testerów lub dodać ich identyfikatory UDID do aplikacji, wystarczy uruchomić jedno polecenie: fastlane distribute.

Nie musisz już samodzielnie zbierać identyfikatorów UDID od testerów ani aktualizować list urządzeń i profili obsługi administracyjnej w konsoli Apple dla deweloperów. Nie musisz nawet otwierać XCode.

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

Więcej informacji

• Poznaj funkcje usługi Rozpowszechniania aplikacji Firebase, w tym nasz pakiet SDK w aplikacji na iOS.
• Więcej informacji o fastlane
• Zarządzaj podpisywaniem kodu zespołu za pomocą match
• Zintegruj fastlane z CI