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

1. Zanim zaczniesz

W tym laboratorium dowiesz się, jak używać Rozpowszechniania aplikacji przez Firebase 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 aprowizacji aplikacji, aby szybko udostępniać testerom kompilacje ad hoc.

Czego się nauczysz

• Jak przesyłać i udostępniać testerom przedpremierową wersję aplikacji na iOS (Ad Hoc) za pomocą usługi Rozpowszechnianie aplikacji przez Firebase i fastlane.
• Jak zarejestrować się jako tester i pobrać rozpowszechnianą aplikację na urządzenie testowe.
• Jak szybko zarejestrować urządzenia testowe, eksportując identyfikatory UDID urządzeń testowych za pomocą wtyczki fastlane usługi App Distribution.
• Jak zaktualizować profil obsługi administracyjnej aplikacji i ponownie przesłać go w celu dystrybucji.

Czego potrzebujesz

• konto Google;
• Urządzenie Apple z zainstalowanym XCode w wersji 11.7 lub nowszej
• Aplikacja na iOS w wersji przedpremierowej Ad Hoc utworzona w Xcode
• płatne konto dewelopera Apple,
• fizyczne urządzenie z iOS do testowania;

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

Możesz jednak sprawdzić, czy konfiguracja działa, upewniając się, że w aplikacji internetowej testera App Distribution widoczny jest przycisk „Pobierz”.

2. Rozpocznij

Konfigurowanie fastlane

Usługa Rozpowszechnianie aplikacji integruje się z fastlane, co umożliwia automatyzację rozpowszechniania przedpremierowych wersji aplikacji. Usługa Rozpowszechnianie aplikacji integruje się z konfiguracją fastlane.

1. Zainstaluj i skonfiguruj fastlane.
2. Podczas konfiguracji uruchom fastlane init w katalogu głównym projektu i wybierz „Konfiguracja ręczna”. Zobaczysz podkatalog o nazwie fastlane, który zawiera pliki Fastfile, Appfile i Pluginfile. Będą one potrzebne do skonfigurowania fastlane.

Instalowanie wiersza poleceń Firebase

Musisz też zainstalować wiersz poleceń Firebase. Jeśli używasz systemu macOS lub Linux, możesz uruchomić to polecenie cURL:

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

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

Po zainstalowaniu interfejsu CLI uruchomienie polecenia firebase --version powinno zwrócić wersję 12.0.0 lub nowszą:

$ firebase --version
12.0.0

3. Kompilowanie aplikacji za pomocą fastlane

Tworzenie aplikacji

1. Ustaw zmienne globalne dla fastlane w ./fastlane/Appfile.. Podaj identyfikator aplikacji i identyfikator Apple ID:

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

2. Utwórz pierwszą ścieżkę i użyj działania fastlane build_app (znanego też jako gym), aby skompilować aplikację, dodając do pliku ./fastlane/Fastfile te wiersze:

default_platform(:ios)

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

3. Podpisz aplikację w celu dystrybucji.

W tym laboratorium kodowania będziesz zarządzać własną certyfikacją i profilem za pomocą get_certificates (znanego też jako cert), które generuje certyfikaty podpisywania lokalnie i przechowuje wszystkie dane w pęku kluczy macOS. Zwykle jednak do bezpiecznego zarządzania certyfikatami i profilami podpisywania kodu zespołu warto używać fastlane sync_code_signing action (znanego też jako match).

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

4. Skonfiguruj profil administracyjny dla aplikacji, korzystając z działania get_provisioning_profile (znanego też jako sigh). Umożliwi Ci to udostępnianie aplikacji testerom.

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

5. [Opcjonalnie] Jeśli aplikacja nie była jeszcze uruchamiana, wpisz to polecenie, aby utworzyć ją w konsoli dewelopera Apple:

$ fastlane produce --skip_itc

6. Na koniec skompiluj aplikację, uruchamiając ścieżkę.

Pojawi się prośba o podanie identyfikatora Apple ID, hasła (które jest przechowywane w pęku kluczy) i identyfikatora pakietu aplikacji.

$ fastlane build

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

4. Przesyłanie aplikacji do Firebase

Po utworzeniu aplikacji możesz przesłać ją do usługi Rozpowszechnianie aplikacji.

Tworzenie nowego projektu Firebase

1. Zaloguj się w konsoli Firebase, korzystając ze swojego konta Google.
2. Kliknij przycisk, aby utworzyć nowy projekt, a następnie wpisz jego nazwę (np. UDID Export Codelab).
3. Kliknij Dalej.
4. Po wyświetleniu monitu przeczytaj i zaakceptuj warunki usługi Firebase, a potem kliknij Dalej.
5. (Opcjonalnie) Włącz w konsoli Firebase pomoc AI (nazywaną „Gemini w Firebase”).
6. W tym samouczku nie potrzebujesz Google Analytics, więc wyłącz opcję Google Analytics.
7. Kliknij Utwórz projekt, poczekaj, aż projekt zostanie udostępniony, a następnie kliknij Dalej.

