Como configurar o roteamento do WKWebView para suportar Universal Links no iOS

opoinstall
2026-10-07
5 min read

Como posso habilitar Universal Links dentro de um WKWebView no iOS? Os Universal Links já podem ser resolvidos a partir de links compatíveis dentro de um WKWebView. A implementação do WKNavigationDelegate permite que o aplicativo host personalize as políticas de roteamento — interceptando destinos próprios do aplicativo, controlando handoffs externos via decidePolicyForNavigationAction e aplicando segurança em nível de frame.

Na arquitetura de aplicativos iOS, a interceptação de navegação do WKWebView permite que o aplicativo host personalize políticas de roteamento em Universal Links, esquemas de URL personalizados e destinos web. Ao avaliar metadados de solicitação de navegação dentro de um WKNavigationDelegate, o aplicativo pode rotear destinos internos, delegar alvos externos para manipuladores do sistema e aplicar políticas de segurança em nível de frame.

Termo Definição Entidade Relacionada Intenção de Busca
WebView Um componente de visualização baseado em WebKit que renderiza conteúdo web interativo dentro de aplicativos iOS. iOS SDK Informativa / Comercial
Universal Links Um mecanismo HTTPS padrão que vincula domínios web verificados a visualizações nativas do aplicativo iOS. Roteamento de Deep Link Técnica / Informativa
Custom URL Scheme Um esquema de URI definido pelo aplicativo usado para rotear URLs para um aplicativo nativo. Mobile Deep Linking Informativa

Como o WKWebView e o Roteamento de Universal Links interagem no iOS

O WKNavigationDelegate decide se o WebKit carrega, roteia internamente, transfere ou cancela.

Ciclos de vida de navegação do WebKit e políticas de roteamento internas

A Apple implementa Universal Links como um mecanismo de roteamento em nível de sistema suportado em ambientes Safari e WKWebView. Quando um usuário toca em um link compatível dentro de um WKWebView integrado, a plataforma pode resolver associações de domínio e rotear a execução de acordo com as políticas do sistema operacional.

Embora Universal Links reconhecidos pelo sistema possam transferir a execução para manipuladores nativos, ambientes de navegador integrados frequentemente exigem lógica de roteamento específica do aplicativo. Por exemplo, quando um link aponta para o domínio do próprio aplicativo, os desenvolvedores preferem navegar diretamente por view controllers nativos sem acionar reinicializações externas completas. Implementar WKNavigationDelegate fornece ao aplicativo host controle granular sobre a avaliação de links, permitindo que as equipes apliquem listas de permissões personalizadas e roteiem destinos internos de forma previsível.

A barreira da experiência do usuário: Quando a navegação web in-app aprisiona usuários em loops de redirecionamento

WebViews são frequentemente implantadas para hospedar microsites promocionais, centros de ajuda, catálogos de parceiros e landing pages de marketing dentro de aplicativos iOS. Quando uma página web integrada inclui links destinados a navegar usuários para outras seções do aplicativo host (ex: botões “Ver no App”) ou para aplicativos parceiros, a navegação padrão pode levar a renderizações redundantes:

  • Renderização web redundante: Em vez de renderizar view controllers nativos, o usuário pode ser apresentado a versões web responsivas de páginas do aplicativo, exigindo autenticações repetidas e degradando a consistência visual.
  • Aprisionamento web: Usuários podem ficar presos em pilhas de navegação web sem formas intuitivas de retornar às interfaces nativas primárias.
  • Falhas nas transições entre aplicativos: Tocar em links que apontam para serviços de terceiros (como aplicativos de navegação, diálogos de compartilhamento social ou gateways de pagamento) exige delegação explícita se esses serviços dependerem de esquemas de URL personalizados.

Comparando WKWebView com SFSafariViewController para Handoffs Web-to-App

