iOS: Jak otevřít hluboké odkazy, oznámení a zkratky

Jeden nástroj, který jim všem vládne

Už jste někdy vytvořili aplikaci, která zpracovává oznámení Push? Pokud je vaše aplikace něco složitějšího než aplikace „Ahoj, svět!“, Je s největší pravděpodobností odpovědí ano.

A co otevření zástupců? Když všechna nová zařízení iOS podporují 3D dotek, stává se tato funkce něčím víc než jen příjemným doplňkem.

Podporuje vaše aplikace univerzální odkazy? Jedná se o relativně novou funkci, která se v moderních aplikacích stává populární. Pokud jej tedy nepoužíváte, můžete začít.

Dobrá věc je, že můžete snadno najít desítky učebních materiálů, příkladů a tutoriálů pro každé z těchto tří témat.

Co ale vaše aplikace musí podporovat všechny tyto funkce? Opravdu ji musíte implementovat jako tři samostatné komponenty?

Než budeme pokračovat, vysvětlíme si podmínky:

  1. Universal Links je způsob, jak zachytit některé adresy URL a namísto zpracování adresy URL v prohlížeči Safari otevřete konkrétní stránku aplikace. Univerzální odkazy vyžadují nějakou backendovou práci, takže se budeme držet Deep Links v tomto tutoriálu. Hluboké odkazy fungují podobně, ale zpracovává vlastní schémata adres URL. Jeho implementace se příliš neliší, takže nebude obtížné přidat podporu Universal Links, pokud ji budete potřebovat.
  2. Zkratka je způsob, jak spustit na konkrétní stránce na základě vybrané položky zástupce, když vynutíte stisknutí ikony aplikace. Tato funkce vyžaduje zařízení podporující 3d-touch.
  3. Upozornění: Když klepnete na oznámení (vzdálené nebo místní), aplikace se spustí na konkrétní stránce nebo provede určité akce.

Z tohoto popisu můžete vidět, že všechny tyto tři funkce jsou pouze různými typy stejné podstaty: když aplikace zpracovává kteroukoli z nich, spustí se z určité stránky.

Apple to nazval Launching Options, které jsou zpracovávány metodou AppDelegate didFinishLaunchingWithOptions.

Pokud však jde o implementaci všech možností spouštění, stává se matoucí a často vede ke stovkám řádků redundantního kódu. Implementace se stává ještě složitější, když se aplikace nespouští, ale vstupuje do režimu popředí. Zpracování zkratek, hluboké propojení a zpracování oznámení probíhá u různých metod delegování a zdá se, že nemají nic společného.

Abych to objasnil, uvedu to znovu: všechny tyto funkce slouží stejnému účelu - otevření konkrétní stránky aplikace.

Otázkou je, jak zajistit, aby to všechno fungovalo společně pěkným a čistým způsobem.

Nastavení projektu

Než začneme implementovat některou z možností spuštění, vytvořte seznam stránek, ke kterým chcete přistupovat. Řekněme, že vytváříme aplikaci pro rezervace bytů a chceme mít rychlý přístup k následujícím částem:

  • Stránka Moje zprávy (náhled): přístupná prostřednictvím zástupce
  • Zprávy (konkrétní chat): dostupné prostřednictvím oznámení push
  • Vytvořit nový zápis: přístupný prostřednictvím zástupce pouze pro profil hostitele
  • Moje aktivita: dostupná prostřednictvím zástupce
  • Žádost o rezervaci: přístupná prostřednictvím e-mailového odkazu (přímý odkaz) a oznámení push

Nejprve vytvořte jednoduchý projekt s ViewControllerem, názvem navigace a tlačítkem Přepnout profil:

Nastavení projektu

View Controller bude mít aktuální typ profilu a mechanismus pro přepínání mezi profily.

Nepoužívám žádné vzory softwarového designu, protože to není součástí tohoto tutoriálu. Ve skutečné aplikaci budete muset najít lepší strukturu, než jen ukládat ProfileType přímo v ViewControlleru.
enum ProfileType: String {
   case guest = "Guest" // default
   case host = "Host"
}
třída ViewController: UIViewController {
   var currentProfile = ProfileType.guest
   přepsat func viewDidLoad () {
      super.viewDidLoad ()
      configureFor (profilType: currentProfile)
   }
   @IBAction func didPressSwitchProfile (_ sender: Any) {
      currentProfile = currentProfile == .guest? .host: .guest
      configureFor (profilType: currentProfile)
   }
   funcfigurFor (profileType: ProfileType) {
      title = profileType.rawValue
   }
}

