Zestaw SDK usługi Azure Notification Hubs dla języka JavaScript

Artykuł
05/22/2024

Usługa Azure Notification Hubs udostępnia skalowany w poziomie aparat wypychania, który umożliwia wysyłanie powiadomień do dowolnej platformy (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows itp.) z dowolnego zaplecza (chmury lub środowiska lokalnego). Usługa Notification Hubs działa dobrze zarówno w scenariuszach korporacyjnych, jak i konsumenckich. Poniżej przedstawiono kilka przykładowych scenariuszy:

Wysyłanie powiadomień o najważniejszych wiadomościach do milionów osób z małym opóźnieniem.
Wysyłanie kuponów opartych na lokalizacji do segmentów zainteresowanych użytkowników.
Wysyłanie powiadomień o zdarzeniach do użytkowników lub grup dla aplikacji związanych z mediami, sportem i finansami oraz gier.
Wypychanie promocyjnej zawartości do aplikacji w celu zaangażowania klientów i wprowadzania aplikacji na rynek.
Powiadamianie użytkowników o zdarzeniach przedsiębiorstwa, takich jak nowe komunikaty i elementy robocze.
Wysyłanie kodów uwierzytelniania wieloskładnikowego.

Kluczowe linki:

UWAGA: Jeśli pochodzisz z pakietu azure-sb , zobacz migration guide to move from azure-sb to @azure/notification-hubs

Wprowadzenie

Obecnie obsługiwane środowiska

Wersje ltS Node.js
Najnowsze wersje przeglądarek Safari, Chrome, Edge i Firefox.

Aby uzyskać więcej informacji, zobacz nasze zasady pomocy technicznej .

Instalowanie pakietu

npm install @azure/notification-hubs

Wymagania wstępne

Twórca zasobu usługi Azure Notification Hubs

Usługę Azure Notification Hub można utworzyć przy użyciu następujących metod:

Po utworzeniu centrum powiadomień można skonfigurować przy użyciu witryny Azure Portal lub interfejsu wiersza polecenia platformy Azure.

Importowanie klienta

Ten zestaw SDK dla języka JavaScript oferuje dwa sposoby interakcji z usługą Azure Notification Hubs za pomocą podejścia opartego na klasie lub podejścia do projektowania modułowego. Podejście oparte na klasach jest spójne we wszystkich pakietach w celu utworzenia klienta, a następnie interakcji z metodami na kliencie.

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

Podejście modułowe pozwala deweloperowi wybrać i wybrać funkcje do zaimportowania, ponieważ każda metoda jest uwidoczniona indywidualnie. Takie podejście używa eksportów podścieżki z ES-Modules w celu uwidocznienia metod za pośrednictwem importu bezpośredniego. Dzięki poszczególnym eksportom tworzy to lepsze środowisko potrząsania drzewami i mniejsze rozmiary pakietów, z których deweloper może korzystać.

Należy pamiętać, że utworzenie klienta jest uwidocznione za pośrednictwem "@azure/notification-hubs/api" ścieżki podrzędnej, a wszystkie metody klienta są uwidocznione przez ścieżkę podrzędną "@azure/notification-hubs/api" . Każda wyeksportowana funkcja przyjmuje client jako pierwszy parametr, a reszta parametrów pozostaje niezmieniona.

Widoczne są następujące ścieżki podrzędne:

@azure/notification-hubs/api - Główny punkt wejścia klienta za pośrednictwem createClientContext metod i klienta, takich jak getInstallation lub sendNotification
@azure/notification-hubs/models - Modele usługi Notification Hubs i metody fabryki.

Powyższy fragment kodu staje się następujący:

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

Uwierzytelnianie klienta

Interakcja z usługą Azure Notification Hub rozpoczyna się od NotificationHubsClientparametrów połączenia sygnatury dostępu współdzielonego. Obejmuje to następujące poziomy uprawnień: Nasłuchiwanie, Zarządzanie, Wysyłanie.

Funkcja Nasłuchiwania umożliwia klientowi zarejestrowanie się za pośrednictwem interfejsu API rejestracji i instalacji. Funkcja Send umożliwia klientowi wysyłanie powiadomień do urządzeń przy użyciu interfejsów API wysyłania. Na koniec zarządzanie umożliwia użytkownikowi zarządzanie rejestracją i instalacją, takie jak zapytania.

