Guía paso a paso: Integración con las notificaciones de MS Graph (Windows UWP)

Con el SDK del cliente de notificaciones de Graph en Windows, tu aplicación para Windows UWP puede realizar los pasos de registro necesarios para convertirse en un punto de conexión receptor que reciba notificaciones publicadas desde tu servidor de aplicaciones destinadas a un usuario. A continuación, el SDK se utiliza para administrar las notificaciones en el lado cliente, incluidas la recepción de nuevas cargas útiles de la notificación llegadas a este cliente, la administración del estado de las notificaciones y la recuperación del historial de notificaciones. Para obtener más información acerca de las notificaciones de MS Graph y cómo permiten la entrega de notificaciones centradas en las personas, consulta Notificaciones de Microsoft Graph.

Consulta en la página de referencia de API los vínculos a los documentos de referencia pertinentes para escenarios de notificación.

Configuración preliminar para acceder a la plataforma de dispositivos conectados con el fin de utilizar las notificaciones de Graph

Hay unos pocos pasos que debes seguir para la integración con las notificaciones de Graph

• Registro de la aplicación con MSA o AAD
• Incorporación del Centro de desarrollo para proporcionar la identidad de aplicación multiplataforma y las credenciales para las notificaciones push
• Incorporación del SDK e inicialización de la plataforma de dispositivos conectados
• Asociación del servicio de notificación a la plataforma de dispositivos conectados

En primer lugar, debes completar el registro de la aplicación con MSA o AAD. Si lo has hecho ya, ve a la sección siguiente.

Registro de autenticación con MSA y AAD

Todas las características del SDK, incluida Notificaciones, necesitan el registro de autenticación de la cuenta de Microsoft (MSA) o Azure Active Directory (AAD), excepto las API de Uso compartido en proximidad.

Si aún no tienes una cuenta MSA y deseas usarla, regístrate en account.microsoft.com.

Si después utilizas MSA como marco de autenticación e identidad para los usuarios, debes registrar la aplicación con Microsoft; para ello, sigue las instrucciones del Portal de registro de aplicaciones (si no tienes una cuenta de desarrollador de Microsoft, antes debes crearla). Debes recibir una cadena de id. de cliente para la aplicación; asegúrate de recordar la ubicación o guardarla. La usarás más adelante durante la incorporación a Notificaciones de Graph. Ten en cuenta que una aplicación que utiliza la autenticación de MSA debe estar registrada como aplicación de SDK de Live, como se muestra a continuación.

Si escribes una aplicación que usa AAD como marco de autenticación e identidad de cuentas profesionales o educativas, debes registrarla a través de las bibliotecas de autenticación de Azure Active Directory con el fin de obtener el id. de cliente, como se muestra a continuación. Cuando se crea el registro de una nueva aplicación, se necesitan algunos permisos para poder usar las notificaciones de Graph y otras funcionalidades de la plataforma de dispositivos conectados. Consúltalos a continuación.

• Agrega el permiso de inicio de sesión del usuario tal como se muestra a continuación.
• Agrega permisos del servicio de comandos para la información de dispositivo, tal como se muestra a continuación.
• Agrega el permiso para notificaciones de Graph en las API del servicio de fuente de actividades, tal como se muestra a continuación.
• Al final, si escribes una aplicación multiplataforma que incluye una aplicación para UWP que se ejecuta en Windows, asegúrate de agregar el permiso del Servicio de notificaciones de Windows, tal como se muestra a continuación.

A continuación, debes incorporar el Centro de desarrollo de Microsoft Windows para obtener acceso a la plataforma de dispositivos conectados con el fin de integrar experiencias multidispositivo, incluido el uso de notificaciones de Graph. Si lo has hecho ya, ve a la sección siguiente.

Registro de la aplicación en el Centro de desarrollo de Microsoft Windows para experiencias multidispositivo

A continuación, debes registrar la aplicación para acceder a la característica de experiencias multidispositivo del Panel de desarrolladores de Microsoft. Se sigue un procedimiento diferente al registro de la aplicación con MSA y AAD, que se explicó en los pasos anteriores. El objetivo principal de este proceso consiste en asignar las identidades de la aplicación específicas de la plataforma a una identidad de aplicación multiplataforma que se reconozca en la plataforma de dispositivos conectados y, al mismo tiempo, autorizar a la característica Notificaciones de Microsoft Graph para que envíe notificaciones con los servicios de notificación push nativos correspondiente a cada plataforma de sistema operativo. En este caso, permite que la característica Notificaciones de Graph envíe notificaciones a los puntos de conexión de la aplicación para UWP de Windows a través de WNS (Servicio de notificaciones de Windows). Ve al Panel del Centro de desarrollo y allí, a Cross-Device Experiences (Experiencias multidispositivo) en el panel de navegación del lado izquierdo; selecciona la opción de configuración de una nueva aplicación multidispositivo, tal como se muestra a continuación.

