Tworzenie linków dynamicznych w iOS

Wycofane: linki dynamiczne Firebase zostały wycofane i nie należy ich używać w projektach, które ich jeszcze nie używają. Usługa zostanie zamknięta 25 sierpnia 2025 r. Więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania dotyczące wycofywania dynamicznych linków.

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie i długie Dynamic Links. Ten interfejs API akceptuje parametr Dynamic Link lub obiekt zawierający parametry Dynamic Link. Zwraca adresy URL podobne do tych przykładów:

https://example.com/link/WXYZ
https://example.page.link/WXYZ

Wymagania wstępne

Zanim zaczniesz, dodaj Firebase do projektu na iOS.

Konfigurowanie Firebase i pakietu SDK Dynamic Links

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

Odwiedź nasz przewodnik instalatora, aby dowiedzieć się, jak dodać pakiety SDK Firebase do projektu Apple, m.in. za pomocą bezpośredniego importowania frameworków i CocoaPods.

1. Po otwarciu projektu aplikacji w Xcode wybierz 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

Uwaga: nowe projekty powinny używać domyślnej (najnowszej) wersji pakietu SDK, ale w razie potrzeby możesz wybrać starszą wersję.
3. Wybierz bibliotekę Dynamic Links.
4. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji docelowej.
5. 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.
6. Gdy to zrobisz, Xcode automatycznie zacznie wyszukiwać i pobierać zależności w tle.

Teraz wykonaj czynności konfiguracyjne:

1. W konsoli Firebase otwórz sekcję Dynamic Links.

2. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie ustawiłeś prefiksu URI dla usługi Dynamic Links, zrób to, gdy pojawi się taka prośba.

   Jeśli masz już prefiks URI Dynamic Links, zanotuj go. Musisz go podać, gdy Dynamic Links tworzysz programowo.

   

3. Zalecane: określ wzorce adresów URL dozwolone w precyzyjnych linkach i linkach zastępczych. Dzięki temu uniemożliwisz nieupoważnionym osobom tworzenie Dynamic Links, które przekierowują z Twojej domeny do witryn, nad którymi nie masz kontroli. Zobacz sekcję Zezwalanie na określone wzorce adresów URL.

4. 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 korzystania z Dynamic Links w aplikacji na iOS, otwórz plik apple-app-site-association hostowany w domenie Dynamic Links. Firebase będzie udostępniać plik apple-app-site-association z poziomu katalogu głównego domeny oraz z podkatalogu .well-known. Na przykład:

       https://example.com/apple-app-site-association
       https://example.com/.well-known/apple-app-site-association
       

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

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

   Jeśli właściwość details jest pusta, sprawdź, czy podano poprawny prefiks identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może nie być taki sam jak identyfikator zespołu.

Dodaj Firebase do swojej aplikacji

1. Zaimportuj moduł FirebaseCore w pliku UIApplicationDelegate oraz wszystkie inne moduły Firebase, których używa delegowany obiekt 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;
   // ...
         

2. 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];

3. Jeśli używasz SwiftUI, musisz utworzyć obiekt delegujący aplikacji i dołączyć go do struktury App za pomocą funkcji UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć swizlowanie zastępników 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()
         }
       }
     }
   }
         

Korzystanie z konsoli Firebase

Jeśli chcesz wygenerować pojedynczy Dynamic Link na potrzeby testów lub aby umożliwić zespołowi marketingowemu łatwe tworzenie linków do wykorzystania w postach w mediach społecznościowych, najprostszym sposobem jest przejście do konsoli Firebase i ręczne utworzenie linku zgodnie z podanymi instrukcjami.

Korzystanie z interfejsu Builder API na iOS

Za pomocą interfejsu iOS Builder API możesz tworzyć Dynamic Links na podstawie parametrów lub skracać długie Dynamic Link.

Tworzenie Dynamic Link z parametrów

Aby utworzyć Dynamic Link, utwórz nowy obiekt DynamicLinkComponents i określ parametry Dynamic Link, ustawiając odpowiednie właściwości obiektu. Następnie uzyskaj długi link z właściwości url obiektu lub uzyskaj krótki link, wywołując funkcję shorten().