Ao arquitetar navegação web in-app no iOS, as equipes de engenharia devem escolher entre WKWebView e SFSafariViewController:

  • SFSafariViewController: Fornece uma interface de navegação Safari gerenciada pelo sistema, com recursos como Preenchimento Automático e bloqueio de conteúdo. O aplicativo host não pode inspecionar a atividade de navegação ou dados do site, e a personalização da UI é limitada a cores de tonalidade.
  • WKWebView: Um componente de visualização integrado hospedado dentro do processo de UI do aplicativo, enquanto executa conteúdo web em processos WebKit separados. Ele permite personalização profunda de UI, pontes JavaScript e integração de layout personalizado, exigindo a implementação explícita de WKNavigationDelegate para personalizar políticas de roteamento e manipular esquemas personalizados definidos pelo app.

Como o decidePolicyForNavigationAction intercepta o roteamento do WebKit

O pipeline de política de navegação: Entendendo WKNavigationAction, request e decisionHandler

Para controlar o fluxo de navegação dentro de um WKWebView, os desenvolvedores atribuem um delegate personalizado em conformidade com as Diretrizes da Apple para WKNavigationDelegate. O ponto de interceptação primário é o método delegate:

func webView(
    _ webView: WKWebView,
    decidePolicyFor navigationAction: WKNavigationAction,
    decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
)

Ações de navegação acionadas por interações de usuário, redirecionamentos programáticos ou submissões de formulários passam por este método. O objeto WKNavigationAction fornece metadados chave:

  • navigationAction.request.url: A URL de destino solicitada.
  • navigationAction.navigationType: O tipo de gatilho (.linkActivated, .other, .formSubmitted).
  • navigationAction.sourceFrame: Informações sobre o frame que iniciou a solicitação de navegação.
  • navigationAction.targetFrame: Informações sobre o frame de destino onde o conteúdo deve ser carregado.

O decisionHandler é uma closure de conclusão que informa ao WebKit se deve permitir ou cancelar a navegação solicitada.

Quando retornar .allow vs .cancel: Controlando o ciclo de vida de carregamento de recursos do WebKit

A WKNavigationActionPolicy passada ao decisionHandler controla se o WebKit prossegue com a navegação:

  • .allow: Informa ao WebKit para prosseguir com a navegação solicitada dentro da web view.
  • .cancel: Instrui o WebKit a cancelar a navegação solicitada. Esta política é executada sempre que o aplicativo host intercepta um esquema personalizado, roteia um Universal Link internamente ou delega um alvo externo para UIApplication.shared.open().

O decisionHandler deve ser invocado exatamente uma vez por ação de navegação para garantir que a resolução da política de navegação prossiga sem interrupções.

Avaliando tipos de navegação: Distinguindo cliques de usuários (.linkActivated) de redirecionamentos automatizados

O WKNavigationAction.navigationType permite que os desenvolvedores distingam interações explícitas de usuários de scripts automatizados:

  • .linkActivated: O usuário tocou fisicamente em uma tag de âncora HTML (<a href="...">).
  • .other: Representa navegações programáticas, como atualizações window.location.href, meta refreshes ou chamadas iniciais webView.load().
  • .formSubmitted / .formResubmitted: Representa submissões de formulário POST ou GET.

Avaliar o navigationType permite que aplicativos apliquem uma política conservadora de link explícito em nível de aplicação. Para invocações de esquemas personalizados externos ou handoffs para aplicativos de terceiros, exigir .linkActivated como um gate de política ajuda a evitar que scripts em segundo plano acionem lançamentos externos automatizados.

Manipulando políticas de decisão assíncronas sem ciclos de retenção

Quando a validação de rota ou verificações de permissão exigirem consultar caches locais ou validadores de segurança antes de retornar uma decisão:

  1. Garanta que o decisionHandler seja executado em todos os caminhos de execução, incluindo condições de erro e de guarda.
  2. Use referências fracas ([weak self]) dentro de closures de escape para evitar ciclos de retenção entre o WKWebView, seu delegate e o UIViewController pai.

Diferenciando domínios associados do App host de Universal Links externos

Universal Links próprios do aplicativo devem validar e rotear internamente a partir do WKWebView.

Gerenciando destinos próprios do App vs. Delegação de link em nível de sistema

