Deep linking de mensagem no app

Pré-requisitos

Antes de poder usar esse recurso, você precisará integrar o Swift Braze SDK.

Tratamento de links profundos

Etapa 1: Registrar 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: Adicionar uma lista de permissão 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)

Conforme definido por Apple, “A Segurança de Transporte de Aplicativos é um recurso que melhora a segurança das conexões entre um app e serviços 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 especificados como exceções na Info.plist do seu aplicativo, conexões que não seguem esses requisitos falharão com erros semelhantes aos seguintes.

Exemplo de Erro 1:

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

Exemplo de Erro 2:

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.

Trabalhando com ATS

Você pode lidar com ATS de uma das seguintes maneiras, mas recomendamos cumprir os requisitos do ATS.

• comply
• partially disable
• fully disable

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>

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

Decodificando URLs

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 linking para as configurações do app

Você pode aproveitar UIApplicationOpenSettingsURLString para direcionar usuários para as configurações do seu app a partir de notificações push do Braze e mensagens dentro do app.

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

Opções de 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. Braze chamará a implementação do seu delegado de shouldOpenURL antes de lidar com qualquer URI.

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.

Exemplos

BrazeDelegate

Aqui está um exemplo usando BrazeDelegate. Para mais informações, veja referência do SDK Braze Swift.

• 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;
}