Ir para o console

Convidar usuários para seu aplicativo

Uma das maneiras mais eficazes para que novos usuários instalem apps é permitir que compartilhem o conteúdo do app com os amigos. Com o Dynamic Links, você cria uma ótima experiência de compartilhamento entre os usuários. Usuários que recebem recomendações de conteúdo dos amigos podem clicar em um link que os leva diretamente ao conteúdo compartilhado no app, mesmo que tenham de ir antes à App Store ou à Google Play Store para instalar o app.

Ao combinar a aderência das referências de usuários e a persistência do Dynamic Links, é possível criar recursos de compartilhamento e encaminhamento de usuário para usuário que atraem novos usuários diretamente para o conteúdo do seu app ou veiculam promoções que beneficiam o usuário que fez a indicação e o usuário indicado.

Principais vantagens

  • Os novos usuários que abrem o app pela primeira vez recebem uma primeira experiência personalizada que é contextualizada com base no que o amigo queria compartilhar. Por exemplo, é possível exibir o conteúdo compartilhado com eles ou conectá-los automaticamente ao amigo que os convidou.
  • Facilita o compartilhamento de conteúdo pelos usuários com os amigos entre plataformas, independentemente se o app foi instalado ou não pelos amigos.

Veja como começar.

Configurar o Firebase e o SDK do Dynamic Links

Configure um novo projeto do Firebase e instale o SDK do Dynamic Links no seu app.

A instalação do SDK do Dynamic Links permite ao Firebase enviar dados do link dinâmico para o app, inclusive após a instalação do app pelo usuário.

Criar links dinâmicos

Agora é hora de configurar os links que os usuários podem enviar aos amigos. Não se preocupe se os usuários ainda não instalaram o app. O Dynamic Links cuida disso por você.

Para cada elemento de conteúdo que você quer compartilhar, crie um link dinâmico.

Ao criar o link dinâmico, forneça um URL de HTTP ou HTTPS como o parâmetro link, que será usado para identificar o conteúdo que você está compartilhando. Use os URLs do site se você tem um site com conteúdo equivalente. Isso garante que esses links renderizem corretamente em uma plataforma que não oferece suporte a links dinâmicos, como um navegador de área de trabalho. Por exemplo:

https://example.page.link/?link=https://www.example.com/content?item%3D1234&apn=com.example.android&ibi=com.example.ios&isi=12345

Também é possível adicionar mais informações ao payload de dados adicionando parâmetros codificados em URL. Por exemplo, para indicar que o link é destinado a um usuário específico, como em um convite de jogo.

https://example.page.link/?link=https://www.example.com/invitation?gameid%3D1234%26referrer%3D555&apn=com.example.android&ibi=com.example.ios&isi=12345

Antes de compartilhar esses links, use a API Firebase Dynamic Links URL shortener para gerar URLs amigáveis. Um link dinâmico curto se parece com o seguinte:

https://example.page.link/WXYZ

Qualquer que seja o link usado, quando os usuários abrirem o Dynamic Link no dispositivo, o app especificado pelo parâmetro apn (no Android) ou os parâmetros ibi e isi (no iOS) levarão os usuários à Play Store ou à App Store para instalar o app, se ele já não estiver instalado. Em seguida, quando o app é instalado e aberto, o URL especificado no parâmetro "link" é transmitido para o aplicativo.

Adicionar botões "Compartilhar" que enviam links dinâmicos

Primeiro, veja este exemplo simples de um app de bate-papo baseado em salas, como o Hangouts, que gera links para convidar pessoas para salas de bate-papo.

iOS

captura de tela do app de bate-papo captura de tela do app de bate-papo com página de compartilhamento

Android

captura de tela do app de bate-papo captura de tela do app de bate-papo com página de compartilhamento

Swift

func generateContentLink() -> URL {
  let baseURL = URL(string: "https://your-custom-name.page.link")!
  let domain = "https://your-app.page.link"
  let linkBuilder = DynamicLinkComponents(link: baseURL, domainURIPrefix: domain)
  linkBuilder?.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.your.bundleID")
  linkBuilder?.androidParameters =
      DynamicLinkAndroidParameters(packageName: "com.your.packageName")

  // Fall back to the base url if we can't generate a dynamic link.
  return linkBuilder?.link ?? baseURL
}

Objective-C

