Implementação Firebase

Veja neste guia como é simples integrar seu aplicativo Android que utiliza Firebase (Firebase Cloud Messaging) com a plataforma Inngage

1. Obtendo o google-services.json

1.1 Inicialmente acesse o console do Firebase através do endereço: https://console.firebase.google.com/ (você deverá possuir uma conta do Gmail)
1.2 Você poderá importar um projeto existente ou criar um novo projeto
1.3 Ao criar um novo projeto você deverá definir um nome para o mesmo, selecionar o País/Região e clicar no botão "Criar Projeto"

874

1.4 Se tudo correr bem você será direcionado para a tela inicial do console

800

1.5 Na sequência clique na opção "Adicionar o Firebase ao seu aplicativo Android"
1.6 Você deverá informar o nome do pacote do seu aplicativo Android. Certifique-se de informar o applicationId disponível no build.gradle (Module: app). Em seguida clique no botão "Registrar App"

1366

1.7 Clique no botão "Fazer o download google-services.json" e copie o arquivo google-services.json para dentro do diretório app do seu projeto no Android Studio. Em seguida clique no "X" para fechar a janela

629

2. Obtendo a chave de API para conexão com o FCM

2.1 Na tela inicial do console do Firebase navegue até as configurações do seu app

800

2.2 Clique na aba Cloud Messaging e a chave de API será apresentada no campo Chave herdada do servidor

1948

3. Configurando a chave de API na plataforma Inngage

3.1 Acesse o dashboard da plataforma Inngage e navegue até Configurações do App > Plataformas
3.2 Na sequência adicione sua chave de API

1650

4. Configurando o seu App

❗️

Compilação API level 23

Caso o seu app precise ser compilado utilizando a API level 23 (compileSdkVersion 23), para garantir a compatibilidade do Firebase com o Android 6 você deverá usar as versões dos plugins do Google e da nossa biblioteca apresentadas no seguinte link:
https://inngage.readme.io/v1.0/docs/compatibilidade-firebase-android-6-marshmallow

4.1 Dentro do seu projeto no Android Studio, abra o arquivo build.gradle (Module: app) e adicione as seguintes dependências ao seu projeto:

compile 'com.google.android.gms:play-services:11.0.1'
compile 'com.google.firebase:firebase-core:11.0.1'
compile 'com.google.firebase:firebase-messaging:11.0.1'

4.2 Ainda no arquivo build.gradle (Module: app), adicione no final do arquivo o seguinte plugin:

apply plugin: 'com.google.gms.google-services'

Um exemplo completo deste arquivo pode ser obtido em nosso Github.

4.3 Abra o arquivo build.gradle (Project: SeuProjeto) e adicione a seguinte dependência:

classpath 'com.google.gms:google-services:3.1.0'

Um exemplo completo deste arquivo pode ser obtido em nosso Github.

5. Importando a biblioteca inngage-lib

5.1 Adicione a seguinte dependência no arquivo build.gradle (Module: app)

compile 'br.com.inngage.sdk:inngage-lib:2.1.1'

Em alguns casos, se faz necessário dar um refresh nas dependências do projeto através do comando:
./gradlew --refresh-dependencies para Mac
gradle --refresh-dependencies para Windows

6. Alterações no manifesto do projeto

6.1 Adicione as seguintes entradas antes do fechamento da tag no arquivo AndroidManifest.xml do seu projeto:

<service android:name="br.com.inngage.sdk.PushMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>
<service android:name="br.com.inngage.sdk.InngageIDService">
    <intent-filter>
        <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
    </intent-filter>
</service>
<service android:name="br.com.inngage.sdk.InngageIntentService" 
         android:exported="false">
</service>

6.2 Para a abertura de landing pages é necessário adicionar a permissão para acesso à Internet

<uses-permission android:name="android.permission.INTERNET" />

7. Subscrição do usuário na plataforma Inngage

7.1 Visando desacoplar as constantes utilizadas em nossa integração, adicione uma nova classe ao seu projeto denominada InngageConstants

interface InngageConstants {

    String inngageAppToken = "SEU_APP_TOKEN";
    String inngageEnvironment = "AMBIENTE_INNGAGE";
    String googleMessageProvider = "PROVEDOR_GOOGLE";
}

Para a variável inngageEnvironment são aceitos os valores dev ou prod. Estes valores correspondem ao ambiente de desenvolvimento/sandbox ou produção da Inngage.
Já para a variável googleMessageProvider são aceitos os valores FCM ou GCM. Utilize FCM caso o seu projeto use o Firebase Cloud Messaging, e GCM caso ele use o Google Cloud Messaging.

