SDK di Hub di notifica di Azure per JavaScript

Articolo
05/22/2024

Hub di notifica di Azure offre un motore push con scalabilità orizzontale che consente di inviare notifiche a qualsiasi piattaforma (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows e così via) da qualsiasi back-end (cloud o locale). Hub di notifica funziona bene per scenari aziendali e consumer. Di seguito vengono forniti alcuni scenari di esempio:

Invio di notifiche sulle ultime notizie a milioni di utenti con bassa latenza.
Invio di coupon in base alla posizione a segmenti di utenti interessati.
Invio di notifiche sugli eventi a utenti o gruppi per applicazioni di media, sport, finanza e gioco.
Push di contenuti promozionali alle applicazioni per coinvolgere e offrire prodotti ai clienti.
Notifica agli utenti di eventi aziendali, ad esempio nuovi messaggi e elementi di lavoro.
Invio di codici per l'autenticazione a più fattori.

Collegamenti principali:

NOTA: se si proviene dall'uso del azure-sb pacchetto, vedere migration guide to move from azure-sb to @azure/notification-hubs

Introduzione

Ambienti attualmente supportati

Versioni LTS di Node.js
Ultime versioni di Safari, Chrome, Edge e Firefox.

Per altre informazioni, vedere i criteri di supporto.

Installare il pacchetto

npm install @azure/notification-hubs

Prerequisiti

Una sottoscrizione di Azure
Risorsa Hub di notifica app .

Create una risorsa hub di notifica di Azure

È possibile creare un hub di notifica di Azure usando i metodi seguenti:

Dopo aver creato, l'hub di notifica può essere configurato usando il portale di Azure o l'interfaccia della riga di comando di Azure.

Importazione del client

Questo SDK per JavaScript offre due modi per interagire con Hub di notifica di Azure, tramite l'approccio basato sulla classe o con un approccio di progettazione modulare. L'approccio basato sulla classe è coerente tra tutti i pacchetti per creare un client e quindi interagire con i metodi nel client.

import {
  NotificationHubsClient,
  createAppleInstallation
} from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const installation = createAppleInstallation({
  installationId: "<installation-id>",
  pushChannel: "<push-channel>",
  tags: ["likes_javascript"],
});

const result = await client.createOrUpdateInstallation(installation);

L'approccio modulare consente allo sviluppatore di selezionare e scegliere quali funzioni importare come ogni metodo viene esposto singolarmente. Questo approccio usa le esportazioni di sottopath con ES-Modules per esporre i metodi tramite importazioni dirette. Con le singole esportazioni, questo crea un'esperienza migliore di scuotemento degli alberi e dimensioni di bundle più piccole che lo sviluppatore può sfruttare.

Si noti che la creazione di un client viene esposta tramite il "@azure/notification-hubs/api" sottopath e tutti i metodi client vengono esposti tramite il "@azure/notification-hubs/api" sottopath. Ogni funzione esportata accetta client come primo parametro e il resto dei parametri rimane invariato.

Vengono esposti i seguenti sottopath:

@azure/notification-hubs/api - Punto di ingresso principale per il client tramite createClientContext e metodi client, getInstallation ad esempio o sendNotification
@azure/notification-hubs/models - I modelli e i metodi factory di Hub di notifica.

Il frammento di codice precedente diventa quindi il seguente:

import { createClientContext, createOrUpdateInstallation } from "@azure/notification-hubs/api";
import { createAppleInstallation } from "@azure/notification-hubs/models";

const context = createClientContext("<connection string>", "<hub name>");

const installation = createAppleInstallation({
  installationId: "<installation-id>",
  pushChannel: "<push-channel>",
  tags: ["likes_javascript"],
});

const result = await createOrUpdateInstallation(context, installation);

Autenticare il client

L'interazione con un hub di notifica di Azure inizia con la NotificationHubsClient quale supporta le stringhe di connessione firma di accesso condiviso. Sono inclusi i livelli di autorizzazione seguenti: Listen, Manage, Send.

