Saltar al contenido principal

Android: implementar notificaciones remotas

En esta página, aprenderá cómo se manejan las notificaciones en su aplicación y cuáles son todas las opciones disponibles para crear una excelente experiencia de correo electrónico para sus usuarios.

precaución

Notificare admite varios tipos de notificaciones interactivas y procesables que se procesarán por usted sin ningún desarrollo adicional. Si desea evitar este comportamiento predeterminado, tenga en cuenta que deberá administrar todas las funciones usted mismo (registro de métricas, presentación de la interfaz de usuario o recopilación de respuestas) o, si no lo hace, comprende que algunas funciones no funcionarán como deberían. anunciado. .

Solicitar permiso​

Desde Android 13, el permiso de notificación no se otorga de forma predeterminada y debe solicitarse. Recomendamos apuntar a Android 13 para tener más control sobre la solicitud.

Al ejecutar Android 13 y apuntar a Android 12 o anterior, se pedirá permiso a los usuarios al crear el canal de notificación. Normalmente, cuando se inicia la aplicación.

Aunque las solicitudes de permiso deben seguir un estándar recomendado, controlar la experiencia general es algo específico de cada aplicación. Sin embargo, puede utilizar el siguiente código como inspiración para su implementación.

class MainActivity : AppCompatActivity() {

    private val notificationsPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (!granted) {
            // User denied notifications permissions
            return@registerForActivityResult
        }

        // You can enable remote notifications

        lifecycleScope.launch {
            try {
                Notificare.push().enableRemoteNotifications()
            } catch (e: Exception) {
                // ...
            }
        }
    }

    private fun onEnableRemoteNotificationsClicked() {
        // Ensure we have sufficient permissions
        if (!ensureNotificationsPermission()) return

        // We have sufficient permissions to enable remote notifications

        lifecycleScope.launch {
            try {
                Notificare.push().enableRemoteNotifications()
            } catch (e: Exception) {
                // ...
            }
        }
    }

    private fun ensureNotificationsPermission(): Boolean {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return true

        val permission = android.Manifest.permission.POST_NOTIFICATIONS
        val granted = ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED
        if (granted) return true

        if (shouldShowRequestPermissionRationale(permission)) {
            AlertDialog.Builder(this)
                .setTitle(R.string.app_name)
                .setMessage(R.string.notifications_permission_rationale)
                .setPositiveButton(android.R.string.ok) { _, _ ->
                    notificationsPermissionLauncher.launch(permission)
                }
                .show()

            return false
        }

        notificationsPermissionLauncher.launch(permission)
        return false
    }
}

Habilitar notificaciones​

Para permitir que el dispositivo reciba notificaciones, solo necesita invocar un único método.

// Check if the user has previously enabled remote notifications.
Notificare.push().hasRemoteNotificationsEnabled

Normalmente, el paso anterior se realiza durante algún tipo de incorporación de usuarios. Cuando el usuario ya ha seguido este feed, habilitamos automáticamente las notificaciones cuando se inicia Notificare.

También puede comprobar si el usuario se ha registrado para recibir notificaciones remotas.

// Check if the user has previously enabled remote notifications.
Notificare.push().hasRemoteNotificationsEnabled

Además, puede comprobar si el usuario ha desactivado las notificaciones en la configuración del sistema.

Notificare.push().allowedUI

Si también desea brindar acceso a la vista de configuración de su aplicación desde la configuración de notificaciones en la configuración del dispositivo, puede escuchar la intención NOTIFICATION_PREFERENCES. Esto agregará un enlace a su actividad en la configuración del dispositivo.

<activity android:name=".SettingsActivity">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.NOTIFICATION_PREFERENCES" />
    </intent-filter>
</activity>

alt text

Desactivar notificaciones de forma remota​

Deshabilitar las notificaciones de forma remota se puede hacer de la misma manera que habilitarlas.

Notificare.push().disableRemoteNotifications()

Cuando se llama a este método, registraremos automáticamente su dispositivo para nunca recibir notificaciones remotas, aunque siempre mantendrá el mismo perfil de usuario, los mismos mensajes de la bandeja de entrada y disfrutará de todos los demás servicios admitidos por su plan. Puede solicitar volver a registrarse para recibir notificaciones automáticas en cualquier momento si lo desea.

Recibir notificaciones​

Debido a los cambios de Android 12 en la gestión de notificaciones, su actividad debe convertirse en un trampolín. . Suponiendo que permite que su MainActivity reciba los intents de notificación, debe declarar el siguiente intent-filter en su AndroidManifest.xml.

<activity android:name=".MainActivity" android:launchMode="singleTask">
    <intent-filter>
        <action android:name="re.notifica.intent.action.RemoteMessageOpened" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Debes configurar la actividad que recibe estos intents con android:launchMode="singleTask" para evitar recrearla varias veces al procesar la serie de intents desencadenados al abrir una notificación desde el cajón de notificaciones. También puedes usar android:launchMode="singleTop", pero ten en cuenta que el sistema operativo lo recreará cuando procese enlaces profundos activados por NotificationActivity. Para obtener más información sobre los modos de inicio, consulte la documentación de Android.

