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

Otrzymuj dynamiczne linki na iOS

Aby otrzymać utworzone przez siebie linki dynamiczne Firebase , musisz umieścić w swojej aplikacji pakiet SDK Linków dynamicznych i wywołać metody handleUniversalLink: i dynamicLinkFromCustomSchemeURL: podczas wczytywania aplikacji w celu pobrania danych w łączu dynamicznym.

Warunki wstępne

Zanim zaczniesz, dodaj Firebase do swojego projektu iOS .

Skonfiguruj Firebase i pakiet SDK Linków dynamicznych

Użyj Menedżera pakietów Swift, aby zainstalować zależności Firebase i zarządzać nimi.

W Xcode przy otwartym projekcie aplikacji przejdź do pozycji Plik > Dodaj pakiety .
Po wyświetleniu monitu dodaj repozytorium SDK platformy Firebase Apple:

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

Wybierz bibliotekę Dynamic Links.
Aby zapewnić optymalne działanie Linków dynamicznych, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie pakietu SDK Firebase dla Google Analytics do swojej aplikacji. Możesz wybrać bibliotekę bez zbierania IDFA lub z kolekcją IDFA.
Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie twoich zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

W konsoli Firebase otwórz sekcję Linki dynamiczne . Zaakceptuj warunki korzystania z usługi, jeśli zostaniesz o to poproszony.
Upewnij się, że w ustawieniach aplikacji określono identyfikator App Store Twojej aplikacji i prefiks identyfikatora aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, przejdź do strony Ustawienia projektu Firebase i wybierz aplikację na iOS.
Możesz sprawdzić, czy Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania z Linków dynamicznych w Twojej aplikacji na iOS, otwierając następujący adres URL:
```
https://your_dynamic_links_domain/apple-app-site-association
```
Jeśli Twoja aplikacja jest połączona, plik apple-app-site-association zawiera odwołanie do prefiksu identyfikatora aplikacji i identyfikatora pakietu aplikacji. Na przykład:
```
{"applinks":{"apps":[],"details":[{"appID":"1234567890.com.example.ios","paths":["NOT /_/*","/*"]}]}}
```
Jeśli pole details jest puste, sprawdź, czy określono prefiks identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może nie być taki sam jak identyfikator zespołu.
Opcjonalnie : wyłącz korzystanie przez pakiet SDK Dynamic Links ze schowkiem iOS.
Domyślnie pakiet SDK linków dynamicznych korzysta z pulpitu do zwiększania niezawodności precyzyjnych linków po instalacji. Korzystając z pulpitu, Dynamic Links może zapewnić, że gdy użytkownik otworzy Dynamic Link, ale najpierw musi zainstalować Twoją aplikację, może natychmiast przejść do oryginalnej, połączonej zawartości podczas otwierania aplikacji po raz pierwszy po instalacji.
Wadą tego jest to, że użycie schowka wyzwala powiadomienie w iOS 14 i nowszych. Tak więc, gdy użytkownicy po raz pierwszy otworzą Twoją aplikację, jeśli tablica zawiera adres URL, zobaczą powiadomienie, że Twoja aplikacja uzyskała dostęp do tablicy, co może powodować zamieszanie.
Aby wyłączyć to zachowanie, edytuj plik Info.plist projektu Xcode i ustaw klucz FirebaseDeepLinkPasteboardRetrievalEnabled na NO .
Gdy wyłączysz tę funkcję, otrzymane dynamiczne linki będą miały w najlepszym matchType weak typ dopasowania. Dostosuj odpowiednio logikę swojej aplikacji.

Otwórz Dynamic Links w swojej aplikacji

Na karcie Informacje projektu Xcode aplikacji utwórz nowy typ adresu URL, który będzie używany dla Linków dynamicznych. Ustaw pole Identyfikator na unikalną wartość, a pole Schemat adresu URL na identyfikator pakietu, który jest domyślnym schematem adresu URL używanym przez Dynamic Links.
Na karcie Możliwości projektu Xcode aplikacji włącz Powiązane domeny i dodaj następujące pozycje do listy Powiązanych domen :
```
applinks:your_dynamic_links_domain
```
Jeśli chcesz otrzymywać linki dynamiczne z w pełni niestandardową domeną , w pliku Info.plist projektu Xcode utwórz klucz o nazwie FirebaseDynamicLinksCustomDomains i ustaw go na prefiksy adresów URL linków dynamicznych aplikacji. Na przykład:
```
FirebaseDynamicLinksCustomDomains

  https://example.com/promos
  https://example.com/links/share
```
Zaimportuj moduł FirebaseCore do swojego UIApplicationDelegate , a także wszelkie inne moduły Firebase używane przez delegata aplikacji. Na przykład, aby użyć Cloud Firestore i uwierzytelniania:
Szybki
```
import FirebaseCore
import FirebaseFirestore
import FirebaseAuth
// ...
      
```
Cel C
```
@import FirebaseCore;
@import FirebaseFirestore;
@import FirebaseAuth;
// ...
      
```
Skonfiguruj współużytkowane wystąpienie FirebaseApp , zwykle w inicjatorze App lub w metodzie application(_:didFinishLaunchingWithOptions:) :
Szybki
```
// Use Firebase library to configure APIs
FirebaseApp.configure()
```
Cel C
```
// Use Firebase library to configure APIs
[FIRApp configure];
```

Następnie w metodzie application:continueUserActivity:restorationHandler: obsłuż linki otrzymane jako Universal Links , gdy aplikacja jest już zainstalowana:

Szybki

Uwaga: ten produkt nie jest dostępny w systemach docelowych macOS, Mac Catalyst, tvOS lub 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
}

Cel C

Uwaga: ten produkt nie jest dostępny w systemach docelowych macOS, Mac Catalyst, tvOS lub 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<UIUserActivityRestoring>> *_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;
}

Wreszcie, w application:openURL:options: obsługuj linki otrzymane za pośrednictwem niestandardowego schematu adresu URL Twojej aplikacji. Ta metoda jest wywoływana, gdy aplikacja jest otwierana po raz pierwszy po instalacji.

Jeśli Dynamic Link nie zostanie znaleziony przy pierwszym uruchomieniu Twojej aplikacji, ta metoda zostanie wywołana z url DynamicLink ustawionym na nil , co oznacza, że pakiet SDK nie znalazł pasującego oczekującego linku dynamicznego.

Szybki

Uwaga: ten produkt nie jest dostępny w systemach docelowych macOS, Mac Catalyst, tvOS lub 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
}

Cel C

Uwaga: ten produkt nie jest dostępny w systemach docelowych macOS, Mac Catalyst, tvOS lub watchOS.

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<NSString *, id> *)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;
}