L'ascolto consente a un client di registrarsi tramite l'API Registrazione e installazioni. Invia consente al client di inviare notifiche ai dispositivi usando le API di invio. Infine, Gestisci consente all'utente di eseguire la gestione della registrazione e dell'installazione, ad esempio le query.

È possibile creare un nuovo NotificationHubsClient client usando il costruttore con il nome stringa di connessione e Hub di notifica.

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

Usando l'approccio modulare, è createClientContext possibile importare tramite il "@azure/notification-hubs/api" sottopath.

import { createClientContext } from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

Concetti chiave

NotificationHubClient Dopo aver inizializzato, è possibile esaminare i concetti seguenti.

Gestione dispositivi tramite installazioni e registrazioniDescriptions
Inviare notifiche ai dispositivi

Gestione dei dispositivi

La gestione dei dispositivi è un concetto di base per hub di notifica per poter archiviare l'identificatore univoco dal servizio di notifica della piattaforma nativa ( PNS) come LE API o Firebase e i metadati associati, ad esempio i tag usati per l'invio di notifiche push ai destinatari. Questa operazione viene eseguita con due API, l'API di installazione che è il meccanismo più recente e preferito e registrazioni.

API installazioni

Le installazioni sono un approccio JSON più recente e nativo alla gestione dei dispositivi che contiene proprietà aggiuntive, ad esempio un ID di installazione e un ID utente che può essere usato per l'invio ai destinatari. L'API installazioni offre alcuni vantaggi rispetto alle API di registrazione esistenti nei modi seguenti:

API completamente idempotente in modo da chiamare la creazione nell'installazione, quindi un'operazione può essere riprovata senza preoccuparsi delle duplicazioni.
Supporto per userId e installationId proprietà che possono essere quindi usate nelle espressioni di tag, $InstallationId:{myInstallId} ad esempio e $UserId:{bob@contoso.com}.
I modelli fanno ora parte dell'installazione anziché una registrazione separata e possono essere riferimenti per nome come tag per l'invio.
Gli aggiornamenti parziali sono supportati tramite JSON Patch Standard, che consente di aggiungere tag e modificare altri dati senza dover prima eseguire query sull'installazione.

Le installazioni possono essere create tramite il createOrUpdateInstallation metodo, ad esempio quanto segue:

import { NotificationHubsClient, createAppleInstallation } from "@azure/notification-hubs";
import { v4 as uuid } from "uuid";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

// Create an installation for APNs
let installation = createAppleInstallation({
  installationId: uuid(), // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

installation = await client.createOrUpdateInstallation(installation);

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, createOrUpdateInstallation } from "@azure/notification-hubs/api";
import { createAppleInstallation } from "@azure/notification-hubs/models";
import { v4 as uuid } from "uuid";

const context = createClientContext("<connection string>", "<hub name>");

// Create an installation for APNs
let installation = createAppleInstallation({
  installationId: uuid(), // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

installation = await createOrUpdateInstallation(context, installation);

È possibile eseguire un aggiornamento a un'installazione tramite lo schema patch JSON, ad esempio l'aggiunta di un tag e un ID utente usando il updateInstallation metodo .

import { NotificationHubsClient, JsonPatch } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const updates: JsonPatch[] = [
  { op: "add", path: "/tags", value: "likes_baseball" },
  { op: "add", path: "/userId", value: "bob@contoso.com" },
];

const installation = await client.updateInstallation(installationId, updates);

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, updateInstallation } from "@azure/notification-hubs/api";
import { JsonPatch } from "@azure/notification-hubs/models";

const context = createClientContext("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const updates: JsonPatch[] = [
  { op: "add", path: "/tags", value: "likes_baseball" },
  { op: "add", path: "/userId", value: "bob@contoso.com" },
];

const installation = await updateInstallation(context, installationId, updates);

Per recuperare un'installazione esistente, usare il metodo con l'ID getInstallation di installazione univoco esistente.

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const installation = client.getInstallation(installationId);

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, getInstallation } from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const installation = getInstallation(context, installationId);

API registrazioni

Una registrazione è associata a un PNS proprio come l'installazione precedente, con l'identificatore univoco del dispositivo dal PNS e i tag associati. Le registrazioni dei modelli sono un modo per creare modelli di corpo predefiniti che possono quindi essere personalizzati al momento dell'invio con proprietà da compilare per il messaggio. Per altre informazioni sui modelli, vedere Documentazione dei modelli.

Un'installazione può essere creata in uno dei due modi, ottenendo prima un ID di registrazione dal server usando getInstallationId e quindi createOrUpdateRegistration o tramite il createRegistration metodo .

import {
  NotificationHubsClient,
  createAppleRegistrationDescription,
} from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

let registration = createAppleRegistrationDescription({
  deviceToken: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0",
  tags: ["likes_hockey", "likes_football"],
});

registration = await client.createRegistration(registration);

console.log(`New Registration ID: ${registration.registrationId}`);

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, createRegistration } from "@azure/notification-hubs/api";
import { createAppleRegistrationDescription } from "@azure/notification-hubs/models";

