Ostrzegaj testerów o nowych wersjach aplikacji za pomocą pakietu SDK Firebase App Distribution na iOS — Codelab

1. Przegląd

Witamy w laboratorium dotyczącym integracji pakietu SDK do dystrybucji aplikacji Firebase w swojej aplikacji na iOS. W tym laboratorium kodowania dodasz do swojej aplikacji pakiet SDK dystrybucji aplikacji, aby wyświetlać testerom alerty w aplikacji, gdy nowe kompilacje będą dostępne do pobrania. Dowiesz się, jak korzystać zarówno z konfiguracji podstawowej, jak i konfiguracji niestandardowej, aby umożliwić testerom zalogowanie się w celu otrzymywania aktualizacji. Następnie wypchniesz nową wersję do dystrybucji aplikacji i wyzwolisz alert nowej kompilacji bezpośrednio w aplikacji.

Czego się nauczysz

• Jak używać dystrybucji aplikacji do dystrybucji przedpremierowej aplikacji wśród testerów na żywo
• Jak zintegrować pakiet App Distribution iOS SDK ze swoją aplikacją
• Jak powiadomić testera, gdy pojawi się nowa przedpremierowa kompilacja gotowa do zainstalowania
• Jak dostosować SDK do swoich unikalnych potrzeb testowych

Co będziesz potrzebował

• Xcode 12 (lub wyższy)
• CocoaPods 1.9.1 (lub nowszy)
• Konto Apple Developer do dystrybucji Ad Hoc
• Fizyczne urządzenie z systemem iOS do testowania. ( Aplikacja symulatora systemu iOS będzie działać w przypadku większości modułów Codelab, ale symulatory nie mogą pobierać wersji).

2. Utwórz projekt konsoli Firebase

Dodaj nowy projekt Firebase

1. Zaloguj się do Firebase.
2. W konsoli Firebase kliknij Dodaj projekt, a następnie nazwij swój projekt „Firebase Codelab”.

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

3. Kliknij Utwórz projekt .

Dodaj aplikację do Firebase

Postępuj zgodnie z dokumentacją , aby zarejestrować swoją aplikację w Firebase. Użyj „com.google.firebase.codelab.AppDistribution.<twoja_nazwa>” jako identyfikatora pakietu iOS.

Po wyświetleniu monitu pobierz plik GoogleService-Info.plist swojego projektu. Będzie to potrzebne później.

3. Pobierz przykładowy projekt

Pobierz kod

Rozpocznij od sklonowania przykładowego projektu.

git clone git@github.com:googlecodelabs/firebase-appdistribution-ios.git

Jeśli nie masz zainstalowanego git, możesz również pobrać przykładowy projekt z jego strony GitHub lub klikając ten link .

Pobierz zależności i otwórz projekt w Xcode

1. Otwórz plik Podfile w tym samym katalogu

cd firebase-appdistribution-ios/start
Open Podfile

2. Dodaj następującą linię do swojego podfile:

Podplik

pod 'Firebase/AppDistribution'

Uruchom pod update w katalogu projektu i otwórz projekt w Xcode.

pod install --repo-update
xed .

Zaktualizuj identyfikator pakietu, aby pasował do Twojej aplikacji Firebase

W lewym menu kliknij dwukrotnie AppDistributionExample. Następnie znajdź kartę Ogólne i zmień identyfikator pakietu, aby pasował do identyfikatora pakietu Twojej aplikacji Firebase, który można znaleźć w ustawieniach projektu . Powinno to być „com.google.firebase.codelab.AppDistribution.<twoja_nazwa>”

Dodaj Firebase do swojej aplikacji

Znajdź pobrany wcześniej plik GoogleService-Info.plist w swoim systemie plików i przeciągnij go do katalogu głównego projektu Xcode. Możesz też pobrać ten plik w dowolnym momencie ze strony ustawień swojego projektu .

W swoim pliku AppDistributionExample/AppDelegate.swift zaimportuj Firebase na górze pliku

AppDistributionExample/AppDelegate.swift

import Firebase

A w metodzie didFinishLaunchingWithOptions dodaj wywołanie, aby skonfigurować Firebase.

AppDistributionExample/AppDelegate.swift

FirebaseApp.configure()

4. Skonfiguruj alerty o nowych kompilacjach w aplikacji za pomocą zestawu SDK do dystrybucji aplikacji

W tym kroku dodasz do swojej aplikacji pakiet Firebase App Distribution SDK i wyświetlisz alerty w aplikacji swoim testerom, gdy nowe kompilacje Twojej aplikacji będą dostępne do zainstalowania. Aby to zrobić, upewnij się, że w swoim projekcie „Firebase Codelab” (w Google Cloud Console) włączyłeś interfejs Firebase App Testers API . Będziesz musiał zalogować się na to samo konto i wybrać właściwy projekt z rozwijanego menu u góry.

