Save the date for Firebase Demo Day 2024. Learn how to build and run modern, AI-powered apps users love. Learn more.

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

Odbieranie linków dynamicznych w iOS

Aby otrzymać Firebase Dynamic Links, które utworzonej przez siebie, musisz umieścić w aplikacji pakiet Dynamic Links SDK i wywołać metodę handleUniversalLink: i dynamicLinkFromCustomSchemeURL: podczas wczytywania aplikacji, aby pobrać dane przekazywane w Dynamic Link.

Wymagania wstępne

Zanim zaczniesz, dodaj Firebase do projektu na iOS.

Konfigurowanie Firebase i pakietu SDK Dynamic Links

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

Po otwarciu projektu aplikacji w Xcode wybierz Plik > Dodaj pakiety.
Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:

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

Wybierz bibliotekę Dynamic Links.
Dodaj flagę -ObjC w sekcji Inne flagi linkera w ustawieniach kompilacji docelowej.
Aby uzyskać optymalne wyniki w przypadku Dynamic Links, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę z zbieraniem identyfikatorów IDFA lub bez niego.
Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie lub zależności w tle.

Teraz wykonaj czynności konfiguracyjne:

W konsoli Firebase otwórz Dynamic Links . Jeśli pojawi się taka prośba, zaakceptuj warunki korzystania z usługi.
Sprawdź, czy identyfikator App Store i prefiks identyfikatora aplikacji są określone w ustawieniach aplikacji. Aby wyświetlić i zmienić ustawienia aplikacji, otwórz stronę Ustawienia projektu Firebase i wybierz aplikację na iOS.

Aby sprawdzić, czy Twój projekt Firebase jest prawidłowo skonfigurowany do używania funkcji Dynamic Links w aplikacji na iOS, otwórz ten 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. 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 nie być taki sam jak identyfikator zespołu.
Opcjonalnie: wyłącz korzystanie pakietu Dynamic Links SDK z Przystawki na iOS.

Domyślnie pakiet SDK Dynamic Links korzysta z edytora, aby ulepszyć niezawodności precyzyjnych linków po instalacji. Korzystając z taśmy, Dynamic Linksmożesz zadbać o to, aby użytkownik, który otworzy Dynamic Link, ale najpierw będzie musiał zainstalować Twoją aplikację, mógł od razu przejść do oryginalnych treści powiązanych, gdy otworzy aplikację po raz pierwszy po zainstalowaniu.

Minusem jest to, że korzystanie z bufora wydruku powoduje wyświetlenie powiadomienia w systemie iOS 14 lub nowszym. Dlatego gdy użytkownicy po raz pierwszy otworzą aplikację, jeśli schowek zawiera adres URL, zobaczą powiadomienie, że aplikacja uzyskała dostęp do schowka. Może to wywołać ich niepokój.

Aby wyłączyć to zachowanie, otwórz plik Info.plist projektu Xcode i ustaw klucz FirebaseDeepLinkPasteboardRetrievalEnabled na NO.

Gdy wyłączysz tę funkcję, otrzymany Dynamic Links będzie miał w najlepszym przypadku matchTypeweak. Odpowiednio dostosuj strukturę logiczną aplikacji.

Otwórz Dynamic Links w aplikacji

Na karcie Info (Informacje) w projekcie Xcode swojej aplikacji utwórz nowy obiekt. Typ adresu URL dla Dynamic Links. W polu Identyfikator wpisz unikalną wartość, a w polu Schemat URL wpisz identyfikator pakietu, który jest domyślnym schematem URL używanym przez Dynamic Links.
Na karcie Capabilities (Możliwości) w projekcie Xcode aplikacji włącz powiązane domeny i dodaj następujące elementy do powiązanych Lista domen:
```
applinks:your_dynamic_links_domain
```
Jeśli chcesz otrzymywać Dynamic Links z pełną domeną niestandardową, w pliku Info.plist projektu Xcode utwórz klucz o nazwie FirebaseDynamicLinksCustomDomains i przypisz go do prefiksów URL-i Dynamic Links aplikacji. Na przykład:
```
FirebaseDynamicLinksCustomDomains

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

Zaimportuj moduł FirebaseCore do UIApplicationDelegate, jak i wszelkie inne Moduły Firebase używane przez przedstawiciela aplikacji. Aby na przykład użyć właściwości 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;
// ...

Skonfiguruj współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) w delegacie 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];

Jeśli używasz SwiftUI, musisz utworzyć i dołączyć przedstawiciela aplikacji. do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Więcej informacji znajdziesz w instrukcjach SwiftUI.
SwiftUI
```
@main
struct YourApp: App {
  // register app delegate for Firebase setup
  @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate

  var body: some Scene {
    WindowGroup {
      NavigationView {
        ContentView()
      }
    }
  }
}
      
```

Następnie w metodzie

application:continueUserActivity:restorationHandler:

obsługa linków otrzymanych jako Linki uniwersalne, jeśli aplikacja jest już zainstalowana:

Swift

Uwaga: ta usługa nie jest dostępna w przypadku systemów operacyjnych 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: ta usługa nie jest dostępna w przypadku systemów operacyjnych 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<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;
}

W sekcje application:openURL:options: należy obsłużyć linki otrzymane za pomocą schematu niestandardowego adresu URL aplikacji. Ta metoda jest wywoływana, gdy aplikacja jest otwierana po raz pierwszy po zainstalowaniu.

Jeśli przy pierwszym uruchomieniu aplikacji nie uda się znaleźć metody Dynamic Link, zostanie ona wywołana z użyciem metody Wartość url w tabeli DynamicLink została ustawiona na nil, co oznacza, że pakiet SDK nie udało się znaleźć pasującego oczekującego elementu Dynamic Link.

Swift

Uwaga: ta usługa nie jest dostępna w przypadku systemów operacyjnych 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: ta usługa nie jest dostępna na urządzeniach docelowych z systemami macOS, Mac Catalyst, tvOS i 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;
}