El proceso de incorporación del Centro de desarrollo requiere los siguientes pasos:

• Select supported platforms (Seleccionar plataformas compatibles): selecciona las plataformas donde la aplicación estará presente y habilitada para experiencias multidispositivo. En el caso de la integración con las notificaciones de Graph, puedes seleccionar Windows, Android o iOS. Se muestra a continuación.

• Provide app IDs (Proporcionar id. de la aplicación): proporciona los id. de la aplicación para cada una de las plataformas donde la aplicación estará presente. Se muestra a continuación.

Nota

Puedes agregar varios id. (hasta diez) por plataforma; esto se aplica en el caso de tener varias versiones de la misma aplicación, o incluso diferentes aplicaciones, que quieres que reciban las mismas notificaciones enviadas por el servidor de aplicaciones destinadas al mismo usuario.

• Proporciona o selecciona los id. de la aplicación de los registros de la aplicación con MSA o AAD. Estas identificaciones de cliente correspondientes al registro de la aplicación con AAD o MSA se obtuvieron en los pasos de registro de la aplicación con MSA o AAD anteriores, indicados más arriba. Se muestra a continuación.
• Las notificaciones de Graph y otras funcionalidades de la plataforma de dispositivos conectados aprovechan cada una de las plataformas de notificación nativas de las principales plataformas para enviar notificaciones hasta los puntos de conexión cliente de la aplicación, es decir, WNS (para Windows UWP), GCM (para Android) y APNS (para iOS). Proporciona tus credenciales para estas plataformas de notificación para permitir que Notificaciones de Graph entregue las notificaciones para el servidor de aplicaciones al publicar notificaciones destinadas al usuario. Se muestra a continuación.

Nota

En las aplicaciones para UWP de Windows, la habilitación de la notificación push de WNS es un requisito necesario para usar la característica Notificaciones de Microsoft Graph. Consulta Introducción a los Servicios de notificaciones de inserción de Windows (WNS) para obtener más información. Cuando hayas completado la incorporación, puedes proporcionar las credenciales de notificaciones push para la plataforma de dispositivos conectados a través del Centro de desarrollo de Windows.

• El último paso consiste en comprobar el dominio de la aplicación multidispositivo; sirve como proceso de verificación para confirmar que la aplicación tiene la propiedad de este dominio, que actúa como identidad de aplicación multidispositivo para la aplicación que registraste. Se muestra a continuación.
  Ya has terminado con la incorporación. Continúa en la sección siguiente.

A continuación, debes agregar el SDK de Project Rome al proyecto e inicializar la plataforma de dispositivos conectados. Si lo has hecho ya, ve a la sección siguiente.

Incorporación del SDK

Inserta las siguientes referencias de repositorio en el archivo build.gradle situado en la raíz del proyecto.

allprojects {
    repositories {
        jcenter()
        maven { url 'https://maven.google.com' }
        maven { url 'https://projectrome.bintray.com/maven/' }
    }
}

A continuación, inserta la siguiente dependencia en el archivo build.gradle que se encuentra en la carpeta del proyecto.

dependencies { 
    ...
    implementation 'com.microsoft.connecteddevices:connecteddevices-sdk:0.11.0'
}

Si quieres usar ProGuard en la aplicación, agrega las reglas de ProGuard para estas nuevas API. Crea un archivo llamado proguard-rules.txt en la carpeta App del proyecto y pega en él el contenido del archivo ProGuard_Rules_for_Android_Rome_SDK.txt.

En el archivo AndroidManifest.xml del proyecto, agrega los siguientes permisos dentro del elemento <manifest> (si no están ya incluidos). Esto permite que la aplicación se conecte a Internet y habilite la detección de Bluetooth en el dispositivo.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Nota

Los permisos relacionados con Bluetooth solo son necesarios para usar la detección de Bluetooth; no se necesitan para las demás características de la plataforma de dispositivos conectados. Además, ACCESS_COARSE_LOCATION solo es necesario en los niveles de Android SDK 21 y posteriores. En los niveles de Android SDK 23 y posteriores, el desarrollador también debe pedir al usuario que conceda acceso a la ubicación en tiempo de ejecución.