- (NSURL *)generateContentLink {
  NSURL *baseURL = [NSURL URLWithString:@"https://your-custom-name.page.link"];
  NSString *domain = @"https://your-app.page.link";
  FIRDynamicLinkComponents *builder = [[FIRDynamicLinkComponents alloc] initWithLink:baseURL domainURIPrefix:domain];
  builder.iOSParameters = [FIRDynamicLinkIOSParameters parametersWithBundleID:@"com.your.bundleID"];
  builder.androidParameters = [FIRDynamicLinkAndroidParameters parametersWithPackageName:@"com.your.packageName"];

  // Fall back to the base url if we can't generate a dynamic link.
  return builder.link ?: baseURL;
}

Java

public static Uri generateContentLink() {
    Uri baseUrl = Uri.parse("https://your-custom-name.page.link");
    String domain = "https://your-app.page.link";

    DynamicLink link = FirebaseDynamicLinks.getInstance()
            .createDynamicLink()
            .setLink(baseUrl)
            .setDomainUriPrefix(domain)
            .setIosParameters(new DynamicLink.IosParameters.Builder("com.your.bundleid").build())
            .setAndroidParameters(new DynamicLink.AndroidParameters.Builder("com.your.packageName").build())
            .buildDynamicLink();

    return link.getUri();
}

Kotlin

fun generateContentLink(): Uri {
    val baseUrl = Uri.parse("https://your-custom-name.page.link")
    val domain = "https://your-app.page.link"

    val link = FirebaseDynamicLinks.getInstance()
            .createDynamicLink()
            .setLink(baseUrl)
            .setDomainUriPrefix(domain)
            .setIosParameters(DynamicLink.IosParameters.Builder("com.your.bundleid").build())
            .setAndroidParameters(DynamicLink.AndroidParameters.Builder("com.your.packageName").build())
            .buildDynamicLink()

    return link.uri
}

Depois de gerar um link dinâmico, é possível adicionar um botão de compartilhamento à IU que iniciará o fluxo de compartilhamento de plataforma padrão:

Swift

lazy private var shareController: UIActivityViewController = {
  let activities: [Any] = [
    "Learn how to share content via Firebase",
    URL(string: "https://firebase.google.com")!
  ]
  let controller = UIActivityViewController(activityItems: activities,
                                            applicationActivities: nil)
  return controller
}()

@IBAction func shareButtonPressed(_ sender: Any) {
  let inviteController = UIStoryboard(name: "Main", bundle: nil)
    .instantiateViewController(withIdentifier: "InviteViewController")
  self.navigationController?.pushViewController(inviteController, animated: true)
}

Objective-C

- (UIActivityViewController *)shareController {
  if (_shareController == nil) {
    NSArray *activities = @[
      @"Learn how to share content via Firebase",
      [NSURL URLWithString:@"https://firebase.google.com"]
    ];
    UIActivityViewController *controller = [[UIActivityViewController alloc] initWithActivityItems:activities applicationActivities:nil];
    _shareController = controller;
  }
  return _shareController;
}

- (IBAction)shareLinkButtonPressed:(UIView *)sender {
  if (![sender isKindOfClass:[UIView class]]) {
    return;
  }

  self.shareController.popoverPresentationController.sourceView = sender;
  [self presentViewController:self.shareController animated:YES completion:nil];
}

Java

private void onShareClicked() {
    Uri link = DynamicLinksUtil.generateContentLink();

    Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setType("text/plain");
    intent.putExtra(Intent.EXTRA_TEXT, link.toString());

    startActivity(Intent.createChooser(intent, "Share Link"));
}

Kotlin

private fun onShareClicked() {
    val link = DynamicLinksUtil.generateContentLink()

    val intent = Intent(Intent.ACTION_SEND)
    intent.type = "text/plain"
    intent.putExtra(Intent.EXTRA_TEXT, link.toString())

    startActivity(Intent.createChooser(intent, "Share Link"))
}

Neste exemplo, a IU de compartilhamento padrão apresenta automaticamente uma lista de apps para compartilhar o link. Assim, é possível configurar isso no seu próprio app com apenas algumas linhas de código.

Em vez do usuário selecionar contatos e redigir a mensagem no app, essas ações são delegadas ao app escolhido na caixa de diálogo de compartilhamento. Além disso, delegar o compartilhamento a outros apps significa que você não precisa solicitar permissões de contatos ao usuário e permite que os usuários façam a seleção a partir de uma lista de contatos expandida no app escolhido. Para facilitar o compartilhamento em mídias sociais, é possível adicionar metadados de visualização de mídias sociais ao seu link dinâmico, que serão exibidos junto com o link nos principais canais sociais.