Ten minimalny przykład tworzy długi Dynamic Link do https://www.example.com/my-page, który otwiera się w aplikacji na iOS na iOS i w aplikacji com.example.android na Androidzie:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPrefix: dynamicLinksDomainURIPRefix)
linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                               domainURIPrefix:dynamicLinksDomainURIPrefix];
linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];

NSLog(@"The long URL is: %@", linkBuilder.url);

Aby utworzyć krótki Dynamic Link, utwórz DynamicLinkComponents w taki sam sposób, a potem wywołaj funkcję shorten().

Utworzenie krótkiego linku wymaga wywołania sieci, więc zamiast zwracania bezpośrednio linku funkcja shorten() przyjmuje procedurę obsługi zakończenia, która jest wywoływana po zakończeniu przetwarzania żądania. Przykład:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

[linkBuilder shortenWithCompletion:^(NSURL * _Nullable shortURL,
                                     NSArray<NSString *> * _Nullable warnings,
                                     NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];
      

Domyślnie krótkie Dynamic Links są generowane z 17-znakowymi sufiksami linków, które sprawiają, że bardzo mało prawdopodobne jest, aby ktoś zgadł prawidłowy Dynamic Link. Jeśli w Twoim przypadku nie ma znaczenia, czy ktoś zgadnie krótki link, możesz wygenerować sufiksy o długości wystarczającej do zapewnienia ich unikalności. Możesz to zrobić, ustawiając właściwość dynamicLinkComponentsOptions:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

linkBuilder.options = DynamicLinkComponentsOptions()
linkBuilder.options.pathLength = .short
linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

linkBuilder.dynamicLinkComponentsOptions = [[FIRDynamicLinkComponentsOptions alloc] init];
linkBuilder.dynamicLinkComponentsOptions.pathLength = FIRShortDynamicLinkPathLengthShort;
[linkBuilder shortenWithCompletion:^(NSURL * _Nullable shortURL,
                                     NSArray<NSString *> * _Nullable warnings,
                                     NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];
      

Liczba parametrów: Dynamic Link

Do tworzenia Dynamic Links za pomocą dowolnych obsługiwanych parametrów możesz użyć interfejsu Builder API.Dynamic Link Więcej informacji znajdziesz w dokumentacji interfejsu API.

W tym przykładzie Dynamic Link ma kilka typowych parametrów:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPRefix: dynamicLinksDomainURIPrefix)

linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.iOSParameters.appStoreID = "123456789"
linkBuilder.iOSParameters.minimumAppVersion = "1.2.3"

linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")
linkBuilder.androidParameters.minimumVersion = 123

linkBuilder.analyticsParameters = DynamicLinkGoogleAnalyticsParameters(source: "orkut",
                                                                       medium: "social",
                                                                       campaign: "example-promo")

linkBuilder.iTunesConnectParameters = DynamicLinkItunesConnectAnalyticsParameters()
linkBuilder.iTunesConnectParameters.providerToken = "123456"
linkBuilder.iTunesConnectParameters.campaignToken = "example-promo"

linkBuilder.socialMetaTagParameters = DynamicLinkSocialMetaTagParameters()
linkBuilder.socialMetaTagParameters.title = "Example of a Dynamic Link"
linkBuilder.socialMetaTagParameters.descriptionText = "This link works whether the app is installed or not!"
linkBuilder.socialMetaTagParameters.imageURL = "https://www.example.com/my-image.jpg"

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                         domainURIPrefix:dynamicLinksDomainURIPrefix];

linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.iOSParameters.appStoreID = @"123456789";
linkBuilder.iOSParameters.minimumAppVersion = @"1.2.3";

linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];
linkBuilder.androidParameters.minimumVersion = 123;

linkBuilder.analyticsParameters = [[FIRDynamicLinkGoogleAnalyticsParameters alloc]
                                   initWithSource:@"orkut"
                                           medium:@"social"
                                         campaign:@"example-promo"];