Para rotas próprias do aplicativo, evite tentar reentrar no mesmo aplicativo por meio de uma pesquisa redundante de Universal Link. Manipule destinos próprios diretamente através do roteador interno do aplicativo host e use a abertura do sistema principalmente para destinos que devem sair do aplicativo atual ou serem resolvidos por serviços externos.

Essa separação arquitetônica garante uma navegação fluida:

  • Domínios Associados do App Host: Se o host da URL corresponder ao domínio associado do próprio aplicativo (app.example.com), cancele a navegação da web view (decisionHandler(.cancel)), valide o caminho da rota e passe os parâmetros analisados diretamente para o roteador de navegação interno do aplicativo.
  • Aplicativos Externos: Se a URL apontar para um destino de parceiro externo ou um esquema personalizado permitido, aplique um gate de link explícito em nível de aplicação (navigationType == .linkActivated), cancele a navegação da web view e encaminhe a solicitação para UIApplication.shared.open(url) para permitir que o sistema operacional inicie o aplicativo externo.

Arquitetando a validação de rota interna: Extraindo caminhos e parâmetros de consulta via AppRouteValidator

Quando uma URL recebida corresponde ao domínio associado do aplicativo host, a string da URL deve passar por um validador de roteamento rigoroso antes de acionar transições de view controller.

O modelo AppRouteValidator:

  • Valida o caminho da URL contra uma lista de permissões de rotas internas suportadas (ex: /open/, /product/, /promo/, /checkout/).
  • Extrai parâmetros de consulta (ex: id, promo, utm_source).
  • Aplica restrições de conjunto de caracteres, limites de comprimento e rejeição de chaves duplicadas, retornando uma estrutura de dados ValidatedAppRoute limpa.

Manipulando Universal Links de terceiros via delegação de UIApplication do sistema

Universal Links externos podem tentar handoff nativo e retornar para a web.

Quando uma página web dentro de um WKWebView aponta para serviços externos (como apps de parceiros, plataformas sociais ou utilitários externos), o aplicativo host pode delegar o roteamento para o sistema iOS:

let options: [UIApplication.OpenExternalURLOptionsKey: Any] = [
    .universalLinksOnly: true
]
UIApplication.shared.open(url, options: options) { success in
    if !success {
        // Fallback da política do aplicativo: carregar destino web se nenhum aplicativo nativo manipular o Universal Link
    }
}

Usar .universalLinksOnly como política de aplicação garante que o usuário só seja transferido para fora do aplicativo atual se houver um aplicativo nativo verificado instalado para manipular o Universal Link.