Skonfiguruj alerty w aplikacji

Pakiet App Distribution SDK udostępnia testerom dwa sposoby konfigurowania alertów kompilacji w aplikacji: podstawową konfigurację alertów, która zawiera gotowe okno logowania do wyświetlania testerom, oraz zaawansowaną konfigurację alertów, która umożliwia dostosować swój własny interfejs użytkownika (UI).

Zaczniemy od podstawowej konfiguracji alertów. Możesz użyć checkForUpdate aby wyświetlić wstępnie skompilowane okno dialogowe włączania alertów testerom, którzy jeszcze nie włączyli alertów, a następnie sprawdzić, czy dostępna jest nowa kompilacja. Testerzy włączają alerty, logując się na konto, które ma dostęp do aplikacji w dystrybucji aplikacji. Po wywołaniu metoda wykonuje następującą sekwencję:

1. Sprawdza, czy tester włączył alerty. Jeśli nie, wyświetla gotowe okno dialogowe z prośbą o zalogowanie się do usługi App Distribution przy użyciu konta Google.

Włączanie alertów to jednorazowy proces na urządzeniu testowym, który trwa przez wszystkie aktualizacje Twojej aplikacji. Alerty pozostają włączone na urządzeniu testowym do momentu odinstalowania aplikacji lub wywołania metody signOutTester . Zobacz dokumentację referencyjną metody ( Swift lub Objective-C ), aby uzyskać więcej informacji.

2. Sprawdza nowe dostępne kompilacje do zainstalowania przez testera. Zwraca obiekt wydania lub błąd .

Możesz dołączyć checkForUpdate w dowolnym momencie w swojej aplikacji. Na przykład możesz poprosić testerów o zainstalowanie nowo dostępnych kompilacji podczas uruchamiania, włączając checkForUpdate w viewDidAppear UIViewController .

W pliku AppDistributionViewController.swift zaimportuj Firebase na górze pliku

AppDistributionViewController.swift

import Firebase

Otwórz AppDistributionExample/AppDistributionViewController.swift i skopiuj wiersze do metody viewDidAppear w następujący sposób:

AppDistributionViewController.swift

 override func viewDidAppear(_ animated: Bool) {
    checkForUpdate()
 }

Teraz zaimplementujmy metodę checkForUpdate().

AppDistributionViewController.swift

  private func checkForUpdate() {
    AppDistribution.appDistribution().checkForUpdate(completion: { [self] release, error in
      var uiAlert: UIAlertController

      if error != nil {
        uiAlert = UIAlertController(title: "Error", message: "Error Checking for update! \(error?.localizedDescription ?? "")", preferredStyle: .alert)
      } else if release == nil {
        uiAlert = UIAlertController(title: "Check for Update", message: "No releases found!!", preferredStyle: .alert)
        uiAlert.addAction(UIAlertAction(title: "Ok", style: UIAlertAction.Style.default))
      } else {
        guard let release = release else { return }

        let title = "New Version Available"
        let message = "Version \(release.displayVersion)(\(release.buildVersion)) is available."
        uiAlert = UIAlertController(title: title, message: message, preferredStyle: .alert)

        uiAlert.addAction(UIAlertAction(title: "Update", style: UIAlertAction.Style.default) {
          _ in
          UIApplication.shared.open(release.downloadURL)
        })
        uiAlert.addAction(UIAlertAction(title: "Cancel", style: UIAlertAction.Style.cancel) {
          _ in
        })
      }
      self.present(uiAlert, animated: true, completion: nil)
    })
  }

5. Zbuduj i zaproś testerów do pobrania Twojej aplikacji

W tym kroku zbudujesz aplikację i przetestujesz implementację, dystrybuując kompilację do testerów za pomocą konsoli Firebase.

Zbuduj swoją aplikację

Gdy wszystko będzie gotowe do rozpowszechnienia przedpremierowej wersji aplikacji wśród testerów, wybierz „Dowolne urządzenie z systemem iOS (arm64)” jako miejsce docelowe kompilacji i wybierz opcję Produkt->Archiwum. Po utworzeniu archiwum zbuduj podpisaną dystrybucję z profilem dystrybucji deweloperskiej.

Po zakończeniu kompilacji zapisuje plik IPA i niektóre pliki dziennika w określonym folderze. Rozpowszechniasz plik IPA wśród swoich testerów, wykonując następujące kroki.

Jeśli napotkasz problemy podczas tworzenia aplikacji, zapoznaj się z dokumentacją współprojektowania firmy Apple, aby uzyskać informacje o krokach rozwiązywania problemów.

Rozpowszechniaj swoją aplikację wśród testerów

Aby rozpowszechnić aplikację wśród testerów, prześlij plik IPA za pomocą konsoli Firebase:

1. Otwórz stronę Dystrybucja aplikacji w konsoli Firebase. Po wyświetleniu monitu wybierz swój projekt Firebase.
2. Naciśnij Rozpocznij

3. Na stronie Wersje wybierz z menu rozwijanego aplikację, którą chcesz rozpowszechniać.

4. Przeciągnij plik IPA swojej aplikacji do konsoli, aby go przesłać.
5. Po zakończeniu przesyłania określ grupy testerów i poszczególnych testerów, którzy mają otrzymać kompilację. (Dodaj swój adres e-mail, aby otrzymać zaproszenie). Następnie dodaj informacje o wersji dla kompilacji. Zobacz Zarządzanie testerami, aby uzyskać więcej informacji na temat tworzenia grup testerów.

6. Kliknij Rozpowszechnij, aby udostępnić kompilację testerom.

Dodaj siebie jako testera do wydania

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

Aby pobrać i przetestować wersję Ad Hoc, musisz najpierw zarejestrować urządzenie testowe.

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ć łącze w przeglądarce Safari.
2. W wyświetlonej aplikacji internetowej testera dystrybucji aplikacji Firebase zaloguj się na swoje konto Google i kliknij Zaakceptuj zaproszenie.

Teraz zobaczysz wydanie, na które zostałeś zaproszony.

3. Stuknij opcję Zarejestruj urządzenie , aby udostępnić swój identyfikator UDID w Firebase, aby móc później zaktualizować profil udostępniania aplikacji.

4. Postępuj zgodnie z instrukcjami i przejdź do ustawień, aby pobrać profil i udostępnić swój identyfikator UDID.

Teraz, gdy wrócisz do dystrybucji aplikacji, wersja jest teraz oznaczona jako „Zarejestrowane urządzenie”:

Identyfikator UDID testera został teraz udostępniony programiście. Teraz programista musi zbudować testerowi nową wersję aplikacji.

Wyświetl informacje o testerze w konsoli

Po powrocie do widoku programisty w konsoli Firebase tester pojawi się jako „Zaakceptowany” pod wydaniem:

Otrzymasz również wiadomość e-mail jako programista, jeśli używane przez niego urządzenie nie jest jeszcze uwzględnione w profilu udostępniania. Spowoduje to powiadomienie o nowym identyfikatorze UDID, który należy dodać. Masz również możliwość wyeksportowania wszystkich identyfikatorów UDID jako pliku tekstowego.

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

2. Kliknij „Eksportuj identyfikatory UDID firmy Apple”.

Plik powinien zawierać identyfikator UDID urządzenia testowego.

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

Po otrzymaniu jednego z tych e-maili zaktualizuj swój profil udostępniania za pomocą identyfikatora UDID i roześlij testerom nową wersję, wykonując następujące czynności:

1. Dodaj urządzenia do portalu deweloperów Apple.

• Opcja 1: zaimportuj identyfikatory UDID urządzenia jako plik CSV. Na karcie Testerzy i grupy w panelu Dystrybucja aplikacji wybierz opcję Wszyscy testerzy, a następnie kliknij opcję Eksportuj identyfikatory UDID firmy Apple, aby pobrać plik CSV. Następnie zaimportuj plik do konta programisty Apple, korzystając z opcji Zarejestruj wiele urządzeń. Zapoznaj się z dokumentacją firmy Apple, aby dowiedzieć się więcej. Pamiętaj, że Twoje konto programisty Apple może umożliwiać importowanie ograniczonej liczby urządzeń rocznie.
• Opcja 2: Zbierz i wprowadź identyfikatory UDID pocztą e-mail. Na stronie Dodaj urządzenia w portalu dla deweloperów firmy Apple zarejestruj nowy identyfikator UDID podany w otrzymanej wiadomości e-mail.

2. Dodaj zarejestrowane urządzenia do profilu udostępniania .
3. Pobierz profil aprowizacji i użyj go do odbudowania aplikacji. Jeśli przebudowujesz tylko w celu aktualizacji zarejestrowanych urządzeń, nie aktualizuj numeru kompilacji ani wersji.
4. Rozpowszechniaj ponownie swoją aplikację z konsoli Firebase lub CLI. Jeśli dystrybuowałeś już kompilację z tym samym numerem kompilacji i wersją, tylko użytkownicy nowo zarejestrowanych urządzeń otrzymają e-maile z powiadomieniami.

Pobierz wersję z urządzenia testowego

Teraz wersja ma identyfikator UDID urządzenia testowego, więc urządzenie testowe może pobrać i zainstalować aplikację. Dystrybucja aplikacji wysyła wiadomość e-mail do testerów, gdy ich identyfikator UDID zostanie dodany do nowej wersji.

1. 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.