Dodawanie aplikacji na iOS do projektu

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

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

Projekt i aplikacja są teraz dostępne na stronie Przegląd projektu.

Włączanie Rozpowszechniania aplikacji

1. W sekcji Wdrażanie i monitorowanie kliknij Dystrybucja aplikacji.
2. Po zaakceptowaniu warunków kliknij „Rozpocznij”, aby włączyć Rozpowszechnianie aplikacji.

Konfigurowanie dystrybucji w fastlane

1. Aby dodać App Distribution do konfiguracji fastlane, uruchom to polecenie w katalogu głównym projektu na iOS:

Jeśli polecenie wyświetli opcję, wybierz Option 3: RubyGems.org:

$ fastlane add_plugin firebase_app_distribution

2. Sprawdź, czy wtyczka jest zainstalowana:

$ fastlane

Na liście zainstalowanych wtyczek powinna pojawić się pozycja fastlane-plugin-firebase_app_distribution.

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

Uwierzytelnianie projektu Firebase

Aby użyć wtyczki fastlane, musisz najpierw uwierzytelnić projekt Firebase.

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

$ firebase login

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

Dystrybucja aplikacji

Możesz teraz rozpowszechniać aplikację.

1. U góry pliku ./fastlane/Fastfile zdefiniuj zmienną o nazwie firebase_app_id. Zastąp symbol <your_app_id> identyfikatorem aplikacji Firebase utworzonej przez Ciebie (znajdziesz go na stronie ustawień projektu).

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

firebase_app_id = "<your_app_id>"

2. Dodaj nową ścieżkę o nazwie distribute, która wywołuje ścieżkę kompilacji, 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. Uruchom nową ścieżkę, aby skompilować aplikację i utworzyć dystrybucję.

$ fastlane distribute

W tym momencie 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. Zapraszanie testerów do pobrania aplikacji

Gdy tester zaakceptuje zaproszenie do testowania kompilacji Ad Hoc, pojawi się prośba o zgodę na udostępnienie identyfikatora UDID. Jeśli użytkownik wyrazi zgodę, Rozpowszechnianie aplikacji zbierze informacje o jego urządzeniu i powiadomi Cię o tym e-mailem. W tej sekcji dodasz siebie jako testera, aby pobrać i przetestować rozpowszechnianą aplikację.

Dodawanie siebie jako testera wersji

1. W sekcji firebase_app_id u góry pliku Fastfile utwórz zmienną, która będzie przechowywać testerów, i dodaj swój adres e-mail oraz 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 w języku Ruby, aby przekształcić tablicę app_testers w ciąg tekstowy rozdzielany przecinkami, którego oczekuje parametr testers. Następnie przekaż wynik do parametru testers funkcji 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 plik Fastfile powinien wyglądać 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 uruchom pas.

$ fastlane distribute

Gdy uruchomisz ścieżkę, dodani przez Ciebie testerzy otrzymają z App Distribution e-maila z zaproszeniem, w którym poinformujemy ich o nowo dostępnej wersji. W konsoli Firebase możesz teraz zobaczyć dodanych testerów w sekcji wersji aplikacji.

Ponieważ podano adres e-mail, otrzymasz e-maila z Firebase App Distribution z zaproszeniem do testowania aplikacji. Jesteś pierwszym testerem. Aby skonfigurować urządzenie testowe jako tester, przejdź do sekcji poniżej.

Rejestrowanie urządzenia testowego

Aby uzyskać dostęp do wersji aplikacji, do których testowania masz zaproszenie, musisz zalogować się w Google na urządzeniu testowym. Wersja testowa jest wydaniem Ad Hoc, więc musisz też zarejestrować urządzenie testowe, instalując profil Firebase. Później wersje, które staną się dla Ciebie dostępne, będą widoczne w aplikacji internetowej App Distribution dla testerów, do której dostęp uzyskasz za pomocą klipu internetowego dodanego do ekranu głównego urządzenia.

1. Na urządzeniu testowym z iOS otwórz e-maila wysłanego z Rozpowszechniania aplikacji przez Firebase i kliknij link Zacznij korzystać. Otwórz link w Safari.
2. Otworzy się aplikacja internetowa App Distribution Tester. Na wyświetlonej stronie zaloguj się na konto Google i kliknij Accept invitation (Zaakceptuj zaproszenie).

3. Możesz teraz wyświetlić wersje, do których Cię zaproszono. W sekcji jednej z wersji kliknij Zarejestruj urządzenie.

4. Gdy pojawi się monit, pobierz profil Firebase, a następnie zainstaluj go w aplikacji Ustawienia.

Zainstalowanie profilu daje Firebase uprawnienia do:

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

Firebase wysyła do wszystkich właścicieli i edytujących projekt Firebase e-maila z identyfikatorem UDID urządzenia testowego.