linkBuilder.iTunesConnectParameters = [[FIRDynamicLinkItunesConnectAnalyticsParameters alloc] init];
linkBuilder.iTunesConnectParameters.providerToken = @"123456";
linkBuilder.iTunesConnectParameters.campaignToken = @"example-promo";

linkBuilder.socialMetaTagParameters = [[FIRDynamicLinkSocialMetaTagParameters alloc] init];
linkBuilder.socialMetaTagParameters.title = @"Example of a Dynamic Link";
linkBuilder.socialMetaTagParameters.descriptionText = @"This link works whether the app is installed or not!";
linkBuilder.socialMetaTagParameters.imageURL = @"https://www.example.com/my-image.jpg";

NSLog(@"The long URL is: %@", linkBuilder.url);

Parametry Dynamic Link możesz ustawiać za pomocą tych obiektów i właściwości:

DynamicLinkComponents
link	Link, który otwiera aplikacja. Podaj adres URL, który może obsłużyć Twoja aplikacja, zwykle jest to zawartość lub ładunek aplikacji, który inicjuje logikę aplikacji (np. przyznawanie użytkownikowi kuponu lub wyświetlanie ekranu powitalnego). Link musi być poprawnie sformatowanym adresem URL, prawidłowo zakodowanym adresem URL, używać protokołu HTTP lub HTTPS i nie może być innym linkiem dynamicznym. Gdy użytkownicy otworzą Dynamic Link w przeglądarce na komputerze, wczytają ten adres URL (chyba że zostanie podany parametr ofl). Jeśli nie masz wersji internetowej treści dołączonych do linku, adres URL nie musi wskazywać na prawidłowy zasób internetowy. W takim przypadku musisz skonfigurować przekierowanie z tego adresu URL np. na stronę główną.
domainURIPrefix	prefiks adresu URL Dynamic Link, który znajdziesz w konsoli Firebase. Domena Dynamic Link wygląda tak: https://example.com/link https://example.page.link

DynamicLinkAndroidParameters
fallbackURL	Link do otwarcia, gdy aplikacja nie jest zainstalowana. Wpisz ten parametr, aby wykonać inne działanie niż instalacja aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana. Możesz na przykład otworzyć wersję mobilną treści w przeglądarce lub wyświetlić stronę promocyjną aplikacji.
minimumVersion	minimalnej wersji aplikacji, która może otworzyć link.versionCode Jeśli zainstalowana aplikacja jest w starszej wersji, użytkownik zostanie przekierowany do Sklepu Play, aby ją zaktualizować.

DynamicLinkIOSParameters
appStoreID	Identyfikator aplikacji w App Store, który służy do wysyłania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
fallbackURL	Link do otwarcia, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby wykonać inną czynność niż zainstalowanie aplikacji z App Store, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję mobilną treści w przeglądarce lub wyświetlić stronę promocyjną aplikacji.
customScheme	Niestandardowy schemat adresów URL aplikacji, jeśli jest zdefiniowany jako inny niż identyfikator pakietu aplikacji.
iPadFallbackURL	Link do otwarcia na iPadach, gdy aplikacja nie jest zainstalowana. Określ to, aby wykonać inną czynność niż zainstalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
iPadBundleID	Identyfikator pakietu aplikacji na iOS, której należy używać na iPadach do otwierania linku. Aplikacja musi być połączona z Twoim projektem na stronie Przegląd konsoli Firebase.
minimumAppVersion	Numer wersji minimalnej wersji aplikacji, która może otworzyć link. Ten parametr jest przekazywany do aplikacji po jej otwarciu, a ona musi zdecydować, co z nim zrobić.

DynamicLinkNavigationInfoParameters

forcedRedirectEnabled

