Odbieranie linków dynamicznych w iOS

Aby otrzymywać Firebase Dynamic Links, które utworzyłeś, musisz dodać do aplikacji pakiet Dynamic Links SDK i wywołać metody handleUniversalLink: oraz dynamicLinkFromCustomSchemeURL: podczas wczytywania aplikacji, aby uzyskać dane przekazywane w Dynamic Link.

Wymagania wstępne

Zanim zaczniesz, upewnij się, że dodasz Firebase do projektu na iOS.

Konfiguracja Firebase i pakizacja Dynamic Links SDK

Do instalacji zależności Firebase i do zarządzania nimi możesz używać menedżera pakietów Swift.

1. Po otwarciu projektu aplikacji wybierz w Xcode opcję File > Add Packages (Plik > Dodaj pakiety).
2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:

  https://github.com/firebase/firebase-ios-sdk.git

3. Wybierz bibliotekę Dynamic Links.
4. Dodaj flagę -ObjC do sekcji Other Linker Flags (Inne flagi linkera) w ustawieniach kompilacji celu.
5. Aby zapewnić optymalne działanie Dynamic Links, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę bez zbierania identyfikatora IDFA lub ze zbieraniem identyfikatora IDFA. Więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania dotyczące najnowszej organizacji modułów w Google Analytics dla Firebase SDK.
6. Gdy skończysz, Xcode zacznie automatycznie wyszukiwać i pobierać Twoje zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

1. W konsoli Firebase otwórz sekcję Dynamic Links. Jeśli pojawi się prośba, zaakceptuj warunki usługi.

2. Sprawdź, czy w ustawieniach aplikacji podano identyfikator App Store i prefiks identyfikatora aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, otwórz stronę Ustawienia projektu Firebase i wybierz aplikację na iOS.

   Aby sprawdzić, czy projekt w Firebase jest prawidłowo skonfigurowany do używania Dynamic Links w aplikacji na iOS, otwórz ten adres URL:

   https://your_dynamic_links_domain/apple-app-site-association

   Jeśli aplikacja jest połączona, plik apple-app-site-association zawiera odniesienie do prefiksu identyfikatora aplikacji i identyfikatora pakietu. Przykład:

   {"applinks":{"apps":[],"details":[{"appID":"1234567890.com.example.ios","paths":["NOT /_/*","/*"]}]}}

   Jeśli pole details jest puste, sprawdź, czy podano prefiks identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może być inny niż identyfikator zespołu.

3. Opcjonalnie: wyłącz używanie schowka iOS przez pakiet Dynamic Links SDK.

   Domyślnie pakiet Dynamic Links SDK używa schowka, aby zwiększyć niezawodność precyzyjnych linków po instalacji. Dzięki schowkowi Dynamic Links mogą zapewnić, że gdy użytkownik otworzy Dynamic Link ale najpierw będzie musiał zainstalować Twoją aplikację, po jej zainstalowaniu i pierwszym otwarciu będzie mógł od razu przejść do oryginalnej połączonej treści.

   Wadą tego rozwiązania jest to, że użycie schowka powoduje wyświetlenie powiadomienia w iOS 14 i nowszych wersjach. Dlatego, gdy użytkownicy otworzą Twoją aplikację po raz pierwszy, jeśli schowek będzie zawierał adres URL, zobaczą powiadomienie, że aplikacja uzyskała dostęp do schowka, co może być mylące.

   Aby wyłączyć to działanie, otwórz plik Info.plist w projekcie Xcode i ustaw klucz FirebaseDeepLinkPasteboardRetrievalEnabled na NO.

Otwieranie Dynamic Links w aplikacji

1. Na karcie Info w projekcie Xcode aplikacji utwórz nowy typ adresu URL, który będzie używany w Dynamic Links. W polu Identifier (Identyfikator) ustaw unikalną wartość, a w polu URL scheme (Schemat URI adresu URL) ustaw identyfikator pakietu, który jest domyślnym schematem URI adresu URL używanym przez Dynamic Links.
2. Na karcie Capabilities (Możliwości) w projekcie Xcode aplikacji włącz powiązane domeny i dodaj te domeny do listy Associated Domains (Powiązane domeny):

   applinks:your_dynamic_links_domain

3. Jeśli chcesz otrzymywać Dynamic Links z domeną w pełni niestandardową, w pliku Info.plist projektu Xcode utwórz klucz o nazwie FirebaseDynamicLinksCustomDomains i ustaw go na prefiksy adresów URL Dynamic Links. Przykład:

   FirebaseDynamicLinksCustomDomains
   
     https://example.com/promos
     https://example.com/links/share
   

4. Zaimportuj moduł FirebaseCore w UIApplicationDelegate, a także inne moduły Firebase, których używa delegat aplikacji. Na przykład, aby używać Cloud Firestore i Authentication:

   SwiftUI

   import SwiftUI
   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Swift

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Objective-C

   @import FirebaseCore;
   @import FirebaseFirestore;
   @import FirebaseAuth;
   // ...
         