A continuación, ve a las clases de actividad donde deseas agregar la funcionalidad de dispositivos conectados. Importa los espacios de nombres de connecteddevices.

import com.microsoft.connecteddevices.*;

En función de los escenarios que implementes, quizá no necesites todos los espacios de nombres. También es posible que debas agregar otros espacios de nombres nativos de Android a medida que avanzas.

Inicialización de la plataforma de dispositivos conectados

Para usar las características de dispositivos conectados, debes inicializar la plataforma dentro de la aplicación. Los pasos de inicialización deben producirse en los métodos onCreate u onResume de la clase principal, porque son necesarios antes de que puedan tener lugar otros escenarios de dispositivos conectados.

Debes crear una instancia de la clase Platform. El constructor Platform utiliza tres parámetros: Context para la aplicación, NotificationProvider y UserAccountProvider.

El parámetro NotificationProvider solo es necesario para determinados escenarios. Es necesario, por ejemplo, si se utilizan las notificaciones de Microsoft Graph. Déjalo como null por ahora y averigua cómo conseguir que el SDK de cliente controle las notificaciones centradas en el usuario entrantes a través de canales de notificaciones push nativos en la sección siguiente.

El parámetro UserAccountProvider es necesario para entregar un token de acceso OAuth 2.0 para el acceso del usuario actual a la plataforma de dispositivos conectados. Se le llamará la primera vez que se ejecute la aplicación y tras la expiración de un token de actualización administrado por la plataforma.

Para ayudar a que los desarrolladores se incorporen a la plataforma más fácilmente, hemos incluido implementaciones de proveedores de cuentas para iOS y Android. Estas implementaciones, que se encuentran en el ejemplo de proveedor de autenticación, pueden usarse para obtener los token de acceso y actualización OAuth 2.0 para la aplicación.

Configuración de la autenticación y la administración de cuentas

La plataforma de dispositivos conectados requiere que se utilice un token OAuth válido en el proceso de registro. Puedes usar el método preferido para generar y administrar los tokens OAuth. Sin embargo, para ayudar a los desarrolladores a empezar a usar la plataforma, hemos incluido un proveedor de autenticación como parte de la aplicación de ejemplo de Android que se encarga de generar y administrar los tokens de actualización.

Si deseas implementar tú mismo la interfaz ConnectedDevicesAccountManager, tome nota de la siguiente información:

Si usas una cuenta MSA, debes incluir los siguientes ámbitos en la solicitud de inicio de sesión: "wl.offline_access", "ccs.ReadWrite", "dds.read", "dds.register", "wns.connect", "asimovrome.telemetry" y "https://activity.windows.com/UserActivity.ReadWrite.CreatedByApp".

Si usas una cuenta de AAD, deberás solicitar los siguientes destinatarios: "https://cdpcs.access.microsoft.com", "https://cs.dds.microsoft.com", "https://wns.windows.com/" y "https://activity.microsoft.com".

Nota

No se admiten cuentas de Azure Active Directory (AAD) con las API de Retransmisión de dispositivo.

Tanto si usa la implementación de ConnectedDevicesAccountManager proporcionada como si no, si usa AAD tendrá que especificar los siguientes permisos en el registro de la aplicación en Azure Portal (portal.azure.com > Azure Active Directory > Registros de aplicaciones):

• Servicio de fuente de actividades de Microsoft
  • Entregar y modificar notificaciones del usuario para esta aplicación
  • Leer y escribir la actividad de la aplicación en la fuente de actividades de los usuarios
• Servicio de notificaciones de Windows
  • Conectar su dispositivo al Servicio de notificaciones de Windows
• Servicio de directorio de dispositivos de Microsoft
  • Ver la lista de dispositivos
  • Se agregará a su lista de dispositivos y aplicaciones
• Servicio de comandos de Microsoft
  • Comunicarse con los dispositivos de usuario
  • Leer dispositivos de usuario

En el código siguiente, mSignInHelper hace referencia a MSAAccountProvider, que también se inicializa a continuación. La clase proporcionada implementa la interfaz de UserAccountProvider.

private MSAAccountProvider mSignInHelper;

// ...

// Create sign-in helper from helper lib, which does user account and access token management for us
// Takes two parameters: a client id for msa, and the Context
mSignInHelper = new MSAAccountProvider(Secrets.MSA_CLIENT_ID, getContext());

