Ta strona została przetłumaczona przez Cloud Translation API.

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

1. Zanim zaczniesz

W tym laboratorium kodowania dowiesz się, jak używać usługi Firebase App Distribution i jej wtyczki fastlane do dystrybucji 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 udostępniać kompilacje Ad Hoc testerom ' ręce.

Czego się nauczysz

Jak przesłać i rozpowszechnić przedpremierową 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 do dystrybucji aplikacji.
Jak zaktualizować profil udostępniania aplikacji i ponownie przesłać ją do dystrybucji.

Co będziesz potrzebował

Konto Google
Komputer Apple z zainstalowanym XCode 11.7+
Przedpremierowa aplikacja Ad Hoc na iOS zbudowana w Xcode
Płatne konto Apple Developer
Fizyczne urządzenie z systemem iOS do testowania.

Aplikacja symulatora systemu iOS będzie działać z większością modułów Codelab, 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 dystrybucji aplikacji.

2. Rozpocznij

Ustaw fastlane

Dystrybucja aplikacji integruje się z fastlane , aby umożliwić automatyzację dystrybucji przedpremierowych kompilacji aplikacji. Dystrybucja aplikacji integruje się z konfiguracją Fastlane .

Zainstaluj i skonfiguruj fastlane .
Uruchom fastlane init w katalogu głównym swojego projektu podczas instalacji i wybierz „Konfiguracja ręczna”. Zobaczysz podkatalog o nazwie fastlane , który zawiera Fastfile , Appfile i Pluginfile , których użyjesz do skonfigurowania 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 CLI uruchomienie firebase --version powinno zgłosić wersję 12.0.0 lub nowszą:

$ firebase --version
12.0.0

3. Zbuduj swoją aplikację z fastlane

Zbuduj swoją aplikację

Ustaw kilka zmiennych globalnych dla fastlane w pliku ./fastlane/Appfile. Dołącz identyfikator swojej aplikacji i swój Apple ID:

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

Utwórz swój pierwszy tor i użyj akcji build_app 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

Podpisz swoją aplikację do dystrybucji.

W tym laboratorium kodowania będziesz zarządzać własną certyfikacją i profilem za pomocą get_certificates (znanego również jako cert ), które lokalnie generuje certyfikaty podpisywania i przechowuje wszystko w pęku kluczy systemu 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

Skonfiguruj profil aprowizacji dla swojej aplikacji, używając 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

[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

Na koniec utwórz aplikację, uruchamiając ścieżkę.

Zostanie wyświetlony monit o podanie 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

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

Nie musisz włączać Google Analytics dla tego projektu.

Kliknij Utwórz projekt .

Dodaj swoją aplikację na iOS do projektu

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

Pomiń kilka następnych kroków, a następnie kliknij Kontynuuj do konsoli . Pakiety SDK dodasz później do swojej aplikacji.

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

Włącz dystrybucję aplikacji

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

Skonfiguruj dystrybucję w fastlane

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

Potwierdź, że wtyczka jest zainstalowana:

$ fastlane

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

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

Uwierzytelnij swój projekt Firebase

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

Uruchom następujące polecenie, aby połączyć CLI ze swoim kontem Google:

$ firebase login

Gdy polecenie wyświetli łącze uwierzytelniające, otwórz je w przeglądarce.
Po wyświetleniu monitu zaloguj się na swoje konto Google i zezwól na dostęp do swojego projektu Firebase.

Rozpowszechniaj swoją aplikację

Możesz teraz rozpowszechniać swoją aplikację.

U góry pliku ./fastlane/Fastfile zdefiniuj zmienną o nazwie firebase_app_id . Zamień <your_app_id> na identyfikator aplikacji Firebase dla utworzonej aplikacji (można go znaleźć na stronie ustawień projektu ).

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

firebase_app_id = "<your_app_id>"

Dodaj nowy tor o nazwie distribute , który wywołuje tor kompilacji, a następnie dystrybuuje Twoją 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

Uruchom nowy tor, aby zbudować swoją aplikację i stworzyć dystrybucję.

$ fastlane distribute

W tym momencie Twój plik 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.

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ą aplikację.

Dodaj siebie jako testera do wydania

W obszarze firebase_app_id u góry pliku 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",
]