Jeden nástroj, který jim všem vládne

Chcete-li narovnat účel tohoto článku, když otevřeme konkrétní stránku aplikace, budu to nazývat Hluboký odkaz, bez ohledu na to, jaký mechanismus používáme.

Nyní, když máme základní strukturu a uživatelské rozhraní, uspořádáme náš seznam prvků Deep Link:

enum DeeplinkType {
   výčet zpráv {
      kořen případu
      podrobnosti případu (id: String)
   }
   případové zprávy (zprávy)
   činnost případu
   případ newListing
   žádost o případ (id: String)
}
V tomto tutoriálu se nebudu zabývat teorií rychlého výčtu. Zde si můžete přečíst, pokud potřebujete vysvětlení, jak používat vnořené výčty a výčty s přidruženými hodnotami.

Dále můžeme vytvořit singleton manažera, který bude mít všechny možnosti Deep Linking:

nechat Deeplinker = DeepLinkManager ()
class DeepLinkManager {
   fileprivate init () {}
}

Přidejte volitelnou vlastnost, která bude držet aktuální DeeplinkType:

nechat Deeplinker = DeepLinkManager ()
class DeepLinkManager {
   fileprivate init () {}
   private var deeplinkType: DeeplinkType?
}

Na základě tohoto typu deeplinkType se aplikace rozhodne, kterou stránku má otevřít:

nechat Deeplinker = DeepLinkManager ()
class DeepLinkManager {
   fileprivate init () {}
   private var deeplinkType: DeeplinkType?
   // zkontrolovat existující deeplikaci a provést akci
   func checkDeepLink () {
   }
}

Ať už aplikace spouští nebo vstupuje do režimu popředí, bude volat metodu didBecomeActive appDelegate. Zde zkontrolujeme všechny existující přímé odkazy, které zvládneme:

func applicationDidBecomeActive (_ application: UIApplication) {
   // zpracovat jakýkoli deeplink
   Deeplinker.checkDeepLink ()
}

Pokaždé, když se aplikace stane aktivní, zkontroluje, zda existuje přímý odkaz na otevření. Vytvořme třídu navigátoru, která otevře konkrétní stránku aplikace na základě typu DeeplinkType:

class DeeplinkNavigator {
   static let shared = DeeplinkNavigator ()
   soukromý init () {}
   
   funcceedToDeeplink (_ type: DeeplinkType) {
   }
}

V tomto tutoriálu jednoduše zobrazíme upozornění s názvem typu DeeplinkType, který jsme zpracovali:

private var alertController = UIAlertController ()
private func displayAlert (title: String) {
   alertController = UIAlertController (název: název, zpráva: nula, preferovaný typ: .alert)
   let okButton = UIAlertAction (název: "Ok", styl: default, handler: nil)
   alertController.addAction (okButton)
   if let vc = UIApplication.shared.keyWindow? .rootViewController {
      if vc.presentedViewController! = nil {
         alertController.dismiss (animovaný: false, dokončení: {
            vc.present (self.alertController, animated: true, complete: nil)
         })
      } jinde {
          vc.present (alertController, animated: true, complete: nil)
      }
   }
}

VceedToDeeplink přepínáme mezi DeeplinkTypes a rozhodujeme, jaké upozornění zobrazit:

funcceedToDeeplink (_ type: DeeplinkType) {
   typ přepínače {
   případová činnost:
      displayAlert (title: "Activity")
   případové zprávy (.root):
      displayAlert (title: "Root Messages")
   case .messages (.details (id: let id)):
      displayAlert (title: "Podrobnosti o zprávách \ (id)")
   case .newListing:
      displayAlert (title: "New Listing")
   case .request (id: let id):
      displayAlert (title: "Podrobnosti požadavku \ (id)")
   }
}

Vraťte se do DeepLinkManageru a použijte navigátor ke zpracování deepLink:

// zkontrolovat existující deeplikaci a provést akci
func checkDeepLink () {
   stráž nechal deeplinkType = deeplinkType else {
      vrátit se
   }
 
   DeeplinkNavigator.shared.proceedToDeeplink (deeplinkType)
   // reset deeplink po zpracování
   self.deeplinkType = nula // (1)
}
Nezapomeňte resetovat deepLink na nulu (1) po jeho použití. Jinak bude stejný odkaz zpracován při příštím otevření aplikace.