Nowy NotificationHubsClient klient można utworzyć przy użyciu konstruktora z nazwą parametry połączenia i centrum powiadomień.

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

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

Przy użyciu podejścia createClientContext modułowego można zaimportować go za pośrednictwem ścieżki podrzędnej "@azure/notification-hubs/api" .

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

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

Kluczowe pojęcia

NotificationHubClient Po zainicjowaniu można zapoznać się z następującymi pojęciami.

Zarządzanie urządzeniami za pośrednictwem instalacji i rejestracjiDescriptions
Wysyłanie powiadomień do urządzeń

Zarządzanie urządzeniami

Zarządzanie urządzeniami to podstawowa koncepcja usługi Notification Hubs umożliwiająca przechowywanie unikatowego identyfikatora z natywnej usługi powiadomień platformy (PNS), takiej jak APNs lub Firebase, oraz skojarzonych metadanych, takich jak tagi używane do wysyłania powiadomień wypychanych do odbiorców. Odbywa się to za pomocą dwóch interfejsów API, interfejsu API instalacji, który jest nowszym i preferowanym mechanizmem oraz rejestracjami.

Interfejs API instalacji

Instalacje to nowsze i natywne podejście JSON do zarządzania urządzeniami, które zawiera dodatkowe właściwości, takie jak identyfikator instalacji i identyfikator użytkownika, które mogą być używane do wysyłania do odbiorców. Interfejs API instalacji ma kilka zalet w stosunku do istniejących interfejsów API rejestracji w następujący sposób:

W pełni idempotentny interfejs API, aby wywołać metodę create w instalacji, aby można było ponowić operację bez obaw o duplikacje.
Obsługa userId właściwości i installationId , które mogą być następnie używane w wyrażeniach tagów, takich jak $InstallationId:{myInstallId} i $UserId:{bob@contoso.com}.
Szablony są teraz częścią instalacji zamiast oddzielnej rejestracji i mogą być odwoływane według nazwy jako tag do wysyłania.
Częściowe aktualizacje są obsługiwane za pośrednictwem standardu JSON Patch Standard, co umożliwia dodawanie tagów i zmienianie innych danych bez konieczności uprzedniego wykonywania zapytań dotyczących instalacji.

Instalacje można utworzyć za pomocą createOrUpdateInstallation metody, takiej jak:

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Aktualizacja instalacji może zostać wykonana za pomocą schematu poprawek JSON, takiego jak dodanie tagu i identyfikator użytkownika przy użyciu updateInstallation metody .

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Aby pobrać istniejącą instalację, użyj getInstallation metody z istniejącym unikatowym identyfikatorem instalacji.

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

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

const installationId = "<unique installation ID>";

const installation = client.getInstallation(installationId);

Przy użyciu modułowego podejścia kod będzie następujący:

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

Interfejs API rejestracji

Rejestracja jest skojarzona z usługą PNS tak samo jak powyżej z unikatowym identyfikatorem urządzenia z pnS i skojarzonymi tagami. Rejestracje szablonów to sposób tworzenia wstępnie zdefiniowanych szablonów treści, które następnie można dostosować w czasie wysyłania z właściwościami w celu wypełnienia komunikatu. Aby uzyskać więcej informacji na temat szablonów, zobacz dokumentację szablonów.

Instalacja może zostać utworzona na jeden z dwóch sposobów, najpierw przez pobranie identyfikatora rejestracji z serwera przy użyciu metody getInstallationId , a następnie createOrUpdateRegistration lub za pomocą createRegistration metody .

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Aktualizacje można wykonać za pomocą updateRegistration metody , ale w przeciwieństwie do instalacji, nie obsługuje aktualizacji przyrostowych. Wykonywanie zapytań dotyczących istniejącej rejestracji można wykonać za pomocą getRegistration metody .

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Rejestracje, w przeciwieństwie do instalacji, można odpytować, aby uzyskać wszystkie rejestracje, pasujące rejestracje do warunku lub według tagów. Rejestracje można wykonywać przy użyciu listRegistrationsmetody i listRegistrationsByChannellistRegistrationsByTag . Wszystkie metody obsługują ograniczanie za pośrednictwem top opcji i obsługują stronicowanie asynchroniczne.

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Wysyłanie operacji