Às vezes, porém, apenas enviar um link sem texto não é suficiente para uma indicação atraente. Ao acompanhar o link com uma mensagem curta e, se possível, uma apresentação mais completa, os usuários podem entender a proposta de valor da indicação quando a recebem:

iOS

captura de tela de indicação premiada captura de tela da indicação premiada com página de compartilhamento

Android

captura de tela de indicação premiada captura de tela da indicação premiada com página de compartilhamento

Embora isso seja mais complexo do que o último exemplo, a abordagem será mais ou menos igual. Nesta tela, há um gráfico grande com a proposta de valor do convite e botões para compartilhar nos principais canais sociais. Há alguma redundância nesse fluxo da interface do usuário: alguns canais de compartilhamento são apresentados individualmente para permitir uma personalização maior da mensagem específica do canal, como adicionar uma linha de assunto a convites por e-mail. Neste menu de convite, é possível:

  • apresentar o e-mail, a mensagem de texto e os botões de compartilhamento para copiar o link, além de personalizar suas mensagens adequadamente. O e-mail incluirá um assunto e poderá incluir um corpo mais longo com quebras de linha, imagens e espaços em branco. A mensagem de texto precisa incluir um corpo mais curto com quebras de linha, mas pouco espaço em branco e sem imagens. A cópia do link precisa apenas copiar o link e nada mais;
  • usar a IU de compartilhamento do sistema para todo o restante, incluindo uma breve mensagem de convite para acompanhar o link;
  • incluir um link direto por meio do esquema de URL ou link universal para outro app que tenha uma lógica especial para lidar com os convites do seu app. Isso não funcionará sem uma parceria entre sua organização e o outro app, e provavelmente não é uma opção para organizações menores. Dito isso, alguns apps podem documentar publicamente o comportamento de vinculação universal/direta deles. Implementaremos uma versão fictícia disso na nossa amostra.

Primeiro, defina um tipo de conteúdo de convite, que encapsula apenas as informações em um convite e não contém nenhuma funcionalidade. Assim, você pode começar com os tipos de dados e pensar no seu código em termos de como esses dados são reunidos.

Swift

/// The content within an invite, with optional fields to accommodate all presenters.
/// This type could be modified to also include an image, for sending invites over email.
struct InviteContent {

  /// The subject of the message. Not used for invites without subjects, like text message invites.
  var subject: String?

  /// The body of the message. Indispensable content should go here.
  var body: String?

  /// The URL containing the invite. In link-copy cases, only this field will be used.
  var link: URL

}

Objective-C

/// The content within an invite, with optional fields to accommodate all presenters.
/// This type could be modified to also include an image, for sending invites over email.
@interface InviteContent : NSObject <NSCopying>

/// The subject of the message. Not used for invites without subjects, like text message invites.
@property (nonatomic, readonly, nullable) NSString *subject;

/// The body of the message. Indispensable content should go here.
@property (nonatomic, readonly, nullable) NSString *body;

/// The URL containing the invite. In link-copy cases, only this field will be used.
@property (nonatomic, readonly) NSURL *link;

- (instancetype)initWithSubject:(nullable NSString *)subject
                           body:(nullable NSString *)body
                           link:(NSURL *)link NS_DESIGNATED_INITIALIZER;

- (instancetype)init NS_UNAVAILABLE;

@end

Java

/**
 * The content of an invitation, with optional fields to accommodate all presenters.
 * This type could be modified to also include an image, for sending invites over email.
 */
public class InviteContent {

    /**
     * The subject of the message. Not used for invites without subjects, like SMS.
     **/
    @Nullable
    public final String subject;

    /**
     * The body of the message. Indispensable content should go here.
     **/
    @Nullable
    public final String body;

    /**
     * The URL containing the link to invite. In link-copy cases, only this field will be used.
     **/
    @NonNull
    public final Uri link;

    public InviteContent(@Nullable String subject, @Nullable String body, @NonNull Uri link) {
        // ...
    }

}

Kotlin

/**
 * The content of an invitation, with optional fields to accommodate all presenters.
 * This type could be modified to also include an image, for sending invites over email.
 */
data class InviteContent(
    /** The subject of the message. Not used for invites without subjects, like SMS.  */
    val subject: String?,
    /** The body of the message. Indispensable content should go here.  */
    val body: String?,
    /** The URL containing the link to invite. In link-copy cases, only this field will be used.  */
    val link: Uri
)