7.2 Na activity que será responsável por fazer a subscrição do usuário na plataforma Inngage, implemente uma chamada ao método startInit.

InngageIntentService.startInit(
                this,
                InngageConstants.inngageAppToken,
                InngageConstants.inngageEnvironment,
                InngageConstants.googleMessageProvider);

As seguintes sobrecargas são aceitas no método startInit:
A) Passagem do identificador do usuário (CPF, e-mail, etc) como parâmetro:

InngageIntentService.startInit(
                this,
                InngageConstants.inngageAppToken,
                "[email protected]",
                InngageConstants.inngageEnvironment,
                InngageConstants.googleMessageProvider);

B) Passagem do identificador do usuário (CPF, e-mail, etc) e de campos adicionais a serem utilizados na segmentação de campanhas como parâmetros:

JSONObject jsonCustomField = new JSONObject();

        try {
            jsonCustomField.put("primeiro_nome", "Manoel");
            jsonCustomField.put("cidade", "São Paulo");
            jsonCustomField.put("estado", "SP");

        } catch (JSONException e) {

            e.printStackTrace();
        }

        InngageIntentService.startInit(
                this,
                InngageConstants.inngageAppToken,
                "[email protected]",
                InngageConstants.inngageEnvironment,
                InngageConstants.googleMessageProvider,
                jsonCustomField);

8. Exibição do Push

8.1 Configure o nome do pacote do seu app e a classe que receberá o evento do push em Configurações do App > Plataformas:

1650

8.2 Implemente o recebimento da notificação na classe que receberá o evento de abertura push.

private void handleNotification() {

        String notifyID = "", title = "", body = "";

        Bundle bundle = getIntent().getExtras();

        if (getIntent().hasExtra("EXTRA_NOTIFICATION_ID")) {

            notifyID = bundle.getString("EXTRA_NOTIFICATION_ID");
        }
        if (getIntent().hasExtra("EXTRA_TITLE")) {

            title = bundle.getString("EXTRA_TITLE");
        }
        if (getIntent().hasExtra("EXTRA_BODY")) {

            body = bundle.getString("EXTRA_BODY");
        }
        if (!"".equals(notifyID) || !"".equals(title) || !"".equals(body)) {

            InngageUtils.showDialog(
                    title,
                    body, 
              			notifyID,
                    InngageConstants.inngageAppToken,
                    InngageConstants.inngageEnvironment,
                    this);
        }
    }

Implemente no onStart() da sua activity a chamada ao método handleNotification() para que a notificação seja exibida.

@Override
    protected void onStart() {
        super.onStart();

        handleNotification();

    }

8.3 Caso você necessite receber algum tipo de Extra Data para abrir uma nova Activity, por exemplo, inclua a seguinte tratativa dentro do método handleNotification():

if (getIntent().hasExtra("EXTRA_DATA")) {

  try {

	  JSONArray jsonData = new JSONArray(bundle.getString("EXTRA_DATA"));

    String action = jsonData.getJSONObject(0).getString("action");

    if("payments".equals(action)) {

      startActivity(new Intent(this, PaymentsActivity.class));
    }

  } catch (JSONException e) {
  
    e.printStackTrace();
  }
}

🚧

Chamada ao método handleNotification()

Não se esqueça que o método handleNotification() deverá ser chamado dentro do onCreate ou onStart da activity que será responsável por apresentar a notificação. Em caso de dúvidas, veja um um exemplo desta chamada em nosso Git.

9. Ícone da Notificação

9.1 Para uma perfeita visualização do ícone do seu aplicativo na versões superiores ao Android 5 - Lollipop (API level 21), é recomendada a criação de um ícone na cor branca e com transparência. Além disso, a seguinte entrada deve ser adicionada ao manifesto do seu projeto.

<meta-data
            android:name="com.google.firebase.messaging.default_notification_icon"
            android:resource="@mipmap/ic_notification" />

<meta-data
            android:name="com.google.firebase.messaging.default_notification_color"
            android:resource="@color/colorGreen" />

Onde:
ic_notification é o ícone na cor branca e com transparência que será exibido na notificação.
colorGreen é a cor de fundo do ícone.

2154

10. Geolocalização

Os passos a seguir deverão ser seguidos para incluir no seu app o suporte ao nosso serviço de geolocalização inteligente.

10.1 Adicione as seguintes constantes na classe InngageConstants que foi criada no passo 7.1. Para ver a estrutura completa desta classe, acesso o nosso Git.

int updateInterval = 60000;
int priorityAccuracy = 104;
int displacement = 100;
int PERMISSION_ACCESS_LOCATION_CODE = 99;
String LOCATION_NOT_FOUND = "Não foi possível obter a localização do usuário";}

