Freigeben über

Azure Notification Hubs SDK für JavaScript

Azure Notification Hubs bieten eine horizontal skalierte Push-Engine, mit der Sie Benachrichtigungen an eine beliebige Plattform (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows usw.) von einem beliebigen Back-End (Cloud oder lokal) senden können. Notification Hubs eignet sich sowohl für Unternehmens- als auch für Verbraucherszenarien. Hier sind einige Beispielszenarien:

  • Senden Sie Benachrichtigungen über aktuelle Nachrichten mit geringer Latenz an Millionen.
  • Senden Sie standortbezogene Coupons an interessierte Nutzersegmente.
  • Senden Sie ereignisbezogene Benachrichtigungen an Benutzer oder Gruppen für Medien-/Sport-/Finanz-/Gaming-Anwendungen.
  • Pushen Sie Werbeinhalte in Anwendungen, um Kunden zu binden und zu vermarkten.
  • Benachrichtigen Sie Benutzer über Unternehmensereignisse, z. B. neue Nachrichten und Arbeitsaufgaben.
  • Senden Sie Codes für die Multi-Faktor-Authentifizierung.

Wichtige Links:

HINWEIS: Wenn Sie das azure-sb Paket nicht verwenden, lesen Sie die migration guide to move from azure-sb to @azure/notification-hubs

Erste Schritte

Derzeit unterstützte Umgebungen

Weitere Details finden Sie in unserer Supportrichtlinie .

Installiere das Paket

npm install @azure/notification-hubs

Voraussetzungen

Erstellen einer Azure Notification Hubs-Ressource

Ein Azure Notification Hub kann mit den folgenden Methoden erstellt werden:

  1. Azure-Portal
  2. Azure CLI
  3. Bicep
  4. ARM-Vorlage

Nach der Erstellung kann der Notification Hub über das Azure-Portal oder die Azure CLI konfiguriert werden.

Importieren des Clients

Dieses SDK für JavaScript bietet zwei Möglichkeiten der Interaktion mit Azure Notification Hubs, entweder über den klassenbasierten Ansatz oder über einen modularen Entwurfsansatz. Der klassenbasierte Ansatz ist in allen Paketen konsistent, um einen Client zu erstellen und dann mit den Methoden auf dem Client zu interagieren.

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);

Der modulare Ansatz ermöglicht es dem Entwickler, auszuwählen, welche Funktionen importiert werden sollen, da jede Methode einzeln verfügbar gemacht wird. Dieser Ansatz verwendet Subpath-Exporte mit ES-Modules, um die Methoden über direkte Importe verfügbar zu machen. Mit den einzelnen Exporten entsteht ein besseres Tree-Shaking-Erlebnis und kleinere Paketgrößen, die der Entwickler nutzen kann.

Beachten Sie, dass das Erstellen eines Clients über den "@azure/notification-hubs/api" Unterpfad verfügbar gemacht wird und alle Clientmethoden über den "@azure/notification-hubs/api" Unterpfad verfügbar gemacht werden. Jede exportierte Funktion nimmt den client als ersten Parameter an, und die restlichen Parameter bleiben unverändert.

Die folgenden Unterpfade werden verfügbar gemacht:

  • @azure/notification-hubs/api - Der Haupteinstiegspunkt für den Client über createClientContext und Clientmethoden wie getInstallation oder sendNotification
  • @azure/notification-hubs/models - Die Notification Hubs-Modelle und Factorymethoden.

Der obige Codeausschnitt sieht dann wie folgt aus:

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

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);

Authentifizieren des Clients

Die Interaktion mit einem Azure Notification Hub beginnt mit dem, der NotificationHubsClientShared Access Signature-Verbindungszeichenfolgen unterstützt. Dazu gehören die folgenden Berechtigungsstufen: Zuhören, Verwalten, Senden.

Listen ermöglicht es einem Client, sich über die Registrierungs- und Installations-API zu registrieren. Send ermöglicht es dem Client, Benachrichtigungen an Geräte zu senden, die die Sende-APIs verwenden. Schließlich ermöglicht Manage dem Benutzer die Verwaltung der Registrierung und Installation, z. B. Abfragen.