Nyní musíme jen zkontrolovat, zda je třeba zpracovat nějaké přímé odkazy (zkratky, přímé odkazy nebo oznámení), analyzovat je na DeeplinkType a dát jim DeepLinkManager.

Nejprve musíme udělat základní nastavení pro zástupce, přímé odkazy a oznámení.

Chceme, aby DeepLinkManager zvládl jakýkoli druh přímých odkazů, pamatujte však na SRP (princip jediné odpovědnosti): nebudeme kombinovat způsoby, jak analyzujeme různé typy přímých odkazů.

Klávesové zkratky

Běžným způsobem vytváření statických zástupců je použití souboru info.plist. Zde je krátký návod, pokud si to chcete prohlédnout.

V našem případě budou některé zkratky dynamické. Takže uděláme vše v kódu. Tato metoda vám dává větší flexibilitu a kontrolu a ve skutečnosti je mnohem snáze pochopitelná.

Nejprve vytvoříme ShortcutParser. Tato třída bude zodpovědná pouze za zkratky.

class ShortcutParser {
   static let shared = ShortcutParser ()
   soukromý init () {}
}

Pak musíme definovat možné klávesové zkratky:

enum ShortcutKey: String {
   case newListing = "com.myApp.newListing"
   case activity = "com.myApp.activity"
   case messages = "com.MyApp.messages"
}

V ShortcutParser vytvoříme metodu registerShortcutsFor, která zaregistruje zástupce pro různé typy uživatelů.

func registerShortcuts (pro profileType: ProfileType) {
   let activityIcon = UIApplicationShortcutIcon (templateImageName: "Alert Icon")
   let activityShortcutItem = UIApplicationShortcutItem (typ: ShortcutKey.activity.rawValue, localizedTitle: "Nedávná aktivita", localizedSubtitle: nil, ikona: activityIcon, userInfo: nil)
   let messageIcon = UIApplicationShortcutIcon (templateImageName: "Messenger Icon")
   let messageShortcutItem = UIApplicationShortcutItem (typ: ShortcutKey.messages.rawValue, localizedTitle: "Messages", localizedSubtitle: nil, icon: messageIcon, userInfo: nil)
   UIApplication.shared.shortcutItems = [activityShortcutItem, messageShortcutItem]
switch profileType {
      případ .host:
         let newListingIcon = UIApplicationShortcutIcon (templateImageName: "Nová ikona seznamu")
         let newListingShortcutItem = UIApplicationShortcutItem (typ: ShortcutKey.newListing.rawValue, localizedTitle: "New Listing", localizedSubtitle: nil, ikona: newListingIcon, userInfo: nil)
    UIApplication.shared.shortcutItems? .Append (newListingShortcutItem)
      případ .guest:
         přestávka
   }
}

Vytváříme activityShortcutItem a messageShortcutItem pro oba typy profilů. Pokud je aktuálním uživatelem hostitel, přidáme newListingShortcutItem. Pro každou zkratku používáme UIApplicationShortcutIcon (tato ikona se zobrazí vedle názvu zkratky, když se dotknete ikony aplikace).

Tuto metodu budeme volat z našeho ViewControlleru: když uživatel přepne profil, budou zkratky překonfigurovány na základě nového typu profilu:

funcfigurFor (profileType: ProfileType) {
   title = profileType.rawValue
   ShortcutParser.registerShortcuts (pro: profileType)
}
Pro statické zkratky je lepší nastavit zkratky z appDelegate, takže aplikace nemusí načíst ViewController před tím, než nastaví zkratky

Vytvořte a spusťte aplikaci a otestujte její chování:

  1. Klepnutím na ikonu aplikace zobrazíte možnosti zástupců
  2. Přepněte profil
  3. Chcete-li zobrazit další sadu možností klávesových zkratek, znovu klepněte na ikonu aplikace

Pokud však klepnete na některou z klávesových zkratek, aplikace se otevře pouze na výchozí stránce. Důvodem je, že jsme do aplikace přidali pouze zástupce, ale dosud jsme jí neřekli, jak s nimi zacházet.

Přepněte do AppDelegate a přidejte metodu delegování performActionForShortcutItem:

// MARK: Klávesové zkratky
func application (_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completeHandler: @escaping (Bool) -> Void) {
}

Tato metoda zjistí, kdy je zkratka spuštěna, a completeHandler sdělí delegátovi, zda ji má či nemá zpracovat. V aplikaci appDelegate opět neuvidíme žádnou zkratkovou logiku. Místo toho vytvoříme v DeeplinkManageru metodu:

@discardableResult
func handleShortcut (item: UIApplicationShortcutItem) -> Bool {
   deeplinkType = ... // zde budeme analyzovat položku
   return deeplinkType! = nula
}

Tato metoda se nejprve pokusí analyzovat položku zástupce na DeeplinkType a poté vrátí booleovskou hodnotu s uvedením, zda analýza byla úspěšná nebo ne. Současně uloží analyzovanou zkratku do proměnné deeplinkType.

@discardableResult říká kompilátoru, aby ignoroval výslednou hodnotu, pokud ji nepoužíváme, takže nemáme varování „nepoužitý výsledek“

Návrat na appDelegate a kompletní metodu performActionFor:

// MARK: Klávesové zkratky
func application (_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completeHandler: @escaping (Bool) -> Void) {
   dokončeníHandler (Deeplinker.handleShortcut (item: shortcutItem))
}

Poslední věcí, kterou musíme udělat, je analyzovat položku zástupce na DeeplinkType. Již máme třídu ShortcutParser, která je zodpovědná za všechny akce související se zkratkami. Přidat další metodu:

func handleShortcut (_ zkratka: UIApplicationShortcutItem) -> DeeplinkType? {
   switch shortcut.type {
   case ShortcutKey.activity.rawValue:
      návratnost
   case ShortcutKey.messages.rawValue:
      return .messages (.root)
   case ShortcutKey.newListing.rawValue:
      return .newListing
   výchozí:
      návrat nula
   }
}

Nyní se vraťte do DeeplinkManageru a dokončete metodu handleShortcut:

@discardableResult
func handleShortcut (item: UIApplicationShortcutItem) -> Bool {
   deeplinkType = ShortcutParser.shared.handleShortcut (položka)
   return deeplinkType! = nula
}

To je všechno nastavení, které musíme zvládnout s klávesovými zkratkami! Podívejme se na to znovu krok za krokem. Když klepneme na ikonu zástupce:

  1. Akce zástupce spustí metodu appDelegate performActionForShortcutItem
  2. metoda performActionForShortcutItem předá ShortcutItem DeeplinkManager
  3. DeeplinkManager se pokusí analyzovat ShortcutItem na DeeplinkType pomocí ShortcutParser
  4. Na applicationDidBecomeActive provedeme kontrolu všech DeeplinkTypes
  5. Pokud DeeplinkType existuje (to znamená, že krok 3 je úspěšný), provedeme příslušnou akci pomocí DeeplinkNavigator
  6. Jakmile je zkratka zpracována, DeeplinkManager resetuje aktuální položku zástupce na nulu, takže ji nebude možné znovu použít

Spusťte aplikaci a otestujte, jak to funguje ve 2 scénářích: když se aplikace spustí z uzavřeného stavu a kdy se aplikace obnovuje z režimu na pozadí. V obou případech by se upozornění mělo zobrazit s příslušnou zprávou:

Hluboké odkazy

Deeplinks, se kterými budeme pracovat, budou mít následující formát:

deeplinkTutorial: // messages / 1
deeplinkTutorial: // request / 1

Zkopírujte a uložte tyto adresy URL v poznámkách na testovacím zařízení. Pokud klepnete na některý z odkazů, nic se nestane.

Pokud se jednalo o univerzální odkaz, klepnutím na odkaz se otevře prohlížeč s adresou URL odkazu.

Až skončíme s touto částí, klepnutím na adresu URL se otevře příslušná stránka v naší aplikaci.

AppDelegate zjistí, zda byla aplikace otevřena s deeplink URL, a spustí metodu openUrl:

// MARK: Deeplinks
func application (_ app: UIApplication, open url: URL, options: [UIApplicationOpenURLOptionsKey: Any] = [:]) -> Bool {
}

Návratová hodnota řekne delegátovi, zda má nebo nemá otevřít URL.

Pokud chcete podporovat univerzální odkazy (představené v iOS9), přidejte také následující metodu delegování:

// MARK: Universal Links
func application (_ application: UIApplication, pokračovat userActivity: NSUserActivity, restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
   if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
      if let url = userActivity.webpageURL {
         
      }
   }
   vrátit nepravdivé
}
Aplikace ContunueUserActivity se také spustí, když spustíte aplikaci prostřednictvím položek Spotlighs (nejsou pokryty v tomto tutoriálu).

Podle stejného vzoru, jaký jsme použili pro zástupce, vytvoříme DeeplinkParser:

class DeeplinkParser {
   static let shared = DeeplinkParser ()
   soukromý init () {}
}

Abychom analyzovali Deeplink, vytvořili jsme metodu, která vezme URL a vrací volitelný DeeplinkType:

func parseDeepLink (_ url: URL) -> DeeplinkType? {
   guard let components = URLComponents (url: url, resolutionAgainstBaseURL: true), nechť host = components.host else {
      návrat nula
   }
   var pathComponents = components.path.components (oddělenýBy: "/")
   // první komponenta je prázdná
   pathComponents.removeFirst ()
   přepnout hostitele {
   případ "zprávy":
      if nechat messageId = pathComponents.first {
         return DeeplinkType.messages (.details (id: messageId))
      }
   případ "žádost":
      if nechť requestId = pathComponents.first {
         return DeeplinkType.request (id: requestId)
      }
   výchozí:
      přestávka
   }
   návrat nula
}
Tato metoda syntaktické analýzy bude záviset na struktuře deeplinku a moje řešení je pouze příkladem.

Nyní můžeme připojit tento analyzátor k naší hlavní třídě deeplinku. Přidejte tuto metodu do DeeplinkManager:

@discardableResult
func handleDeeplink (url: URL) -> Bool {
   deeplinkType = DeeplinkParser.shared.parseDeepLink (url)
   return deeplinkType! = nula
}

V aplikaci appDelegate dokončujeme metody openUrl a ContinueUserActivity:

// MARK: Deeplinks
func application (_ app: UIApplication, open url: URL, options: [UIApplicationOpenURLOptionsKey: Any] = [:]) -> Bool {
   return Deeplinker.handleDeeplink (url: url)
}
// MARK: Universal Links
func application (_ application: UIApplication, pokračovat userActivity: NSUserActivity, restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
   if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
      if let url = userActivity.webpageURL {
         return Deeplinker.handleDeeplink (url: url)
      }
   }
   vrátit nepravdivé
}

Musíme udělat ještě jednu věc: sdělte naší aplikaci, jaký druh odkazu by měl detekovat. Přidejte tento zlomek kódu do souboru info.plist (klikněte pravým tlačítkem na info.plist -> Otevřít jako -> Zdrojový kód):

 CFBundleURLTypes 

   
       CFBundleURLName 
       com.deeplinkTut.Deeplink 
       CFBundleURLSchemes 
      
          deeplinkTutorial 
      
   
Ujistěte se, že nenarušujete strukturu souborů XML.

Jakmile přidáte tento kód, zkuste otevřít seznam jako seznam vlastností. Měli byste vidět následující řádky:

Aplikace to vyzve, aby detekovala pouze odkazy s adresou URL „deeplinkTutorial“.

Podívejme se znovu na všechny kroky:

  1. Uživatel klepne na deeplink mimo aplikaci
  2. AppDelegate detekuje odkaz a spustí metodu delegování openUrl (nebo metodu delegování ContinueUserActivity pro univerzální odkazy)
  3. metoda openUrl předá odkaz Správci Deeplink
  4. Deeplink Manager se pokusí analyzovat odkaz na Deeplink Type pomocí DeeplinkParser
  5. Na applicationDidBecomeActive provedeme kontrolu všech DeeplinkTypes
  6. Pokud DeeplinkType existuje (to znamená, že krok 4 je úspěšný), provedeme příslušnou akci pomocí DeeplinkNavigator
  7. Jakmile je zkratka zpracována, DeeplinkManager resetuje aktuální položku zástupce na nulu, takže ji nebude možné znovu použít

Spusťte aplikaci a zkuste otevřít odkaz, který jste si uložili do svých poznámek:

Oznámení

Konfigurace projektu na podporu oznámení push není součástí tohoto tutoriálu, ale podrobné příklady najdete zde a zde.

K odeslání oznámení APNS můžete použít místní server a PusherAPI (to je jeden z jednoduchých způsobů).

Pokrýváme pouze část mezi klepnutím na oznámení push a zobrazením výsledku.

Když je aplikace zavřená nebo spuštěna na pozadí více, klepnutím na oznamovací pruh se spustí metoda didReceiveRemoteNotification appDelegate:

func application (_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any], fetchCompletionHandler dokončeníHandler: @escaping (UIBackgroundFetchResult) -> Void) {
   
}
Tato metoda bude také spuštěna, když aplikace obdrží oznámení push, když je spuštěna v režimu popředí. Protože zvažujeme scénáře pouze tehdy, když chcete aplikaci otevřít na určité stránce, nebudeme se zabývat oznámeními o zpracování v režimu popředí.

