Android SDK
A versão mais recente da SDK Android é a v4.2.0-rc.
Passos da integração
1. Configuração do projeto no Firebase
2. Configuração no painel Inngage
3. Configuração nativa Android
Após concluir a configuração do serviço Firebase, estamos prontos para iniciar a integração da SDK da Inngage em aplicativos Android.
Nossa SDK para Android desempenha um papel crucial na conexão entre aplicativos móveis e o backend de notificações inteligentes da Inngage. Ela permite a administração do registro de dispositivos, a configuração de campos personalizáveis, o processamento de notificações push e mensagens In-App e uma série de outras funcionalidades.
Instalação
Importando o FCM Token (API Key)
Para aproveitar nossos SDKs, será necessário importar o FCM Token (API Key) do seu projeto Firebase em nossa plataforma. Siga o passo a passo neste link para executar essa ação.
Configurando o GMS e os serviços do Firebase no projeto
Antes de proceder com a implementação da biblioteca, é necessário abrir o arquivo build.gradle
(Module: app) dentro do seu projeto no Android Studio. A seguir, adicione as seguintes dependências ao seu projeto, conforme demonstrado abaixo:
plugins {
id 'com.android.application'
id 'com.google.gms.google-services'
}
dependencies {
// Firebase
implementation 'com.google.firebase:firebase-core:19.0.2'
implementation 'com.google.firebase:firebase-messaging:22.0.0'
// Adicione esta dependência para executar o WorkManager para o serviço de registro de usuário da Inngage.
implementation 'androidx.work:work-runtime:2.8.0'
}
No arquivo build.gradle
(Project: AppName), inclua o seguinte código para adicionar a dependência do plugin google-services
, que é necessário para configurar os serviços do Google, como Firebase, no projeto Android:
buildscript {
dependencies {
classpath 'com.google.gms:google-services:4.3.15'
}
}
Instalando a lib da Inngage
Para adicionar a SDK Android da Inngage ao seu projeto, implemente o seguinte código no build.gradle
(Module: app):
dependencies {
implementation 'com.github.inngage:inngage-lib:v4.2.0-rc"
}
No arquivo build.gradle
(Project: AppName), certifique-se de que as configurações e dependências necessárias para a fase de build do projeto estejam corretamente definidas, incluindo os repositórios onde o Gradle buscará essas dependências para a compilação.
buildscript {
repositories {
google()
mavenCentral()
maven { url 'https://jitpack.io' }
}
}
Em alguns casos, é necessário fazer refresh nas dependências do projeto. Clique em "Sync"/"Sincronizar" na IDE ou execute o comando:
./gradlew --refresh-dependencies para Mac
gradle --refresh-dependencies para Windows
Implementando a SDK
Notificações push
As notificações serão enviadas do servidor da Inngage para um ou mais dispositivos móveis, mesmo quando o aplicativo estiver em primeiro plano, segundo plano ou até mesmo fechado. Essas mensagens têm o objetivo de alertar o usuário sobre informações importantes, atualizações ou qualquer outro dado relevante relacionado ao seu aplicativo.
As notificações push aparecem na tela de bloqueio ou na barra de notificações do dispositivo. Quando o usuário toca na notificação, o aplicativo é aberto e pode direcioná-lo para uma página específica ou exibir mais detalhes sobre o conteúdo da notificação.
Interface InngageConstantes { }
Com o objetivo de desacoplar as constantes usadas na integração, crie uma nova interface em seu projeto chamada InngageConstants
e adicione o seguinte código:
public interface InngageConstants {
String appToken = "<app_token>"; // Adicione o app_token da plataforma Inngage.
String environment = "prod";
String provider = "FCM";
String email = "<email>"; // Adicione o email do cliente. (Opcional)
String phoneNumber = "<phone_number>"; // Adicione o telefone do cliente. (Opcional)
}
Configuração da Activity de abertura do aplicativo
Na Activity inicial do seu aplicativo, adicione o código abaixo:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_splash);
final Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.putExtras(getIntent());
new Handler().postDelayed(() -> startActivity(intent), 2000);
}
Registrando usuário na Inngage
InngageService.subscribe();
Esse método deve ser chamado para informar o usuário sobre a chegada das notificações e inicializar o Inngage dentro do seu aplicativo. Geralmente, é chamado na MainActivity
dentro do onCreate()
.
import com.example.inngage_lib.InngageService;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
InngageService.subscribe(
this,
InngageConstants.appToken,
InngageConstants.environment,
InngageConstants.provider,
InngageConstants.identifier
);
}
}
O trecho de código menciona alguns parâmetros e funcionalidades do Inngage SDK no contexto do Flutter. Aqui está uma explicação das principais informações:
- appToken: É o token do aplicativo na plataforma Inngage, essencial para a comunicação com os serviços da Inngage.
- environment: Valor padrão: prod.
- provider: Valor padrão: FCM.
- identifier: É usado para identificar o usuário dentro do sistema. Esse parâmetro deve ser preenchido para que o usuário possa ser corretamente associado e receber as notificações push de forma personalizada.
Configurando o recebimento de notificações push
InngageUtils.handleNotification();
Esse método deve ser chamado para realizar as configurações de push no aplicativo e, principalmente, solicitar o acesso às notificações do usuário. Ao executar esse método, o aplicativo informa ao sistema operacional que deseja receber notificações push e é autorizado a fazê-lo, desde que o usuário conceda permissão para receber tais notificações.
import com.example.inngage_lib.InngageService;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
InngageService.subscribe(
this,
InngageConstants.appToken,
InngageConstants.environment,
InngageConstants.provider,
InngageConstants.identifier
);
// Adicione este método da Inngage:
InngageUtils.handleNotification(this, getIntent(), appToken, env);
}
}
Personalização (para sua identidade)
Adicionando Campos Personalizados
A SDK permite que o desenvolvedor que está integrando a SDK adicione campos customizáveis (customFields), como nome, e-mail, gênero, etc. No entanto, esses parâmetros devem ser configurados previamente na plataforma da Inngage.
private JSONObject setCustomFields(){
JSONObject customFields = new JSONObject();
try {
customFields.put("nome", user.name);
customFields.put("email", user.email);
customFields.put("telefone", user.phone);
customFields.put("dataRegistro", user.registerDate);
customFields.put("dataNascimento", user.birthDate);
} catch (JSONException e) {
e.printStackTrace();
}
return customFields;
}
Adicione o método como parâmetro logo após o identifier:
InngageService.subscribe(
this,
InngageConstants.appToken,
InngageConstants.environment,
InngageConstants.provider,
InngageConstants.identifier,
setCustomFields() // Adicione o método dos campos customizáveis
);
Envio de eventos
InngageService.sendEvent()
A SDK permite que o desenvolvedor que está integrando a SDK envie eventos customizados. É importante configurá-los na plataforma Inngage para garantir uma boa performance e integração.
private JSONObject setEventValues(){
JSONObject eventValues = new JSONObject();
try {
eventValues.put("nome", "");
eventValues.put("email", "");
eventValues.put("telefone", "");
} catch (JSONException e) {
e.printStackTrace();
}
return eventValues;
}
Adicione o método dos valores do evento no método da Inngage de envio de eventos:
InngageService.sendEvent(
InngageConstants.appToken,
InngageConstants.identifier,
"Event Name", // Nome do evento
setEventValues() // Valores do evento
);
Existem três valores obrigatórios para garantir o correto funcionamento:
- eventName: Define o nome do evento, que será usado para identificá-lo rapidamente na plataforma.
- appToken: É necessário para validar suas credenciais.
- identifier: É usado para identificar o usuário dentro do sistema.
Você também pode adicionar valores avançados para esse evento usando o parâmetro eventValues, que é um array contendo chaves e valores com dados que serão anexados ao evento.
A API de eventos também pode receber um evento de conversão, para isso, existem os seguintes campos:
- conversion_event: Defina como True para indicar que é um evento de conversão.
- conversion_value: Esse campo permite inserir o valor monetário da conversão. O valor padrão é FLOAT 11000.00.
- conversion_notid: Opção para enviar o ID Único da Notificação da Inngage (NOTID), que foi recebido pelo app no momento do Push. Isso possibilita atribuir uma conversão a um determinado Push."
In App Messages
A SDK Android da Inngage possibilita a exibição de Mensagens In App para os usuários. Essas mensagens podem ser enviadas tanto pela plataforma quanto pela API e são automaticamente apresentadas com base nas configurações recebidas pelo payload do Firebase.
Para que a Activity da In App tenha seu fundo transparente, adicione na resource do seu projeto em styles o seguinte código:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<style name="Theme.AppCompat.Translucent" parent="Theme.AppCompat.DayNight.NoActionBar">
<item name="android:windowNoTitle">true</item>
<item name="android:windowFullscreen">true</item>
<item name="android:windowBackground">@android:color/transparent</item>
<item name="android:colorBackgroundCacheHint">@null</item>
<item name="android:windowIsTranslucent">true</item>
<item name="android:windowAnimationStyle">@android:style/Animation</item>
<item name="android:windowActionBar">false</item>
</style>
</resources>
Para apresentar a mensagem In App, no cenário com o aplicativo aberto ou segundo plano, adicione a Activity do In App da Inngage em seu AndroidManifest.xml:
<activity
android:name="br.com.inngage.sdk.InApp"
android:theme="@style/Theme.AppCompat.Translucent">
</activity>
Agora para que possa apresentar a mensagem In App, no cenário da abertura do aplicativo logo após dele estar fechado, adicione o seguinte código na MainActivity de seu projeto dentro do onCreate():
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new InAppUtils().startInApp(this); // Adicione esse código.
}
Finalizando configuração do AndroidManifest.xml
Adicionando permissões
Se estiver utilizando seu próprio
PushMessagingService
, consulte a documentação neste link para concluir as últimas implementações da SDK e finalizar o processo de integração.
Depois de implementar a biblioteca da Inngage, o arquivo de manifesto precisa de algumas permissões e serviços a serem adicionados:
Antes da tag <application>
:
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
Dentro da tag <application>
:
<service android:name="br.com.inngage.sdk.PushMessagingService">
<intent-filter>
<action android:name="com.google.firebase.MESSAGING_EVENT"/>
</intent-filter>
</service>
<meta-data
android:name="com.google.firebase.messaging.default_notification_icon"
android:resource="@drawable/ic_notification" />
Ícone de notificação !
É obrigatório colocar o ícone de notificação no repositório drawable sob o nome ic_notification como no exemplo abaixo:
android:resource="@drawable/ic_notification"
Você está pronto para começar!
Seguindo os passos acima da documentação você estará pronto para utilizar todas as ferramentas necessárias para as funcionalidades da SDK. 👏
Confira nossa POC da SDK Inngage:
Para ajudar você na integração com a SDK da Inngage, disponibilizamos para você uma POC da implementação nestes links: Kotlin e Java.
Updated about 2 months ago