// add an event listener, which changes the button text when account state changes
mSignInHelper.addUserAccountChangedListener(new EventListener<UserAccountProvider, Void>() {
    @Override
    public void onEvent(UserAccountProvider provider, Void aVoid){
        if (mSignInHelper.isSignedIn()) {
            // update the UI indicating a user is signed in.
        }
        else
        {
            // update the UI indicating a user is not signed in.
        }
    }
});

Ahora puedes construir una instancia de Platform. Puede que quieras incluir el código siguiente en una clase auxiliar independiente.

// Platform helper class:

private static Platform sPlatform;

//...

// This is the main Platform-generating method
public static synchronized Platform getOrCreatePlatform(Context context, UserAccountProvider accountProvider, NotificationProvider notificationProvider) {
    // check whether the local platform variable is already initialized.
    Platform platform = getPlatform();

    if (platform == null) {
        // if it is not initialized, do so:
        platform = createPlatform(context, accountProvider, notificationProvider);
    }
    return platform;
}

// gets the local platform variable
public static synchronized Platform getPlatform() {
        return sPlatform;
}

// creates and returns a new Platform instance
public static synchronized Platform createPlatform(Context context, UserAccountProvider accountProvider, NotificationProvider notificationProvider) {
    sPlatform = new Platform(context, accountProvider, notificationProvider);
    return sPlatform;
}

En la clase principal, donde se inicializa mSignInHelper, agrega el código siguiente.

private Platform mPlatform;

//...

mPlatform = PlatformHelperClass.getOrCreatePlatform(this, mSignInHelper, null);

Debes apagar la plataforma cuando la aplicación sale del primer plano.

mPlatform.shutdownAsync();

Por último, debes habilitar la aplicación para que reciba notificaciones push. Si lo has hecho ya, ve a la sección siguiente.

Asociación de la plataforma de dispositivos conectados a la notificación push nativa para cada plataforma móvil

Como se mencionó anteriormente, los clientes de la aplicación deben proporcionar el conocimiento acerca de la canalización de las notificaciones push nativas que se usa para cada plataforma móvil en el SDK de cliente y la plataforma de dispositivos conectados durante el proceso de registro, de forma que el servicio de notificaciones de Graph pueda realizar la distribución ramificada de las notificaciones a cada punto de conexión cliente de la aplicación cuando el servidor de aplicaciones publique una notificación destinada al usuario a través de las API de Microsoft Graph.

En los pasos anteriores, inicializaste la plataforma con un parámetro null notificationProvider. Ahora debes construir y pasar un objeto que implemente NotificationProvider. Lo más importante que debes tener en cuenta es el método getNotificationRegistrationAsync, que debe devolver una instancia de NotificationRegistration. NotificationRegistration es responsable de proporcionar a la plataforma de dispositivos conectados un token de acceso (y la información relacionada) para el servicio de notificación.

private NotificationRegistration mNotificationRegistration;

// ...

/**
* NotificationRegistration is constructed with four parameters:
* Type: This is the notification platform type.
* Token: This is the string that GCM or FCM sends to your registration intent service.
* SenderId: This is the numeric Sender ID that you received when you registered your app for push notifications.
* DisplayName: This should be the name of the app that you used when you registered it on the Microsoft dev portal. 
*/
mNotificationRegistration = new NotificationRegistration(NotificationType.FCM, token, FCM_SENDER_ID, "MyAppName");

Incluye este registro en la implementación de NotificationProvider. A continuación, la llamada de inicialización de Platform debe proporcionar a la instancia de Platform local el acceso al servicio de notificaciones push, lo que permite que la aplicación reciba datos de las notificaciones de Microsoft Graph en el servidor.

Paso de notificaciones push entrantes al SDK de cliente

Ahora, amplía la clase del servicio del cliente de escucha nativo (FirebaseMessagingService en este caso, dado que este tutorial utiliza Firebase Cloud Messaging) con una sobrecarga especial del método onMessageReceived (el método de administración de notificaciones).