Ein neuer NotificationHubsClient Client kann mithilfe des Konstruktors mit der Verbindungszeichenfolge und dem Namen des Notification Hubs erstellt werden.

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

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

Durch den modularen Ansatz können diese createClientContext über den "@azure/notification-hubs/api" Subpath importiert werden.

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

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

Wichtige Begriffe

Sobald der initialisiert NotificationHubClient wurde, können die folgenden Konzepte untersucht werden.

  • Geräteverwaltung über Installationen und RegistrierungBeschreibungen
  • Senden von Benachrichtigungen an Geräte

Geräteverwaltung

Die Geräteverwaltung ist ein Kernkonzept von Notification Hubs, um den eindeutigen Bezeichner aus dem nativen Platform Notification Service (PNS) wie APNs oder Firebase und zugehörige Metadaten wie Tags, die zum Senden von Pushbenachrichtigungen an Zielgruppen verwendet werden, speichern zu können. Dies geschieht mit zwei APIs, der Installations-API, der neueren und bevorzugten Mechanism, und Registrierungen.

Installations-API

Installationen sind ein neuerer und nativer JSON-Ansatz für die Geräteverwaltung, der zusätzliche Eigenschaften wie eine Installations-ID und eine Benutzer-ID enthält, die zum Senden an Zielgruppen verwendet werden können. Die Installations-API hat gegenüber den vorhandenen Registrierungs-APIs auf folgende Weise einige Vorteile:

  • Vollständig idempotente API, die create für die Installation aufruft, sodass ein Vorgang wiederholt werden kann, ohne sich Gedanken über Duplikate machen zu müssen.
  • Unterstützung für userId und installationId Eigenschaften, die dann in Tag-Ausdrücken wie $InstallationId:{myInstallId} und $UserId:{bob@contoso.com}verwendet werden können.
  • Vorlagen sind nun Teil der Installation anstelle einer separaten Registrierung und können als Tag für den Versand namentlich referenziert werden.
  • Teilaktualisierungen werden durch den JSON Patch Standard unterstützt, der es ermöglicht, Tags hinzuzufügen und andere Daten zu ändern, ohne dass die Installation zuerst abgefragt werden muss.

Installationen können mit der createOrUpdateInstallation folgenden Methode erstellt werden:

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

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

// Create an installation for APNs
const installation = createAppleInstallation({
  installationId: "0d8ab095-c449-493f-9195-17e4917806c4", // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

const response = await client.createOrUpdateInstallation(installation);

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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

// Create an installation for APNs
const installation = createAppleInstallation({
  installationId: "0d8ab095-c449-493f-9195-17e4917806c4", // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

const response = await createOrUpdateInstallation(context, installation);

Eine Aktualisierung einer Installation kann über das JSON-Patch-Schema vorgenommen werden, z. B. durch Hinzufügen eines Tags und einer Benutzer-ID mithilfe der updateInstallation Methode.

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);

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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);

Um eine vorhandene Installation abzurufen, verwenden Sie die getInstallation Methode mit Ihrer vorhandenen eindeutigen Installations-ID.

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

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

const installationId = "<unique installation ID>";

const installation = client.getInstallation(installationId);

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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);

Registrierungs-API

Eine Registrierung wird genau wie die obige Installation mit einem PNS verknüpft, mit der eindeutigen Gerätekennung aus dem PNS und den zugehörigen Tags. Vorlagenregistrierungen sind eine Möglichkeit, vordefinierte Textvorlagen zu erstellen, die dann zum Sendezeitpunkt mit Eigenschaften angepasst werden können, die für die Nachricht ausgefüllt werden müssen. Weitere Informationen zu Vorlagen finden Sie in der Dokumentation zu Vorlagen.

Eine Installation kann auf zwei Arten erstellt werden: zuerst durch Abrufen einer Registrierungs-ID vom Server mit getInstallationId und dann createOrUpdateRegistration oder über die createRegistration Methode.

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

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

const registration = createAppleRegistrationDescription({
  deviceToken: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0",
  tags: ["likes_hockey", "likes_football"],
});
const updatedRegistration = await client.createRegistration(registration);

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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

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

const updatedRegistration = await createRegistration(context, registration);

Updates können über die updateRegistration Methode durchgeführt werden, unterstützt aber im Gegensatz zu Installationen keine inkrementellen Updates. Die Abfrage einer vorhandenen Registrierung kann mit der getRegistration Methode erfolgen.

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

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

const registrationId = "<unique Registration ID>";

const registration = await client.getRegistration(registrationId);

if (registration.tags) {
  registration.tags.push("likes_sports");
} else {
  registration.tags = ["likes_sports"];
}

const updatedRegistration = await client.updateRegistration(registration);

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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

const registrationId = "<unique Registration ID>";

const registration = await getRegistration(context, registrationId);

if (registration.tags) {
  registration.tags.push("likes_sports");
} else {
  registration.tags = ["likes_sports"];
}

const updatedRegistration = await updateRegistration(context, registration);

Registrierungen können im Gegensatz zu Installationen abgefragt werden, um alle Registrierungen abzurufen, Registrierungen mit einer Bedingung abzugleichen, oder nach Tags. Registrierungen können mit der listRegistrationsMethode und listRegistrationsByTag abgefragt werden. listRegistrationsByChannel Alle Methoden unterstützen das Limitieren über die top Option und unterstützen asynchrones Paging.

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

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

const registrations = 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));
  }
}

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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));
  }
}