const context = createClientContext("<connection string>", "<hub name>");

let registration = createAppleRegistrationDescription({
  deviceToken: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0",
  tags: ["likes_hockey", "likes_football"],
});

registration = await createRegistration(context, registration);

console.log(`New Registration ID: ${registration.registrationId}`);

Aggiornamenti può essere eseguita tramite il updateRegistration metodo, ma a differenza delle installazioni, non supporta gli aggiornamenti incrementali. È possibile eseguire query per una registrazione esistente con il getRegistration metodo .

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const registrationId = "<unique Registration ID>";

let registration = await client.getRegistration(registrationId);

registration.tags.push("likes_sports");

registration = await client.updateRegistration(registration);

Usando l'approccio modulare, il codice sarà il seguente:

import {
  createClientContext,
  getRegistration,
  updateRegistration
} from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

const registrationId = "<unique Registration ID>";

let registration = await getRegistration(context, registrationId);

registration.tags.push("likes_sports");

registration = await updateRegistration(context, registration);

Le registrazioni, a differenza delle installazioni, possono essere sottoposte a query per ottenere tutte le registrazioni, le registrazioni corrispondenti a una condizione o per tag. Le registrazioni possono essere sottoposte a query usando il listRegistrationsmetodo e listRegistrationsByChannellistRegistrationsByTag . Tutti i metodi supportano la limitazione tramite l'opzione e supportano il top paging asincrono.

import { NotificationHubsClient } from "@azure/notification-hubs/api";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const registrations = await client.listRegistrationsByTag("likes_hockey");

let page = 0;
for await (const pages of registrations.byPage()) {
  console.log(`Page number ${page++}`);
  for (const item of pages) {
    console.log(JSON.stringify(item, null, 2));
  }
}

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, listRegistrationsByTag } from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

const registrations = await listRegistrationsByTag(context, "likes_hockey");

let page = 0;
for await (const pages of registrations.byPage()) {
  console.log(`Page number ${page++}`);
  for (const item of pages) {
    console.log(JSON.stringify(item, null, 2));
  }
}

Operazioni di invio

Hub di notifica supporta l'invio di notifiche ai dispositivi direttamente usando l'identificatore specificato dal PNS univoco, usando tag per l'invio di destinatari o una trasmissione generale a tutti i dispositivi. Usando lo SKU Standard e versioni successive, l'invio pianificato consente all'utente di pianificare le notifiche fino a sette giorni in anticipo. Tutte le operazioni di invio restituiscono un ID di rilevamento e un ID di correlazione che possono essere usati per i casi di supporto di Hub di notifica. Con lo SKU Standard e versioni precedenti viene restituito anche un ID di notifica che può essere usato per ottenere i dati di telemetria delle notifiche tramite il getNotificationOutcomeDetails metodo .

A scopo di debug, le enableTestSend opzioni possono essere impostate su true cui viene ottenuto un feedback immediato dal PNS nel sendNotification metodo, tuttavia, non è supportato negli scenari di produzione. Questa operazione non è supportata nei metodi di invio pianificati.

