Azure Notification Hubs SDK für JavaScript

Artikel
05/21/2024

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-sbmigration 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 über createClientContext und Clientmethoden wie getInstallation 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 NotificationHubsClientVerbindungszeichenfolgen 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 und installationId 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
- Create oder Aktualisieren der Installation
- Updateinstallation
Registrierungs-API

Sendevorgänge:

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 instanceNOTIFICATION_HUB_NAME=Notification Hub name
cd sdk\notificationhubs\notification-hubs
rushx test.

Weitere Informationen finden Sie in unserem Testordner .

Aufrufe

Share via

Azure Notification Hubs SDK für JavaScript

Erste Schritte

Die derzeitig unterstützten Umgebungen

Installieren des Pakets

Voraussetzungen

Create einer Azure Notification Hubs-Ressource

Importieren des Clients

Authentifizieren des Clients

Wichtige Begriffe

Geräteverwaltung

Installations-API

Registrierungs-API

Sendevorgänge

Senden von Sendungen

Direkt senden

Audience Send

Geplantes Senden

Problembehandlung

React Native Support

Diagnostizieren gelöschter Benachrichtigungen

Protokollierung

Nächste Schritte

Mitwirken

Feedback

Zusätzliche Ressourcen

Share via

Azure Notification Hubs SDK für JavaScript

Erste Schritte

Die derzeitig unterstützten Umgebungen

Installieren des Pakets

Voraussetzungen

Create einer Azure Notification Hubs-Ressource

Importieren des Clients

Authentifizieren des Clients

Wichtige Begriffe

Geräteverwaltung

Installations-API

Registrierungs-API

Sendevorgänge

Senden von Sendungen

Direkt senden

Audience Send

Geplantes Senden

Problembehandlung

React Native Support

Diagnostizieren gelöschter Benachrichtigungen

Protokollierung

Nächste Schritte

Mitwirken

Verwandte Projekte

Feedback

Zusätzliche Ressourcen