Onde:
updateInterval é a quantidade de tempo em milissegundos que o aplicativo deverá receber atualizações de localização
displacement é o deslocamento mínimo entre as atualizações de localização em metros
priorityAccuracy é a precisão da localização a ser recebida, podendo receber o seguinte valores:

ConstanteDescrição
100Utilize para obter uma maior precisão o que resultará na melhor localização disponível. Em contrapartida, esta opção demandará um maior consumo de bateria do aparelho.
102O nível de precisão da localização será de aproximadamente 100 metros ou uma quadra. Esta opção demandará um menor consumo de bateria do aparelho.
104O nível de precisão da localização será de aproximadamente 10 quilômetros. Esta opção demandará um baixo consumo de bateria do aparelho.
105O nível de precisão da localização será o melhor possível sem nenhum consumo adicional de bateria. Nesta opção, nenhuma localização será retornada até que algum outro aplicativo a requisite, dessa forma a recuperação da localização será feita de forma passiva.

Na activity principal do seu projeto que será responsável por iniciar o serviço de geolocalização, declare a seguinte variável de instância:

ServiceUtils serviceUtils = new ServiceUtils(MainActivity.this);

Onde:
MainActivity.this deve ser a referência da sua classe

10.2 A partir do Android 6 ou Android M, para utilizar qualquer recurso do dispositivo temos que solicitar a permissão do usuário em tempo de execução. Para que possamos obter a permissão e recuperarmos a localização do usuário, adicione o seguinte método dentro da sua activity principal.

public void askPermissions() {
    mBothPermissionRequest =
        InngagePermissionUtil.with(this).request(
            android.Manifest.permission.ACCESS_COARSE_LOCATION,
            android.Manifest.permission.ACCESS_FINE_LOCATION).onResult(
            new GrantPermission() {@
                Override
                protected void call(int requestCode, String[] permissions, int[] grantResults) {

                    if (grantResults[0] == PackageManager.PERMISSION_GRANTED &&
                        grantResults[1] == PackageManager.PERMISSION_GRANTED) {

                        serviceUtils.startService(
                            InngageConstants.updateInterval,
                            InngageConstants.priorityAccuracy,
                            InngageConstants.displacement,
                            InngageConstants.inngageAppToken);

                    } else {

                        Toast.makeText(
                            MainActivity.this,
                            InngageConstants.LOCATION_NOT_FOUND,
                            Toast.LENGTH_LONG).show();
                    }
                }

            }).ask(InngageConstants.PERMISSION_ACCESS_LOCATION_CODE);
}

Assim que a activity for iniciada, a seguinte janela será apresentada para o usuário:

300

10.3 Implemente o método handleLocation() para iniciar o serviço de geolocalização.

private void handleLocation() {

        if (InngageUtils.hasM() && !(ContextCompat.checkSelfPermission(
                this,
                Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
                && ContextCompat.checkSelfPermission(
                        this,
                Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED)) {

            askPermissions();

        } else {

            serviceUtils.startService(
                    InngageConstants.updateInterval,
                    InngageConstants.priorityAccuracy,
                    InngageConstants.displacement,
                    InngageConstants.inngageAppToken);
        }
    }

No método onStart da sua activity principal será necessário chamar o método handleLocation():

@Override
    protected void onStart() {
        super.onStart();
      
        handleLocation();
    }

10.4 As seguintes entradas deverão ser adicionadas ao manifesto do seu projeto (antes do fechamento da tag ):

<service android:name="br.com.inngage.sdk.InngageIntentService"
            android:exported="false">
        </service>
        <service
            android:name="br.com.inngage.sdk.InngageLocationService"
            android:enabled="true"
            android:exported="true"
            android:label="Geo Service"
            android:permission="android.permission.BIND_JOB_SERVICE">
        </service>

        <receiver android:name=".LocationServiceReceiver">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>

10.5 Adicione as seguintes permissões no manifesto do projeto:

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

10.6 Para que o serviço de geolocalização seja iniciado após o aparelho for reiniciado, adicione a implementação da seguinte classe ao seu projeto:

public class LocationServiceReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {


        InngageServiceUtils serviceUtils = new InngageServiceUtils(context);
        serviceUtils.startService(
                InngageConstants.updateInterval,
                InngageConstants.priorityAccuracy,
                InngageConstants.displacement,
                InngageConstants.inngageAppToken);
    }
}

📘

Projeto Exemplo

Disponibilizamos em nosso Git o projeto exemplo que foi utilizado neste guia.
https://github.com/inngage/geolocation-demo