Compartir vía

Tutorial: uso de notificaciones locales en Xamarin.Android

  • Artículo

En este tutorial se demuestra cómo usar notificaciones locales las aplicaciones de Xamarin.Android. Muestra los aspectos básicos de la creación y publicación de una notificación local. Cuando el usuario hace clic en la notificación del área de notificaciones, inicia una segunda actividad.

Información general

En este tutorial, crearemos una aplicación Android que genere una notificación cuando el usuario haga clic en un botón en una actividad. Cuando el usuario hace clic en la notificación, inicia una segunda actividad que muestra el número de veces que el usuario hizo clic en el botón en la primera actividad.

En las capturas de pantalla siguientes se muestran algunos ejemplos de esta aplicación:

Capturas de pantalla de ejemplo con notificación

Nota:

Esta guía se centra en las API NotificationCompat de la biblioteca de soporte técnico de Android. Estas API garantizarán la compatibilidad máxima con versiones anteriores a Android 4.0 (nivel de API 14).

Creación del proyecto

Para empezar, vamos a crear un nuevo proyecto de Android mediante la plantilla Aplicación de Android. Vamos a llamar a este proyecto LocalNotifications. (Si no conoce la creación de proyectos de Xamarin.Android, consulte Hello, Android.)

Edite el archivo de recursos values/Strings.xml para que contenga dos recursos de cadena adicionales que se usarán cuando sea el momento de crear el canal de notificación:

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

<resources>
  <string name="Hello">Hello World, Click Me!</string>
  <string name="ApplicationName">Notifications</string>

  <string name="channel_name">Local Notifications</string>
  <string name="channel_description">The count from MainActivity.</string>
</resources>

Adición del paquete NuGet Android.Support.V4

En este tutorial, se usa NotificationCompat.Builder para crear la notificación local. Como se explica en Notificaciones locales, debemos incluir el NuGet de la biblioteca de soporte técnico de Android v4 en nuestro proyecto para usar NotificationCompat.Builder.

A continuación, vamos a editar MainActivity.cs y a agregar la siguiente instrucción using para que los tipos de Android.Support.V4.App estén disponibles para nuestro código:

using Android.Support.V4.App;

Además, debemos aclarar al compilador que estamos usando la versión Android.Support.V4.App de TaskStackBuilder en lugar de la versión Android.App. Agregue la siguiente instrucción using para resolver cualquier ambigüedad:

using TaskStackBuilder = Android.Support.V4.App.TaskStackBuilder;

Creación del canal de notificación

A continuación, agregue un método a MainActivity que creará un canal de notificación (si es necesario):

void CreateNotificationChannel()
{
    if (Build.VERSION.SdkInt < BuildVersionCodes.O)
    {
        // Notification channels are new in API 26 (and not a part of the
        // support library). There is no need to create a notification
        // channel on older versions of Android.
        return;
    }

    var name = Resources.GetString(Resource.String.channel_name);
    var description = GetString(Resource.String.channel_description);
    var channel = new NotificationChannel(CHANNEL_ID, name, NotificationImportance.Default)
                  {
                      Description = description
                  };

    var notificationManager = (NotificationManager) GetSystemService(NotificationService);
    notificationManager.CreateNotificationChannel(channel);
}

Actualice el método OnCreate para llamar a este nuevo método:

protected override void OnCreate(Bundle bundle)
{
    base.OnCreate(bundle);
    SetContentView(Resource.Layout.Main);

    CreateNotificationChannel();
}

Definición del identificador de notificación

Necesitaremos un identificador único para nuestro canal de notificación y notificación. Vamos a editar MainActivity.cs y agregaremos la siguiente variable de instancia estática a la clase MainActivity:

static readonly int NOTIFICATION_ID = 1000;
static readonly string CHANNEL_ID = "location_notification";
internal static readonly string COUNT_KEY = "count";

Adición de código para generar la notificación

A continuación, es necesario crear un nuevo controlador de eventos para el evento de botón Click. Agregue el método siguiente a MainActivity:

void ButtonOnClick(object sender, EventArgs eventArgs)
{
    // Pass the current button press count value to the next activity:
    var valuesForActivity = new Bundle();
    valuesForActivity.PutInt(COUNT_KEY, count);

    // When the user clicks the notification, SecondActivity will start up.
    var resultIntent = new Intent(this, typeof(SecondActivity));

    // Pass some values to SecondActivity:
    resultIntent.PutExtras(valuesForActivity);

    // Construct a back stack for cross-task navigation:
    var stackBuilder = TaskStackBuilder.Create(this);
    stackBuilder.AddParentStack(Class.FromType(typeof(SecondActivity)));
    stackBuilder.AddNextIntent(resultIntent);

    // Create the PendingIntent with the back stack:
    var resultPendingIntent = stackBuilder.GetPendingIntent(0, (int) PendingIntentFlags.UpdateCurrent);

    // Build the notification:
    var builder = new NotificationCompat.Builder(this, CHANNEL_ID)
                  .SetAutoCancel(true) // Dismiss the notification from the notification area when the user clicks on it
                  .SetContentIntent(resultPendingIntent) // Start up this activity when the user clicks the intent.
                  .SetContentTitle("Button Clicked") // Set the title
                  .SetNumber(count) // Display the count in the Content Info
                  .SetSmallIcon(Resource.Drawable.ic_stat_button_click) // This is the icon to display
                  .SetContentText($"The button has been clicked {count} times."); // the message to display.

    // Finally, publish the notification:
    var notificationManager = NotificationManagerCompat.From(this);
    notificationManager.Notify(NOTIFICATION_ID, builder.Build());

    // Increment the button press count:
    count++;
}

El método OnCreate de MainActivity debe realizar la llamada para crear el canal de notificación y asignar el método ButtonOnClick al evento de botón Click (reemplace el controlador de eventos delegado proporcionado por la plantilla):

protected override void OnCreate(Bundle bundle)
{
    base.OnCreate(bundle);
    SetContentView(Resource.Layout.Main);

    CreateNotificationChannel();

    // Display the "Hello World, Click Me!" button and register its event handler:
    var button = FindViewById<Button>(Resource.Id.MyButton);
    button.Click += ButtonOnClick;
}

Creación de una segunda actividad

Ahora es necesario crear otra actividad que Android mostrará cuando el usuario haga clic en nuestra notificación. Agregue otra actividad de Android al proyecto denominada SecondActivity. Abra SecondActivity.cs y reemplace su contenido por este código:

using System;
using Android.App;
using Android.OS;
using Android.Widget;

namespace LocalNotifications
{
    [Activity(Label = "Second Activity")]
    public class SecondActivity : Activity
    {
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            // Get the count value passed to us from MainActivity:
            var count = Intent.Extras.GetInt(MainActivity.COUNT_KEY, -1);

            // No count was passed? Then just return.
            if (count <= 0)
            {
                return;
            }

            // Display the count sent from the first activity:
            SetContentView(Resource.Layout.Second);
            var txtView = FindViewById<TextView>(Resource.Id.textView1);
            txtView.Text = $"You clicked the button {count} times in the previous activity.";
        }
    }
}

También debemos crear un diseño de recursos para SecondActivity. Agregue un nuevo archivo de diseño de Android al proyecto llamado Second.axml. Edite Second.axml y pegue el código de diseño siguiente:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:minWidth="25px"
    android:minHeight="25px">
    <TextView
        android:text=""
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:id="@+id/textView1" />
</LinearLayout>

Agregar un icono de notificación

Por último, agregue un pequeño icono que aparecerá en el área de notificación cuando se inicie la notificación. Puede copiar este icono en el proyecto o crear su propio icono personalizado. Asigne al archivo de icono el nombre ic_stat_button_click.png y cópielo en la carpeta Resources/drawable. No olvide usar Agregar > Elemento existente... para incluir este archivo de icono en el proyecto.

Ejecución de la aplicación

Compile y ejecute la aplicación. Debe presentar la primera actividad, similar a la captura de pantalla siguiente:

Captura de pantalla de la primera actividad

Al hacer clic en el botón, debe observar que el icono pequeño de la notificación aparece en el área de notificación:

Aparece el icono de notificación

Si desliza el dedo hacia abajo y expone el cajón de notificaciones, debería ver la notificación:

Mensaje de notificación

Al hacer clic en la notificación, debería desaparecer y debería iniciarse nuestra otra actividad, con un aspecto similar al siguiente captura de pantalla:

Captura de pantalla de la segunda actividad

Felicidades. En este momento ha completado el tutorial de notificación local de Android y tiene un ejemplo de trabajo al que puede hacer referencia. Hay mucho más en las notificaciones que hemos mostrado aquí, por lo que si quiere más información, eche un vistazo a la documentación de Google sobre las notificaciones.

Resumen

Este tutorial usa NotificationCompat.Builder para crear y mostrar notificaciones. Mostró un ejemplo básico de cómo iniciar una segunda actividad como una manera de responder a la interacción del usuario con la notificación y mostró la transferencia de datos de la primera actividad a la segunda actividad.