Sendevorgänge

Notification Hubs unterstützt das Senden von Benachrichtigungen an Geräte, entweder direkt unter Verwendung des eindeutigen PNS-bereitgestellten Bezeichners, mithilfe von Tags für das Senden von Zielgruppen oder einer allgemeinen Übertragung an alle Geräte. Bei Verwendung der Standard-SKU und höher ermöglicht der geplante Versand dem Benutzer, Benachrichtigungen bis zu sieben Tage im Voraus zu planen. Alle Sendevorgänge geben eine Nachverfolgungs-ID und eine Korrelations-ID zurück, die für Notification Hubs-Supportfälle verwendet werden können. Mit der Standard-SKU und höher wird auch eine Benachrichtigungs-ID zurückgegeben, die zum Abrufen von Benachrichtigungstelemetriedaten über die getNotificationOutcomeDetails Methode verwendet werden kann.

Zu Debugzwecken können die enableTestSend Optionen auf true die Option festgelegt werden, die sofortiges Feedback vom PNS zur sendNotification Methode erhält, jedoch in Produktionsszenarien nicht unterstützt wird. Dies wird bei den geplanten Sendemethoden nicht unterstützt.

Unformatierte JSON- oder XML-Zeichenfolgen können an die Sendemethode oder die geplante Sendemethode gesendet werden, oder die Benachrichtigungs-Generatoren können verwendet werden, um Nachrichten pro PNS zu erstellen, z. B. APNs, Firebase, Baidu, ADM und WNS. Diese Generatoren erstellen das native Nachrichtenformat, sodass nicht verraten werden muss, welche Felder für die einzelnen PNS verfügbar sind.

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

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,
});

Broadcast Senden

Notification Hubs können verwendet werden, um Benachrichtigungen an alle registrierten Geräte pro Plattform zu senden, indem die Broadcast-Sendemethode verwendet sendBroadcastNotification wird.

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

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

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

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

const result = await client.sendBroadcastNotification(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}`);
}

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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

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

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

const result = await sendBroadcastNotification(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}`);
}

Direkter Versand

Um ein Gerät direkt zu senden, kann der Benutzer mithilfe der von der Plattform bereitgestellten eindeutigen Kennung senden, z. B. APNs-Gerätetoken, indem er die sendNotification Methode mit einem deviceHandle Parameter aufruft.

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

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

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}`);
}

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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

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}`);
}

Publikum senden

