Implementar notificaciones push en Android

Una vez que el equipo de Actito haya realizado la configuración necesaria y haya obtenido el archivo SDK del repositorio Git para la aplicación push en Android, ya estará listo para implemente la biblioteca Notificare de Android en su aplicación. Nuestra biblioteca es compatible con la versión 6 de Android y superiores. Asegúrese de tener siempre el último SDK de Android cuando utilice esta biblioteca.

Dependencias

Para su comodidad, hemos creado un complemento de Gradle que simplifica la forma de configurar el SDK de Notificare. Abra el archivo build.gradle de su proyecto y agregue las siguientes entradas:

buildscript {
    repositories {
        maven { url 'https://maven.notifica.re/releases' }
    }
    dependencies {
        classpath 're.notifica.gradle:notificare-services:1.0.1'
    }
}

allprojects {
    repositories {
        maven { url 'https://maven.notifica.re/releases' }

        // Include the pre-releases repository to access beta builds.
        maven { url 'https://maven.notifica.re/prereleases' }
    }
}

Entendemos que no todas las aplicaciones aprovecharán todas las funciones que ofrece nuestra plataforma. Para ayudarlo a reducir el tamaño de su aplicación, la huella de dependencia y los permisos incluidos automáticamente, puede seleccionar qué módulos desea incluir en su aplicación.

En app/build.gradle de tu aplicación, agrega el complemento y las dependencias que necesitas.

plugins {
    // ...
    id 're.notifica.gradle.notificare-services'
}

dependencies {
    def notificare_version = 'REPLACE_WITH_LATEST_VERSION'
    implementation "re.notifica:notificare:$notificare_version"

    //
    // Optional modules
    //

    // Support for remote notifications
    implementation "re.notifica:notificare-push:$notificare_version"

    // Our standard UI for notification (recommended)
    implementation "re.notifica:notificare-push-ui:$notificare_version"

    // The tools to build a custom inbox UI
    // Choose one of the following modules depending on your use case
    implementation "re.notifica:notificare-inbox:$notificare_version"
    implementation "re.notifica:notificare-user-inbox:$notificare_version"

    // Automatically display in-app messages
    implementation "re.notifica:notificare-in-app-messaging:$notificare_version"

    // Location tracking and geofencing support
    implementation "re.notifica:notificare-geo:$notificare_version"
    implementation "re.notifica:notificare-geo-beacons:$notificare_version"     // Enable support for beacons detection.

    // Contextual storage
    implementation "re.notifica:notificare-assets:$notificare_version"

    // Enables native integration with Google Wallet
    implementation "re.notifica:notificare-loyalty:$notificare_version"

    // Handle NFC and QR-code scannables
    implementation "re.notifica:notificare-scannables:$notificare_version"
}

Agregar mensajería en la nube de Firebase

Android Studio facilita la importación rápida del proyecto FCM que creó anteriormente a su aplicación. Simplemente despliegue el menú Herramientas y haga clic en Firebase:

Esto abrirá una ventana del Asistente como la siguiente:

Simplemente haga clic en Configurar Firebase Cloud Messaging y siga las guías en la siguiente pantalla:

Completar los puntos anteriores preparará su aplicación con todo lo necesario para usar el proyecto FCM que creó previamente.

Se debe crear un archivo app/google-services.json. Este archivo contendrá la información de ID del remitente de su proyecto FCM.

Archivo de configuración

Para conectar su aplicación a Notificare, debe descargar el archivo de configuración del SDK que el equipo de Actito colocó en la caja de transferencia.

Para su información, así es como debería verse este archivo:

{
  "project_info": {
    "application_id": "{{ YOUR APPLICATION ID }}",
    "application_key": "{{ YOUR APPLICATION KEY }}",
    "application_secret": "{{ YOUR APPLICATION SECRET }}"
  }
}

De forma predeterminada, crearemos dos aplicaciones diferentes en Notificare utilizando entornos separados para desarrollo y producción. Para cada aplicación tendrá un conjunto diferente de claves, lo que dará como resultado dos archivos de configuración diferentes. Recomendamos aprovechar variantes de compilación/tipos de productos de Android para administrar qué archivo se integrará en la aplicación.

Crear un receptor de intenciones

Aunque este es un paso opcional, al crear su propio receptor de intenciones puede escuchar los eventos ready y device_registered. Podrás aprovechar para realizar pasos adicionales cuando Notificare esté listo o cuando el dispositivo esté actualizado.

Kotlin

class CustomIntentReceiver : NotificareIntentReceiver() {

    override fun onReady(context: Context, application: NotificareApplication) {
        // At this point you have been assigned a temporary device identifier
        // All services subscribed can be used
    }

    override fun onDeviceRegistered(context: Context, device: NotificareDevice) {
        // At this point you know a device is registered with the Notificare API.
        // This method will be called once when the device is registered.
    }
}

Java

public class CustomIntentReceiver extends NotificareIntentReceiver {

    @Override
    protected void onReady(@NonNull Context context, @NonNull NotificareApplication application) {
        // At this point you have been assigned a temporary device identifier
        // All services subscribed can be used
    }

    @Override
    protected void onDeviceRegistered(@NonNull Context context, @NonNull NotificareDevice device) {
        // At this point you know a device is registered with the Notificare API.
        // This method will be called once when the device is registered.
    }
}

Para notificar a Notificare de su destinatario de intención, puede ejecutar la siguiente declaración:

Kotlin

Notificare.intentReceiver = CustomIntentReceiver::class.java

Java

Notificare.setIntentReceiver(CustomIntentReceiver.class);