5. Skonfiguruj FirebaseApp współdzieloną instancję w metodzie application(_:didFinishLaunchingWithOptions:) delegata aplikacji:

   SwiftUI

   // Use Firebase library to configure APIs
   FirebaseApp.configure()

   Swift

   // Use Firebase library to configure APIs
   FirebaseApp.configure()

   Objective-C

   // Use Firebase library to configure APIs
   [FIRApp configure];

6. Jeśli używasz SwiftUI, musisz utworzyć delegata aplikacji i dołączyć go do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć swizzling delegata aplikacji. Więcej informacji znajdziesz w instrukcjach dotyczących SwiftUI.

   SwiftUI

   @main
   struct YourApp: App {
     // register app delegate for Firebase setup
     @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate
   
     var body: some Scene {
       WindowGroup {
         NavigationView {
           ContentView()
         }
       }
     }
   }
         

7. Następnie w metodzie application:continueUserActivity:restorationHandler: obsługuj linki otrzymywane jako Linki uniwersalne gdy aplikacja jest już zainstalowana:

   Swift

   Uwaga: ten produkt nie jest dostępny w przypadku celów macOS, Mac Catalyst, tvOS ani watchOS.

   func application(_ application: UIApplication, continue userActivity: NSUserActivity,
                    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
     let handled = DynamicLinks.dynamicLinks()
       .handleUniversalLink(userActivity.webpageURL!) { dynamiclink, error in
         // ...
       }
   
     return handled
   }

   Objective-C

   Uwaga: ten produkt nie jest dostępny w przypadku celów macOS, Mac Catalyst, tvOS ani watchOS.

   - (BOOL)application:(UIApplication *)application
   continueUserActivity:(nonnull NSUserActivity *)userActivity
    restorationHandler:
   #if defined(__IPHONE_12_0) && (__IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_12_0)
   (nonnull void (^)(NSArray<id> *_Nullable))restorationHandler {
   #else
       (nonnull void (^)(NSArray *_Nullable))restorationHandler {
   #endif  // __IPHONE_12_0
     BOOL handled = [[FIRDynamicLinks dynamicLinks] handleUniversalLink:userActivity.webpageURL
                                                             completion:^(FIRDynamicLink * _Nullable dynamicLink,
                                                                          NSError * _Nullable error) {
                                                               // ...
                                                             }];
     return handled;
   }

8. Na koniec w metodzie application:openURL:options: obsługuj linki otrzymywane za pomocą niestandardowego schematu URI adresu URL aplikacji. Ta metoda jest wywoływana, gdy aplikacja zostanie otwarta po raz pierwszy po instalacji.

   Jeśli Dynamic Link nie zostanie znaleziony podczas pierwszego uruchomienia aplikacji, ta metoda zostanie wywołana z ustawionym na nil parametrem url w DynamicLink, co oznacza, że pakiet SDK nie znalazł pasującego oczekującego Dynamic Link.

   Swift

   Uwaga: ten produkt nie jest dostępny w przypadku celów macOS, Mac Catalyst, tvOS ani watchOS.

   @available(iOS 9.0, *)
   func application(_ app: UIApplication, open url: URL,
                    options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
     return application(app, open: url,
                        sourceApplication: options[UIApplication.OpenURLOptionsKey
                          .sourceApplication] as? String,
                        annotation: "")
   }
   
   func application(_ application: UIApplication, open url: URL, sourceApplication: String?,
                    annotation: Any) -> Bool {
     if let dynamicLink = DynamicLinks.dynamicLinks().dynamicLink(fromCustomSchemeURL: url) {
       // Handle the deep link. For example, show the deep-linked content or
       // apply a promotional offer to the user's account.
       // ...
       return true
     }
     return false
   }

   Objective-C

   Uwaga: ten produkt nie jest dostępny w przypadku celów macOS, Mac Catalyst, tvOS ani watchOS.

   - (BOOL)application:(UIApplication *)app
               openURL:(NSURL *)url
               options:(NSDictionary *)options {
     return [self application:app
                      openURL:url
            sourceApplication:options[UIApplicationOpenURLOptionsSourceApplicationKey]
                   annotation:options[UIApplicationOpenURLOptionsAnnotationKey]];
   }
   
   - (BOOL)application:(UIApplication *)application
               openURL:(NSURL *)url
     sourceApplication:(NSString *)sourceApplication
            annotation:(id)annotation {
     FIRDynamicLink *dynamicLink = [[FIRDynamicLinks dynamicLinks] dynamicLinkFromCustomSchemeURL:url];
   
     if (dynamicLink) {
       if (dynamicLink.url) {
         // Handle the deep link. For example, show the deep-linked content,
         // apply a promotional offer to the user's account or show customized onboarding view.
         // ...
       } else {
         // Dynamic link has empty deep link. This situation will happens if
         // Firebase Dynamic Links iOS SDK tried to retrieve pending dynamic link,
         // but pending link is not available for this device/App combination.
         // At this point you may display default onboarding view.
       }
       return YES;
     }
     return NO;
   }