Os únicos dados necessários aqui são os do URL, porque sem eles não é possível convidar usuários para seu app. Os outros dados são claramente estruturados para enviar e-mails, o que os torna um pouco estranhos em outros casos. Ao enviar um convite por mensagem de texto, a sinopse que acompanha o link pode ser semelhante ao assunto de um e-mail, mas no compartilhamento com mídias sociais, o link que acompanha o texto pode ser mais como o corpo de um e-mail. Faça testes para encontrar o melhor equilíbrio para seu app e, se não tiver certeza, sempre é possível usar um serviço como o Configuração remota para permitir que você altere os valores de texto após o lançamento do app.

Swift

/// A type responsible for presenting an invite given using a specific method
/// given the content of the invite.
protocol InvitePresenter {

  /// The name of the presenter. User-visible.
  var name: String { get }

  /// An icon representing the invite method. User-visible.
  var icon: UIImage? { get }

  /// Whether or not the presenter's method is available. iOS devices that aren't phones
  /// may not be able to send texts, for example.
  var isAvailable: Bool { get }

  /// The content of the invite. Some of the content type's fields may be unused.
  var content: InviteContent { get }

  /// Designated initializer.
  init(content: InviteContent, presentingController: UIViewController)

  /// This method should cause the presenter to present the invite and then handle any actions
  /// required to complete the invite flow.
  func sendInvite()

}

Objective-C

/// A type responsible for presenting an invite given using a specific method
/// given the content of the invite.
@protocol InvitePresenter <NSObject>

/// The name of the presenter. User-visible.
@property (nonatomic, readonly) NSString *name;

/// An icon representing the invite method. User-visible.
@property (nonatomic, readonly, nullable) UIImage *icon;

/// Whether or not the presenter's method is available. iOS devices that aren't phones
/// may not be able to send texts, for example.
@property (nonatomic, readonly) BOOL isAvailable;

/// The content of the invite. Some of the content type's fields may be unused.
@property (nonatomic, readonly) InviteContent *content;

/// Designated initializer.
- (instancetype)initWithContent:(InviteContent *)content presentingViewController:(UIViewController *)controller;

/// This method should cause the presenter to present the invite and then handle any actions
/// required to complete the invite flow.
- (void)sendInvite;

@end

Java

/**
 * Presents the invite using a specific method, such as email or social.
 */
public class InvitePresenter {

    /**
     * The user-visible name of the invite method, like 'Email' or 'SMS'
     **/
    public final String name;

    /**
     * An icon representing the invite method.
     **/
    @DrawableRes
    public final int icon;

    /**
     * Whether or not the method is available on this device. For example, SMS is phone only.
     **/
    public final boolean isAvailable;

    /**
     * The Content of the invitation
     **/
    public final InviteContent content;

    public InvitePresenter(String name, @DrawableRes int icon, boolean isAvailable, InviteContent content) {
        // ...
    }

    /**
     * Send the invitation using the specified method.
     */
    public void sendInvite(Context context) {
        // ...
    }

}

Kotlin

/**
 * Presents the invite using a specific method, such as email or social.
 */
open class InvitePresenter(
    /** The user-visible name of the invite method, like 'Email' or 'SMS'  */
    val name: String,
    /** An icon representing the invite method.  */
    @param:DrawableRes @field:DrawableRes
    val icon: Int,
    /** Whether or not the method is available on this device. For example, SMS is phone only.  */
    val isAvailable: Boolean,
    /** The Content of the invitation  */
    val content: InviteContent
) {
    /**
     * Send the invitation using the specified method.
     */
    open fun sendInvite(context: Context) {
        // ...
    }
}

Agora, o que resta é incluir isso em um componente da IU de sua escolha. Para saber mais sobre a implementação completa desse fluxo de convite, consulte as amostras no GitHub para iOS e Android (ambos em inglês).

Esses são os métodos para permitir que seus usuários enviem convites para os amigos deles, que é a solução de convite mais leve. Muitos apps conhecidos também enviam convites enviando e-mails por meio do próprio back-end, o que exige a integração de um serviço de envio de e-mails, mas oferece vários benefícios que não estão disponíveis de outra forma, com apenas alguns inconvenientes menores.