2. Jeśli korzystasz z urządzenia fizycznego, naciśnij Pobierz, a następnie zainstaluj i uruchom aplikację!
3. Po uruchomieniu aplikacja poprosi o włączenie alertów o nowych kompilacjach. Wybierz „Włącz”

4. Następnie poprosi Cię o zalogowanie. Kliknij „Kontynuuj”.

5. Zaloguj się na swoje konto testera.

6. Zostaniesz przeniesiony z powrotem do aplikacji. Nie będziesz musiał się logować ani akceptować alertów przy następnym uruchomieniu aplikacji.

Przekaż aktualizację swoim testerom

1. Zaktualizuj swój numer kompilacji do „2”.

2. Wybierz „Dowolne urządzenie iOS (arm64)” jako miejsce docelowe kompilacji, a następnie Produkt->Archiwum. Po wygenerowaniu archiwum zbuduj podpisaną dystrybucję z profilem dystrybucji deweloperskiej.
3. Po zakończeniu kompilacji zapisuje plik IPA i niektóre pliki dziennika w określonym folderze. Prześlij ten nowy IPA do konsoli Firebase, ponownie dodaj swój adres e-mail jako tester i rozpowszechnij.

Przetestuj alerty kompilacji

1. Upewnij się, że zamknąłeś aplikację, jeśli była otwarta. Uruchom ponownie aplikację.
2. Po ponownym uruchomieniu aplikacji powinieneś otrzymać alert „Dostępna nowa wersja”.

3. Kliknij „Aktualizuj”, aby otrzymać najnowszą wersję.
4. Kliknij „Zainstaluj” na następnym ekranie.

5. Gratulacje! Udało Ci się zaktualizować aplikację za pomocą wbudowanych alertów.

6. Dostosuj logowanie testera

Metody signInTester/signOutTester i isTesterSignedIn zapewniają większą elastyczność w dostosowywaniu środowiska logowania testera, dzięki czemu lepiej pasuje do wyglądu i działania Twojej aplikacji.

Poniższy przykład sprawdza, czy tester zalogował się już na swoje konto testera Firebase App Distribution, więc możesz wybrać wyświetlanie interfejsu logowania tylko dla testerów, którzy jeszcze się nie zalogowali. Po zalogowaniu się testera możesz wywołaj checkForUpdate, aby sprawdzić, czy tester ma dostęp do nowej wersji.

Wyłączmy automatyczne sprawdzanie aktualizacji w viewDidAppear , komentując wywołanie checkForUpdate() .

AppDistributionViewController.swift

 override func viewDidAppear(_ animated: Bool) {
    // checkForUpdate()
 }

Zamiast tego wywołajmy metodę checkForUpdate() w metodzie checkForUpdateButtonClicked( ).

 @objc func checkForUpdateButtonClicked() {
    checkForUpdate()
 }

Teraz zaimplementujmy naszą metodę signInOutButtonClicked() , która zaloguje użytkownika, jeśli jest wylogowany, lub wyloguje użytkownika, jeśli jest już zalogowany.

AppDistributionViewController.swift

 @objc func signInOutButtonClicked() {
    if isTesterSignedIn() {
      AppDistribution.appDistribution().signOutTester()

      self.configureCheckForUpdateButton()
      self.configureSignInSignOutButton()
      self.configureSignInStatus()

    } else {
      AppDistribution.appDistribution().signInTester(completion: { error in
        if error == nil {
          self.configureCheckForUpdateButton()
          self.configureSignInSignOutButton()
          self.configureSignInStatus()
        } else {
          let uiAlert = UIAlertController(title: "Custom:Error", message: "Error during tester sign in! \(error?.localizedDescription ?? "")", preferredStyle: .alert)
          uiAlert.addAction(UIAlertAction(title: "Ok", style: UIAlertAction.Style.default) {
            _ in
          })

          self.present(uiAlert, animated: true, completion: nil)
        }
      })
    }
  }

Na koniec zaimplementujmy metodę isTesterSignedI n.

AppDistributionViewController.swift

 private func isTesterSignedIn() -> Bool {
    return AppDistribution.appDistribution().isTesterSignedIn
 }

Zbuduj i przetestuj swoją implementację

7. Gratulacje!

Wbudowałeś funkcję „wyświetlanie alertów w aplikacji” w aplikacji przy użyciu Firebase App Distribution iOS SDK.

Co omówiliśmy

• Dystrybucja aplikacji Firebase
• Dystrybucja aplikacji Firebase Nowe alerty iOS SDK

Następne kroki

• Korzystanie z wtyczki Fastlane
• Korzystanie z narzędzi CLI

Ucz się więcej

• Firebase.google.com
• Jak Twitter używa nowego zestawu SDK dla iOS

Mam pytanie?

• Stackoverflow „firebase-app-distribution ”
• Kanał społeczności Firebase Slack #app-distribution

Zgłoś problemy

• Problemy z Githubem