Zastosuj metodę Array#join języka Ruby, aby zamienić tablicę app_testers w łańcuch oddzielony 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

Uruchom ponownie pas.

$ fastlane distribute

Gdy uruchomisz ścieżkę, 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.

Ponieważ podałeś swój adres e-mail, otrzymasz wiadomość e-mail 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 zostałeś zaproszony. Ponieważ Twoja wersja testowa jest wersją Ad Hoc, musisz także zarejestrować swoje urządzenie testowe, instalując profil Firebase. Następnie dostępne wersje będą dostępne z poziomu aplikacji internetowej App Distribution tester, przy użyciu klipu internetowego dodawanego do ekranu głównego urządzenia.

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ć łącze w przeglądarce Safari.
Jesteś teraz w aplikacji internetowej testera dystrybucji aplikacji. Na wyświetlonej stronie zaloguj się na swoje konto Google i dotknij Zaakceptuj zaproszenie.

Teraz możesz zobaczyć wydania, na które Cię zaproszono. Stuknij Zarejestruj urządzenie pod jedną z wersji.

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 e-maila zawierającego 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ę i dostęp do wszystkich aplikacji testowych.

W aplikacji internetowej App Distribution Tester Twoje urządzenie testowe jest teraz zarejestrowane do wydania Twojej aplikacji.

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

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

Wyeksportuj identyfikatory UDID testera

Jako programista otrzymasz e-maila z Firebase zawierającego identyfikator UDID urządzenia testowego. Opcjonalnie aplikacja App Distribution ułatwia jednoczesne gromadzenie wielu nowych identyfikatorów UDID urządzeń, umożliwiając eksportowanie ich bezpośrednio z konsoli Firebase jako nieprzetworzonego pliku tekstowego.

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

Kliknij opcję Eksportuj identyfikatory UDID firmy Apple .

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 udostępniania aplikacji, odbudujesz wersję aplikacji, która działa na Twoim urządzeniu, i rozpowszechnisz nową wersję.

Dodaj ścieżkę eksportu UDID

Dodaj kolejną zmienną na górze pliku Fastfile i ustaw ją na ścieżkę do pliku, do którego 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"

Skonfiguruj nowy tor, który używa akcji eksportu UDID wtyczki Dystrybucja aplikacji, aby pobrać identyfikatory UDID testera, tak jak zrobiłeś to z konsoli.

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

Uruchom następujący pas, aby pobrać identyfikatory UDID.

$ fastlane download_udids

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

$ cat tester_udids.txt

Dodaj urządzenia do konsoli programisty Apple

Utwórz następujący tor, 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

Następnie uruchom pas:

$ fastlane add_new_devices

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

Dodaj urządzenia do profilu udostępniania

Dodaj argument force do kroku profilu udostępniania na linii 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 linię, aby zbudować i przesłać

Teraz zaktualizujesz tor distribute o nowe tory, aby dodać urządzenia do profilu aprowizacji, ponownie skompilować aplikację, a następnie ją rozpowszechnić.

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

Uruchom linię 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ądzeń testowych, można je zainstalować na urządzeniach testowych.

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

Gdy przejdziesz do aplikacji UDID codelab, zobaczysz, że wersja jest gotowa do pobrania.

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

7. Gratulacje

Dystrybucja aplikacji i fastlane zostały już skonfigurowane, aby zautomatyzować proces testowania przedpremierowego. Teraz, gdy chcesz zaprosić dodatkowych testerów lub dodać ich identyfikatory UDID do swojej aplikacji, wystarczy uruchomić tylko 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 udostępniania. Nie musisz nawet otwierać XCode!

Ten przepływ pracy można łatwo skonfigurować do uruchamiania co godzinę lub codziennie w środowisku ciągłej integracji.

Dalsza lektura

Poznaj funkcje Firebase App Distribution , w tym nasz pakiet SDK w aplikacji na iOS
Dowiedz się więcej o fastlane
Zarządzaj podpisywaniem kodu przez swój zespół za pomocą match
Zintegruj fastlane ze swoim CI