Por motivos de cumplimiento, seguridad y posibles optimizaciones, la notificación entrante de Google Cloud Messaging procedente de las notificaciones de Graph en el servidor podría ser un simple toque, que no contenga ningún dato inicialmente publicado por el servidor de aplicaciones. La recuperación del contenido real de la notificación publicada por el servidor de aplicaciones se oculta detrás de las API del SDK de cliente. Por este motivo, el SDK puede proporcionar un modelo de programación coherente en el que el cliente de la aplicación siempre pase la carga entrante de Google Cloud Messaging al SDK. Esto permite que el SDK determine si se trata de una notificación para escenarios de la plataforma de dispositivos conectados o no (en caso de que el cliente de la aplicación utilice el canal de Google Cloud Messaging nativo de Android para otros fines) y a qué escenario o capacidad corresponde esta notificación entrante (Notificaciones de Graph, Actividad del usuario, etc.). Tras esto, el cliente de la aplicación puede ejecutar lógicas específicas al tratar con diferentes tipos de escenarios.

/**
* Check whether it's a Connected Devices Platform notification or not.
* If it is a Connected Devices Platform notification, it will notify the apps with the information in the notification.
* @param from describes message sender.
* @param data message data as String key/value pairs.
*/
@Override
public void onMessageReceived(String from, Bundle data) {
    Log.d(TAG, "From: " + from);

    // Ensure that the Platform is initialized here before going on
    // ...

    // This method passes the data to the Connected Devices Platform if is compatible.
    if (!NotificationReceiver.Receive(data)) {
        // a value of false indicates a non-Rome notification
        Log.d(TAG, "GCM client received a message that was not a Rome notification");
    }
}

Ahora la aplicación puede controlar notificaciones de la plataforma de dispositivos conectados.

Inicialización de un canal de notificaciones de Graph

En un nivel alto, el SDK permite que la aplicación se suscriba a diferentes canales para recibir y administrar diferentes tipos de datos de usuario, incluidas las notificaciones de Graph y las actividades de usuario entre otras. Todos ellos se almacenan y sincronizan en UserDataFeed. UserNotification es la clase y el tipo de datos correspondiente a una notificación destinada al usuario enviada mediante las notificaciones de Graph. Para la integración con las notificaciones de Graph y comenzar a recibir la UserNotification publicada por tu servidor de aplicaciones, primero es necesario inicializar la fuente de datos de usuario mediante la creación de una clase UserNotificationChannel. Debes tratar este paso como el paso anterior de inicialización de la plataforma: debe comprobarse y, posiblemente, rehacerse siempre que la aplicación pasa al primer plano (pero no antes de la inicialización de la plataforma).

Creación de una clase UserNotificationReader para recibir UserNotifications entrantes y acceder al historial de UserNotification.

Una vez que tengas una referencia a UserNotificationChannel, necesitarás una clase UserNotificationReader para que el SDK pueda obtener del servidor el contenido real de la notificación. En este caso, una clase UserNotificationReader permite al cliente de la aplicación acceder a esta fuente de datos para recibir la última carga útil de la notificación a través de la escucha de eventos; o bien para acceder a la colección completa de UserNotification que puede utilizarse como modelo de visualización del historial de notificaciones del usuario.

El siguiente código muestra los pasos para crear una instancia de un canal de notificaciones de usuario, crear un lector de notificaciones de usuario y agregar un controlador de eventos en el lector de notificaciones de usuario que se activa cuando la plataforma de dispositivos conectados completa cada sincronización y tiene nuevos cambios que notificarte.

public async Task SetupChannel()
{
    var account = m_accoutProvider.SignedInAccount;

    if (m_feed == null)
    {
        await Task.Run(() =>
        {
            lock (this)
            {
                if (m_feed == null)
                {
                    m_platform = new ConnectedDevicesPlatform(m_accoutProvider, this);

                    Logger.Instance.LogMessage($"Create feed for {account.Id} {account.Type}");
                    m_feed = new UserDataFeed(account, m_platform, "graphnotifications.sample.windows.com");
                    m_feed.SyncStatusChanged += Feed_SyncStatusChanged;
                    m_feed.AddSyncScopes(new List<IUserDataFeedSyncScope>
                    {
                        UserNotificationChannel.SyncScope
                    });

                    m_channel = new UserNotificationChannel(m_feed);
                    m_reader = m_channel.CreateReader();
                    m_reader.DataChanged += Reader_DataChanged;
                }
            }
        });
    }
}

Recepción de UserNotifications

En la sección anterior se ve que se agrega una escucha de eventos al lector de notificaciones de usuario. Debes implementar esta escucha de eventos para leer todas las notificaciones nuevas y las actualizaciones de notificaciones del lector, e implementar tu propia lógica de negocio para controlar cada uno de estos nuevos cambios.

Sugerencia