Gerenciando fallbacks de esquemas de URL personalizados (myapp://) junto com HTTPS Universal Links

Embora os Universal Links HTTPS representem o deep linking padrão no iOS, esquemas personalizados definidos pelo app (myapp:// ou partnerapp://) permanecem comuns em campanhas promocionais e integrações de parceiros.

Em uma implementação unificada de WKNavigationDelegate:

  • Esquemas não-HTTP/HTTPS são inspecionados primeiro. Se o esquema corresponder a um protocolo personalizado permitido e satisfizer a política de link explícito (navigationType == .linkActivated), o delegate verifica o host, o caminho e os parâmetros antes de despachar para UIApplication.shared.open().
  • Esquemas não reconhecidos ou invocações de esquema em segundo plano não solicitadas são cancelados imediatamente, prevenindo erros de navegação não tratados ou inundações de intenção orientadas por script.
[Usuário interage com link dentro do WKWebView do iOS]
                       │
                       ▼
[WKNavigationDelegate: decidePolicyForNavigationAction]
                       │
         ┌─────────────┴─────────────┐
         ▼                           ▼
[!action.sourceFrame.isMainFrame] [action.sourceFrame.isMainFrame]
         │                           │
         ▼                           ▼
[Gate de Segurança de Subframe]       [Inspecionar Esquema e Host de Destino]
├─ HTTP(S) -> .allow                 │
└─ Não-Web -> .cancel    ┌───────────┼───────────┐
   (Suprimir Subframe)   ▼           ▼           ▼
                   [Domínio Host] [Web Externa] [Esquema Personalizado]
                         │           │           │
                         ▼           ▼           ▼
                   [AppRoute]    [Verificar Link]   [Verificar Link]
                   ├─ Válido ->   ├─ Parceiro ->   ├─ Válido e Clique ->
                   │  Interno     │  Abrir App      │  Abrir App
                   └─ Inválido ->  └─ Web ->      └─ Inválido/Auto ->
                      .cancel       .allow         .cancel

Como aplicar a segurança do Main Frame e prevenir sequestro de Iframe

A origem do frame do WKNavigationAction e o contexto de destino determinam a política de navegação segura.

Tratando a navegação web integrada como entrada não confiável: Padrões de segurança de Deep Link OWASP

De acordo com o Guia de Testes de Segurança de Aplicativos Móveis OWASP sobre Deep Links Inseguros, todas as URLs e payloads de parâmetros processados por manipuladores de navegação móvel devem ser tratados como entrada externa não confiável.

Páginas web renderizadas dentro de um WKWebView podem carregar scripts de terceiros, banners publicitários ou conteúdo gerado pelo usuário. Se um delegate de navegação encaminha URLs arbitrárias para view controllers nativos ou para UIApplication.shared.open() sem validação, parâmetros inesperados podem atingir rotas sensíveis do aplicativo interno.

Isolando navegações do Main Frame de Iframes integrados e alvos de nova janela

De acordo com a Documentação do desenvolvedor da Apple sobre WKNavigationAction, avaliar a segurança do frame requer verificar o frame de inicialização:

  • sourceFrame.isMainFrame == true: A navegação foi iniciada diretamente pelo frame do documento primário (top-level).
  • sourceFrame.isMainFrame == false: A navegação foi iniciada por um subframe ou iframe integrado.
  • targetFrame == nil: A navegação solicita um novo alvo de janela (como uma âncora com target="_blank").

Para evitar o sequestro de iframe — onde um iframe integrado tenta lançar aplicativos externos ou acionar transições de visualização nativa em segundo plano — o delegate deve avaliar sourceFrame.isMainFrame. Se o frame de inicialização for um iframe (sourceFrame.isMainFrame == false), permita a navegação padrão de subframe HTTP/HTTPS (.allow), mas bloqueie quaisquer esquemas personalizados não web ou handoffs de roteamento nativo (.cancel).

Prevenindo invocações de protocolo de subframe maliciosas e inundações de esquema em segundo plano

Aplicar verificações de frame de inicialização impede que subframes acionem invocações de esquema externo não solicitadas:

if !navigationAction.sourceFrame.isMainFrame {
    let scheme = url.scheme?.lowercased() ?? ""
    if scheme == "http" || scheme == "https" {
        decisionHandler(.allow) // Permitir navegação padrão de subframe HTTP(S)
    } else {
        decisionHandler(.cancel) // Suprimir esquemas não web de subframes
    }
    return
}

Aplicando listas de permissões rigorosas de caminho e parâmetros de consulta no roteamento do cliente

Tanto URLs de domínio associado interno quanto esquemas personalizados externos devem passar por modelos de validador rigorosos antes da execução:

  • Listas de permissões de prefixo de caminho: Aplique prefixos de rota aprovados (ex: /open/, /product/, /promo/, /checkout/), rejeitando caminhos arbitrários ou malformados.
  • Filtragem de chave de consulta: Descarte chaves de consulta inesperadas e rejeite chaves de parâmetro duplicadas para evitar poluição de parâmetros.
  • Restrições de tipo de dados e comprimento: Restrinja valores de parâmetro a conjuntos de caracteres alfanuméricos e aplique limites máximos de comprimento (≤64\le 64 caracteres).

Implementação de WKNavigationDelegate em produção com Swift

Estruturando CustomWebViewController e arquitetura de delegate em Swift

Um controlador WKWebView de produção coordena a configuração web, avaliação de política de navegação, roteamento interno e delegação externa. A implementação encapsula regras de validação dentro de classes validadoras dedicadas (AppRouteValidator e CustomSchemeValidator) para manter os callbacks de delegate limpos, testáveis e seguros.

Implementando modelos AppRouteValidator e CustomSchemeValidator

Os modelos de validador aplicam segurança rigorosa de fail-closed:

  • AppRouteValidator valida domínios associados internos, verificando prefixos de caminho e higienizando parâmetros de consulta em um objeto ValidatedAppRoute estruturado.
  • CustomSchemeValidator verifica esquemas personalizados autorizados (myapp), valida hosts permitidos (open, product, event) e higieniza valores de consulta.

O OpoInstall pode ser integrado junto a uma camada de roteamento pertencente ao aplicativo para atribuição e recuperação de parâmetros adiados. Revise a documentação de integração do SDK para guias completos de integração.

A implementação técnica abaixo demonstra como configurar um WKNavigationDelegate seguro em Swift:

// iOS: CustomWebViewController com Roteamento de WKNavigationDelegate Rigoroso e Segurança de Frame
// Exemplo de integração de referência. Verifique as assinaturas de método e mapeamentos de domínio contra sua arquitetura implantada.
import UIKit
import WebKit

struct ValidatedAppRoute {
    let path: String
    let queryParams: [String: String]
}

// 1. Validador para o Domínio Associado do Aplicativo Host (Rotas Internas)
class AppRouteValidator {
    private static let allowedPrefixes = ["/open/", "/product/", "/promo/", "/checkout/"]
    private static let allowedQueryKeys = Set(["target", "id", "promo", "utm_source"])

    static func validate(url: URL) -> ValidatedAppRoute? {
        let path = url.path
        // Aplicar lista de permissões de prefixo de caminho
        guard allowedPrefixes.contains(where: { path.hasPrefix($0) }) else {
            return nil
        }

        var sanitizedParams: [String: String] = [:]
        var seenKeys = Set<String>()

        if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
           let queryItems = components.queryItems {
            let validChars = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
            
            for item in queryItems {
                // Validação fail-closed: rejeitar URL se chaves de consulta não autorizadas ou duplicadas existirem
                guard allowedQueryKeys.contains(item.name), !seenKeys.contains(item.name) else { return nil }
                seenKeys.insert(item.name)

                let value = item.value ?? ""
                if value.count <= 64 && value.rangeOfCharacter(from: validChars.inverted) == nil {
                    sanitizedParams[item.name] = value
                } else {
                    return nil
                }
            }
        }

        return ValidatedAppRoute(path: path, queryParams: sanitizedParams)
    }
}

// 2. Validador para Esquemas Personalizados Externos (myapp://)
class CustomSchemeValidator {
    private static let allowedSchemes = Set(["myapp"])
    private static let allowedHosts = Set(["open", "product", "event"])
    private static let allowedPathPrefixes = ["/detail/", "/view/", "/main/"]
    private static let allowedQueryKeys = Set(["target", "id", "promo", "utm_source"])

    static func validate(url: URL) -> URL? {
        guard let scheme = url.scheme?.lowercased(), allowedSchemes.contains(scheme) else {
            return nil
        }
        guard let host = url.host?.lowercased(), allowedHosts.contains(host) else {
            return nil
        }

        let path = url.path
        if !path.isEmpty && !allowedPathPrefixes.contains(where: { path.hasPrefix($0) }) {
            return nil
        }

        var seenKeys = Set<String>()
        if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
           let queryItems = components.queryItems {
            let validChars = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
            for item in queryItems {
                guard allowedQueryKeys.contains(item.name), !seenKeys.contains(item.name) else { return nil }
                seenKeys.insert(item.name)

                let value = item.value ?? ""
                if value.count > 64 || value.rangeOfCharacter(from: validChars.inverted) != nil {
                    return nil
                }
            }
        }

        return url
    }
}

// 3. UIViewController Hospedando WKWebView com Interceptação de Política de Navegação Segura
class CustomWebViewController: UIViewController, WKNavigationDelegate {

    var webView: WKWebView!
    private let hostAssociatedDomain = "app.example.com"
    private let allowedExternalPartnerHosts = Set(["partner.example.com"])

    override func viewDidLoad() {
        super.viewDidLoad()

        let configuration = WKWebViewConfiguration()
        webView = WKWebView(frame: view.bounds, configuration: configuration)
        webView.navigationDelegate = self
        view.addSubview(webView)
    }

    func webView(
        _ webView: WKWebView,
        decidePolicyFor navigationAction: WKNavigationAction,
        decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
    ) {
        guard let url = navigationAction.request.url else {
            decisionHandler(.allow)
            return
        }

        // Verificação de Segurança 1: Aplicar fronteira de frame de inicialização (sourceFrame) para prevenir sequestro de iframe
        if !navigationAction.sourceFrame.isMainFrame {
            let scheme = url.scheme?.lowercased() ?? ""
            if scheme == "http" || scheme == "https" {
                decisionHandler(.allow) // Permitir navegação de subframe HTTP(S) padrão
            } else {
                decisionHandler(.cancel) // Suprimir esquemas não web de subframes/iframes
            }
            return
        }

        let scheme = url.scheme?.lowercased() ?? ""
        let isExplicitLinkActivation = (navigationAction.navigationType == .linkActivated)

        // Verificação de Segurança 2: Manipular Domínio Associado do próprio App Host
        // Roteie internamente em vez de chamar UIApplication.shared.open
        if scheme == "https", let host = url.host?.lowercased(), host == hostAssociatedDomain {
            if let validatedRoute = AppRouteValidator.validate(url: url) {
                AppInternalRouter.shared.navigate(to: validatedRoute)
            }
            decisionHandler(.cancel) // Cancelar carregamento na webview para rotear internamente
            return
        }

        // Verificação de Segurança 3: Manipular Esquemas Personalizados Permitidos (myapp://) com Política de Ativação de Link
        if scheme != "http" && scheme != "https" && scheme != "about" {
            // Garantir que lançamentos de aplicativos externos por esquema personalizado exijam ativação de link explícita do usuário
            if isExplicitLinkActivation, let validatedURL = CustomSchemeValidator.validate(url: url) {
                UIApplication.shared.open(validatedURL, options: [:], completionHandler: nil)
            }
            decisionHandler(.cancel) // Cancelar carregamento na webview para evitar erros de esquema não tratados
            return
        }

        // Verificação de Segurança 4: Manipular Destinos Externos e Solicitações de Nova Janela (target="_blank")
        if scheme == "http" || scheme == "https" {
            let host = url.host?.lowercased() ?? ""
            
            // Delegar Universal Links de parceiros verificados para app externo com política de link explícito
            if allowedExternalPartnerHosts.contains(host) && isExplicitLinkActivation {
                let options: [UIApplication.OpenExternalURLOptionsKey: Any] = [
                    .universalLinksOnly: true
                ]
                UIApplication.shared.open(url, options: options) { [weak self] success in
                    if !success {
                        // Fallback da política do aplicativo: carregar destino de parceiro externo dentro da web view se nenhum app nativo o manipular
                        guard let self = self else { return }
                        self.webView.load(navigationAction.request)
                    }
                }
                decisionHandler(.cancel)
                return
            }

            // Se targetFrame for nil (solicitação de nova janela), carregar com segurança na webView atual
            if navigationAction.targetFrame == nil {
                webView.load(navigationAction.request)
                decisionHandler(.cancel)
                return
            }

            // Conteúdo web padrão continua carregando dentro do WKWebView
            decisionHandler(.allow)
            return
        }

        decisionHandler(.allow)
    }
}

// Placeholder do roteador interno específico do aplicativo (não uma API do OpoInstall SDK)
class AppInternalRouter {
    static let shared = AppInternalRouter()

    func navigate(to route: ValidatedAppRoute) {
        // Executar transição de view controller de UI interno com base no caminho e parâmetros de consulta
    }
}

Execução Thread-Safe: Garantindo que as transições de UI sejam executadas no Main Actor

Nos modelos atuais de concorrência do Swift, os callbacks do WKNavigationDelegate são isolados no Main Actor. O roteamento de aplicativos e as transições de view controller são executados no Main Actor, mantendo a thread-safety em fluxos de trabalho de navegação nativos.

Erros de navegação de Deep Link no WKWebView e Matriz de Diagnóstico

Guia abrangente de solução de problemas de Deep Linking em WKWebView no iOS

A matriz abaixo descreve modos de falha comuns encontrados ao gerenciar deep links e esquemas personalizados dentro de WKWebView no iOS, junto com causas raízes primárias e remediações de engenharia recomendadas:

Assinatura de Erro / Sintoma Causa Raiz Primária Versões do iOS Ponto de verificação de diagnóstico Remediação Recomendada
Universal Link carrega na Web Domínio do aplicativo não interceptado iOS 9+ decidePolicyForNavigationAction não tratado Interceptar domínio host, analisar caminho, rotear internamente, .cancel
Link de domínio próprio falha ao rotear Chamada de UIApplication.open no próprio domínio iOS 9+ UIApplication.shared.open chamado no próprio host Evitar abertura externa própria; rotear diretamente para o roteador interno
Esquema personalizado falha silenciosamente Protocolo não-HTTP não reconhecido pelo WebKit iOS 9+ Esquema não delegado ao UIApplication Interceptar esquema no delegate, validar lista de permissões, abrir via UIApplication
Sequestro de protocolo de Iframe Subframe disparando esquema personalizado externo iOS 9+ sourceFrame.isMainFrame não verificado Proteger com if !sourceFrame.isMainFrame e suprimir esquemas não-web
Aviso de Handoff de UI ou problema de transição Transições de UI executadas fora da thread principal iOS 9+ Falta despacho no main-actor Garantir execução no main-actor para roteador interno e transições de view controller

Perguntas Frequentes (FAQ)

Como os desenvolvedores podem interceptar Universal Links em um WKWebView?
Os desenvolvedores implementam <code>WKNavigationDelegate</code> e inspecionam URLs recebidas dentro de <code>decidePolicyForNavigationAction</code>. Se a URL corresponder a um destino próprio do aplicativo, o delegate cancela a navegação na webview com <code>.cancel</code> e passa os parâmetros validados diretamente para o roteador interno do aplicativo.
Posso usar UIApplication.shared.open para lançar meu próprio aplicativo a partir de um WKWebView?
A documentação da Apple especifica que chamar <code>UIApplication.shared.open()</code> em um Universal Link que aponta para o domínio associado do próprio aplicativo host não abrirá o link no aplicativo como um Universal Link. Para links de domínio próprio, o aplicativo deve cancelar a navegação da webview e invocar seu roteador de navegação interno diretamente.
Como posso impedir que iframes integrados em um WKWebView disparem lançamentos de aplicativos externos?
Para evitar o sequestro de iframe, verifique <code>navigationAction.sourceFrame.isMainFrame</code> dentro de <code>decidePolicyForNavigationAction</code>. Se <code>isMainFrame</code> for <code>false</code>, permita a navegação padrão de subframe HTTP(S) com <code>.allow</code>, mas cancele esquemas personalizados não web com <code>.cancel</code> para impedir que iframes de terceiros executem lançamentos externos não solicitados.

Resumo e Estrutura de Decisão

Manipular Universal Links e esquemas personalizados dentro de um WKWebView no iOS requer preencher a lacuna entre o contêiner de renderização web do WebKit e os ciclos de vida de navegação do UIKit nativo. Confiar nas políticas de navegação padrão pode impedir handoffs fluidos quando a lógica de roteamento própria do aplicativo é necessária.

Ao implementar um WKNavigationDelegate robusto que verifique fronteiras de frame, aplique políticas de ativação de link conservadoras em handoffs externos, analise domínios associados internos via validadores de rota rigorosos e delegue alvos externos com segurança para UIApplication.shared.open, as equipes de engenharia mantêm uma navegação controlada e se protegem contra o sequestro de protocolo por iframes.

Para explorar arquiteturas de roteamento de parâmetros e deep linking nativo no iOS, consulte a documentação de integração do SDK.

Materiais Relacionados

Share this article