È possibile inviare stringhe JSON o XML non elaborate ai metodi di invio o pianificati oppure i generatori di notifiche possono essere usati per costruire messaggi per PNS, ad esempio API, Firebase, Baidu, ADM e WNS. Questi generatori creeranno il formato del messaggio nativo in modo che non vi sia alcuna indovinazione su quali campi sono disponibili per ogni PNS.

// Using the class-based approach
import { createAppleNotificationBody } from "@azure/notification-hubs";

// Using the modular approach
import { createAppleNotification, createAppleNotificationBody } from "@azure/notification-hubs/models";

const apnsBody = createAppleNotificationBody({
  alert: {
    title: "Notification Title",
    subtitle: "Notification Subtitle",
    body: "Notification body goes here",
  },
  sound: "default",
  interruptionLevel: "time-sensitive",
});

// Send the message using the modular approach
const notification = createAppleNotification({
  body: apnsBody
})

const result = await sendNotification(context, notification);

Trasmissione di trasmissione

Hub di notifica può essere usato per inviare notifiche a tutti i dispositivi registrati per piattaforma usando l'invio di trasmissione tramite il sendNotification metodo .

import {
  NotificationHubsClient,
  createAppleNotification,
} from "@azure/notification-hubs/api";

const context = createClientContext(connectionString, hubName);

const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendNotification(message);

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, sendNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs/models";

const context = createClientContext(connectionString, hubName);

const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendNotification(context, message);

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Invio diretto

Per inviare direttamente un dispositivo, l'utente può inviare usando la piattaforma fornita un identificatore univoco, ad esempio il token del dispositivo APN chiamando il sendNotification metodo con un deviceHandle parametro.

import {
  NotificationHubsClient,
  createAppleNotification,
} from "@azure/notification-hubs";

const client = new NotificationHubsClient(connectionString, hubName);

const deviceHandle = "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendNotification(message, { deviceHandle });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, sendDirectNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs/models";

const context = createClientContext(connectionString, hubName);

const deviceHandle = "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendNotification(context, message, { deviceHandle });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Invio destinatari

Oltre alla destinazione di un singolo dispositivo, un utente può indirizzare più dispositivi usando tag. Questi tag possono essere forniti come elenco di tag, che quindi crea un'espressione di tag per corrispondere ai dispositivi registrati o tramite un'espressione di tag che può quindi usare la logica booleana per indirizzare il pubblico corretto. Per altre informazioni sui tag e sulle espressioni di tag, vedere Routing e Espressioni tag.

Se si vuole creare un'espressione di tag da una matrice di tag, è disponibile un Generatore espressioni tag con il createTagExpression metodo esposto all'importazione o all'importazione modulare di primo livello che crea un'espressione "o @azure/notification-hubs/models/tagExpressionBuilder tag" dai tag.

// Top level import
import { createTagExpression } from "@azure/notification-hubs";

// Modular import
import { createTagExpression } from "@azure/notification-hubs/models";

const tags = ["likes_football", "likes_hockey"];
const tagExpression = createTagExpression(tags);

console.log(tagExpression);
// likes_football||likes_hockey

È possibile inviare messaggi di espressione tag usando il codice seguente:

