Registre os dados da mensagem no app
Aprenda como registrar os dados da mensagem no app (IAM) através do SDK Braze.
Pré-requisitos
Antes de poder usar esse recurso, você precisará integrar o Braze Web SDK.
Envio de mensagens de registro de dados
O registro de impressões e cliques de mensagens no app é realizado automaticamente quando se usa o método showInAppMessage ou automaticallyShowInAppMessage.
Se não usar nenhum dos métodos e aceitar exibir a mensagem manualmente usando seu próprio código de interface do usuário, use os seguintes métodos para registrar análises de dados:
// Registers that a user has viewed an in-app message with the Braze server.
braze.logInAppMessageImpression(inAppMessage);
// Registers that a user has clicked on the specified in-app message with the Braze server.
braze.logInAppMessageClick(inAppMessage);
// Registers that a user has clicked a specified in-app message button with the Braze server.
braze.logInAppMessageButtonClick(button, inAppMessage);
// Registers that a user has clicked on a link in an HTML in-app message with the Braze server.
braze.logInAppMessageHtmlClick(inAppMessage, buttonId?, url?)
Pré-requisitos
Antes de poder usar esse recurso, você precisará integrar o Flutter Braze SDK.
Registrando dados de mensagens
Para registrar análise de dados usando o BrazeInAppMessage, passe a instância para a função de análise de dados desejada:
logInAppMessageClickedlogInAppMessageImpressionlogInAppMessageButtonClicked(juntamente com o índice do botão)
Por exemplo:
// Log a click
braze.logInAppMessageClicked(inAppMessage);
// Log an impression
braze.logInAppMessageImpression(inAppMessage);
// Log button index `0` being clicked
braze.logInAppMessageButtonClicked(inAppMessage, 0);
Acessando dados de mensagens
Para acessar os dados de mensagens no app no seu app Flutter, o BrazePlugin oferece suporte ao envio de dados de mensagens no app usando Dart Streams.
O objeto BrazeInAppMessage é compatível com um subconjunto de campos disponíveis nos objetos do modelo nativo, incluindo uri, message, header, buttons, extras, entre outros.
Ouvir dados de mensagens no app na camada Dart
Para receber os dados da mensagem no app na camada Dart, use o código abaixo para criar um StreamSubscription e chamar braze.subscribeToInAppMessages(). Lembre-se de usar cancel() na inscrição do stream quando ela não for mais necessária.
// Create stream subscription
StreamSubscription inAppMessageStreamSubscription;
inAppMessageStreamSubscription = braze.subscribeToInAppMessages((BrazeInAppMessage inAppMessage) {
// Handle in-app messages
}
// Cancel stream subscription
inAppMessageStreamSubscription.cancel();
Para ver um exemplo, consulte main.dart no app de amostra do Braze Flutter SDK.
Encaminhar dados de mensagens no app a partir da camada nativa
Os dados de mensagens no app são encaminhados automaticamente a partir das camadas nativas do Android e do iOS. Nenhuma configuração adicional é necessária.
Se você estiver usando o Flutter SDK 17.1.0 ou anterior, o encaminhamento de dados de mensagens no app a partir da camada nativa do iOS requer configuração manual. Seu aplicativo provavelmente contém uma das opções a seguir. Para migrar para o Flutter SDK 18.0.0, remova a chamada BrazePlugin.processInAppMessage(_:) — o encaminhamento de dados agora é feito automaticamente.
Remova a chamada BrazePlugin.processInAppMessage(_:) da sua implementação do delegado willPresent.
Remova a chamada BrazePlugin.processInAppMessage(message) da implementação present(message:) do seu apresentador personalizado:
class CustomInAppMessagePresenter: BrazeInAppMessageUI {
override func present(message: Braze.InAppMessage) {
// Pass in-app message data to the Dart layer.
BrazePlugin.processInAppMessage(message)
// If you want the default UI to display the in-app message.
super.present(message: message)
}
}
Reproduzindo o retorno de chamada para mensagens no app (opcional)
Para armazenar mensagens no app disparadas antes que o retorno de chamada esteja disponível e reproduzi-las depois que ele for definido, adicione a seguinte entrada ao mapa customConfigs ao inicializar o BrazePlugin:
BrazePlugin braze = new BrazePlugin(customConfigs: {replayCallbacksConfigKey: true});
Pré-requisitos
Antes de poder usar esse recurso, você precisará integrar o SDK React Native da Braze.
Métodos para registro
Você pode usar esses métodos passando sua instância de BrazeInAppMessage para registrar análise de dados e executar ações:
| Método | Descrição |
|---|---|
logInAppMessageClicked(inAppMessage) |
Registra um clique para os dados da mensagem no app fornecida. |
logInAppMessageImpression(inAppMessage) |
Registra uma impressão para os dados da mensagem no app fornecida. |
logInAppMessageButtonClicked(inAppMessage, buttonId) |
Registra um clique de botão para os dados da mensagem no app e o ID do botão fornecidos. |
hideCurrentInAppMessage() |
Descarta a mensagem no app exibida no momento. |
performInAppMessageAction(inAppMessage) |
Executa a ação de uma mensagem no app. |
performInAppMessageButtonAction(inAppMessage, buttonId) |
Executa a ação de um botão de mensagem no app. |
Manipulando dados de mensagens
Na maioria dos casos, você pode usar o método Braze.addListener para registrar ouvintes de eventos que manipulam dados vindos de mensagens no app.
Além disso, você pode acessar os dados da mensagem no app na camada JavaScript chamando o método Braze.subscribeToInAppMessage para que os SDKs publiquem um evento inAppMessageReceived quando uma mensagem no app for disparada. Passe um retorno de chamada para esse método para executar seu próprio código quando a mensagem no app for disparada e recebida pelo ouvinte.
Para personalizar como os dados de mensagens são manipulados, consulte os seguintes exemplos de implementação:
Para aprimorar o comportamento padrão, ou se você não tiver acesso para personalizar o código nativo do iOS ou Android, recomendamos desativar a interface padrão enquanto ainda recebe eventos de mensagens no app da Braze. Para desativar a interface padrão, passe false para o método Braze.subscribeToInAppMessage e use os dados da mensagem no app para construir sua própria mensagem em JavaScript. Observe que será necessário registrar manualmente a análise de dados das suas mensagens se optar por desativar a interface padrão.
import Braze from "@braze/react-native-sdk";
// Option 1: Listen for the event directly via `Braze.addListener`.
//
// You may use this method to accomplish the same thing if you don't
// wish to make any changes to the default Braze UI.
Braze.addListener(Braze.Events.IN_APP_MESSAGE_RECEIVED, (event) => {
console.log(event.inAppMessage);
});
// Option 2: Call `subscribeToInAppMessage`.
//
// Pass in `false` to disable the automatic display of in-app messages.
Braze.subscribeToInAppMessage(false, (event) => {
console.log(event.inAppMessage);
// Use `event.inAppMessage` to construct your own custom message UI.
});
Para incluir lógica mais avançada para determinar se uma mensagem no app deve ou não ser exibida usando a interface integrada, implemente as mensagens no app pela camada nativa.

Como esta é uma opção de personalização avançada, observe que substituir a implementação padrão da Braze também anulará a lógica de emissão de eventos de mensagens no app para seus ouvintes JavaScript. Se desejar continuar usando Braze.subscribeToInAppMessage ou Braze.addListener conforme descrito em Acessando dados de mensagens no app, será necessário publicar os eventos por conta própria.
Implemente o IInAppMessageManagerListener conforme descrito em nosso artigo sobre Android em Custom Manager Listener. Na sua implementação de beforeInAppMessageDisplayed, você pode acessar os dados de inAppMessage, enviá-los para a camada JavaScript e decidir se deseja exibir ou não a mensagem nativa com base no valor de retorno.
Para mais informações sobre esses valores, consulte nossa documentação do Android.
// In-app messaging
@Override
public InAppMessageOperation beforeInAppMessageDisplayed(IInAppMessage inAppMessage) {
WritableMap parameters = new WritableNativeMap();
parameters.putString("inAppMessage", inAppMessage.forJsonPut().toString());
getReactNativeHost()
.getReactInstanceManager()
.getCurrentReactContext()
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("inAppMessageReceived", parameters);
// Note: return InAppMessageOperation.DISCARD if you would like
// to prevent the Braze SDK from displaying the message natively.
return InAppMessageOperation.DISPLAY_NOW;
}
Substituindo o delegate de interface padrão
Por padrão, BrazeInAppMessageUI é criado e atribuído quando você inicializa a instância braze. BrazeInAppMessageUI é uma implementação do protocolo BrazeInAppMessagePresenter e vem com uma propriedade delegate que pode ser usada para personalizar a manipulação de mensagens no app que foram recebidas.
-
Implemente o delegate
BrazeInAppMessageUIDelegateconforme descrito em nosso tutorial de interface de mensagens no app para iOS. -
No método de delegate
inAppMessage(_:displayChoiceForMessage:), você pode acessar os dados deinAppMessage, enviá-los para a camada JavaScript e decidir se deseja exibir ou não a mensagem nativa com base no valor de retorno.
Para mais detalhes sobre esses valores, consulte nossa documentação do iOS.
- (enum BRZInAppMessageUIDisplayChoice)inAppMessage:(BrazeInAppMessageUI *)ui
displayChoiceForMessage:(BRZInAppMessageRaw *)message {
// Convert the message to a JavaScript representation.
NSData *inAppMessageData = [message json];
NSString *inAppMessageString = [[NSString alloc] initWithData:inAppMessageData encoding:NSUTF8StringEncoding];
NSDictionary *arguments = @{
@"inAppMessage" : inAppMessageString
};
// Send to JavaScript.
[self sendEventWithName:@"inAppMessageReceived" body:arguments];
// Note: Return `BRZInAppMessageUIDisplayChoiceDiscard` if you would like
// to prevent the Braze SDK from displaying the message natively.
return BRZInAppMessageUIDisplayChoiceNow;
}
Para usar esse delegate, atribua-o a brazeInAppMessagePresenter.delegate após inicializar a instância braze.

BrazeUI só pode ser importado em Objective-C ou Swift. Se estiver usando Objective-C++, será necessário lidar com isso em um arquivo separado.
@import BrazeUI;
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:apiKey endpoint:endpoint];
Braze *braze = [BrazeReactBridge initBraze:configuration];
((BrazeInAppMessageUI *)braze.inAppMessagePresenter).delegate = [[CustomDelegate alloc] init];
AppDelegate.braze = braze;
}
Substituindo a interface nativa padrão
Se deseja personalizar completamente a apresentação das suas mensagens no app na camada nativa do iOS, implemente o protocolo BrazeInAppMessagePresenter e atribua seu apresentador personalizado seguindo este exemplo:
BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:apiKey endpoint:endpoint];
Braze *braze = [BrazeReactBridge initBraze:configuration];
braze.inAppMessagePresenter = [[MyCustomPresenter alloc] init];
AppDelegate.braze = braze;
Pré-requisitos
Antes de usar este recurso, você precisará integrar o SDK Android da Braze.
Envio de mensagens de registro de dados
Você precisará garantir que certas funções sejam chamadas para lidar com a análise de dados da sua campanha.
Envio de mensagens
Quando uma mensagem é exibida ou vista, registre uma impressão:
LogInAppMessageImpression(in_app_message.id, brazetask)
Envio de mensagens clicadas
Depois que um usuário clica na mensagem, registre um clique e então processe in_app_message.click_action:
LogInAppMessageClick(in_app_message.id, brazetask)
Botões clicados
Se o usuário clicar em um botão, registre o clique do botão e depois processe inappmessage.buttons[selected].click_action:
LogInAppMessageButtonClick(inappmessage.id, inappmessage.buttons[selected].id, brazetask)
Após o processamento de uma mensagem
Depois de processar uma mensagem no app, você deve limpar o campo:
m.BrazeTask.BrazeInAppMessage = invalid
Inscrevendo-se em mensagens no aplicativo
Você pode registrar objetos de jogo Unity para serem notificados sobre mensagens no app. Recomendamos configurar os ouvintes de objetos de jogo no editor de configuração do Braze. No editor de configuração, os ouvintes devem ser definidos separadamente para Android e iOS.
Se você precisar configurar o ouvinte do objeto do jogo em tempo de execução, use AppboyBinding.ConfigureListener() e especifique BrazeUnityMessageType.IN_APP_MESSAGE.
Analisando mensagens
As mensagens string recebidas em seu retorno de chamada de objeto de jogo de mensagem no app podem ser analisadas em nossos objetos de modelo pré-fornecidos por conveniência.
Use InAppMessageFactory.BuildInAppMessage() para analisar sua mensagem no app. O objeto resultante será uma instância de IInAppMessage.cs ou IInAppMessageImmersive.cs dependendo de seu tipo.
// Automatically logs a button click, if present.
void InAppMessageReceivedCallback(string message) {
IInAppMessage inApp = InAppMessageFactory.BuildInAppMessage(message);
if (inApp is IInAppMessageImmersive) {
IInAppMessageImmersive inAppImmersive = inApp as IInAppMessageImmersive;
if (inAppImmersive.Buttons != null && inAppImmersive.Buttons.Count > 0) {
inAppImmersive.LogButtonClicked(inAppImmersive.Buttons[0].ButtonID);
}
}
}
Registrando dados de mensagens
Os cliques e impressões devem ser registrados manualmente para mensagens no app não exibidas diretamente pelo Braze.
Use LogClicked() e LogImpression() em IInAppMessage para registrar os cliques e as impressões da sua mensagem.
Use LogButtonClicked(int buttonID) on IInAppMessageImmersive para registrar os cliques nos botões. Observe que os botões são representados como listas de instânciasInAppMessageButton cada uma das quais contém um ButtonID.