Pro zpracování oznámení vytvoříme program NotificationParser:

class NotificationParser {
   static let shared = NotificationParser ()
   soukromý init () {}
   func handleNotification (_ userInfo: [AnyHashable: Any]) -> DeeplinkType? {
      návrat nula
   }
}

Nyní můžeme tuto metodu připojit ke Správci Deeplink:

func handleRemoteNotification (_ upozornění: [AnyHashable: Any]) {
   deeplinkType = NotificationParser.shared.handleNotification (upozornění)
}

A dokončete metodu appDelegate didReceiveRemoteNotification:

func application (_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any], fetchCompletionHandler dokončeníHandler: @escaping (UIBackgroundFetchResult) -> Void) {
   Deeplinker.handleRemoteNotification (userInfo)
}

Posledním krokem je dokončení metody analýzy v programu NotificationParser. To bude záviset na struktuře vašich oznámení, ale základní technika analýzy bude podobná:

func handleNotification (_ userInfo: [AnyHashable: Any]) -> DeeplinkType? {
   pokud nechť data = userInfo ["data"] jako? [Řetězec: Libovolný] {
      pokud nechat messageId = data ["messageId"] jako? Řetězec {
         return DeeplinkType.messages (.details (id: messageId))
      }
   }
   návrat nula
}

Pokud jste nakonfigurovali aplikaci tak, aby podporovala oznámení push a chcete ji vyzkoušet, zde je oznámení, které používám k doručení zprávy:

apns: {
    aps: {
        upozornění: {
            název: „Nová zpráva!“,
            podnadpis: „“,
            tělo: "Ahoj!"
        },
        "mutable-content": 0,
        kategorie: "pusher"
    },
    data: {
        "messageId": "1"
    }
}
Používám místní NodeJS server a Pusher API pro zasílání oznámení v tomto tutoriálu. Nastavení trvá jen několik minut a vyžaduje základní znalost NodeJS nebo některé dovednosti vkládání kopií.

Spusťte aplikaci, přejděte do režimu na pozadí a odešlete oznámení. Jakmile obdržíte oznámení, klepnutím na něj otevřete aplikaci:

Co se děje za scénou:

  1. Když klepnete na oznámení, aplikace spustí metodu delegování didReceiveRemoteNotification
  2. didReceiveRemoteNotification předá informace o oznámení správci Deeplink
  3. Správce Deeplink se pokusí analyzovat informace o uživateli oznámení na typ Deeplink pomocí nástroje NotificationParser
  4. Na applicationDidBecomeActive provedeme kontrolu všech DeeplinkTypes
  5. Pokud DeeplinkType existuje (to znamená, že krok 3 je úspěšný), provedeme příslušnou akci pomocí DeeplinkNavigator
  6. Jakmile je zkratka zpracována, DeeplinkManager resetuje aktuální položku zástupce na nulu, takže ji nebude možné znovu použít

Pomocí tohoto přístupu můžete snadno přidat nebo upravit kteroukoli položku bez významných změn kódu. A co je důležitější, můžete analyzovat jakýkoli deeplink pomocí vhodného analyzátoru. Chcete-li například přidat do obslužného programu Notification „New Request“, musíte pouze upravit metodu handleNotification v NotificationParser:

func handleNotification (_ userInfo: [AnyHashable: Any]) -> DeeplinkType? {
   pokud nechť data = userInfo ["data"] jako? [Řetězec: Libovolný] {
      pokud nechat messageId = data ["messageId"] jako? Řetězec {
         return DeeplinkType.messages (.details (id: messageId))
      }
      pokud nechat requestId = data ["requestId"] jako? Řetězec {
         return DeeplinkType.request (.details (id: requestId))
      }
   }
   návrat nula
}
Upozorňujeme, že nepoužíváme didFinishLaunchingWithOptions pro žádný z těchto deeplinků. Vše je zpracováno pomocí aplikaceDidBecomeActive.

Gratulujeme! Nyní má vaše aplikace univerzální podporu zástupců, odkazů a oznámení!

Podívejte se na závěrečný projekt zde:

Děkuji za přečtení! Pokud se vám tento tutoriál líbí, prosím stiskněte .

Píšu také pro blog American Express Engineering Blog. Podívejte se na moje další díla a díla mých talentovaných spolupracovníků na AmericanExpress.io.