Al crear su receptor de intenciones personalizado, también debe declararlo en su archivo AndroidManifest.xml.

<?xml version="1.0" encoding="utf-8"?>
<manifest>

    <application>

        <receiver
            android:name=".CustomIntentReceiver"
            android:exported="false" />

    </application>

</manifest>

Actividad de notificación

Si planea utilizar el enfoque predeterminado para mostrar notificaciones, debe agregar un tema translúcido a NotificationActivity. Esto le permite mostrar alertas flotantes sobre su contenido.

<application>
    <activity
        android:name="re.notifica.push.ui.NotificationActivity"
        android:theme="@style/Theme.App.Translucent" />
</application>

Como referencia, puede utilizar el tema de muestra a continuación. Esto debe agregarse a su carpeta de recursos. Asegúrese de que el tema que está heredando sea un tema AppCompat. Por ejemplo, Theme.AppCompat.Light.DarkActionBar.

<resources>
    <!-- adjust the name and parent to match your theme -->
    <style name="Theme.App.Translucent" parent="Theme.App">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@android:color/transparent</item>
    </style>
</resources>

Puede encontrar información adicional sobre el sistema de temas en la documentación oficial de Android ubicada aquí.

Iniciar notificación

Iniciar Notificare es tan simple como llamar a Notificare.launch(). Sin embargo, antes de comenzar, es posible que desees considerar personalizar algunas propiedades.

Si creó un receptor de intenciones personalizado, también debe configurar la propiedad Notificare.intentReceiver para indicarle a Notificare qué clase manejará las intenciones.

Debe iniciar Notificare cuando se crea la aplicación de Android. A continuación se puede encontrar un pequeño código de muestra.

Kotlin

class MainApplication : Application() {
    private val applicationScope = MainScope()

    override fun onCreate() {
        super.onCreate()

        // In case you want to setup your custom intent receiver.
        Notificare.intentReceiver = CustomIntentReceiver::class.java

        applicationScope.launch {
            try {
                // Launch Notificare! 🚀
                Notificare.launch()

                // Notificare is now ready.
            } catch (e: Exception) {
                // Something went wrong ...
            }
        }
    }
}

Java

public class MainApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        // In case you want to setup your custom intent receiver.
        Notificare.setIntentReceiver(CustomIntentReceiver.class);

        // Launch Notificare! 🚀
        Notificare.launch(new NotificareCallback<Unit>() {
            @Override
            public void onSuccess(Unit result) {
                // Notificare is now ready.
            }

            @Override
            public void onFailure(@NonNull Exception e) {
                // Something went wrong ...
            }
        });
    }
}

Puedes retrasar el inicio de Notificare por primera vez. De lo contrario, asegúrese de iniciar() durante la fase de inicialización de la aplicación para evitar perder actualizaciones importantes mientras la aplicación se construye en segundo plano.

Aunque launch() es una función de suspensión (con una alternativa de devolución de llamada), también puedes usar el método onReady() desde un NotificareIntentReceiver personalizado o agregar un oyente como se muestra a continuación cuando lo desees. . para controlar el estado de las dependencias en el flujo de inicialización de su aplicación.

Kotlin

class MainActivity : AppCompatActivity(), Notificare.Listener {
    override fun onCreate(savedInstanceState: Bundle?) {
        // more code ...

        Notificare.addListener(this)
    }

    override fun onDestroy() {
        // more code ...

        Notificare.removeListener(this)
    }

    override fun onReady(application: NotificareApplication) {
        // Notificare is now safe to use.
    }
}

Java

public class MainActivity extends AppCompatActivity implements Notificare.Listener {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        // more code ...

        Notificare.addListener(this);
    }

    @Override
    protected void onDestroy() {
        // more code ...

        Notificare.removeListener(this);
    }

    @Override
    public void onReady(@NonNull NotificareApplication application) {
        // Notificare is now safe to use.
    }
}

Cancelar el lanzamiento de Notificare

Es posible eliminar completamente todos los datos de un dispositivo, tanto localmente en su aplicación como de forma remota en nuestros servidores. Desea evitar hacer esto, pero en los casos en que el usuario solicite eliminar su cuenta, puede utilizar el siguiente método:

Kotlin

Notificare.unlaunch()

Java

Notificare.unlaunch(new NotificareCallback<Unit>() {
    @Override
    public void onSuccess(Unit result) {

    }

    @Override
    public void onFailure(@NonNull Exception e) {

    }
});

Después de invocar esta función, todos los datos del dispositivo se destruirán y ya no se podrán deshacer. Una vez que se complete el proceso, se ejecutará el método onUnlaunched de su NotificareIntentReceiver personalizado o de sus oyentes.

Kotlin

class MainActivity : AppCompatActivity(), Notificare.Listener {
    override fun onCreate(savedInstanceState: Bundle?) {
        // more code ...

        Notificare.addListener(this)
    }

    override fun onDestroy() {
        // more code ...

        Notificare.removeListener(this)
    }

    override fun onUnlaunched() {
        // All device data was deleted.
        // Notificare cannot be used until it's launched again.
    }
}

Java

public class MainActivity extends AppCompatActivity implements Notificare.Listener {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        // more code ...

        Notificare.addListener(this);
    }

    @Override
    protected void onDestroy() {
        // more code ...

        Notificare.removeListener(this);
    }

    @Override
    public void onUnlaunched() {
        // All device data was deleted.
        // Notificare cannot be used until it's launched again.
    }
}

En este punto, llamar a cualquier otro método en Notificare fallará y la única forma de comenzar a usar el SDK nuevamente es invocar su contraparte, el método launch.