import {
  NotificationHubsClient,
  createAppleNotification,
} from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const notification = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendNotification(notification, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, sendNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs/models";

const context = createClientContext("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const notification = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendNotification(context, notification, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Invio pianificato

Le notifiche push possono essere pianificate fino a sette giorni in anticipo con spazi dei nomi SKU Standard e versioni successive usando il scheduleBroadcastNotification metodo per inviare ai dispositivi con tag o una trasmissione generale. In questo modo viene restituito un ID di notifica che può essere usato per annullare se necessario tramite il cancelScheduledNotification metodo .

import {
  NotificationHubsClient,
  createAppleNotification,
} from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

// Schedule 8 hours from now
const scheduledTime = new Date(Date.now() + (8 * 60 * 60 * 1000));

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.scheduleNotification(scheduledTime, message, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Can be used to cancel via the cancelScheduledSend method
console.log(`Notification ID: ${result.notificationId}`);

Usando l'approccio modulare, il codice sarà il seguente:

import { createClientContext, scheduleNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs/models";

const context = createClientContext("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

// Schedule 8 hours from now
const scheduledTime = new Date(Date.now() + (8 * 60 * 60 * 1000));

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await scheduleNotification(context, scheduledTime, message, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Can be used to cancel via the cancelScheduledSend method
console.log(`Notification ID: ${result.notificationId}`);

Risoluzione dei problemi

supporto React Native

React Native attualmente non ha supporto per [URLSearchParams] che viene usato dall'SDK di Hub di notifica di Azure. Per usare l'SDK in React Native, è necessario installare il url-search-params-polyfill pacchetto e importarlo prima di usare l'SDK.

import 'url-search-params-polyfill';

È anche necessario fornire polyfill per TextEncoder l'API e l'API iteratore asincrona. Per altre informazioni, vedere il nostro esempio di React Native con Expo.

Diagnosticare le notifiche eliminate

Hub di notifica di Azure offre una guida completa alla risoluzione dei problemi relativi alle notifiche eliminate nella Guida diagnostica delle notifiche eliminate in Hub di notifica di Azure.

L'inviosendNotification di test è supportato nel metodo con l'opzione enableTestSend :

// Using the client
const result = await client.sendNotification(notification, { tags, enableTestSend: true });

// Using the modular approach
const result = await sendNotification(context, notification, { tags, enableTestSend: true });

Registrazione

L'abilitazione della registrazione consente di individuare informazioni utili sugli errori. Per visualizzare un log di richieste e risposte HTTP, impostare la variabile di ambiente AZURE_LOG_LEVEL su info. In alternativa, la registrazione può essere abilitata in fase di esecuzione chiamando setLogLevel in @azure/logger:

const { setLogLevel } = require("@azure/logger");

setLogLevel("info");

Per istruzioni più dettagliate su come abilitare i log, è possibile esaminare la documentazione del pacchetto @azure/logger.

Passaggi successivi

Gli esempi seguenti illustrano i vari modi in cui è possibile interagire con Hub di notifica di Azure:

Gestione dispositivi:

API installazioni
- Create o aggiornamento installazione
- Aggiornamento dell'installazione
API di registrazione

Operazioni di invio:

Operazioni di gestione:

Contributo

Per contribuire a questa libreria, leggere la guida ai contributi per altre informazioni su come compilare e testare il codice.

I test di questo modulo sono una combinazione di unit test live e unit test, che richiedono di avere un'istanza di Hub di notifica di Azure. Per eseguire i test, è necessario eseguire:

rush update
rush build -t @azure/notification-hubs
Create un file con estensione env con questi contenuti nella sdk\notificationhubs\notification-hubs cartella:NOTIFICATIONHUBS_CONNECTION_STRING=connection string for your Notification Hubs instanceNOTIFICATION_HUB_NAME=Notification Hub name
cd sdk\notificationhubs\notification-hubs
rushx test.

Visualizzare la cartella test per altri dettagli.

Impression

Condividi tramite

SDK di Hub di notifica di Azure per JavaScript

Introduzione

Ambienti attualmente supportati

Installare il pacchetto

Prerequisiti

Create una risorsa hub di notifica di Azure

Importazione del client

Autenticare il client

Concetti chiave

Gestione dei dispositivi

API installazioni

API registrazioni

Operazioni di invio

Trasmissione di trasmissione

Invio diretto

Invio destinatari

Invio pianificato

Risoluzione dei problemi

supporto React Native

Diagnosticare le notifiche eliminate

Registrazione

Passaggi successivi

Contributo

Risorse aggiuntive

Condividi tramite

SDK di Hub di notifica di Azure per JavaScript

Introduzione

Ambienti attualmente supportati

Installare il pacchetto

Prerequisiti

Create una risorsa hub di notifica di Azure

Importazione del client

Autenticare il client

Concetti chiave

Gestione dei dispositivi

API installazioni

API registrazioni

Operazioni di invio

Trasmissione di trasmissione

Invio diretto

Invio destinatari

Invio pianificato

Risoluzione dei problemi

supporto React Native

Diagnosticare le notifiche eliminate

Registrazione

Passaggi successivi

Contributo

Progetti correlati

Risorse aggiuntive