Deep linking

O deep linking é uma forma de fornecer um link que inicia um app nativo, mostra conteúdo específico ou executa alguma ação específica. Para implementar deep links em seu app iOS pela primeira vez, siga estas etapas.

Para obter informações gerais sobre o que são deep links, consulte nosso artigo de perguntas frequentes.

Etapa 1: Registro de um esquema

Para lidar com o deep linking, um esquema personalizado deve ser declarado em seu arquivo Info.plist. A estrutura de navegação é definida por uma matriz de dicionários. Cada um desses dicionários contém um vetor de strings.

Use o Xcode para editar seu Info.plist arquivo:

1. Adicione uma nova chave, URL types. O Xcode fará automaticamente disso um vetor contendo um dicionário chamado Item 0.
2. Dentro de Item 0, adicione uma chave URL identifier. Defina o valor para seu esquema personalizado.
3. Dentro de Item 0, adicione uma chave URL Schemes. Isso será automaticamente um vetor contendo uma Item 0 string.
4. Defina URL Schemes » Item 0 para seu esquema personalizado.

Alternativamente, se você deseja editar seu arquivoInfo.plist diretamente, siga esta especificação:

1
2
3
4
5
6
7
8
9
10
11
<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLName</key>
        <string>YOUR.SCHEME</string>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>YOUR.SCHEME</string>
        </array>
    </dict>
</array>

Etapa 2: Adição de uma lista de permissões de esquema

Você deve declarar os esquemas de URL que deseja passar para canOpenURL(_:) adicionando a chave LSApplicationQueriesSchemes ao arquivo Info.plist do seu app. Tentar chamar esquemas fora desta lista de permissão fará com que o sistema registre um erro nos logs do dispositivo, e o deep link não abrirá. Um exemplo desse erro é o seguinte:

1
<Warning>: -canOpenURL: failed for URL: "yourapp://deeplink" – error: "This app is not allowed to query for scheme yourapp"

Por exemplo, se uma mensagem no app deve abrir o aplicativo do Facebook ao ser tocada, o app deve ter o esquema personalizado do Facebook (fb) em sua lista de permissões. Caso contrário, o sistema rejeitará o deep link. Os deep linkings que direcionam para uma página ou exibição dentro do seu próprio aplicativo ainda exigem que o esquema personalizado do seu aplicativo seja listado no site Info.plist.

Seu exemplo de lista de permissões pode ser algo como:

1
2
3
4
5
6
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>myapp</string>
    <string>fb</string>
    <string>twitter</string>
</array>

Para saber mais, consulte a documentação da Apple sobre a tecla LSApplicationQueriesSchemes.

Etapa 3: Implementar um manipulador

Depois de ativar seu app, o iOS chamará o método application:openURL:options:. O argumento importante é o objeto NSURL.

• swift
• objective c

1
2
3
4
5
6
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
  let path = url.path
  let query = url.query
  // Insert your code here to take some action based upon the path and query.
  return true
}

1
2
3
4
5
6
- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  NSString *path  = [url path];
  NSString *query = [url query];
  // Insert your code here to take some action based upon the path and query.
  return YES;
}

Segurança de transporte de aplicativos (ATS)

Requisitos do ATS

Da documentação da Apple: “O App Transport Security é um recurso que melhora a segurança das conexões entre um app e os serviços da Web. O recurso consiste em requisitos de conexão padrão que estão em conformidade com as melhores práticas para conexões seguras. Os apps podem substituir esse comportamento padrão e desativar a segurança de transporte.”

O ATS é aplicado por padrão. Requer que todas as conexões usem HTTPS e sejam criptografadas usando TLS 1.2 com sigilo direto. Consulte Requisitos para Conexão Usando ATS para saber mais. Todas as imagens servidas pela Braze para dispositivos finais são gerenciadas por uma rede de entrega de conteúdo (“CDN”) que suporta TLS 1.2 e é compatível com ATS.

A menos que sejam especificadas como exceções em seu Info.plist, as conexões que não seguirem esses requisitos falharão com erros que se parecem com isto:

1
2
CFNetwork SSLHandshake failed (-9801)
Error Domain=NSURLErrorDomain Code=-1200 "An SSL error has occurred, and a secure connection to the server cannot be made."

1
NSURLSession/NSURLConnection HTTP load failed (kCFStreamErrorDomainSSL, -9802)

A conformidade com ATS é aplicada para links abertos dentro do app móvel (nosso tratamento padrão de links clicados) e não se aplica a sites abertos externamente por meio de um navegador da web.

Atendendo aos requisitos do ATS

Você pode lidar com ATS de uma das três maneiras a seguir:

Certifique-se de que todos os links estejam em conformidade com o ATS (recomendado)

Sua integração com a Braze pode atender aos requisitos do ATS, garantindo que todos os links existentes para os quais você direciona os usuários (por exemplo, por meio de mensagens no app e campanhas de mensagens) atendam aos requisitos do ATS. Embora existam maneiras de contornar as restrições do ATS, nossa recomendação é garantir que todos os URLs vinculados estejam em conformidade com o ATS. Dada a crescente ênfase da Apple na segurança dos aplicativos, as seguintes abordagens para permitir exceções de ATS não têm garantia de suporte da Apple.