• Zainstaluj klip internetowy na ekranie głównym urządzenia testowego. Skrót otworzy aplikację internetową testera Rozpowszechniania aplikacji, która umożliwia instalowanie wszystkich aplikacji testowych i uzyskiwanie do nich dostępu.

W aplikacji internetowej testera usługi Rozpowszechnianie aplikacji urządzenie testowe jest teraz zarejestrowane w wersji aplikacji.

Uwaga: jeśli to urządzenie zostało już dodane do konta dewelopera, mogło zostać uwzględnione w profilu aprowizacji i w tym miejscu będzie już widoczny przycisk „Pobierz”.

Po udostępnieniu identyfikatora UDID urządzenia testowego Firebase możesz wrócić do roli dewelopera. Na karcie Testerzy w panelu App Distribution informacje o testerze pojawią się teraz pod wersją aplikacji ze stanem „Zaakceptowano”:

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

Eksportowanie identyfikatorów UDID urządzeń testerów

Jako deweloper otrzymasz od Firebase e-maila z identyfikatorem UDID urządzenia testowego. App Distribution ułatwia zbieranie wielu nowych identyfikatorów UDID urządzeń jednocześnie, umożliwiając eksportowanie ich bezpośrednio z konsoli Firebase w postaci pliku tekstowego.

1. Aby wyeksportować wszystkie identyfikatory UDID, otwórz kartę Testerzy i 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ż wyeksportować z wiersza poleceń za pomocą narzędzia fastlane, co zrobisz w następnej sekcji.

6. Zaktualizuj profil udostępniania aplikacji i ponownie ją skompiluj.

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

Dodawanie ścieżki eksportu identyfikatorów UDID

1. Dodaj kolejną zmienną na początku pliku Fastfile i ustaw ją na ścieżkę pliku, do którego zostaną pobrane identyfikatory UDID urządzeń testerów.

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

2. Skonfiguruj nową ścieżkę, która używa działania eksportowania identyfikatorów UDID wtyczki App Distribution do pobierania identyfikatorów UDID testerów, tak jak w przypadku 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, uruchom następującą ścieżkę:

$ fastlane download_udids

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

$ cat tester_udids.txt

Adodawanie urządzeń do konsoli programisty Apple.

1. Utwórz następującą ścieżkę, aby dodać identyfikatory UDID do listy urządzeń w konsoli dewelopera Apple. Dzięki temu możesz dodać je do profilu administracyjnego za pomocą działania register_devices w fastlane :

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

2. Następnie uruchom ścieżkę:

$ fastlane add_new_devices

Nowe urządzenia powinny być widoczne na liście urządzeń w konsoli dewelopera.

Dodawanie urządzeń do profilu udostępniania

1. Dodaj argument force do kroku profilu aprowizacji w ścieżce build, aby wymusić wybieranie nowych urządzeń przy każdej kompilacji.

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

Ponowne uruchomienie ścieżki w celu utworzenia i przesłania

Teraz zaktualizuj distribute o nowe ścieżki, aby dodać urządzenia do profilu udostępniania, ponownie skompilować aplikację, a następnie ją rozpowszechnić.

1. Zadzwoń na nowe numery 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. Uruchom ścieżkę distribute:

$ fastlane distribute

W tym momencie plik Fastfile powinien wyglądać 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 na urządzenie testowe

Teraz, gdy aplikacja zawiera identyfikatory UDID urządzeń testowych, można ją zainstalować na tych urządzeniach.

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

Gdy przejdziesz do aplikacji z ćwiczenia z programowania dotyczącego identyfikatora UDID, zobaczysz, że wersja jest gotowa do pobrania.

2. Jeśli korzystasz z urządzenia fizycznego, kliknij pobieranie, a następnie zainstaluj i uruchom aplikację.

Uwaga: pobieranie wersji działa tylko na urządzeniach fizycznych. Jeśli korzystasz z symulatora, pobieranie nie będzie działać, ale możesz sprawdzić, czy konfiguracja została przeprowadzona prawidłowo, sprawdzając, czy w aplikacji internetowej testera App Distribution pojawił się przycisk „Pobierz”.

7. Gratulacje

Usługa App Distribution i fastlane zostały skonfigurowane, aby zautomatyzować proces testowania wersji przedpremierowych. Teraz, gdy chcesz zaprosić dodatkowych testerów lub dodać ich identyfikatory UDID do aplikacji, wystarczy, że wykonasz jedno polecenie: fastlane distribute.

Nie musisz już zbierać identyfikatorów UDID od testerów ani przechodzić do konsoli Apple dla deweloperów, aby aktualizować listy urządzeń lub profile udostępniania. 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 Firebase App Distribution, w tym pakiet SDK w aplikacji na iOS.
• Więcej informacji o fastlane
• Zarządzanie podpisywaniem kodu zespołu za pomocą match
• Zintegruj fastlane z CI