Zusätzlich zur Ausrichtung auf ein einzelnes Gerät kann ein Benutzer mithilfe von Tags mehrere Geräte als Ziel verwenden. Diese Tags können als Liste von Tags bereitgestellt werden, die dann einen Tag-Ausdruck erstellen, der den registrierten Geräten entspricht, oder über einen Tag-Ausdruck, der dann die boolesche Logik verwenden kann, um die richtige Zielgruppe anzusprechen. Weitere Informationen zu Tags und Tag-Ausdrücken finden Sie unter Routing und Tag-Ausdrücke.

Wenn Sie einen Tag-Ausdruck aus einem Array von Tags erstellen möchten, steht ein Tag Expression Builder mit der Methode zur Verfügung, die createTagExpression beim Top-Level-Import oder @azure/notification-hubs/models/tagExpressionBuilder beim modularen Import verfügbar gemacht wird, der einen "oder Tag-Ausdruck" aus den Tags erstellt.

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

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

console.log(tagExpression);

Tagausdrucksmeldungen können mit dem folgenden Code gesendet werden:

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}`);
}

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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}`);
}

Geplanter Versand

Pushbenachrichtigungen können mit Standard-SKU-Namespaces und höher bis zu sieben Tage im Voraus geplant werden, indem die scheduleNotification Methode zum Senden an Geräte mit Tags oder eine allgemeine Übertragung mit scheduleBroadcastNotificationverwendet wird. Diese gibt eine Benachrichtigungs-ID zurück, die dann verwendet werden kann, um bei Bedarf über die cancelScheduledNotification Methode abzubrechen.

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}`);

Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:

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

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}`);

Problembehandlung

React Native-Unterstützung

React Native bietet derzeit keine Unterstützung für [URLSearchParams], das vom Azure Notification Hubs SDK verwendet wird. Um das SDK in React Native verwenden zu können, müssen Sie das url-search-params-polyfill Paket installieren und importieren, bevor Sie das SDK verwenden.

Wir müssen auch Polyfill für TextEncoder die API und die asynchrone Iterator-API bereitstellen. Weitere Informationen finden Sie in unserem React Native-Beispiel mit Expo .

Diagnostizieren von verworfenen Benachrichtigungen

Einen vollständigen Leitfaden zur Problembehandlung bei Problemen mit gelöschten Benachrichtigungen finden Sie in Azure Notification Hubs im Leitfaden Diagnostizieren gelöschter Benachrichtigungen in Azure Notification Hubs.

Test Send wird in den sendNotificationsendBroadcastNotification und-Methoden mit der enableTestSend Option unterstützt:

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,
  enableTestSend: true,
});

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

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,
  enableTestSend: true,
});

Protokollierung

Das Aktivieren der Protokollierung kann hilfreiche Informationen zu Fehlern aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die AZURE_LOG_LEVEL Umgebungsvariable auf infofest. Alternativ kann die Protokollierung zur Laufzeit durch Aufrufen von setLogLevel im @azure/loggeraktiviert werden:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Ausführlichere Anweisungen zum Aktivieren von Protokollen finden Sie in den @azure/Logger-Paketdokumenten.

Nächste Schritte

Die folgenden Beispiele zeigen Ihnen die verschiedenen Möglichkeiten, wie Sie mit Azure Notification Hubs interagieren können:

Geräteverwaltung:

Sende-Operationen:

Management-Operationen:

Contributing

Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie bitte den Beitragsleitfaden , um mehr über das Erstellen und Testen des Codes zu erfahren.

Bei den Tests dieses Moduls handelt es sich um eine Mischung aus Live- und Komponententests, für die Sie über eine Azure Notification Hubs-Instanz verfügen müssen. Zum Ausführen der Tests müssen Sie Folgendes ausführen:

  1. pnpm install
  2. pnpm build --filter @azure/notification-hubs...
  3. Erstellen Sie eine .env-Datei mit folgendem sdk\notificationhubs\notification-hubs Inhalt im Ordner: NOTIFICATIONHUBS_CONNECTION_STRING=connection string for your Notification Hubs instanceNOTIFICATION_HUB_NAME=Notification Hub name
  4. cd sdk\notificationhubs\notification-hubs
  5. npm run test.

Weitere Informationen finden Sie in unserem Testordner .

  • Last updated on