Azure Notification Hubs SDK für JavaScript
Azure Notification Hubs bieten eine skalierte Push-Engine, mit der Sie Benachrichtigungen an jede Plattform (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows usw.) von jedem Back-End (Cloud oder lokal) senden können. Notification Hubs eignet sich sowohl für Unternehmens- als auch für Consumerszenarien. Es folgen einige Beispielszenarios:
- Senden von Benachrichtigungen zu brandaktuellen Nachrichten an Millionen von Empfängern mit niedriger Latenz
- Senden standortbasierter Gutscheine an interessierte Kundengruppen
- Senden von Ereignisbenachrichtigungen an Benutzer oder Gruppen für Medien-/Sport-/Finanz-/Spieleanwendungen
- Pushübertragung von Werbeinhalten an Anwendungen, um Kunden anzusprechen und zum Kauf anzuregen
- Informieren von Benutzern über Unternehmensereignisse (beispielsweise neue Nachrichten und Arbeitselemente)
- Senden von Codes für die mehrstufige Authentifizierung
Wichtige Links:
HINWEIS: Wenn Sie das Paket verwenden, lesen Sie die azure-sb
migration guide to move from azure-sb to @azure/notification-hubs
Erste Schritte
Die derzeitig unterstützten Umgebungen
- LTS-Versionen von Node.js
- Neueste Versionen von Safari, Chrome, Edge und Firefox.
Ausführlichere Informationen finden Sie in der Supportrichtlinie.
Installieren des Pakets
npm install @azure/notification-hubs
Voraussetzungen
- Ein Azure-Abonnement
- Eine App Notification Hubs-Ressource .
Create einer Azure Notification Hubs-Ressource
Ein Azure Notification Hub kann mit den folgenden Methoden erstellt werden:
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 mit einem 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, die zu importierenden Funktionen auszuwählen, wenn jede Methode einzeln verfügbar gemacht wird. Bei diesem Ansatz werden Subpfadexporte mit ES-Modules verwendet, um die Methoden über direkte Importe verfügbar zu machen. Mit den einzelnen Exporten entsteht dadurch eine bessere Strukturbeschütterung und kleinere Bündelgröß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 der Rest der Parameter bleibt unverändert.
Die folgenden Unterpfade werden verfügbar gemacht:
@azure/notification-hubs/api
- Der Standard Einstiegspunkt für den Client übercreateClientContext
und Clientmethoden wiegetInstallation
odersendNotification
@azure/notification-hubs/models
– Die Notification Hubs-Modelle und Factorymethoden.
Der obige Codeausschnitt wird dann wie folgt:
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);
Authentifizieren des Clients
Die Interaktion mit einem Azure Notification Hub beginnt mit dem, das NotificationHubsClient
Verbindungszeichenfolgen für Shared Access Signature unterstützt. Dies umfasst die folgenden Berechtigungsstufen: Listen, Verwalten, Senden.
Listen ermöglicht es einem Client, sich über die Registrierungs- und Installations-API zu registrieren. Senden ermöglicht dem Client das Senden von Benachrichtigungen an Geräte mithilfe der Sende-APIs. Schließlich ermöglicht verwalten dem Benutzer die Verwaltung der Registrierung und Installation, z. B. Abfragen.
Ein neuer NotificationHubsClient
Client kann mithilfe des Konstruktors mit dem namen Verbindungszeichenfolge und Notification Hub erstellt werden.
import { NotificationHubsClient } from "@azure/notification-hubs";
const client = new NotificationHubsClient("<connection string>", "<hub name>");
Mit dem modularen Ansatz kann der createClientContext
über den "@azure/notification-hubs/api"
Unterpfad importiert werden.
import { createClientContext } from "@azure/notification-hubs/api";
const context = createClientContext("<connection string>", "<hub name>");
Wichtige Begriffe
Nachdem die NotificationHubClient
initialisiert wurde, können die folgenden Konzepte untersucht werden.
- Geräteverwaltung über Installations- und Registrierungsbeschreibungen
- Senden von Benachrichtigungen an Geräte
Geräteverwaltung
Die Geräteverwaltung ist ein Kernkonzept für Notification Hubs, um den eindeutigen Bezeichner des nativen Plattformbenachrichtigungsdiensts (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 Mechanismus, und Registrierungen.
Installations-API
Installationen sind ein neuerer und nativer JSON-Ansatz für die Geräteverwaltung, der zusätzliche Eigenschaften wie eine Installations- und Benutzer-ID enthält, die zum Senden an Zielgruppen verwendet werden können. Die Installations-API hat folgende Vorteile gegenüber den vorhandenen Registrierungs-APIs:
- Vollständig idempotente API, also das Aufrufen von create bei der Installation, damit ein Vorgang ohne Sorge um Duplikate wiederholt werden kann.
- Unterstützung für
userId
undinstallationId
Eigenschaften, die dann in Tagausdrücken wie$InstallationId:{myInstallId}
und$UserId:{bob@contoso.com}
verwendet werden können. - Vorlagen sind jetzt Teil der Installation anstelle einer separaten Registrierung und können als Tag für das Senden nach Name referenziert werden.
- Partielle Updates werden durch den JSON Patch Standard unterstützt, der das Hinzufügen von Tags und das Ändern anderer Daten ermöglicht, ohne die Installation zuvor abfragen zu müssen.
Installationen können mit der createOrUpdateInstallation
folgenden Methode erstellt werden:
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);
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/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);
Ein Update für eine Installation kann über das JSON-Patchschema 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/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);
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 ist einem PNS wie der obigen Installation mit dem eindeutigen Gerätebezeichner des PNS und zugeordneten Tags zugeordnet. Vorlagenregistrierungen sind eine Möglichkeit zum Erstellen vordefinierter Textvorlagen, die dann zur Sendezeit mit Eigenschaften angepasst werden können, die für die Nachricht ausgefüllt werden können. Weitere Informationen zu Vorlagen finden Sie unter Vorlagendokumentation.
Eine Installation kann auf zwei Arten erstellt werden, zunächst durch Abrufen einer Registrierungs-ID vom Server mithilfe getInstallationId
und dann createOrUpdateRegistration
oder über die createRegistration
-Methode.
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}`);
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/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}`);
Updates kann über die updateRegistration
-Methode erfolgen, unterstützt aber im Gegensatz zu Installationen keine inkrementellen Updates. Abfragen nach einer vorhandenen Registrierung können mit der getRegistration
-Methode durchgeführt werden.
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);
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>";
let registration = await getRegistration(context, registrationId);
registration.tags.push("likes_sports");
registration = await updateRegistration(context, registration);
Registrierungen können im Gegensatz zu Installationen abgefragt werden, um alle Registrierungen abzurufen, Registrierungen mit einer Bedingung oder durch Tags abzugleichen. Registrierungen können mit der listRegistrations
- listRegistrationsByChannel
und listRegistrationsByTag
-Methode abgefragt werden. Alle Methoden unterstützen die Begrenzung über die top
Option und unterstützen asynchrones Paging.
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));
}
}
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, die entweder direkt den eindeutigen PNS-Bezeichner verwenden, Tags für das Senden von Zielgruppen oder eine allgemeine Übertragung an alle Geräte verwenden. Mithilfe der Standard-SKU und höher ermöglicht das geplante Senden dem Benutzer, Benachrichtigungen bis zu sieben Tage im Voraus zu planen. Alle Sendevorgänge geben eine Nachverfolgungs-ID und 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 verwendet werden kann, um Benachrichtigungtelemetrie über die getNotificationOutcomeDetails
-Methode abzurufen.
Zum Debuggen können die enableTestSend
Optionen festgelegt werden, die true
vom PNS sofortiges Feedback zur sendNotification
Methode erhalten, wird jedoch in Produktionsszenarien nicht unterstützt. Dies wird für die geplanten Sendemethoden nicht unterstützt.
Unformatierte JSON- oder XML-Zeichenfolgen können an die Sende- oder geplanten Sendemethoden gesendet werden, oder die Benachrichtigungs-Generatoren können verwendet werden, um Nachrichten pro PNS wie APNs, Firebase, Baidu, ADM und WNS zu erstellen. Diese Generatoren erstellen das native Nachrichtenformat, sodass sie nicht erraten können, welche Felder für die einzelnen PNS verfügbar sind.
// 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);
Senden von Sendungen
Notification Hubs können zum Senden von Benachrichtigungen an alle registrierten Geräte pro Plattform mithilfe der sendNotification
Broadcast-Sendemethode verwendet werden.
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}`);
}
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/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}`);
}
Direkt senden
Um ein Gerät direkt zu senden, kann der Benutzer mithilfe des von der Plattform bereitgestellten eindeutigen Bezeichners 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(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}`);
}
Bei Verwendung des modularen Ansatzes würde der Code wie folgt aussehen:
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}`);
}
Audience Send
Zusätzlich zur Ausrichtung auf ein einzelnes Gerät kann ein Benutzer mehrere Geräte mithilfe von Tags als Ziel verwenden. Diese Tags können als Liste von Tags bereitgestellt werden, die dann einen Tagausdruck für registrierte Geräte erstellt, oder über einen Tagausdruck, der dann boolesche Logik verwenden kann, um die richtige Zielgruppe anzusprechen. Weitere Informationen zu Tags und Tags-Ausdrücken finden Sie unter Routing und Tagausdrücke.
Wenn Sie einen Tagausdruck aus einem Array von Tags erstellen möchten, steht ein Tagausdrucks-Generator mit der -Methode zur Verfügung, die createTagExpression
beim Import auf oberster Ebene oder @azure/notification-hubs/models/tagExpressionBuilder
beim modularen Import verfügbar gemacht wird, wodurch ein "oder Tagausdruck" aus den Tags erstellt wird.
// 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
Tagausdrucksmeldungen können mithilfe des folgenden Codes 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/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}`);
}
Geplantes Senden
Pushbenachrichtigungen können bis zu sieben Tage im Voraus mit Standard-SKU-Namespaces und höher mithilfe der scheduleBroadcastNotification
-Methode zum Senden an Geräte mit Tags oder einer allgemeinen Übertragung geplant werden. Dadurch wird eine Benachrichtigungs-ID zurückgegeben, die dann bei Bedarf über die cancelScheduledNotification
-Methode zum Abbrechen verwendet werden kann.
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/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}`);
Problembehandlung
React Native Support
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.
import 'url-search-params-polyfill';
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 gelöschter Benachrichtigungen
Azure Notification Hubs enthält einen vollständigen Leitfaden zur Behandlung von Problemen mit gelöschten Benachrichtigungen im Leitfaden Diagnose von gelöschten Benachrichtigungen in Azure Notification Hubs.
Das Senden von Tests wird in der sendNotification
-Methode mit der enableTestSend
Option unterstützt:
// 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 });
Protokollierung
Die Aktivierung der Protokollierung kann hilfreiche Informationen über Fehler aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die Umgebungsvariable AZURE_LOG_LEVEL
auf info
fest. Alternativ kann die Protokollierung zur Laufzeit aktiviert werden, indem Sie setLogLevel
in @azure/logger
aufrufen:
const { setLogLevel } = require("@azure/logger");
setLogLevel("info");
Ausführlichere Anweisungen zum Aktivieren von Protokollen finden Sie in der Paketdokumentation zu @azure/logger.
Nächste Schritte
In den folgenden Beispielen werden die verschiedenen Möglichkeiten gezeigt, wie Sie mit Azure Notification Hubs interagieren können:
Geräteverwaltung:
- Installations-API
- Registrierungs-API
Sendevorgänge:
- Senden von Übertragungen
- Direct Send
- Liste "Zielgruppen senden mit Tags"
- Zielgruppensendung mit Tagausdruck
- Geplantes Senden von Übertragungen
- Geplantes Senden
Verwaltungsvorgänge:
Mitwirken
Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie die Anleitung für Mitwirkende, um mehr darüber zu erfahren, wie Sie den Code erstellen und testen können.
Die Tests dieses Moduls sind eine Mischung aus Live- und Komponententests, die eine Azure Notification Hubs-instance erfordern. Zum Ausführen der Tests müssen Sie Folgendes ausführen:
rush update
rush build -t @azure/notification-hubs
- Create eine ENV-Datei mit den folgenden Inhalten
sdk\notificationhubs\notification-hubs
im Ordner:NOTIFICATIONHUBS_CONNECTION_STRING=connection string for your Notification Hubs instance
NOTIFICATION_HUB_NAME=Notification Hub name
cd sdk\notificationhubs\notification-hubs
rushx test
.
Weitere Informationen finden Sie in unserem Testordner .
Verwandte Projekte
Azure SDK for JavaScript