Receber o Firebase Dynamic Links em um app Flutter

Para receber os Firebase Dynamic Links que você criou, inclua o SDK do Dynamic Links no seu app e chame o método FirebaseDynamicLinks.getDynamicLink() quando o app for carregado para receber os dados transmitidos no Dynamic Link.

Configurar o Firebase e o SDK do Dynamic Links

Instale e inicialize os SDKs do Firebase para Flutter, caso ainda não tenha feito isso.
No diretório raiz do seu projeto do Flutter, execute o comando a seguir para instalar o plug-in do Dynamic Links:
```
flutter pub add firebase_dynamic_links
```
Se você estiver criando um app Android, abra a página Configurações do projeto no Console do Firebase e verifique se a chave de assinatura SHA-1 foi especificada. Se você usa links de apps, também precisa especificar sua chave SHA-256.

Integração de plataformas

Conclua as etapas de integração de plataforma a seguir para as plataformas em que você está criando o app.

Android

No Android, você precisa adicionar um novo filtro de intent que identifique links diretos do seu domínio, já que o link dinâmico será redirecionado ao seu domínio, se o app estiver instalado. Isso é necessário para que o app receba os dados do link dinâmico depois de ser instalado/atualizado na Play Store e depois de alguém tocar no botão "Continuar". Em AndroidManifest.xml:

<intent-filter>
    <action android:name="android.intent.action.VIEW"/>
    <category android:name="android.intent.category.DEFAULT"/>
    <category android:name="android.intent.category.BROWSABLE"/>
    <data
        android:host="example.com"
        android:scheme="https"/>
</intent-filter>

Quando os usuários abrem um link dinâmico com um link direto para o esquema e o host especificados, seu app inicia a atividade usando esse filtro de intent para processar o link.

A próxima etapa é garantir que a impressão digital SHA-256 do certificado de assinatura seja registrada para o app no Console do Firebase. Veja mais detalhes sobre como recuperar sua impressão digital SHA-256 na página Como autenticar seu cliente.

Plataformas da Apple

Crie uma conta de desenvolvedor da Apple, se ainda não tiver uma.
Na página Configurações do projeto do Console do Firebase, verifique se o app iOS está configurado corretamente com os IDs da App Store e da equipe.
No site para desenvolvedores da Apple, crie um perfil de provisionamento para o app com o recurso "Domínio associado" ativado.
No Xcode, faça o seguinte:
1. Abra seu app no cabeçalho DESTINOS.
2. Na página "Signing & Capabilities", verifique se a equipe está registrada e o perfil de provisionamento está definido.
3. Na página "Signing & Capabilities", ative Associated Domains e adicione o seguinte à lista de domínios associados (exemplo de substituição pelo seu domínio):
```
applinks:example.page.link
```
4. Na página de informações, adicione um tipo de URL ao seu projeto. Defina o campo "Esquemas de URL" como o ID do pacote do seu app. O identificador pode ser Bundle ID ou o que você quiser.
5. Se você tiver configurado um domínio personalizado para seu projeto do Firebase, adicione o prefixo de URL do link dinâmico ao arquivo Info.plist do projeto do iOS usando a chave FirebaseDynamicLinksCustomDomains.
```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>FirebaseDynamicLinksCustomDomains</key>
<array>
    <string>https://custom.domain.io/path1</string>
    <string>https://custom.domain.io/path2</string>
</array>

...other settings

</dict>
</plist>
```
6. Opcional: desative o uso do SDK do Dynamic Links na área de transferência do iOS.
  
  Por padrão, o SDK do Dynamic Links usa a área de transferência para melhorar a confiabilidade dos links diretos pós-instalação. Ao usar a área de transferência, os Dynamic Links garantem que, quando um usuário abrir um Dynamic Links, mas precisar instalar o app primeiro, ele poderá acessar imediatamente o conteúdo vinculado original ao abrir o app pela primeira vez.
  
  A desvantagem disso é que o uso da área de trabalho aciona uma notificação no iOS 14 e em versões posteriores. Dessa forma, na primeira vez que os usuários abrirem seu app, se a área de transferência tiver um URL de link dinâmico, eles verão uma notificação de que o aplicativo acessou a área de transferência, o que pode causar problemas.
  
  Para desativar este comportamento, edite o arquivo Info.plist do seu projeto do Xcode e defina a chave FirebaseDeepLinkPasteboardRetrievalEnabled como NO.
  
  Observação: ao desativar esse recurso, os Dynamic Links recebidos terão um matchType de weak na melhor das hipóteses. Ajuste a lógica do seu app adequadamente.

Processar links diretos

Para lidar com um link dinâmico no seu aplicativo, é preciso implementar dois cenários.

Estado encerrado

Configure os seguintes métodos:

FirebaseDynamicLinks.getInitialLink: retorna um Future<PendingDynamicLinkData?>.
FirebaseDynamicLinks.onLink: manipulador de eventos que retorna um Stream contendo um PendingDynamicLinkData?.

O Android sempre vai receber o link via FirebaseDynamicLinks.getInitialLink a partir de um estado encerrado, mas isso não é garantido no iOS. Portanto, vale a pena configurar os dois na ordem a seguir para garantir que seu aplicativo receba o link:

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(options: DefaultFirebaseConfig.platformOptions);

  // Check if you received the link via `getInitialLink` first
  final PendingDynamicLinkData? initialLink = await FirebaseDynamicLinks.instance.getInitialLink();

  if (initialLink != null) {
    final Uri deepLink = initialLink.link;
    // Example of using the dynamic link to push the user to a different screen
    Navigator.pushNamed(context, deepLink.path);
  }

  FirebaseDynamicLinks.instance.onLink.listen(
        (pendingDynamicLinkData) {
          // Set up the `onLink` event listener next as it may be received here
          if (pendingDynamicLinkData != null) {
            final Uri deepLink = pendingDynamicLinkData.link;
            // Example of using the dynamic link to push the user to a different screen
            Navigator.pushNamed(context, deepLink.path);
          }
        },
      );

  runApp(MyApp(initialLink));
}

Na lógica do aplicativo, é possível verificar se um link foi processado e realizar uma ação, por exemplo:

if (initialLink != null) {
  final Uri deepLink = initialLink.link;
  // Example of using the dynamic link to push the user to a different screen
  Navigator.pushNamed(context, deepLink.path);
}

Estado do segundo/primeiro plano

Enquanto o aplicativo estiver aberto ou em segundo plano, use o getter FirebaseDynamicLinks.onLink:

FirebaseDynamicLinks.instance.onLink.listen((dynamicLinkData) {
  Navigator.pushNamed(context, dynamicLinkData.link.path);
}).onError((error) {
  // Handle errors
});

Como alternativa, se você quiser identificar se um link dinâmico exato foi usado para abrir o aplicativo, transmita-o para o método getDynamicLink:

String link = 'https://dynamic-link-domain/ke2Qa';

final PendingDynamicLinkData? initialLink = await FirebaseDynamicLinks.instance.getDynamicLink(Uri.parse(link));

Como testar um link dinâmico na plataforma iOS

Para testar um link dinâmico no iOS, é necessário usar um dispositivo real. Você também precisará executar o app no modo de lançamento (por exemplo, flutter run --release) se estiver testando um link dinâmico de um estado encerrado do app (por exemplo, se o app tiver sido fechado).