Twórz dynamiczne linki na iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie lub długie linki dynamiczne. Ten interfejs API akceptuje albo długi link dynamiczny, albo obiekt zawierający parametry linku dynamicznego, i zwraca adresy URL, jak w poniższych przykładach:

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

Wymagania wstępne

Przed rozpoczęciem upewnij się, aby dodać Firebase do projektu iOS .

Skonfiguruj Firebase i pakiet SDK Linków dynamicznych

1. Dodaj Firebase do projektu iOS .
2. Zawierać następujące kapsułę w swoim Podfile :

   pod 'Firebase/Analytics'
   pod 'Firebase/DynamicLinks'
       

3. Run pod install i otworzyć utworzony .xcworkspace pliku.
4. W konsoli Firebase otwórz sekcję dynamiczne linki.

5. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i ustawiłeś prefiks URI dla linków dynamicznych, zrób to po wyświetleniu monitu.

   Jeśli masz już prefiks identyfikatora URI Dynamic Links, zanotuj go. Musisz go podać podczas automatycznego tworzenia Linków dynamicznych.

   

6. Zalecane: Określanie wzorców adresów URL dozwolony w swoich głębokich linków i awaryjnych połączeń. W ten sposób uniemożliwiasz nieautoryzowanym stronom tworzenie linków dynamicznych, które przekierowują z Twojej domeny do witryn, których nie kontrolujesz. Zobacz Pozwól wzory określonego adresu URL .

7. Upewnij się, że identyfikator App Store Twojej aplikacji i prefiks identyfikatora aplikacji są określone w ustawieniach aplikacji. Aby przeglądać i edytować ustawienia w aplikacji, przejdź do projektu Firebase za Ustawienia strony i wybierz swoją aplikację na iOS.

   Potwierdź, że Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania dynamiczne linki w aplikacji iOS otwierając apple-app-site-association plik, który jest gospodarzem na dynamiczne linki domenie. Firebase posłuży apple-app-site-association plik z katalogu głównego domeny, jak również .well-known podkatalogu. Na przykład:

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

   Jeśli aplikacja jest podłączony, apple-app-site-association plik zawiera odniesienie do aplikacji App ID prefiks i wiązki ID. Na przykład:

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

   Jeżeli details nieruchomość jest pusta, sprawdź, czy podano swój prefiks App ID. Pamiętaj, że prefiks identyfikatora aplikacji może nie być taki sam jak identyfikator zespołu.

Dodaj Firebase do swojej aplikacji

1. Zaimportować moduł Firebase w UIApplicationDelegate :

   Szybki

   import Firebase

   Cel C

   @import Firebase;

2. Skonfiguruj FirebaseApp wspólne wystąpienie, zazwyczaj w swojej aplikacji application:didFinishLaunchingWithOptions: metodę:

   Szybki

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

   Cel C

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

Użyj konsoli Firebase

Jeśli chcesz wygenerować pojedynczy Dynamic Link, zarówno w celach testowych lub dla zespołu marketingowego, aby łatwo utworzyć łącze, które można wykorzystać w czymś w rodzaju social media postu, najprostszym sposobem byłoby odwiedzić konsolę Firebase i utworzyć ręcznie postępując zgodnie z formularzem krok po kroku.

Użyj iOS Builder API

Możesz użyć interfejsu iOS Builder API do tworzenia dynamicznych linków z parametrów lub skrócenia długiego dynamicznego linku.

Utwórz łącze dynamiczne z parametrów

Aby utworzyć Dynamic Link, należy utworzyć nowy DynamicLinkComponents obiekt i określić parametry Dynamic Link poprzez ustawienie odpowiednich właściwości obiektu. Następnie czeka długi link z obiektu url własności lub uzyskać krótki link wywołując shorten() .

Poniższy przykład tworzy minimalny długą Dynamic Link do https://www.example.com/my-page że otwiera aplikacji iOS na iOS i aplikacja com.example.android na Androida:

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)")

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 stworzyć krótki Dynamic Link, zbudować DynamicLinkComponents w ten sam sposób, a następnie zadzwonić shorten() .

Budowanie krótki związek wymaga połączenia sieciowego, więc zamiast bezpośrednio powrocie link, shorten() akceptuje obsługi zakończenia, która jest wywoływana, gdy finalizuje życzenie. Na przykład:

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

[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 linki dynamiczne są generowane z 17-znakowymi sufiksami linków, co sprawia, że ​​jest bardzo mało prawdopodobne, aby ktoś mógł odgadnąć prawidłowy link dynamiczny. Jeśli w Twoim przypadku użycia, nie ma nic złego w ktoś z powodzeniem zgadywania krótki link, może wolisz, aby wygenerować przyrostków, które są tylko tak długo, jak to konieczne, aby być unikalny, co można zrobić poprzez ustawienie dynamicLinkComponentsOptions właściwość:

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)")
}

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);
}];
      

Parametry łącza dynamicznego

Możesz użyć interfejsu API Dynamic Link Builder do tworzenia dynamicznych linków z dowolnymi obsługiwanymi parametrami. Zobacz odniesienie API szczegóły.

Poniższy przykład tworzy łącze dynamiczne z kilkoma typowymi zestawami parametrów:

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)")

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);

Możesz ustawić parametry łącza dynamicznego z następującymi obiektami i właściwościami:

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

Skróć długi Dynamic Link

Aby skrócić długą Dynamic Link, przejść długą Dynamic Link do shortenURL(url:options:) wraz z DynamicLinkComponentsOptions sprzeciw jeśli chcesz wygenerować link z krótkim przyrostkiem:

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

[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 adresów URL dla Linków dynamicznych

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

Jednak programiści, którzy już używają niestandardowego schematu adresu URL do innych celów, mogą chcieć użyć tego samego niestandardowego schematu adresu URL również w swoich Linkach dynamicznych. W takiej sytuacji możesz określić inny schemat adresów URL dla Linków dynamicznych Firebase, wykonując te czynności:

1. Podczas konfigurowania aplikacji, upewnij się, że określenie domyślnego schematu URL być wykorzystywane przez aplikację przed skonfigurowaniem FirebaseApp udostępnionego instancji:

   Szybki

   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
   }
   

   Cel C

   - (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. Za każdym razem, gdy tworzysz link dynamiczny, musisz określić niestandardowy schemat adresu URL, z którego korzysta Twoja aplikacja. Można to zrobić za pomocą konsoli Firebase, ustawienie customScheme w API Builder, określając ius parametr w adresie URL, lub wysyłając iosCustomScheme parametr API REST

Następne kroki

Teraz, po utworzeniu linków dynamicznych, musisz skonfigurować swoją aplikację tak, aby odbierała linki dynamiczne i wysyłała użytkowników we właściwe miejsce w aplikacji po ich otwarciu.

Aby otrzymać dynamiczne linki w swojej aplikacji, zobacz dokumentację dla iOS , Androida , C ++ i Jedności .