Usługa Notification Hubs obsługuje wysyłanie powiadomień do urządzeń bezpośrednio przy użyciu unikatowego identyfikatora dostarczonego przez usługę PNS, przy użyciu tagów do wysyłania odbiorców lub ogólnej emisji na wszystkich urządzeniach. Przy użyciu jednostki SKU w warstwie Standardowa i nowszej zaplanowane wysyłanie umożliwia użytkownikowi zaplanowanie powiadomień do siedmiu dni wcześniej. Wszystkie operacje wysyłania zwracają identyfikator śledzenia i identyfikator korelacji, które mogą być używane w przypadku spraw pomocy technicznej usługi Notification Hubs. W przypadku jednostki SKU w warstwie Standardowa i nowszej zwracany jest również identyfikator powiadomienia, który może służyć do pobierania danych telemetrycznych powiadomień za pośrednictwem getNotificationOutcomeDetails metody .

W celach debugowania można ustawić opcje, enableTestSend do true których można uzyskać natychmiastową opinię z usługi PNS w sendNotification metodzie, jednak nie jest obsługiwana w scenariuszach produkcyjnych. Nie jest to obsługiwane w zaplanowanych metodach wysyłania.

Nieprzetworzone ciągi JSON lub XML można wysyłać do metod wysyłania lub zaplanowanego wysyłania albo konstruktorów powiadomień, które ułatwiają konstruowanie komunikatów dla systemów PNS, takich jak APNs, Firebase, Baidu, ADM i WNS. Te konstruktory skompilują format komunikatu natywnego, więc nie ma wątpliwości, które pola są dostępne dla każdego systemu powiadomień.

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

Wysyłanie emisji

Usługa Notification Hubs może służyć do wysyłania powiadomień do wszystkich zarejestrowanych urządzeń na platformę przy użyciu wysyłania sendNotification emisji za pośrednictwem metody .

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Bezpośrednie wysyłanie

Aby wysłać urządzenie bezpośrednio, użytkownik może wysłać przy użyciu platformy podanego unikatowego identyfikatora, takiego jak token urządzenia APNs, wywołując metodę za pomocą parametru sendNotificationdeviceHandle .

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Wyślij odbiorców

Oprócz określania wartości docelowej pojedynczego urządzenia użytkownik może kierować wiele urządzeń przy użyciu tagów. Te tagi można podać jako listę tagów, która następnie tworzy wyrażenie tagu w celu dopasowania zarejestrowanych urządzeń lub za pomocą wyrażenia tagu, które może następnie użyć logiki logicznej w celu kierowania odpowiednich odbiorców. Aby uzyskać więcej informacji na temat wyrażeń tagów i tagów, zobacz Routing and Tag Expressions (Wyrażenia routingu i tagów).

Jeśli chcesz utworzyć wyrażenie tagu na podstawie tablicy tagów, dostępny jest konstruktor createTagExpression wyrażeń tagów z metodą uwidacznianą na najwyższym poziomie importu lub @azure/notification-hubs/models/tagExpressionBuilder importowania modułowego, który tworzy wyrażenie "lub tag" z tagów.

// 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

Komunikaty wyrażeń tagów można wysyłać przy użyciu następującego kodu:

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Zaplanowane wysyłanie

Powiadomienia wypychane można zaplanować z maksymalnie siedmiodniowym wyprzedzeniem z przestrzeniami nazw jednostki SKU w warstwie Standardowa i nowszym przy użyciu scheduleBroadcastNotification metody wysyłania do urządzeń z tagami lub emisją ogólną. Spowoduje to zwrócenie identyfikatora powiadomienia, który można następnie użyć do anulowania w razie potrzeby za pośrednictwem cancelScheduledNotification metody .

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

Przy użyciu modułowego podejścia kod będzie następujący:

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

Rozwiązywanie problemów

obsługa React Native

React Native obecnie nie obsługuje platformy [URLSearchParams], która jest używana przez zestaw SDK usługi Azure Notification Hubs. Aby użyć zestawu SDK w React Native, należy zainstalować url-search-params-polyfill pakiet i zaimportować go przed użyciem zestawu SDK.