Jeśli wartość to „1”, po otwarciu Dynamic Link pomiń stronę podglądu aplikacji i przekieruj użytkownika do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może skuteczniej kierować użytkowników do najbardziej odpowiedniego miejsca po kliknięciu Dynamic Links w aplikacjach. Jeśli jednak chcesz, aby Dynamic Link otwierał się tylko w aplikacjach, które mogą otwierać Dynamic Links bez tej strony, możesz wyłączyć ją za pomocą tego parametru. Ten parametr będzie miał wpływ na działanie Dynamic Link tylko na iOS.

DynamicLinkSocialMetaTagParameters
tytuł	Tytuł, który ma być używany podczas udostępniania Dynamic Link w postach w mediach społecznościowych.
descriptionText	Opis, który ma być używany, gdy Dynamic Link jest udostępniany w postach w mediach społecznościowych.
imageURL	Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary co najmniej 300 x 200 pikseli i nie więcej niż 300 KB.

DynamicLinkGoogleAnalyticsParameters
source medium campaign term content	Parametry Google Play. Te parametry (utm_source, utm_medium, utm_campaign, utm_term, utm_content) są przekazywane do Sklepu Play, a także dołączane do danych przesyłanych w linku.

DynamicLinkItunesConnectAnalyticsParameters
providerToken affiliateToken campaignToken	Parametry analityczne iTunes Connect. Te parametry (pt, at, ct) są przekazywane do App Store.

Skrócenie długiego Dynamic Link

Aby skrócić długi Dynamic Link, prześlij długi Dynamic Link do funkcji shortenURL(url:options:) wraz z obiektem DynamicLinkComponentsOptions, jeśli chcesz wygenerować link z krótkim sufiksem:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

DynamicLinkComponents.shortenURL(url: longLinkUrl, options: nil) { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

[FIRDynamicLinkComponents shortenURL:longLinkUrl
                             options:nil
                          completion:^(NSURL * _Nullable shortURL,
                                       NSArray<NSString *> * _Nullable warnings,
                                       NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];

Określanie niestandardowego schematu adresu URL dla Dynamic Links

Domyślnie Dynamic Links używa identyfikatora pakietu aplikacji jako schematu adresu URL potrzebnego do otwarcia aplikacji. Zalecamy zachowanie tej wartości domyślnej, aby uprościć implementację.

Deweloperzy, którzy już używają niestandardowego schematu URL do innych celów, mogą jednak chcieć użyć tego samego schematu w przypadku Dynamic Links. W takim przypadku możesz określić inny schemat adresu URL dla Firebase Dynamic Links, wykonując te czynności:

1. Podczas konfigurowania aplikacji przed skonfigurowaniem FirebaseApp wspólnej instancji należy określić domyślny schemat adresów URL, którego ma używać aplikacja:

   Swift

   Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

   func application(_ application: UIApplication,
                    didFinishLaunchingWithOptions launchOptions: [UIApplication
                      .LaunchOptionsKey: Any]?) -> Bool {
     // Set deepLinkURLScheme to the custom URL scheme you defined in your
     // Xcode project.
     FirebaseOptions.defaultOptions()?.deepLinkURLScheme = customURLScheme
     FirebaseApp.configure()
   
     return true
   }

   Objective-C

   Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS.

   - (BOOL)application:(UIApplication *)application
       didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
     // Set deepLinkURLScheme to the custom URL scheme you defined in your
     // Xcode project.
     [FIROptions defaultOptions].deepLinkURLScheme = CUSTOM_URL_SCHEME;
     [FIRApp configure];
   
     return YES;
   }

2. Podczas tworzenia Dynamic Link musisz podać niestandardowy schemat adresu URL, którego używa Twoja aplikacja. Możesz to zrobić w konsoli Firebase, ustawiając parametr customScheme w Builder API, podając parametr ius w adresie URL lub wysyłając parametr iosCustomScheme do interfejsu API typu REST.

Dalsze kroki

Po utworzeniu Dynamic Links musisz skonfigurować aplikację tak, aby odbierała Dynamic Links i kierowała użytkowników do odpowiedniego miejsca w aplikacji po otwarciu tych wiadomości.

Aby otrzymywać Dynamic Links w aplikacji, zapoznaj się z dokumentacją dotyczącą iOS, Androida, C++ i Unity.