En esta escucha de eventos es donde se controla la lógica principal del negocio y "consume" el contenido de la carga útil de la notificación en función en tus escenarios. Si utilizas la notificación sin procesar de WNS para crear una notificación del sistema local en el centro de actividades a nivel de sistema operativo o si utilizas el contenido de la notificación para actualizar una interfaz de usuario en la aplicación, este es el lugar para hacerlo.

El código siguiente muestra cómo la aplicación de ejemplo elige generar una notificación del sistema local para todas las notificaciones de usuario (UserNotification) entrantes que están activas y quitar la interfaz de usuario de notificaciones correspondiente en la vista de la aplicación si se elimina una notificación.

private void Reader_DataChanged(UserNotificationReader sender, object args)
{
    ReadNotifications(sender, true);
}

private async void ReadNotifications(UserNotificationReader reader, bool showToast)
{
    var notifications = await reader.ReadBatchAsync(UInt32.MaxValue);

    foreach (var notification in notifications)
    {

        if (notification.Status == UserNotificationStatus.Active)
        {
            m_newNotifications.RemoveAll((n) => { return (n.Id == notification.Id); });
            if (notification.UserActionState == UserNotificationUserActionState.NoInteraction)
            {
                // new notification, show this to user using the Windows local toast notification APIs
                m_newNotifications.Add(notification);
                if (!string.IsNullOrEmpty(notification.Content) && showToast)
                {
                    ShowToastNotification(BuildToastNotification(notification.Id, notification.Content));
                }
            }

            m_historicalNotifications.RemoveAll((n) => { return (n.Id == notification.Id); });
            m_historicalNotifications.Insert(0, notification);
        }
        else
        {
            // Existing notification is marked as deleted, remove from display
            m_newNotifications.RemoveAll((n) => { return (n.Id == notification.Id); });
            m_historicalNotifications.RemoveAll((n) => { return (n.Id == notification.Id); });
            RemoveToastNotification(notification.Id);
        }
    }
}

Actualización del estado de una clase UserNotification existente

En la sección anterior se mencionó que a veces un cambio en UserNotification recibido a través de la escucha puede ser una actualización de estado de una UserNotification existente, independientemente de si está marcada como descartada o como leída. En este caso, el cliente de la aplicación puede elegir qué hacer; por ejemplo, habilitar el descarte universal al eliminar la notificación visual correspondiente en este dispositivo concreto. Dando un paso atrás, el cliente de la aplicación es a menudo el que inició esta actualización de cambio de UserNotification desde otro dispositivo. Puedes elegir la hora para actualizar el estado de tus UserNotifications, pero normalmente se actualizan cuando el usuario controla la notificación visual correspondiente en ese dispositivo o en alguna experiencia en la aplicación que habilites. A continuación, se muestra un ejemplo del aspecto del flujo: el servidor de aplicaciones publica una notificación destinada al usuario A, y este usuario recibe esta notificación tanto en su PC como en el teléfono donde están instalados los clientes de la aplicación. El usuario hace clic en la notificación en su PC y se dirige a la aplicación para controlar la tarea correspondiente. El cliente de la aplicación en su PC llamará al SDK de la plataforma de dispositivos conectados para actualizar el estado de la UserNotification correspondiente con el fin de sincronizar esta actualización en todos los dispositivos de este usuario. Los demás clientes de la aplicación, al recibir esta actualización de estado en tiempo real, eliminarán la alerta visual, mensaje o notificación del sistema correspondiente del centro de notificación, la bandeja de notificación o el centro de actividades del dispositivo. Así es como las notificaciones se descartan universalmente en los dispositivos de un usuario.

Sugerencia

Actualmente, la clase UserNotification proporciona dos tipos de actualizaciones de estado: puedes modificar UserNotificationReadState o UserNotificationUserActionState y definir tu propia lógica sobre lo que debe ocurrir cuando se actualizan las notificaciones. Por ejemplo, puedes marcar UserActionState para que esté activada o descartada y basarte en ese valor para implementar el descarte universal. Si lo prefieres, o al mismo tiempo, puedes marcar ReadState como leído o no leído y, en función de ello, determinar qué notificaciones deben aparecer en la vista del historial de notificaciones en la aplicación. El fragmento de código siguiente muestra cómo marcar el elemento UserNotificationUserActionState de una notificación como desestimado.

public async void Dismiss(string id)
{
    var notification = m_newNotifications.Find((n) => { return (n.Id == id); });
    if (notification != null)
    {
        notification.UserActionState = UserNotificationUserActionState.Dismissed;
        await notification.SaveAsync();
    }
}