import 'url-search-params-polyfill';

Musimy również zapewnić wielowypełnianie interfejsu TextEncoder API i interfejs API iteratora asynchronicznego. Aby uzyskać więcej informacji, zobacz nasz przykład React Native z expo.

Diagnozowanie porzuconych powiadomień

Usługa Azure Notification Hubs zawiera kompletny przewodnik rozwiązywania problemów z porzuconymi powiadomieniami w przewodniku Diagnozowanie porzuconych powiadomień w usłudze Azure Notification Hubs.

Wysyłanie testowe jest obsługiwane w metodzie sendNotification z opcją 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 });

Rejestrowanie

Włączenie rejestrowania może pomóc odkryć przydatne informacje o błędach. Aby wyświetlić dziennik żądań HTTP i odpowiedzi, ustaw zmienną AZURE_LOG_LEVEL środowiskową na info. Możesz też włączyć rejestrowanie w czasie wykonywania, wywołując polecenie w elemecie setLogLevel@azure/logger:

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

setLogLevel("info");

Aby uzyskać bardziej szczegółowe instrukcje dotyczące włączania dzienników, zapoznaj się z dokumentami dotyczącymi pakietu @azure/rejestratora.

Następne kroki

W poniższych przykładach przedstawiono różne sposoby interakcji z usługą Azure Notification Hubs:

Zarządzanie urządzeniami:

Interfejs API instalacji
- Twórca lub instalacja aktualizacji
- Aktualizacja instalacji
Interfejs API rejestracji

Operacje wysyłania:

Operacje zarządzania:

Współtworzenie

Jeśli chcesz współtworzyć tę bibliotekę, przeczytaj przewodnik współtworzenia , aby dowiedzieć się więcej na temat sposobu kompilowania i testowania kodu.

Testy tego modułu to kombinacja testów na żywo i testów jednostkowych, które wymagają wystąpienia usługi Azure Notification Hubs. Aby wykonać testy, należy uruchomić:

rush update
rush build -t @azure/notification-hubs
Twórca pliku env z następującą zawartością w folderzesdk\notificationhubs\notification-hubs:NOTIFICATIONHUBS_CONNECTION_STRING=connection string for your Notification Hubs instanceNOTIFICATION_HUB_NAME=Notification Hub name
cd sdk\notificationhubs\notification-hubs
rushx test.

Aby uzyskać więcej informacji, zobacz nasz folder testowy .

Wrażenia

Udostępnij za pośrednictwem

Zestaw SDK usługi Azure Notification Hubs dla języka JavaScript

Wprowadzenie

Obecnie obsługiwane środowiska

Instalowanie pakietu

Wymagania wstępne

Twórca zasobu usługi Azure Notification Hubs

Importowanie klienta

Uwierzytelnianie klienta

Kluczowe pojęcia

Zarządzanie urządzeniami

Interfejs API instalacji

Interfejs API rejestracji

Wysyłanie operacji

Wysyłanie emisji

Bezpośrednie wysyłanie

Wyślij odbiorców

Zaplanowane wysyłanie

Rozwiązywanie problemów

obsługa React Native

Diagnozowanie porzuconych powiadomień

Rejestrowanie

Następne kroki

Współtworzenie

Dodatkowe zasoby

Udostępnij za pośrednictwem

Zestaw SDK usługi Azure Notification Hubs dla języka JavaScript

Wprowadzenie

Obecnie obsługiwane środowiska

Instalowanie pakietu

Wymagania wstępne

Twórca zasobu usługi Azure Notification Hubs

Importowanie klienta

Uwierzytelnianie klienta

Kluczowe pojęcia

Zarządzanie urządzeniami

Interfejs API instalacji

Interfejs API rejestracji

Wysyłanie operacji

Wysyłanie emisji

Bezpośrednie wysyłanie

Wyślij odbiorców

Zaplanowane wysyłanie

Rozwiązywanie problemów

obsługa React Native

Diagnozowanie porzuconych powiadomień

Rejestrowanie

Następne kroki

Współtworzenie

Powiązane projekty

Dodatkowe zasoby