Desativar parcialmente o ATS

Você pode permitir que um subconjunto de links com determinados domínios ou esquemas sejam tratados como exceções às regras do ATS. Sua integração com o Braze atenderá aos requisitos do ATS se todos os links usados em um canal de envio de mensagens do Braze estiverem em conformidade com o ATS ou forem tratados por uma exceção.

Para adicionar um domínio como exceção do ATS, adicione o seguinte ao arquivo Info.plist do seu app:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>
    <key>NSExceptionDomains</key>
    <dict>
        <key>example.com</key>
        <dict>
            <key>NSExceptionAllowsInsecureHTTPLoads</key>
            <false/>
            <key>NSIncludesSubdomains</key>
            <true/>
        </dict>
    </dict>
</dict>

Consulte o artigo da Apple sobre [chaves de segurança de transporte de app para saber mais.

Desativar totalmente o ATS

Você pode desativar o ATS completamente. Note que essa não é uma prática recomendada, devido à perda de proteções de segurança e à compatibilidade futura com o iOS. Para desativar o ATS, insira o seguinte no arquivo Info.plist do seu app:

1
2
3
4
5
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>
</dict>

Codificação de URL

O SDK codifica os links em porcentagem para criar URLs válidos. Todos os caracteres de link que não são permitidos em um URL devidamente formado, como caracteres Unicode, serão escapados por porcentagem.

Para decodificar um link codificado, use a propriedade String removingPercentEncoding. Você também deve retornar true em BrazeDelegate.braze(_:shouldOpenURL:). Uma chamada para ação é necessária para disparar o tratamento da URL pelo seu aplicativo.

Por exemplo:

• swift
• objective c

1
2
3
4
5
  func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
    let urlString = url.absoluteString.removingPercentEncoding
    // Handle urlString
    return true
  }

1
2
3
4
5
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary<NSString *, id> *)options {
  NSString *urlString = [url.absoluteString stringByRemovingPercentEncoding];
  // Handle urlString
  return YES;
}

Deep links para as configurações do app

Você pode aproveitar o UIApplicationOpenSettingsURLString para fazer um deep linking entre os usuários e as configurações do seu app a partir de notificações por push do Braze, mensagens no app e feed de notícias.

Para levar os usuários do seu app para as configurações do iOS:

1. Primeiro, confira se o seu aplicativo está configurado para [links profundos baseados em esquema ou [links universais.
2. Decida sobre um URI para deep linking para a página de Configurações (por exemplo, myapp://settings ou https://www.braze.com/settings).
3. Se você estiver usando links profundos baseados em esquemas personalizados, adicione o seguinte código ao seu método application:openURL:options::

• swift
• objective c

1
2
3
4
5
6
7
func application(_ app: UIApplication, open url: URL, options: [UIApplicationOpenURLOptionsKey : Any] = [:]) -> Bool {
  let path = url.path
  if (path == "settings") {
    UIApplication.shared.openURL(URL(string:UIApplication.openSettingsURLString)!)
  }
  return true
}

1
2
3
4
5
6
7
8
9
10
- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
  NSString *path  = [url path];
  if ([path isEqualToString:@"settings"]) {
    NSURL *settingsURL = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
    [[UIApplication sharedApplication] openURL:settingsURL];
  }
  return YES;
}

Personalização

Personalização padrão do WebView

A classe Braze.WebViewController exibe URLs da web abertas pelo SDK, normalmente quando “Abrir URL da Web Dentro do App” é selecionado para um deep link da web.

Você pode personalizar Braze.WebViewController por meio do método delegado BrazeDelegate.braze(_:willPresentModalWithContext:).

Personalização do manuseio de links

O protocolo BrazeDelegate pode ser usado para personalizar o tratamento de URLs, como deep links, URLs da web e links universais. Para definir o delegado durante a inicialização da Braze, defina um objeto delegado na instância Braze. A Braze chamará a implementação de seu delegado em shouldOpenURL antes de manipular quaisquer URIs.

Links universais

O Braze oferece suporte a links universais em notificações por push, mensagens no app e cartões de conteúdo. Para ativar o suporte a links universais, configuration.forwardUniversalLinks deve ser definido como true.

Quando ativada, a Braze encaminhará links universais para o AppDelegate do seu app por meio do método application:continueUserActivity:restorationHandler:.

Seu aplicativo também precisa ser configurado para lidar com links universais. Consulte a documentação da Apple para garantir que seu aplicativo esteja configurado corretamente para links universais.

Exemplo de integração: BrazeDelegate

• swift
• objective c

1
2
3
4
5
6
7
8
func braze(_ braze: Braze, shouldOpenURL context: Braze.URLContext) -> Bool {
  if context.url.host == "MY-DOMAIN.com" {
    // Custom handle link here
    return false
  }
  // Let Braze handle links otherwise
  return true
}

1
2
3
4
5
6
7
8
- (BOOL)braze:(Braze *)braze shouldOpenURL:(BRZURLContext *)context {
  if ([[context.url.host lowercaseString] isEqualToString:@"MY-DOMAIN.com"]) {
    // Custom handle link here
    return NO;
  }
  // Let Braze handle links otherwise
  return YES;
}

Para saber mais, consulte BrazeDelegate.