Vantagens:

  • Permite o envio de e-mails com marcação complexa que não podem ser modificados pelo usuário antes do envio.
  • Permite um rastreamento e uma análise mais granulares (ou seja, sucessos e falhas de envio no back-end).

Desvantagens:

  • Os e-mails são mais propensos a serem sinalizados como spam.
  • Requer uma integração com um serviço de envio de e-mail.
  • Requer permissões de acesso aos contatos no app.

Geralmente, o envio de convites por meio do seu próprio serviço de envio de e-mail oferece uma experiência de convite mais consistente e potencialmente mais complexa, mas menos versátil.

Abrir o conteúdo vinculado no app

Finalmente, você precisa receber o link passado ao app para exibir o conteúdo vinculado ao destinatário. Isso é fácil usando o SDK do Dynamic Links:

iOS

No iOS, você recebe o link dinâmico ao implementar o método application:continueUserActivity:restorationHandler:. No gerenciador de restauração, chame handleUniversalLink:completion: para ter acesso ao link dinâmico. Se um link dinâmico foi transmitido ao seu app, use a propriedade url da classe FIRDynamicLink para ter acesso a ele. Por exemplo:

Objective-C

[[FIRDynamicLinks dynamicLinks]
    handleUniversalLink:userActivity.webpageURL
             completion:^(FIRDynamicLink * _Nullable dynamicLink,
                          NSError * _Nullable error) {
      NSString *link = dynamicLink.url;
      BOOL strongMatch = dynamicLink.matchConfidence == FIRDynamicLinkMatchConfidenceStrong;
      // ...
    }];

Swift

FIRDynamicLinks.dynamicLinks()?.handleUniversalLink(userActivity.webpageURL!) { (dynamiclink, error) in
    let link = dynamicLink.url
    let strongMatch = dynamicLink.matchConfidence == FIRDynamicLinkMatchConfidenceStrong
    // ...
}

Além disso, é preciso chamar dynamicLinkFromCustomSchemeURL: no método application:openURL:options: para receber os links dinâmicos transmitidos ao aplicativo como URLs de esquema personalizado. Por exemplo:

Objective-C

FIRDynamicLink *dynamicLink = [[FIRDynamicLinks dynamicLinks] dynamicLinkFromCustomSchemeURL:url];
if (dynamicLink) {
  NSString *link = dynamicLink.url;
  BOOL strongMatch = dynamicLink.matchConfidence == FIRDynamicLinkMatchConfidenceStrong;
  // ...
  return YES;
}

Swift

let dynamicLink = FIRDynamicLinks.dynamicLinks()?.dynamicLinkFromCustomSchemeURL(url)
if let dynamicLink = dynamicLink {
  let link = dynamicLink.url
  let strongMatch = dynamicLink.matchConfidence == FIRDynamicLinkMatchConfidenceStrong
  // ...
  return true
}

Agora que você tem o valor do parâmetro link, exiba o conteúdo vinculado ao destinatário ou processe os dados especificados pelo parâmetro de outra maneira. Uma biblioteca de roteamento de URL, como JLRoutes (em inglês), pode ajudá-lo nessa tarefa.

Se você recebeu um link para um destinatário específico, garanta que a confiança da correspondência do link dinâmico seja strong antes de executar qualquer lógica específica de usuário.

Android

No Android, use o método getDynamicLink() para receber dados do link dinâmico:

Java

FirebaseDynamicLinks.getInstance()
        .getDynamicLink(getIntent())
        .addOnCompleteListener(new OnCompleteListener<PendingDynamicLinkData>() {
            @Override
            public void onComplete(@NonNull Task<PendingDynamicLinkData> task) {
                if (!task.isSuccessful()) {
                    // Handle error
                    // ...
                }

                FirebaseAppInvite invite = FirebaseAppInvite.getInvitation(task.getResult());
                if (invite != null) {
                    // Handle invite
                    // ...
                }
            }
        });

Kotlin

FirebaseDynamicLinks.getInstance()
        .getDynamicLink(intent)
        .addOnCompleteListener { task ->
            if (!task.isSuccessful) {
                // Handle error
                // ...
            }

            val invite = FirebaseAppInvite.getInvitation(task.result)
            if (invite != null) {
                // Handle invite
                // ...
            }
        }

Agora que você tem o valor do parâmetro link, exiba o conteúdo vinculado ao destinatário ou processe os dados especificados pelo parâmetro de outra maneira. Uma biblioteca de roteamento de URL pode ajudar nessa tarefa.