Además, para procesar estos intents, debes cuidarlos en tu MainActivity como se muestra a continuación.

override fun onCreate(savedInstanceState: Bundle?) {
    // more code ...

    if (intent != null) handleIntent(intent)
}

override fun onNewIntent(intent: Intent?) {
    // more code ...

    if (intent != null) handleIntent(intent)
}

private fun handleIntent(intent: Intent) {
    if (Notificare.push().handleTrampolineIntent(intent)) {
        Log.d(TAG, "Trampoline intent handled.")
        return
    }

    // more code ...
}

Escuchar las notificaciones recibidas​

Una vez que reciba notificaciones en su aplicación, podremos profundizar y comprender completamente cómo se procesan. Nuestra biblioteca se encarga de colocar una notificación en el centro de notificaciones para que los desarrolladores no necesiten ninguna acción para mostrar las notificaciones. Si desea recibir notificaciones de notificaciones entrantes en su propio receptor de intenciones, por ejemplo, para agregar una insignia al ícono del iniciador de su aplicación, puede usar NotificarePushIntentReceiver.

Comience creando una subclase de este receptor de intención y anulando el método onNotificationReceived().

class CustomPushIntentReceiver: NotificarePushIntentReceiver() {
    override fun onNotificationReceived(
        context: Context,
        notification: NotificareNotification,
        deliveryMechanism: NotificareNotificationDeliveryMechanism
    ) {
        // more code ...
    }
}

Para recibir estos intents en su receptor de intents, debe informarle a Notificare sobre su clase.

Notificare.push().intentReceiver = CustomPushIntentReceiver::class.java

Finalmente, declara tu receptor de intención personalizado en tu AndroidManifest.xml.

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

Mostrar notificaciones​

Se puede abrir una notificación tocando la notificación misma o tocando una acción dentro de la notificación. Emitiremos un intent en cada caso para una Actividad que declara los filtros de intención apropiados. Para recibir estos intents, agregue lo siguiente a su MainActivity en AndroidManifest.xml.

<activity android:name=".MainActivity">
    <intent-filter>
        <action android:name="re.notifica.intent.action.NotificationOpened" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
    <intent-filter>
        <action android:name="re.notifica.intent.action.ActionOpened" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Para manejar los intentos anteriores, puede adoptar el enfoque administrado y utilizar nuestro módulo NotificarePushUI que admite todos los eventos y tipos de UI, así como acciones, o puede admitirlos por completo y presentarlos como desee. Sin embargo, tenga en cuenta si adopta un enfoque no administrado, ya que deberá administrar todos los aspectos y tipos de presentación de notificaciones, incluidos los eventos necesarios para mostrar la participación del usuario en nuestro panel.

El siguiente código ilustra cómo funciona esto cuando se utiliza el enfoque administrado.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // more code ...

    if (intent != null) handleIntent(intent)
}

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    // more code ...

    if (intent != null) handleIntent(intent)
}

private fun handleIntent(intent: Intent) {
    if (NotificarePushCompat.handleTrampolineIntent(intent)) return;

    Notificare.push().parseNotificationOpenedIntent(intent)?.also { result ->
        Notificare.pushUI().presentNotification(this, result.notification)
        return
    }

    Notificare.push().parseNotificationActionOpenedIntent(intent)?.also { result ->
        Notificare.pushUI().presentAction(this, result.notification, result.action)
        return
    }

    // more code ...
}

Además, cuando utiliza el enfoque administrado, puede escuchar los eventos del ciclo de vida de las notificaciones y tomar los pasos adicionales que pueda necesitar. Deje que su Actividad implemente NotificarePushUI.NotificationLifecycleListener y agregue los siguientes métodos si es necesario.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // more code ...

    Notificare.pushUI().addLifecycleListener(this)
}

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

    Notificare.pushUI().removeLifecycleListener(this)
}

override fun onNotificationWillPresent(notification: NotificareNotification) {

}

override fun onNotificationPresented(notification: NotificareNotification) {

}

override fun onNotificationFinishedPresenting(notification: NotificareNotification) {

}

override fun onNotificationFailedToPresent(notification: NotificareNotification) {

}

override fun onNotificationUrlClicked(notification: NotificareNotification, uri: Uri) {

}

override fun onActionWillExecute(notification: NotificareNotification, action: NotificareNotification.Action) {

}

override fun onActionExecuted(notification: NotificareNotification, action: NotificareNotification.Action) {

}

override fun onActionFailedToExecute(
    notification: NotificareNotification,
    action: NotificareNotification.Action,
    error: Exception?
) {

}

override fun onCustomActionReceived(
    notification: NotificareNotification,
    action: NotificareNotification.Action,
    uri: Uri,
) {

}