Uwaga
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Dodaj czat w czasie rzeczywistym do aplikacji przy użyciu zestawu SDK czatu usług komunikacyjnych. W tym artykule opisano sposób używania zestawu SDK czatu do tworzenia wątków czatu, które umożliwiają użytkownikom prowadzenie konwersacji ze sobą. Aby dowiedzieć się więcej na temat pojęć związanych z czatem, zobacz dokumentację koncepcyjną czatu.
Wymagania wstępne
Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
Aktywny zasób usług komunikacyjnych i parametry połączenia. Utwórz zasób usług komunikacyjnych.
Zainstaluj Azure CLI.
Zanotuj punkt końcowy zasobów Usług Komunikacyjnych. Punkt końcowy można pobrać z witryny Azure Portal. Możesz też znaleźć adres URL punktu końcowego w parametry połączenia. Jest to adres URL, który pojawia się po
endpoint=
i zaczyna się odhttps://
.Token dostępu użytkownika. Pamiętaj, aby ustawić zakres na czat i zanotować ciąg znaków tokenu oraz ciąg znaków identyfikatora użytkownika. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić następujące polecenie za pomocą ciągu połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Ustawienia
Dodawanie rozszerzenia
Dodaj rozszerzenie Azure Communication Services dla interfejsu wiersza polecenia Azure, używając polecenia az extension
.
az extension add --name communication
Logowanie do interfejsu wiersza polecenia platformy Azure
Musisz zalogować się do interfejsu wiersza polecenia platformy Azure. Możesz się zalogować, uruchamiając az login
polecenie z poziomu terminalu i podając poświadczenia.
(Optional) Korzystanie z operacji związanych z tożsamością Azure CLI bez przekazywania punktu końcowego lub tokenu dostępu
Przechowuj punkt końcowy w zmiennej środowiskowej
Możesz skonfigurować zmienną środowiska AZURE_COMMUNICATION_ENDPOINT
, aby korzystać z operacji czatu w Azure CLI, bez konieczności podawania punktu końcowego przez --endpoint
. Aby skonfigurować zmienną środowiskową, otwórz okno konsoli i wybierz system operacyjny z poniższych kart. Zastąp <yourEndpoint>
element rzeczywistym punktem końcowym.
Otwórz okno konsoli i wprowadź następujące polecenie:
setx AZURE_COMMUNICATION_ENDPOINT "<yourEndpoint>"
Po dodaniu zmiennej środowiskowej może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które muszą odczytać zmienną środowiskową, w tym okno konsoli. Jeśli na przykład używasz programu Visual Studio jako edytora, uruchom ponownie program Visual Studio przed uruchomieniem przykładu.
Przechowywanie tokenu dostępu w zmiennej środowiskowej
Możesz skonfigurować zmienną AZURE_COMMUNICATION_ACCESS_TOKEN
środowiskową do korzystania z operacji czatu za pomocą interfejsu wiersza polecenia platformy Azure, bez konieczności używania --access-token
do przekazywania tokenu dostępu. Aby skonfigurować zmienną środowiskową, otwórz okno konsoli i wybierz system operacyjny z poniższych kart. Zastąp <yourAccessToken>
rzeczywistym tokenem dostępu.
Otwórz okno konsoli i wprowadź następujące polecenie:
setx AZURE_COMMUNICATION_ACCESS_TOKEN "<yourAccessToken>"
Po dodaniu zmiennej środowiskowej może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które muszą odczytać zmienną środowiskową, w tym okno konsoli. Jeśli na przykład używasz programu Visual Studio jako edytora, uruchom ponownie program Visual Studio przed uruchomieniem przykładu.
Operacje
Rozpoczynanie wątku czatu
Użyj polecenia , thread create
aby utworzyć wątek czatu.
az communication chat thread create --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"
Jeśli punkt końcowy i token dostępu są przechowywane w zmiennych środowiskowych, jak określono wcześniej, nie musisz przekazywać ich do polecenia.
az communication chat thread create --topic "<chatTopic>"
- Użyj polecenia
<chatTopic>
, aby nadać wątkowi temat. Temat można zaktualizować po utworzeniu wątku czatuthread update-topic
za pomocą polecenia . - Zastąp
<endpoint>
swoim punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Aktualizowanie tematu wątku czatu
az communication chat thread update-topic --thread "<chatThreadId>" --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Zastąp
<chatTopic>
element nowym tematem czatu, który chcesz ustawić. - Zastąp
<endpoint>
punktem końcowym usługi Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Wyświetl wszystkie wątki czatu
Polecenie thread list
zwraca listę wątków czatu użytkownika.
az communication chat thread list --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
- Opcjonalnie: użyj polecenia
<startTime>
, aby określić najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie. - Zastąp
<endpoint>
punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Wysyłanie wiadomości do wątku czatu
Użyj polecenia message send
aby wysłać wiadomość do utworzonego wątku czatu, zidentyfikowanego przez threadId
program.
az communication chat message send --thread "<chatThreadId>" --display-name "<displayName>" --content "<content>" --message-type "<messageType>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Użyj polecenia
<content>
, aby podać zawartość wiadomości czatu. - Użyj
<messageType>
polecenia , aby określić typ zawartości wiadomości. Możliwe wartości totext
ihtml
. Jeśli nie określisz wartości, wartość domyślna totext
. - Możesz opcjonalnie użyć
<displayName>
do określenia nazwy wyświetlanej nadawcy. - Zastąp
<endpoint>
punktem końcowym w Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Wyświetlanie listy wiadomości czatu w wątku czatu
Polecenie message list
zwraca listę wiadomości czatu w wątku czatu.
az communication chat message list --thread "<chatThreadId>" --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Możesz opcjonalnie użyć
<startTime>
do określenia najwcześniejszego punktu w czasie, aby móc uzyskać wiadomości na czacie. - Zastąp
<endpoint>
swoim punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Odbieranie wiadomości czatu z wątku czatu
Wiadomości czatu można pobrać przy użyciu message list
polecenia .
az communication chat message get --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Zastąp
<messageId>
identyfikatorem wiadomości, którą chcesz pobrać. - Zastąp
<endpoint>
punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Wyślij potwierdzenie odczytu
Używasz polecenia message receipt send
do publikowania zdarzenia potwierdzenia odczytu w wątku w imieniu użytkownika.
az communication chat message receipt send --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Zastąp
<messageId>
element , aby określić identyfikator najnowszej wiadomości odczytanej przez bieżącego użytkownika. - Zastąp
<endpoint>
element punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Dodawanie użytkownika jako uczestnika do wątku czatu
Podczas tworzenia wątku czatu możesz dodawać i usuwać użytkowników. Dodając użytkowników, możesz przyznać im dostęp, aby mogli wysyłać wiadomości do wątku czatu i dodawać lub usuwać innych uczestników. Przed wywołaniem participant add
polecenia upewnij się, że uzyskasz nowy token dostępu i tożsamość dla tego użytkownika.
az communication chat participant add --thread "<chatThreadId>" --user "<userId>" --display-name "<displayName>" --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Zastąp
<userId>
identyfikatorem użytkownika userId. - Opcjonalnie użyj
<displayName>
do określenia nazwy wyświetlanej nadawcy. - Opcjonalnie określ
<startTime>
najwcześniejszy moment do otrzymania wiadomości na czacie. - Zastąp
<endpoint>
swoim punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Lista uczestników wątku czatu
Podobnie jak w przypadku dodawania uczestnika, można również wyświetlić listę uczestników z wątku.
Użyj polecenia participant list
, aby pobrać uczestników wątku.
az communication chat participant list --thread "<chatThreadId>" --skip "<skip>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Opcjonalnie można użyć
<skip>
do pominięcia uczestników do określonej pozycji w odpowiedzi. - Zastąp
<endpoint>
swoim punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Usuwanie uczestnika z wątku czatu
Możesz usunąć uczestnika czatu z wątku czatu przy użyciu polecenia "usuń uczestnika".
az communication chat participant remove --thread "<chatThreadId>" --user "<userId>" --endpoint "<endpoint>" --access-token "<token>"
- Zastąp
<chatThreadId>
element identyfikatorem wątku czatu. - Zamień
<userId>
na userId użytkownika, którego chcesz usunąć z wątku czatu. - Zastąp
<endpoint>
punktem końcowym usług Azure Communication Services. - Zastąp
<token>
element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionegoidentity token issue
polecenia.
Wymagania wstępne
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj wersje Active LTS i Maintenance LTS Node.js.
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. Musisz zarejestrować punkt końcowy zasobu i parametry połączenia dla tego artykułu.
Utwórz trzech użytkowników usług Azure Communication Services i wystaw im token dostępu użytkownika. Pamiętaj, aby ustawić zakres na czat, oraz zanotować zarówno ciąg tokenu, jak i ciąg user_id. Pełna prezentacja tworzy wątek z dwoma początkowymi uczestnikami, a następnie dodaje trzeciego uczestnika. Możesz również użyć Azure CLI i uruchomić następujące polecenie z użyciem ciągu połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Ustawienia
Tworzenie nowej aplikacji internetowej
Najpierw otwórz terminal lub okno polecenia, aby utworzyć nowy katalog dla aplikacji i przejść do niego.
mkdir chat-quickstart && cd chat-quickstart
Uruchom polecenie npm init -y
, aby utworzyć plik package.json z ustawieniami domyślnymi.
npm init -y
Instalowanie pakietów
Użyj polecenia , npm install
aby zainstalować następujące zestawy SDK usług Communication Services dla języka JavaScript.
npm install @azure/communication-common --save
npm install @azure/communication-identity --save
npm install @azure/communication-signaling --save
npm install @azure/communication-chat --save
Opcja --save
wyświetla bibliotekę jako zależność w pliku package.json .
Konfigurowanie struktury aplikacji
W tym artykule do pakowania zasobów aplikacji używany jest Parcel. Uruchom następujące polecenie, aby go zainstalować i wyświetlić jako zależność programową w package.json:
npm install parcel --save-dev
Utwórz plik index.html w katalogu głównym projektu. Użyj tego pliku jako szablonu, aby dodać możliwość czatu przy użyciu zestawu AZURE Communication Chat SDK dla języka JavaScript.
<!DOCTYPE html>
<html>
<head>
<title>Communication Client - Chat Sample</title>
</head>
<body>
<h4>Azure Communication Services</h4>
<h1>Chat Quickstart</h1>
<script src="./client.js" type="module"></script>
</body>
</html>
Utwórz plik w katalogu głównym projektu o nazwie client.js , aby zawierał logikę aplikacji dla tego artykułu.
Tworzenie klienta czatu
Aby utworzyć klienta czatu w aplikacji internetowej, użyj punktu końcowego usługi Communications Service i tokenu dostępu , który został wygenerowany w ramach kroków wymagań wstępnych.
Tokeny dostępu użytkowników umożliwiają tworzenie aplikacji klienckich, które są bezpośrednio uwierzytelniane w usługach Azure Communication Services. W tym artykule nie opisano tworzenia warstwy usługi do zarządzania tokenami dla aplikacji do czatu. Aby uzyskać więcej informacji na temat architektury czatów, zobacz pojęcia dotyczące czatów. Aby uzyskać więcej informacji na temat tokenów dostępu, zobacz Tokeny dostępu użytkowników.
Wewnątrz client.js użyj punktu końcowego i tokenu dostępu w poniższym kodzie, aby dodać funkcję czatu przy użyciu zestawu SDK czatu komunikacji platformy Azure dla języka JavaScript.
import { ChatClient } from '@azure/communication-chat';
import { AzureCommunicationTokenCredential } from '@azure/communication-common';
// Your unique Azure Communication service endpoint
let endpointUrl = '<replace with your resource endpoint>';
// The user access token generated as part of the pre-requisites
let userAccessToken = '<USER_ACCESS_TOKEN>';
let chatClient = new ChatClient(endpointUrl, new AzureCommunicationTokenCredential(userAccessToken));
console.log('Azure Communication Chat client created!');
- Zastąp endpointUrl końcowym punktem zasobów usługi Communication Services. Aby uzyskać więcej informacji, zobacz Create an Azure Communication Services resource.
- Zastąp userAccessToken tokenem, który wystawiłeś.
Uruchamianie kodu
Uruchom następujące polecenie, aby uruchomić aplikację:
npx parcel index.html
Otwórz przeglądarkę i przejdź do strony http://localhost:1234/. W konsoli narzędzi deweloperskich w przeglądarce powinny zostać wyświetlone następujące elementy:
Azure Communication Chat client created!
Model obiektów
Następujące klasy i interfejsy obsługują niektóre główne funkcje zestawu SDK czatu usług Azure Communication Services dla języka JavaScript.
Nazwa/nazwisko | opis |
---|---|
ChatClient | Ta klasa jest wymagana w przypadku funkcji czatu. Instancjujesz go za pomocą informacji o subskrypcji i używasz do tworzenia, pobierania, usuwania wątków oraz subskrybowania zdarzeń czatu. |
ChatThreadClient | Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz instancję za pośrednictwem ChatClient i używasz jej do wysyłania, odbierania, aktualizowania i usuwania wiadomości, dodawania, usuwania i pobierania użytkowników, wysyłania powiadomień o pisaniu oraz potwierdzeń przeczytania. |
Rozpoczynanie wątku czatu
createThread
Użyj metody , aby utworzyć wątek czatu.
createThreadRequest
służy do opisywania żądania wątku:
- Użyj
topic
, aby ustawić temat tej rozmowy. Tematy można zaktualizować po utworzeniu wątku czatuUpdateThread
przy użyciu funkcji . - Użyj
participants
polecenia , aby wyświetlić listę uczestników do dodania do wątku czatu.
Po rozwiązaniu createChatThread
metoda zwraca wartość CreateChatThreadResult
. Ten model zawiera właściwość chatThread
, która umożliwia dostęp do id
nowo utworzonego wątku. Następnie możesz użyć id
, aby uzyskać wystąpienie ChatThreadClient
. Następnie ChatThreadClient
może służyć do wykonywania operacji w wątku, takich jak wysyłanie komunikatów lub wyświetlanie listy uczestników.
async function createChatThread() {
const createChatThreadRequest = {
topic: "Hello, World!"
};
const createChatThreadOptions = {
participants: [
{
id: { communicationUserId: '<USER_ID>' },
displayName: '<USER_DISPLAY_NAME>'
}
]
};
const createChatThreadResult = await chatClient.createChatThread(
createChatThreadRequest,
createChatThreadOptions
);
const threadId = createChatThreadResult.chatThread.id;
return threadId;
}
createChatThread().then(async threadId => {
console.log(`Thread created:${threadId}`);
// PLACEHOLDERS
// <CREATE CHAT THREAD CLIENT>
// <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD>
// <SEND MESSAGE TO A CHAT THREAD>
// <LIST MESSAGES IN A CHAT THREAD>
// <ADD NEW PARTICIPANT TO THREAD>
// <LIST PARTICIPANTS IN A THREAD>
// <REMOVE PARTICIPANT FROM THREAD>
});
Po odświeżeniu karty przeglądarki w konsoli powinien zostać wyświetlony następujący komunikat:
Thread created: <thread_id>
Pobierz aplikację klienta czatu
Metoda getChatThreadClient
zwraca chatThreadClient
dla wątku, który już istnieje. Może służyć do wykonywania operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp. threadId jest unikatowym identyfikatorem istniejącego wątku czatu.
let chatThreadClient = chatClient.getChatThreadClient(threadId);
console.log(`Chat Thread client for threadId:${threadId}`);
Dodaj ten kod zamiast komentarza <CREATE CHAT THREAD CLIENT>
w client.js, odśwież kartę przeglądarki i sprawdź konsolę. Powinna zostać wyświetlona następująca pozycja:
Chat Thread client for threadId: <threadId>
Wyświetl wszystkie wątki czatu
Metoda listChatThreads
zwraca obiekt PagedAsyncIterableIterator
typu ChatThreadItem
. Może służyć do wyświetlania listy wszystkich wątków czatu.
Iterator elementu [ChatThreadItem]
to odpowiedź zwrócona z list wątków
const threads = chatClient.listChatThreads();
for await (const thread of threads) {
// your code here
}
Wysyłanie wiadomości do wątku czatu
Użyj sendMessage
metody , aby wysłać komunikat do wątku zidentyfikowanego przez threadId.
sendMessageRequest
służy do opisywania żądania komunikatu:
- Użyj
content
do podania zawartości wiadomości czatu;
sendMessageOptions
służy do opisywania opcjonalnych parametrów operacji:
- Użyj
senderDisplayName
polecenia , aby określić nazwę wyświetlaną nadawcy; - Użyj
type
polecenia , aby określić typ wiadomości, taki jak "tekst" lub "html"; - Opcjonalnie użyj
metadata
polecenia , aby uwzględnić inne dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment: true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.
SendChatMessageResult
to odpowiedź zwrócona po wysłaniu wiadomości. Zawiera unikatowy identyfikator wiadomości.
const sendMessageRequest =
{
content: 'Please take a look at the attachment'
};
let sendMessageOptions =
{
senderDisplayName : 'Jack',
type: 'text',
metadata: {
'hasAttachment': 'true',
'attachmentUrl': 'https://contoso.com/files/attachment.docx'
}
};
const sendChatMessageResult = await chatThreadClient.sendMessage(sendMessageRequest, sendMessageOptions);
const messageId = sendChatMessageResult.id;
console.log(`Message sent!, message id:${messageId}`);
Dodaj ten kod zamiast komentarza <SEND MESSAGE TO A CHAT THREAD>
w client.js, odśwież kartę przeglądarki i sprawdź konsolę.
Message sent!, message id:<number>
Odbieranie wiadomości czatu z wątku czatu
Za pomocą sygnałów w czasie rzeczywistym można subskrybować nasłuchiwanie nowych przychodzących komunikatów i odpowiednio aktualizować bieżące komunikaty w pamięci. Usługi Azure Communication Services obsługują listę zdarzeń, do których można zasubskrybować.
// open notifications channel
await chatClient.startRealtimeNotifications();
// subscribe to new notification
chatClient.on("chatMessageReceived", (e) => {
console.log("Notification chatMessageReceived!");
// your code here
});
Dodaj ten kod zamiast komentarza <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD>
w client.js.
Odśwież kartę przeglądarki, w konsoli powinien zostać wyświetlony komunikat Notification chatMessageReceived
;
Alternatywnie możesz pobrać wiadomości czatu, sondując metodę listMessages
w określonych odstępach czasu.
const messages = chatThreadClient.listMessages();
for await (const message of messages) {
// your code here
}
Dodaj ten kod zamiast komentarza <LIST MESSAGES IN A CHAT THREAD>
w client.js.
Odśwież kartę, a w konsoli programu powinna pojawić się lista wiadomości wysłanych w tym wątku czatu.
listMessages
Zwraca różne typy komunikatów, które można zidentyfikować za pomocą chatMessage.type
.
Aby uzyskać więcej informacji, zobacz Typy komunikatów.
Dodawanie użytkownika jako uczestnika do wątku czatu
Po utworzeniu wątku czatu można dodawać i usuwać użytkowników. Dodając użytkowników, możesz przyznać im dostęp do wysyłania wiadomości do wątku czatu i dodawać/usuwać innych uczestników.
Przed wywołaniem addParticipants
metody upewnij się, że uzyskasz nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik potrzebuje tego tokenu dostępu, aby zainicjować klienta czatu.
addParticipantsRequest
opisuje obiekt żądania, w którym wymieniono participants
uczestników do dodania do wątku czatu;
-
id
, wymagany jest identyfikator komunikacji, który ma zostać dodany do wątku czatu. -
displayName
, opcjonalnie, to nazwa wyświetlana uczestnika wątku. -
shareHistoryTime
, opcjonalnie, to czas, z którego historia czatu jest udostępniana uczestnikowi. Aby udostępnić historię od momentu utworzenia wątku czatu, ustaw tę właściwość na dowolną datę równą lub mniejszą niż czas tworzenia wątku. Aby nie udostępniać historii sprzed momentu dodania uczestnika, ustaw datę na bieżącą. Aby udostępnić historię częściową, ustaw ją na datę wyboru.
const addParticipantsRequest =
{
participants: [
{
id: { communicationUserId: '<NEW_PARTICIPANT_USER_ID>' },
displayName: 'Jane'
}
]
};
await chatThreadClient.addParticipants(addParticipantsRequest);
Zastąp NEW_PARTICIPANT_USER_ID nowym identyfikatoremużytkownika Dodaj ten kod zamiast komentarza <ADD NEW PARTICIPANT TO THREAD>
w client.js
Utwórz listę użytkowników w wątku czatu
const participants = chatThreadClient.listParticipants();
for await (const participant of participants) {
// your code here
}
Dodaj ten kod zamiast komentarza <LIST PARTICIPANTS IN A THREAD>
w client.js, odśwież kartę przeglądarki i sprawdź konsolę. Powinny zostać wyświetlone informacje o użytkownikach w wątku.
Usuwanie użytkownika z wątku czatu
Podobnie jak w przypadku dodawania uczestnika, można usunąć uczestników z wątku czatu. Aby usunąć, musisz śledzić identyfikatory uczestników, których dodałeś.
Użyj removeParticipant
metody , w której participant
użytkownik komunikacji ma zostać usunięty z wątku.
await chatThreadClient.removeParticipant({ communicationUserId: <PARTICIPANT_ID> });
await listParticipants();
Zastąp PARTICIPANT_ID identyfikatorem użytkownika używanym w poprzednim kroku (<NEW_PARTICIPANT_USER_ID>).
Dodaj ten kod zamiast komentarza <REMOVE PARTICIPANT FROM THREAD>
w client.js.
Subskrybowanie stanu połączenia powiadomień w czasie rzeczywistym
Subskrypcja zdarzeń realTimeNotificationConnected
i realTimeNotificationDisconnected
umożliwia określenie, kiedy połączenie z serwerem wywołań jest aktywne.
// subscribe to realTimeNotificationConnected event
chatClient.on('realTimeNotificationConnected', () => {
console.log("Real time notification is now connected!");
// your code here
});
// subscribe to realTimeNotificationDisconnected event
chatClient.on('realTimeNotificationDisconnected', () => {
console.log("Real time notification is now disconnected!");
// your code here
});
Przykładowy kod
Znajdź sfinalizowany kod dla tego artykułu w przykładzie GitHub Add Chat to your application (Przykładowe dodawanie czatu do aplikacji w usłudze GitHub).
Wymagania wstępne
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj język Python w wersji 3.7 lub nowszej.
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Szybki start: tworzenie zasobów usług komunikacyjnych i zarządzanie nimi. Musisz zarejestrować punkt końcowy zasobu i parametry połączenia dla tego artykułu.
Token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Możesz również użyć Azure CLI i uruchomić następujące polecenie za pomocą łańcucha połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Konfigurowanie
Tworzenie nowej aplikacji w języku Python
Otwórz terminal lub okno polecenia, utwórz nowy katalog dla aplikacji i przejdź do niego.
mkdir chat-quickstart && cd chat-quickstart
Użyj edytora tekstów, aby utworzyć plik o nazwie start-chat.py w katalogu głównym projektu. Dodaj strukturę programu, w tym podstawową obsługę wyjątków. W poniższych sekcjach dodaj do tego pliku cały kod źródłowy tego artykułu.
import os
# Add required SDK components from quickstart here
try:
print('Azure Communication Services - Chat Quickstart')
# Quickstart code goes here
except Exception as ex:
print('Exception:')
print(ex)
Instalowanie zestawu SDK
Użyj następującego polecenia, aby zainstalować zestaw SDK:
pip install azure-communication-chat
Model obiektów
Następujące klasy i interfejsy obsługują niektóre główne funkcje zestawu SDK czatu usług Azure Communication Services dla języka Python.
Nazwa/nazwisko | opis |
---|---|
ChatClient |
Ta klasa jest wymagana do obsługi funkcji czatu. Inicjujesz wystąpienie z informacjami o subskrypcji i używasz jej do tworzenia, pobierania i usuwania wątków. |
ChatThreadClient |
Ta klasa jest wymagana w przypadku funkcji wątku czatu. Obiekt można uzyskać za pośrednictwem metody ChatClient , i używać go do wysyłania, odbierania, aktualizowania i usuwania komunikatów. Można go również użyć do dodawania, usuwania i pozyskiwania użytkowników oraz wysyłania powiadomień o wpisywaniu i odczytywaniu wiadomości. |
Tworzenie klienta czatu
Aby utworzyć klienta czatu, użyj punktu końcowego usług komunikacyjnych i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych.
pip install azure-communication-identity
from azure.communication.chat import ChatClient, CommunicationTokenCredential
endpoint = "<replace with your resource endpoint>"
chat_client = ChatClient(endpoint, CommunicationTokenCredential("<Access Token>"))
W tym artykule nie opisano tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, ale jest to zalecane. Aby uzyskać więcej informacji, zobacz sekcję "Architektura czatu" w temacie Architektura czatu>.
Rozpoczynanie wątku czatu
create_chat_thread
Użyj metody , aby utworzyć wątek czatu.
- Użyj polecenia
topic
, aby nadać wątkowi temat. Możesz zaktualizować temat po utworzeniu wątku czatu, korzystając z funkcjiupdate_thread
. - Użyj
thread_participants
, aby wymienićChatParticipant
, które mają być dodane do wątku czatu. ParametrChatParticipant
przyjmujeCommunicationUserIdentifier
typ jakouser
.
CreateChatThreadResult
jest wynikiem zwróconym podczas tworzenia wątku. Możesz go użyć do pobrania id
utworzonego wątku czatu. Następnie można id
użyć, aby pobrać obiekt ChatThreadClient
przy użyciu metody get_chat_thread_client
. Możesz użyć ChatThreadClient
, aby wykonać inne operacje czatu w tym wątku.
topic="test topic"
create_chat_thread_result = chat_client.create_chat_thread(topic)
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)
Uzyskaj klienta czatu
Metoda get_chat_thread_client
zwraca klienta wątku dla wątku, który już istnieje. Można jej użyć do wykonywania operacji w utworzonym wątku. Można na przykład dodawać uczestników i wysyłać wiadomości.
thread_id
jest unikatowym identyfikatorem istniejącego wątku czatu.
Możesz użyć ChatThreadClient
do wykonania innych funkcji czatu w tym wątku.
thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
Wyświetl wszystkie wątki czatu
Metoda list_chat_threads
zwraca iterator typu ChatThreadItem
.
- Użyj polecenia
start_time
, aby określić najwcześniejszy punkt w czasie, aby uzyskać wątki czatu. - Użyj
results_per_page
do określenia maksymalnej liczby wątków czatu zwracanych na stronę.
Iteratorem [ChatThreadItem]
jest odpowiedź zwrócona z operacji wylistowania wątków.
from datetime import datetime, timedelta
start_time = datetime.utcnow() - timedelta(days=2)
chat_threads = chat_client.list_chat_threads(results_per_page=5, start_time=start_time)
for chat_thread_item_page in chat_threads.by_page():
for chat_thread_item in chat_thread_item_page:
print(chat_thread_item)
print('Chat Thread Id: ', chat_thread_item.id)
Wysyłanie wiadomości do wątku czatu
Użyj metody send_message
, aby wysłać wiadomość do utworzonego wątku czatu zidentyfikowanego przez thread_id
.
- Użyj polecenia
content
, aby podać zawartość wiadomości czatu. - Użyj
chat_message_type
polecenia , aby określić typ zawartości wiadomości. Możliwe wartości totext
ihtml
. Jeśli nie określisz wartości, wartość domyślna totext
. - Użyj
sender_display_name
polecenia , aby określić nazwę wyświetlaną nadawcy. - Opcjonalnie użyj
metadata
polecenia , aby uwzględnić inne dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment:true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.
SendChatMessageResult
to odpowiedź zwrócona z wysyłania komunikatu. Zawiera identyfikator, który jest unikatowy dla wiadomości.
from azure.communication.chat import ChatMessageType
topic = "test topic"
create_chat_thread_result = chat_client.create_chat_thread(topic)
thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)
content='Please take a look at the attachment'
sender_display_name='sender name'
metadata={
'hasAttachment': 'true',
'attachmentUrl': 'https://contoso.com/files/attachment.docx'
}
# specify chat message type with pre-built enumerations
send_message_result_w_enum = chat_thread_client.send_message(content=content, sender_display_name=sender_display_name, chat_message_type=ChatMessageType.TEXT, metadata=metadata)
print("Message sent: id: ", send_message_result_w_enum.id)
Odbieranie wiadomości czatu z wątku czatu
Wiadomości czatu można pobrać, sondując metodę list_messages
w określonych odstępach czasu.
- Użyj
results_per_page
polecenia , aby określić maksymalną liczbę komunikatów, które mają być zwracane na stronę. - Użyj
start_time
, aby określić najwcześniejszy punkt w czasie w celu pobrania komunikatów.
Iterator [ChatMessage]
elementu to odpowiedź zwrócona z listy komunikatów.
from datetime import datetime, timedelta
start_time = datetime.utcnow() - timedelta(days=1)
chat_messages = chat_thread_client.list_messages(results_per_page=1, start_time=start_time)
for chat_message_page in chat_messages.by_page():
for chat_message in chat_message_page:
print("ChatMessage: Id=", chat_message.id, "; Content=", chat_message.content.message)
list_messages
Zwraca najnowszą wersję komunikatu, w tym wszelkie zmiany lub usunięcia, które wystąpiły w komunikacie przy użyciu poleceń update_message
i delete_message
. W przypadku usuniętych komunikatów zwraca wartość wskazującąChatMessage.deleted_on
, datetime
kiedy ten komunikat został usunięty. Dla edytowanych komunikatów, ChatMessage.edited_on
zwraca wartość datetime
, wskazującą kiedy wiadomość została edytowana. Dostęp do oryginalnego czasu tworzenia komunikatów można uzyskać przy użyciu polecenia ChatMessage.created_on
, który może służyć do zamawiania komunikatów.
list_messages
Zwraca różne typy komunikatów, które można zidentyfikować z ChatMessage.type
.
Aby uzyskać więcej informacji, zobacz Typy komunikatów.
Wyślij potwierdzenie odczytu
Użyj metody send_read_receipt
do zamieszczenia zdarzenia potwierdzenia odczytu w wątku w imieniu użytkownika.
- Użyj
message_id
polecenia , aby określić identyfikator najnowszej wiadomości odczytanej przez bieżącego użytkownika.
content='hello world'
send_message_result = chat_thread_client.send_message(content)
chat_thread_client.send_read_receipt(message_id=send_message_result.id)
Dodawanie użytkownika jako uczestnika do wątku czatu
Podczas tworzenia wątku czatu możesz dodawać i usuwać użytkowników. Dodając użytkowników, możesz przyznać im dostęp, aby mogli wysyłać wiadomości do wątku czatu i dodawać lub usuwać innych uczestników. Przed wywołaniem add_participants
metody upewnij się, że uzyskasz nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik potrzebuje tego tokenu dostępu, aby zainicjować klienta czatu.
Możesz dodać co najmniej jednego użytkownika do wątku czatu przy użyciu add_participants
metody , jeśli dla wszystkich użytkowników jest dostępny nowy token dostępu i tożsamość.
Zwracany jest element A list(tuple(ChatParticipant, CommunicationError))
. Po pomyślnym dodaniu uczestnika oczekiwana jest pusta lista. Jeśli podczas dodawania uczestnika wystąpi błąd, lista zostanie wypełniona niepowodzeniem uczestników i napotkanym błędem.
from azure.communication.identity import CommunicationIdentityClient
from azure.communication.chat import ChatParticipant
from datetime import datetime
# create 2 users
identity_client = CommunicationIdentityClient.from_connection_string('<connection_string>')
new_users = [identity_client.create_user() for i in range(2)]
# # conversely, you can also add an existing user to a chat thread; provided the user_id is known
# from azure.communication.identity import CommunicationUserIdentifier
#
# user_id = 'some user id'
# user_display_name = "Wilma Flinstone"
# new_user = CommunicationUserIdentifier(user_id)
# participant = ChatParticipant(
# identifier=new_user,
# display_name=user_display_name,
# share_history_time=datetime.utcnow())
participants = []
for _user in new_users:
chat_thread_participant = ChatParticipant(
identifier=_user,
display_name='Fred Flinstone',
share_history_time=datetime.utcnow()
)
participants.append(chat_thread_participant)
response = chat_thread_client.add_participants(participants)
def decide_to_retry(error, **kwargs):
"""
Insert some custom logic to decide if retry is applicable based on error
"""
return True
# verify if all users has been successfully added or not
# in case of partial failures, you can retry to add all the failed participants
retry = [p for p, e in response if decide_to_retry(e)]
if retry:
chat_thread_client.add_participants(retry)
Wyświetl uczestników wątku czatu
Podobnie jak w przypadku dodawania uczestnika, można również wyświetlić listę uczestników z wątku.
Użyj list_participants
polecenia , aby pobrać uczestników wątku. Oba następujące polecenia są opcjonalne:
- Użyj
results_per_page
polecenia , aby określić maksymalną liczbę uczestników do zwrócenia na stronę. - Użyj
skip
, aby pominąć uczestników do określonej pozycji w odpowiedzi.
Iteratorem [ChatParticipant]
elementu jest odpowiedź zwrócona przez uczestników listy.
chat_thread_participants = chat_thread_client.list_participants()
for chat_thread_participant_page in chat_thread_participants.by_page():
for chat_thread_participant in chat_thread_participant_page:
print("ChatParticipant: ", chat_thread_participant)
Uruchamianie kodu
Uruchom aplikację z katalogu aplikacji przy użyciu polecenia python
.
python start-chat.py
Przykładowy kod
Znajdź sfinalizowany kod dla tego artykułu w przykładzie GitHub Add Chat to your application (Przykładowe dodawanie czatu do aplikacji w usłudze GitHub).
Wymagania wstępne
Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
Zestaw Java Development Kit (JDK) w wersji 8 lub nowszej.
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. Musisz zarejestrować punkt końcowy zasobu i parametry połączenia dla tego artykułu.
Token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Możesz również użyć Azure CLI i uruchomić następujące polecenie, używając ciągu połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Ustawienia
Tworzenie nowej aplikacji Java
Otwórz terminal lub okno polecenia i przejdź do katalogu, w którym chcesz utworzyć aplikację Java. Uruchom następujące polecenie, aby wygenerować projekt Java na podstawie szablonu maven-archetype-quickstart
.
mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
Celem generate
jest utworzenie katalogu o takiej samej nazwie jak artifactId
. W tym katalogu src/main/java directory
plik zawiera kod źródłowy projektu, src/test/java
katalog zawiera źródło testowe, a pom.xml
plik jest projektem Project Object Model lub POM.
Zaktualizuj plik POM aplikacji, aby używać środowiska Java 8 lub nowszego:
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
Dodawanie odwołań do pakietu dla zestawu Chat SDK
W pliku POM odwołaj się do pakietu za pomocą API czatu:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-communication-chat</artifactId>
<version><!-- Please refer to https://search.maven.org/artifact/com.azure/azure-communication-chat for the latest version --></version>
</dependency>
Aby przeprowadzić uwierzytelnianie, klient musi odwołać się do pakietu azure-communication-common
.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-communication-common</artifactId>
<version><!-- Please refer to https://search.maven.org/artifact/com.azure/azure-communication-common for the latest version --></version>
</dependency>
Model obiektów
Następujące klasy i interfejsy obsługują niektóre główne funkcje zestawu SDK czatu usług Azure Communication Services dla języka Java.
Nazwa/nazwisko | opis |
---|---|
ChatClient | Ta klasa jest wymagana w przypadku funkcji czatu. Inicjujesz go za pomocą informacji o subskrypcji, i używasz do tworzenia, uzyskiwania i usuwania wątków. |
ChatAsyncClient | Ta klasa jest wymagana w przypadku funkcji asynchronicznego czatu. Utworzysz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania i usuwania wątków. |
ChatThreadClient | Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz wystąpienie za pośrednictwem obiektu ChatClient i używasz go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń. |
ChatThreadAsyncClient | Ta klasa jest wymagana do asynchronicznej funkcjonalności wątku czatu. Instancję uzyskuje się za pośrednictwem ChatAsyncClient i używa jej do wysyłania/odbierania/aktualizowania/usuwania wiadomości, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień o pisaniu i potwierdzeń przeczytania. |
Tworzenie klienta czatu
Aby utworzyć klienta czatu, użyj punktu końcowego usługi Communications Service i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych. Tokeny dostępu użytkowników umożliwiają tworzenie aplikacji klienckich, które są bezpośrednio uwierzytelniane w usługach Azure Communication Services. Po wygenerowaniu tych tokenów na serwerze przekaż je z powrotem do urządzenia klienckiego. Aby przekazać token do klienta czatu, należy użyć klasy CommunicationTokenCredential z zestawu Common SDK.
Dowiedz się więcej o architekturze czatów
Podczas dodawania instrukcji importu pamiętaj, aby dodać importy tylko z przestrzeni nazw com.azure.communication.chat i com.azure.communication.chat.models, a nie z przestrzeni nazw com.azure.communication.chat.implementation. W pliku App.java, który został wygenerowany za pośrednictwem narzędzia Maven, możesz użyć następującego kodu, aby rozpocząć od:
package com.communication.quickstart;
import com.azure.communication.chat.*;
import com.azure.communication.chat.models.*;
import com.azure.communication.common.*;
import com.azure.core.http.rest.PagedIterable;
import java.io.*;
import java.util.*;
public class App
{
public static void main( String[] args ) throws IOException
{
System.out.println("Azure Communication Services - Chat Quickstart");
// Your unique Azure Communication service endpoint
String endpoint = "<replace with your resource endpoint>";
// User access token fetched from your trusted service
String userAccessToken = "<USER_ACCESS_TOKEN>";
// Create a CommunicationTokenCredential with the given access token, which is only valid until the token is valid
CommunicationTokenCredential userCredential = new CommunicationTokenCredential(userAccessToken);
// Initialize the chat client
final ChatClientBuilder builder = new ChatClientBuilder();
builder.endpoint(endpoint)
.credential(userCredential);
ChatClient chatClient = builder.buildClient();
}
}
Rozpoczynanie wątku czatu
createChatThread
Użyj metody , aby utworzyć wątek czatu.
createChatThreadOptions
służy do opisywania żądania wątku.
-
topic
Użyj parametru konstruktora, aby przekazać temat do tego czatu; Temat można zaktualizować po utworzeniu wątku czatuUpdateThread
przy użyciu funkcji . - Użyj
participants
do wyświetlenia uczestników, którzy mają zostać dodani do wątku.ChatParticipant
pobiera użytkownika utworzonego w tokenie dostępu użytkownika.
CreateChatThreadResult
to odpowiedź zwrócona podczas tworzenia wątku czatu.
Zawiera metodę getChatThread()
, która zwraca obiekt ChatThread
, który można użyć do uzyskania klienta wątku, z którego można uzyskać ChatThreadClient
do wykonywania operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp. Obiekt ChatThread
zawiera również metodę getId()
, która pobiera unikatowy identyfikator wątku.
CommunicationUserIdentifier identity1 = new CommunicationUserIdentifier("<USER_1_ID>");
CommunicationUserIdentifier identity2 = new CommunicationUserIdentifier("<USER_2_ID>");
ChatParticipant firstThreadParticipant = new ChatParticipant()
.setCommunicationIdentifier(identity1)
.setDisplayName("Participant Display Name 1");
ChatParticipant secondThreadParticipant = new ChatParticipant()
.setCommunicationIdentifier(identity2)
.setDisplayName("Participant Display Name 2");
CreateChatThreadOptions createChatThreadOptions = new CreateChatThreadOptions("Topic")
.addParticipant(firstThreadParticipant)
.addParticipant(secondThreadParticipant);
CreateChatThreadResult result = chatClient.createChatThread(createChatThreadOptions);
String chatThreadId = result.getChatThread().getId();
Lista wątków czatu
listChatThreads
Użyj metody , aby pobrać listę istniejących wątków czatu.
PagedIterable<ChatThreadItem> chatThreads = chatClient.listChatThreads();
chatThreads.forEach(chatThread -> {
System.out.printf("ChatThread id is %s.\n", chatThread.getId());
});
Pobierz aplikację do wątków czatu
Metoda getChatThreadClient
zwraca klienta wątku dla wątku, który już istnieje. Może służyć do wykonywania operacji w utworzonym wątku: dodawania uczestników, wysyłania wiadomości itp. chatThreadId
jest unikatowym identyfikatorem istniejącego wątku czatu.
ChatThreadClient chatThreadClient = chatClient.getChatThreadClient(chatThreadId);
Wysyłanie wiadomości do wątku czatu
sendMessage
Użyj metody , aby wysłać wiadomość do utworzonego wątku zidentyfikowanego przez chatThreadId.
sendChatMessageOptions
służy do opisywania żądania wiadomości czatu.
- Użyj polecenia
content
, aby podać zawartość wiadomości czatu. - Użyj
type
do określenia typu zawartości wiadomości czatu,TEXT
lubHTML
. - Użyj
senderDisplayName
polecenia , aby określić nazwę wyświetlaną nadawcy. - Opcjonalnie użyj
metadata
polecenia , aby uwzględnić inne dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład, udostępniając link do pliku w wiadomości, możesz dodaćhasAttachment:true
w metadanych, aby aplikacja adresata mogła to przeanalizować i wyświetlić odpowiednio.
Odpowiedź sendChatMessageResult
zawiera element id
, który jest unikatowym identyfikatorem komunikatu.
Map<String, String> metadata = new HashMap<String, String>();
metadata.put("hasAttachment", "true");
metadata.put("attachmentUrl", "https://contoso.com/files/attachment.docx");
SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
.setContent("Please take a look at the attachment")
.setType(ChatMessageType.TEXT)
.setSenderDisplayName("Sender Display Name")
.setMetadata(metadata);
SendChatMessageResult sendChatMessageResult = chatThreadClient.sendMessage(sendChatMessageOptions);
String chatMessageId = sendChatMessageResult.getId();
Odbieranie wiadomości czatu z wątku czatu
Wiadomości czatu można pobrać, wywołując metodę listMessages
na kliencie wątku czatu w określonych odstępach czasu.
chatThreadClient.listMessages().forEach(message -> {
System.out.printf("Message id is %s.\n", message.getId());
});
listMessages
Zwraca najnowszą wersję komunikatu, w tym wszelkie zmiany lub usunięcia, które wystąpiły w komunikacie przy użyciu poleceń .editMessage()
i .deleteMessage()
. W przypadku usuniętych komunikatów zwraca wartość daty/godziny wskazującą, chatMessage.getDeletedOn()
kiedy ten komunikat został usunięty. W przypadku edytowanych komunikatów chatMessage.getEditedOn()
zwraca datę/godzinę wskazującą, kiedy wiadomość została edytowana. Do oryginalnego czasu tworzenia komunikatów można uzyskać dostęp przy użyciu polecenia chatMessage.getCreatedOn()
i można go użyć do zamawiania komunikatów.
Przeczytaj więcej o typach komunikatów tutaj: Typy komunikatów.
Wyślij potwierdzenie odczytu
Użyj metody sendReadReceipt
, aby opublikować zdarzenie potwierdzenia odczytu w wątku czatu w imieniu użytkownika.
chatMessageId
jest unikatowym identyfikatorem odczytywanej wiadomości na czacie.
String chatMessageId = message.getId();
chatThreadClient.sendReadReceipt(chatMessageId);
Lista uczestników czatu
Użyj listParticipants
do pobierania kolekcji stronicowanej zawierającej uczestników danego wątku czatu zidentyfikowanego przez chatThreadId.
PagedIterable<ChatParticipant> chatParticipantsResponse = chatThreadClient.listParticipants();
chatParticipantsResponse.forEach(chatParticipant -> {
System.out.printf("Participant id is %s.\n", ((CommunicationUserIdentifier) chatParticipant.getCommunicationIdentifier()).getId());
});
Dodawanie użytkownika jako uczestnika do wątku czatu
Po utworzeniu wątku czatu można dodawać i usuwać użytkowników. Dodając użytkowników, możesz przyznać im dostęp do wysyłania wiadomości do wątku czatu i dodawać/usuwać innych uczestników. Musisz zacząć od uzyskania nowego tokenu dostępu i tożsamości dla tego użytkownika. Przed wywołaniem addParticipants
metody upewnij się, że uzyskasz nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik potrzebuje tego tokenu dostępu, aby zainicjować klienta czatu.
addParticipants
Użyj metody , aby dodać uczestników do wątku.
-
communicationIdentifier
, wymagany jest element CommunicationIdentifier utworzony przez element CommunicationIdentityClient w tokenie dostępu użytkownika. -
displayName
, opcjonalnie, to nazwa wyświetlana uczestnika wątku. -
shareHistoryTime
, opcjonalnie, to czas, z którego historia czatu jest udostępniana uczestnikowi. Aby udostępnić historię od momentu utworzenia wątku czatu, ustaw tę właściwość na dowolną datę równą lub mniejszą niż czas tworzenia wątku. Aby nie udostępniać historii poprzedniej do momentu dodania uczestnika, ustaw ją na bieżącą datę. Aby udostępnić historię częściową, ustaw ją na wymaganą datę.
List<ChatParticipant> participants = new ArrayList<ChatParticipant>();
CommunicationUserIdentifier identity3 = new CommunicationUserIdentifier("<USER_3_ID>");
CommunicationUserIdentifier identity4 = new CommunicationUserIdentifier("<USER_4_ID>");
ChatParticipant thirdThreadParticipant = new ChatParticipant()
.setCommunicationIdentifier(identity3)
.setDisplayName("Display Name 3");
ChatParticipant fourthThreadParticipant = new ChatParticipant()
.setCommunicationIdentifier(identity4)
.setDisplayName("Display Name 4");
participants.add(thirdThreadParticipant);
participants.add(fourthThreadParticipant);
chatThreadClient.addParticipants(participants);
Uruchamianie kodu
Przejdź do katalogu zawierającego pom.xml
plik i skompiluj projekt przy użyciu następującego mvn
polecenia.
mvn compile
Następnie skompiluj pakiet.
mvn package
Uruchom następujące mvn
polecenie, aby wykonać aplikację.
mvn exec:java -Dexec.mainClass="com.communication.quickstart.App" -Dexec.cleanupDaemonThreads=false
Przykładowy kod
Znajdź sfinalizowany kod dla tego artykułu w przykładzie GitHub Add Chat to your application (Przykładowe dodawanie czatu do aplikacji w usłudze GitHub).
Wymagania wstępne
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj program Android Studio, używamy programu Android Studio do tworzenia aplikacji systemu Android i instalowania zależności.
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. Musisz zarejestrować punkt końcowy zasobu i parametry połączenia dla tego artykułu.
Utwórz dwóch użytkowników usług komunikacyjnych i wydaj im token dostępu użytkownika. Pamiętaj, aby ustawić zakres na chat i zanotować ciąg tokenu oraz ciąg user_id. W tym artykule utworzymy wątek z początkowym uczestnikiem, a następnie dodamy drugiego uczestnika do wątku. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić następujące polecenie z użyciem ciągu połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Ustawienia
Tworzenie nowej aplikacji systemu Android
- Otwórz program Android Studio i wybierz pozycję
Create a new project
. - W następnym oknie wybierz jako
Empty Activity
szablon projektu. - Podczas wybierania opcji wprowadź
ChatQuickstart
jako nazwę projektu. - Kliknij przycisk Dalej i wybierz katalog, w którym chcesz utworzyć projekt.
Instalowanie bibliotek
Używamy narzędzia Gradle do instalowania niezbędnych zależności usług komunikacyjnych. W wierszu polecenia przejdź do katalogu ChatQuickstart
głównego projektu. Otwórz plik build.gradle aplikacji i dodaj do elementu docelowego ChatQuickstart
następujące zależności:
implementation 'com.azure.android:azure-communication-common:' + $azureCommunicationCommonVersion
implementation 'com.azure.android:azure-communication-chat:' + $azureCommunicationChatVersion
implementation 'org.slf4j:slf4j-log4j12:1.7.29'
Aby uzyskać najnowsze numery wersji, zobacz https://search.maven.org/artifact/com.azure.android/azure-communication-common i https://search.maven.org/artifact/com.azure.android/azure-communication-chat.
Wyklucz pliki meta w opcjach pakowania w głównym pliku build.gradle
android {
...
packagingOptions {
exclude 'META-INF/DEPENDENCIES'
exclude 'META-INF/LICENSE'
exclude 'META-INF/license'
exclude 'META-INF/NOTICE'
exclude 'META-INF/notice'
exclude 'META-INF/ASL2.0'
exclude("META-INF/*.md")
exclude("META-INF/*.txt")
exclude("META-INF/*.kotlin_module")
}
}
(Alternatywna) Aby zainstalować biblioteki za pośrednictwem narzędzia Maven
Aby zaimportować bibliotekę do projektu przy użyciu systemu kompilacji Maven , dodaj ją do dependencies
sekcji pliku aplikacji pom.xml
, określając identyfikator artefaktu i wersję, której chcesz użyć:
<dependency>
<groupId>com.azure.android</groupId>
<artifactId>azure-communication-chat</artifactId>
<version><!-- Please refer to https://search.maven.org/artifact/com.azure.android/azure-communication-chat for the latest version --></version>
</dependency>
Konfigurowanie funkcji platformy Azure
Aby uzyskać szczegółowe informacje, zobacz Integracja funkcji platformy Azure. Zalecamy integrację z Azure Function, aby uniknąć twardego kodowania parametrów aplikacji.
Ustal stałe aplikacji
Utwórz klasę ApplicationConstants
, która przechowuje wszystkie stałe aplikacji:
public class ApplicationConstants {
public static final String SDK_VERSION = "<your_version>";
public final static String SDK_NAME = "azure-communication-com.azure.android.communication.chat";
public final static String APPLICATION_ID = "Chat_Test_App";
public final static String TAG = "[Chat Test App]";
public static CommunicationTokenCredential COMMUNICATION_TOKEN_CREDENTIAL;
}
Konfigurowanie symboli zastępczych
Otwórz i zmodyfikuj plik MainActivity.java
. W tym artykule dodamy kod do MainActivity
, a jego dane wyjściowe wyświetlimy w konsoli. Ten artykuł nie dotyczy tworzenia interfejsu użytkownika. W górnej części pliku zaimportuj biblioteki Azure Communication Common
systemowe , Azure Communication Chat
i inne:
import com.azure.android.communication.chat.*;
import com.azure.android.communication.chat.models.*;
import com.azure.android.communication.common.*;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
import com.jakewharton.threetenabp.AndroidThreeTen;
import java.util.ArrayList;
import java.util.List;
Skopiuj następujący kod do klasy MainActivity
w pliku MainActivity.java
:
private ChatAsyncClient chatAsyncClient;
private void log(String msg) {
Log.i(TAG, msg);
Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
}
@Override
protected void onStart() {
super.onStart();
try {
AndroidThreeTen.init(this);
// Initialize application parameters if one of the conditions in '### Initialize Application Parameters' are met.
// <CREATE A CHAT CLIENT>
// <CREATE A CHAT THREAD>
// <CREATE A CHAT THREAD CLIENT>
// <SEND A MESSAGE>
// <RECEIVE CHAT MESSAGES>
// <ADD A USER>
// <LIST USERS>
// <REMOVE A USER>
// <<SEND A TYPING NOTIFICATION>>
// <<SEND A READ RECEIPT>>
// <<LIST READ RECEIPTS>>
} catch (Exception e){
System.out.println("Quickstart failed: " + e.getMessage());
}
}
Inicjowanie parametrów aplikacji
Uwaga
Inicjowanie ApplicationConstants
należy dodać do elementu MainActivity.java
, jeśli zostaną spełnione którykolwiek z następujących warunków: 1. Funkcja powiadomień push nie jest włączona. 2. Wersja biblioteki czatów usługi Azure Communication dla systemu Android to < 2.0.0. W przeciwnym razie zapoznaj się z krokiem 11 w powiadomieniach wypychanych systemu Android. Odwołaj się do przykładowej aplikacji wersji SDK, którą wykorzystujesz jako odniesienie.
ACS_ENDPOINT
, FIRST_USER_ID
i FIRST_USER_ACCESS_TOKEN
są zwracane z wywoływania funkcji platformy Azure. Aby uzyskać więcej informacji, zobacz Integracja funkcji platformy Azure. Użyjemy odpowiedzi z wywołania funkcji platformy Azure, aby zainicjować listę parametrów:
-
ACS_ENDPOINT
: punkt końcowy zasobu usług komunikacyjnych. -
FIRST_USER_ID
iSECOND_USER_ID
: prawidłowe identyfikatory użytkowników usług komunikacyjnych wygenerowane przez zasób usług komunikacyjnych. -
FIRST_USER_ACCESS_TOKEN
: token dostępu usług komunikacyjnych dla programu<FIRST_USER_ID>
.
Blok kodu umożliwiający inicjowanie parametrów aplikacji przez wywołanie funkcji platformy Azure:
try {
UserTokenClient userTokenClient = new UserTokenClient(AZURE_FUNCTION_URL);
//First user context
userTokenClient.getNewUserContext();
ACS_ENDPOINT = userTokenClient.getACSEndpoint();
FIRST_USER_ID = userTokenClient.getUserId();
FIRST_USER_ACCESS_TOKEN = userTokenClient.getUserToken();
COMMUNICATION_TOKEN_CREDENTIAL = new CommunicationTokenCredential(FIRST_USER_ACCESS_TOKEN);
//Second user context
userTokenClient.getNewUserContext();
SECOND_USER_ID = userTokenClient.getUserId();
} catch (Throwable throwable) {
//Your handling code
logger.logThrowableAsError(throwable);
}
Tworzenie klienta czatu
Zastąp komentarz <CREATE A CHAT CLIENT>
następującym kodem (umieść instrukcje import u góry pliku):
import com.azure.android.core.http.policy.UserAgentPolicy;
chatAsyncClient = new ChatClientBuilder()
.endpoint(endpoint)
.credential(new CommunicationTokenCredential(firstUserAccessToken))
.addPolicy(new UserAgentPolicy(APPLICATION_ID, SDK_NAME, sdkVersion))
.buildAsyncClient();
Model obiektów
Następujące klasy i interfejsy obsługują niektóre główne funkcje zestawu SDK czatu usług Azure Communication Services dla języka JavaScript.
Nazwa/nazwisko | opis |
---|---|
ChatClient/ChatAsyncClient | Ta klasa jest wymagana w przypadku funkcji czatu. Instancjonujesz go przy użyciu informacji o subskrypcji, a następnie używasz go do tworzenia, pobierania, usuwania wątków i subskrybowania zdarzeń czatu. |
ChatThreadClient/ChatThreadAsyncClient | Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz wystąpienie za pośrednictwem obiektu ChatClient i używasz go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń. |
Rozpoczynanie wątku czatu
Użyj naszego ChatAsyncClient
aby utworzyć nowy wątek z użytkownikiem początkowym.
Zastąp komentarz <CREATE A CHAT THREAD>
następującym kodem:
// A list of ChatParticipant to start the thread with.
List<ChatParticipant> participants = new ArrayList<>();
// The display name for the thread participant.
String displayName = "initial participant";
participants.add(new ChatParticipant()
.setCommunicationIdentifier(new CommunicationUserIdentifier(firstUserId))
.setDisplayName(displayName));
// The topic for the thread.
final String topic = "General";
// Optional, set a repeat request ID.
final String repeatabilityRequestID = "";
// Options to pass to the create method.
CreateChatThreadOptions createChatThreadOptions = new CreateChatThreadOptions()
.setTopic(topic)
.setParticipants(participants)
.setIdempotencyToken(repeatabilityRequestID);
CreateChatThreadResult createChatThreadResult =
chatAsyncClient.createChatThread(createChatThreadOptions).get();
ChatThreadProperties chatThreadProperties = createChatThreadResult.getChatThreadProperties();
threadId = chatThreadProperties.getId();
Pobierz klienta wątku czatu
Po utworzeniu wątku czatu musimy uzyskać element ChatThreadAsyncClient
, aby wykonać operacje w wątku. Zastąp komentarz <CREATE A CHAT THREAD CLIENT>
następującym kodem:
ChatThreadAsyncClient chatThreadAsyncClient = new ChatThreadClientBuilder()
.endpoint(endpoint)
.credential(new CommunicationTokenCredential(firstUserAccessToken))
.addPolicy(new UserAgentPolicy(APPLICATION_ID, SDK_NAME, sdkVersion))
.chatThreadId(threadId)
.buildAsyncClient();
Wysyłanie wiadomości do wątku czatu
Wyślij wiadomość do wątku czatu teraz.
Zastąp komentarz <SEND A MESSAGE>
następującym kodem:
// The chat message content, required.
final String content = "Please take a look at the attachment";
// The display name of the sender, if null (i.e. not specified), an empty name will be set.
final String senderDisplayName = "An important person";
// Use metadata optionally to include any additional data you want to send along with the message.
// This field provides a mechanism for developers to extend chat message functionality and add
// custom information for your use case. For example, when sharing a file link in the message, you
// might want to add 'hasAttachment:true' in metadata so that recipient's application can parse
// that and display accordingly.
final Map<String, String> metadata = new HashMap<String, String>();
metadata.put("hasAttachment", "true");
metadata.put("attachmentUrl", "https://contoso.com/files/attachment.docx");
SendChatMessageOptions chatMessageOptions = new SendChatMessageOptions()
.setType(ChatMessageType.TEXT)
.setContent(content)
.setSenderDisplayName(senderDisplayName)
.setMetadata(metadata);
// A string is the response returned from sending a message, it is an id, which is the unique ID
// of the message.
chatMessageId = chatThreadAsyncClient.sendMessage(chatMessageOptions).get().getId();
Odbieranie wiadomości czatu z wątku czatu
Powiadomienia w czasie rzeczywistym
Dzięki sygnalizowaniu w czasie rzeczywistym można odpowiednio subskrybować nowe komunikaty przychodzące i aktualizować bieżące komunikaty w pamięci. Usługi Azure Communication Services obsługują listę zdarzeń, do których można zasubskrybować.
Zastąp komentarz <RECEIVE CHAT MESSAGES>
następującym kodem (umieść instrukcje import u góry pliku):
// Start real time notification
chatAsyncClient.startRealtimeNotifications(firstUserAccessToken, getApplicationContext());
// Register a listener for chatMessageReceived event
chatAsyncClient.addEventHandler(ChatEventType.CHAT_MESSAGE_RECEIVED, (ChatEvent payload) -> {
ChatMessageReceivedEvent chatMessageReceivedEvent = (ChatMessageReceivedEvent) payload;
// You code to handle chatMessageReceived event
});
Ważne
Znany problem: Jeśli używasz zestawu Android Chat i Calling SDK razem w tej samej aplikacji, funkcja powiadomień w czasie rzeczywistym zestawu Chat SDK nie działa. Może wystąpić problem z rozwiązywaniem zależności.
Możesz wyłączyć funkcję powiadomień w trybie rzeczywistym, dodając następujące informacje o zależnościach w pliku aplikacji build.gradle
. Zamiast tego używaj interfejsu API GetMessages do sondowania i wyświetlania użytkownikom przychodzących wiadomości.
implementation ("com.azure.android:azure-communication-chat:1.0.0") {
exclude group: 'com.microsoft', module: 'trouter-client-android'
}
implementation 'com.azure.android:azure-communication-calling:1.0.0'
Zwróć uwagę na tę aktualizację, jeśli aplikacja próbuje skontaktować się z interfejsem API powiadomień przy użyciu chatAsyncClient.startRealtimeNotifications()
lub chatAsyncClient.addEventHandler()
, generuje błąd podczas wykonywania.
Powiadomienia push
Aby uzyskać więcej informacji, zobacz Powiadomienia push systemu Android.
Dodawanie użytkownika jako uczestnika do wątku czatu
Zastąp komentarz <ADD A USER>
następującym kodem:
// The display name for the thread participant.
String secondUserDisplayName = "a new participant";
ChatParticipant participant = new ChatParticipant()
.setCommunicationIdentifier(new CommunicationUserIdentifier(secondUserId))
.setDisplayName(secondUserDisplayName);
chatThreadAsyncClient.addParticipant(participant);
Lista użytkowników w wątku
<LIST USERS>
Zastąp komentarz następującym kodem (umieść instrukcje import u góry pliku):
import com.azure.android.core.rest.util.paging.PagedAsyncStream;
import com.azure.android.core.util.RequestContext;
// The maximum number of participants to be returned per page, optional.
int maxPageSize = 10;
// Skips participants up to a specified position in response.
int skip = 0;
// Options to pass to the list method.
ListParticipantsOptions listParticipantsOptions = new ListParticipantsOptions()
.setMaxPageSize(maxPageSize)
.setSkip(skip);
PagedAsyncStream<ChatParticipant> participantsPagedAsyncStream =
chatThreadAsyncClient.listParticipants(listParticipantsOptions, RequestContext.NONE);
participantsPagedAsyncStream.forEach(chatParticipant -> {
// You code to handle participant
});
Usuwanie użytkownika z wątku czatu
Usuń drugiego użytkownika z wątku.
Zastąp komentarz <REMOVE A USER>
następującym kodem:
// Using the unique ID of the participant.
chatThreadAsyncClient.removeParticipant(new CommunicationUserIdentifier(secondUserId)).get();
Wysyłanie powiadomienia o wpisywaniu
Zastąp komentarz <SEND A TYPING NOTIFICATION>
następującym kodem:
chatThreadAsyncClient.sendTypingNotification().get();
Wyślij potwierdzenie odczytu
Wysyłamy potwierdzenie odczytu dla wcześniej wysłanej wiadomości.
Zastąp komentarz <SEND A READ RECEIPT>
następującym kodem:
chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();
Wyświetlanie listy potwierdzeń odczytu
Zastąp komentarz <READ RECEIPTS>
następującym kodem:
// The maximum number of participants to be returned per page, optional.
maxPageSize = 10;
// Skips participants up to a specified position in response.
skip = 0;
// Options to pass to the list method.
ListReadReceiptOptions listReadReceiptOptions = new ListReadReceiptOptions()
.setMaxPageSize(maxPageSize)
.setSkip(skip);
PagedAsyncStream<ChatMessageReadReceipt> readReceiptsPagedAsyncStream =
chatThreadAsyncClient.listReadReceipts(listReadReceiptOptions, RequestContext.NONE);
readReceiptsPagedAsyncStream.forEach(readReceipt -> {
// You code to handle readReceipt
});
Uruchamianie kodu
W programie Android Studio naciśnij przycisk Uruchom, aby skompilować i uruchomić projekt. W konsoli można wyświetlić dane wyjściowe z kodu oraz dziennik z ChatClient.
Przykładowy kod
Znajdź sfinalizowany kod dla tego artykułu w przykładzie GitHub Add Chat to your application (Przykładowe dodawanie czatu do aplikacji w usłudze GitHub).
Wymagania wstępne
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstalować program Visual Studio
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. Musisz zarejestrować punkt końcowy zasobu i parametry połączenia dla tego artykułu.
Token użytkownika dostępu. Pamiętaj, aby ustawić zakres na czat i zanotować ciąg tokenu oraz ciąg user_id. Możesz również użyć Azure CLI i uruchomić następujące polecenie z użyciem ciągu połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Ustawienia
Tworzenie nowej aplikacji w języku C#
W oknie konsoli (takim jak cmd, PowerShell lub Bash) użyj dotnet new
polecenia , aby utworzyć nową aplikację konsolową o nazwie ChatQuickstart
. To polecenie tworzy prosty projekt języka C# "Hello World" z jednym plikiem źródłowym: Program.cs.
dotnet new console -o ChatQuickstart
Zmień katalog na nowo utworzony folder aplikacji i użyj dotnet build
polecenia , aby skompilować aplikację.
cd ChatQuickstart
dotnet build
Instalowanie pakietu
Instalowanie zestawu AZURE Communication Chat SDK dla platformy .NET
dotnet add package Azure.Communication.Chat
Model obiektów
Poniższe klasy obsługują niektóre główne funkcje zestawu SDK czatu usług Azure Communication Services dla języka C#.
Nazwa/nazwisko | opis |
---|---|
ChatClient | Ta klasa jest wymagana w przypadku funkcji czatu. Utworzysz wystąpienie z informacjami o subskrypcji i użyjesz jego do tworzenia, pobierania i usuwania wątków. |
ChatThreadClient | Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz instancję przez ChatClient i używasz jej do wysyłania, odbierania, aktualizowania oraz usuwania wiadomości, dodawania, usuwania i pobierania uczestników, wysyłania powiadomień o pisaniu oraz potwierdzeń odczytu wiadomości. |
Tworzenie klienta czatu
Aby utworzyć klienta czatu, użyj punktu końcowego usług komunikacyjnych i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych. Musisz użyć CommunicationIdentityClient
klasy z zestawu Identity SDK, aby utworzyć użytkownika i wydać token do przekazania do klienta czatu.
Dowiedz się więcej o tokenach dostępu użytkowników.
W tym artykule nie opisano tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, chociaż jest to zalecane. Aby uzyskać więcej informacji, zobacz Architektura czatu.
Skopiuj następujące fragmenty kodu i wklej je do pliku źródłowego Program.cs
.
using Azure;
using Azure.Communication;
using Azure.Communication.Chat;
using System;
namespace ChatQuickstart
{
class Program
{
static async System.Threading.Tasks.Task Main(string[] args)
{
// Your unique Azure Communication service endpoint
Uri endpoint = new Uri("<replace with your resource endpoint>");
CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(<Access_Token>);
ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);
}
}
}
Rozpoczynanie wątku czatu
Użyj metody createChatThread
na chatClient, aby utworzyć wątek czatu
- Użyj polecenia
topic
, aby nadać temat temu czatowi. Temat można zaktualizować, używając funkcjiUpdateTopic
, po utworzeniu wątku czatu. - Użyj
participants
właściwości , aby przekazać listęChatParticipant
obiektów do dodania do wątku czatu. ObiektChatParticipant
jest inicjowany za pomocąCommunicationIdentifier
obiektu.CommunicationIdentifier
może być typuCommunicationUserIdentifier
,MicrosoftTeamsUserIdentifier
lubPhoneNumberIdentifier
. Aby na przykład uzyskaćCommunicationIdentifier
obiekt, musisz przekazać identyfikator Access, który utworzyłeś zgodnie z instrukcjami dotyczącymi utworzenia użytkownika.
Obiekt odpowiedzi z metody createChatThread
zawiera szczegóły chatThread
. Aby wchodzić w interakcje z operacjami wątku czatu, takimi jak dodawanie uczestników, wysyłanie wiadomości, usuwanie wiadomości itd., instancja klienta chatThreadClient
musi zostać zainicjowana przy użyciu metody GetChatThreadClient
na kliencie ChatClient
.
var chatParticipant = new ChatParticipant(identifier: new CommunicationUserIdentifier(id: "<Access_ID>"))
{
DisplayName = "UserDisplayName"
};
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic: "Hello world!", participants: new[] { chatParticipant });
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: createChatThreadResult.ChatThread.Id);
string threadId = chatThreadClient.Id;
Pobierz klienta czatu
Metoda GetChatThreadClient
zwraca klienta wątku dla wątku, który już istnieje. Służy do wykonywania operacji w utworzonym wątku: dodawania członków, wysyłania wiadomości itd.
threadId
jest unikatowym identyfikatorem istniejącego wątku czatu.
string threadId = "<THREAD_ID>";
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: threadId);
Wyświetl wszystkie wątki czatu
Użyj GetChatThreads
, aby pobrać wszystkie wątki czatu, do których należy użytkownik.
AsyncPageable<ChatThreadItem> chatThreadItems = chatClient.GetChatThreadsAsync();
await foreach (ChatThreadItem chatThreadItem in chatThreadItems)
{
Console.WriteLine($"{ chatThreadItem.Id}");
}
Wysyłanie wiadomości do wątku czatu
Użyj polecenia SendMessage
, aby wysłać wiadomość do wątku.
- Użyj
content
polecenia , aby podać zawartość komunikatu. To jest wymagane. - Użyj
type
dla typu zawartości wiadomości, takiej jak "Tekst" lub "Html". Jeśli nie zostanie określone, ustawiana jest wartość 'Text'. - Użyj
senderDisplayName
polecenia , aby określić nazwę wyświetlaną nadawcy. Jeśli nie zostanie określony, zostanie ustawiony pusty ciąg. - Opcjonalnie: użyj polecenia
metadata
, aby uwzględnić inne dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment:true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.
SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
{
Content = "Please take a look at the attachment",
MessageType = ChatMessageType.Text
};
sendChatMessageOptions.Metadata["hasAttachment"] = "true";
sendChatMessageOptions.Metadata["attachmentUrl"] = "https://contoso.com/files/attachment.docx";
SendChatMessageResult sendChatMessageResult = await chatThreadClient.SendMessageAsync(sendChatMessageOptions);
string messageId = sendChatMessageResult.Id;
Odbieranie wiadomości czatu z wątku czatu
Wiadomości czatu można pobrać, sondując metodę GetMessages
na kliencie wątku czatu w określonych odstępach czasu.
AsyncPageable<ChatMessage> allMessages = chatThreadClient.GetMessagesAsync();
await foreach (ChatMessage message in allMessages)
{
Console.WriteLine($"{message.Id}:{message.Content.Message}");
}
GetMessages
przyjmuje opcjonalny DateTimeOffset
parametr. Jeśli to przesunięcie zostanie określone, otrzymasz komunikaty, które zostały odebrane, zaktualizowane lub usunięte po nim. Komunikaty odebrane przed czasem przesunięcia, ale później edytowane lub usunięte są również zwracane.
GetMessages
Zwraca najnowszą wersję komunikatu, w tym wszelkie zmiany lub usunięcia, które wystąpiły w komunikacie przy użyciu poleceń UpdateMessage
i DeleteMessage
. W przypadku usuniętych komunikatów zwraca wartość daty/godziny wskazującą, chatMessage.DeletedOn
kiedy ten komunikat został usunięty. W przypadku edytowanych komunikatów chatMessage.EditedOn
zwraca datę/godzinę wskazującą, kiedy wiadomość została edytowana. Do oryginalnego czasu tworzenia komunikatów można uzyskać dostęp przy użyciu polecenia chatMessage.CreatedOn
i można go użyć do zamawiania komunikatów.
GetMessages
zwraca różne typy komunikatów. Typ można zidentyfikować z chatMessage.Type
. Rodzaje to:
Text
: Zwykła wiadomość czatu wysłana przez członka wątku.Html
: sformatowana wiadomość SMS. Użytkownicy usług Komunikacyjnych obecnie nie mogą wysyłać komunikatów RichText. Ten typ komunikatu jest obsługiwany w przypadku komunikatów wysyłanych od użytkowników usługi Teams do użytkowników usługi Communication Services w scenariuszach międzyoperacyjności usługi Teams.TopicUpdated
: Komunikat systemowy wskazujący, że temat został zaktualizowany. (tylko do odczytu)ParticipantAdded
: Komunikat systemowy wskazujący, że co najmniej jeden uczestnik jest dodawany do wątku czatu (readonly).ParticipantRemoved
: Komunikat systemowy wskazujący, że uczestnik jest usuwany z wątku czatu.
Aby uzyskać więcej informacji, zobacz Typy komunikatów.
Dodawanie użytkownika jako uczestnika do wątku czatu
Po utworzeniu wątku można dodawać i usuwać użytkowników. Dodając użytkowników, możesz przyznać im dostęp, aby mogli wysyłać wiadomości do wątku i dodawać/usuwać innego uczestnika. Przed wywołaniem AddParticipants
, upewnij się, że uzyskasz nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik potrzebuje tego tokenu dostępu, aby zainicjować klienta czatu.
Służy AddParticipants
do dodawania co najmniej jednego uczestnika do wątku czatu. Poniżej przedstawiono obsługiwane atrybuty dla każdego uczestnika wątku:
-
communicationUser
, wymagane, jest tożsamością uczestnika wątku. -
displayName
, opcjonalnie, to nazwa wyświetlana uczestnika wątku. -
shareHistoryTime
, opcjonalnie, czas, z którego historia czatu jest udostępniana uczestnikowi.
var josh = new CommunicationUserIdentifier(id: "<Access_ID_For_Josh>");
var gloria = new CommunicationUserIdentifier(id: "<Access_ID_For_Gloria>");
var amy = new CommunicationUserIdentifier(id: "<Access_ID_For_Amy>");
var participants = new[]
{
new ChatParticipant(josh) { DisplayName = "Josh" },
new ChatParticipant(gloria) { DisplayName = "Gloria" },
new ChatParticipant(amy) { DisplayName = "Amy" }
};
await chatThreadClient.AddParticipantsAsync(participants: participants);
Pobierz uczestników wątku
Użyj GetParticipants
aby pobrać uczestników wątku czatu.
AsyncPageable<ChatParticipant> allParticipants = chatThreadClient.GetParticipantsAsync();
await foreach (ChatParticipant participant in allParticipants)
{
Console.WriteLine($"{((CommunicationUserIdentifier)participant.User).Id}:{participant.DisplayName}:{participant.ShareHistoryTime}");
}
Wyślij potwierdzenie odczytu
Użyj polecenia SendReadReceipt
, aby powiadomić innych uczestników o przeczytaniu wiadomości przez użytkownika.
await chatThreadClient.SendReadReceiptAsync(messageId: messageId);
Uruchamianie kodu
Uruchom aplikację w katalogu aplikacji przy użyciu polecenia dotnet run
.
dotnet run
Przykładowy kod
Znajdź sfinalizowany kod dla tego artykułu w przykładzie GitHub Add Chat to your application (Przykładowe dodawanie czatu do aplikacji w usłudze GitHub).
Wymagania wstępne
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj programy Xcode i CocoaPods. Do utworzenia aplikacji dla systemu iOS w tym artykule użyjesz środowiska Xcode, a platforma CocoaPods zainstaluje zależności.
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Szybki start: tworzenie zasobów usług komunikacyjnych i zarządzanie nimi. Musisz zarejestrować punkt końcowy zasobu i parametry połączenia dla tego artykułu.
Utwórz dwóch użytkowników w usługach Azure Communication Services i wydaj im token dostępu użytkownika. Pamiętaj, aby ustawić zakres na czat, oraz zanotować ciąg tokenu, jak również ciąg user_id. W tym artykule utworzysz wątek z początkowym uczestnikiem, a następnie dodasz drugiego uczestnika do wątku. Możesz również użyć Microsoft Azure CLI i uruchomić następujące polecenie, podając swój ciąg połączenia, aby utworzyć użytkownika i token dostępu.
az communication identity token issue --scope chat --connection-string "yourConnectionString"
Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.
Ustawienia
Tworzenie nowej aplikacji systemu iOS
Otwórz program Xcode i wybierz pozycję Utwórz nowy projekt Xcode. Następnie wybierz pozycję iOS jako platformę i aplikację dla szablonu.
Jako nazwę projektu wprowadź ChatQuickstart. Następnie wybierz Storyboard jako interfejs, Delegat aplikacji UIKit jako cykl życia i Swift jako język.
Wybierz pozycję Dalej i wybierz katalog, w którym chcesz utworzyć projekt.
Instalowanie bibliotek
Użyj narzędzia CocoaPods, aby zainstalować niezbędne zależności usług komunikacyjnych.
W wierszu polecenia przejdź do katalogu głównego projektu systemu ChatQuickstart
iOS. Utwórz plik Podfile za pomocą następującego polecenia: pod init
.
Otwórz plik Podfile i dodaj następujące zależności do ChatQuickstart
obiektu docelowego:
pod 'AzureCommunicationChat', '~> 1.3.6'
Zainstaluj zależności za pomocą następującego polecenia: pod install
. Spowoduje to również utworzenie obszaru roboczego programu Xcode.
Po uruchomieniu pod install
ponownie otwórz projekt w Xcode, wybierając nowo utworzony .xcworkspace
.
Konfigurowanie symboli zastępczych
Otwórz obszar roboczy ChatQuickstart.xcworkspace
w programie Xcode, a następnie otwórz plik ViewController.swift
.
W tym artykule dodasz swój kod do viewController
, a następnie wyświetlisz wyniki w konsoli Xcode. Ten artykuł nie dotyczy tworzenia interfejsu użytkownika w systemie iOS.
W górnej części viewController.swift
pliku zaimportuj biblioteki AzureCommunication
i AzureCommunicationChat
:
import AzureCommunicationCommon
import AzureCommunicationChat
Skopiuj następujący kod do viewDidLoad()
metody :ViewController
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
let semaphore = DispatchSemaphore(value: 0)
DispatchQueue.global(qos: .background).async {
do {
// <CREATE A CHAT CLIENT>
// <CREATE A CHAT THREAD>
// <LIST ALL CHAT THREADS>
// <GET A CHAT THREAD CLIENT>
// <SEND A MESSAGE>
// <SEND A READ RECEIPT >
// <RECEIVE MESSAGES>
// <ADD A USER>
// <LIST USERS>
} catch {
print("Quickstart failed: \(error.localizedDescription)")
}
}
}
W celach demonstracyjnych używamy semafora do synchronizowania kodu. W kolejnych krokach zastąpisz elementy zastępcze przykładowym kodem, używając biblioteki Czat usług Azure Communication Services.
Tworzenie klienta czatu
Aby utworzyć klienta czatu, użyj punktu końcowego usług komunikacyjnych i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych.
Dowiedz się więcej o tokenach dostępu użytkowników.
W tym artykule nie opisano tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, ale zalecamy to. Dowiedz się więcej o architekturze czatów
Zastąp komentarz <CREATE A CHAT CLIENT>
następującym fragmentem kodu:
let endpoint = "<ACS_RESOURCE_ENDPOINT>"
let credential =
try CommunicationTokenCredential(
token: "<ACCESS_TOKEN>"
)
let options = AzureCommunicationChatClientOptions()
let chatClient = try ChatClient(
endpoint: endpoint,
credential: credential,
withOptions: options
)
Zastąp <ACS_RESOURCE_ENDPOINT>
punktem końcowym zasobu usług Azure Communication Services. Zastąp <ACCESS_TOKEN>
prawidłowym tokenem dostępu usług komunikacyjnych.
Model obiektów
Następujące klasy i interfejsy obsługują niektóre główne funkcje zestawu SDK czatu usług Azure Communication Services dla systemu iOS.
Nazwa/nazwisko | opis |
---|---|
ChatClient |
Ta klasa jest wymagana do obsługi funkcji czatu. Tworzysz wystąpienie z informacjami o subskrypcji i używasz go do tworzenia, pobierania, usuwania wątków oraz do subskrypcji zdarzeń czatu. |
ChatThreadClient |
Ta klasa jest wymagana w przypadku funkcji wątku czatu. Wystąpienie można uzyskać za pośrednictwem metody ChatClient i używać go do wysyłania, odbierania, aktualizowania i usuwania komunikatów. Można go również użyć do dodawania, usuwania i pozyskiwania informacji o użytkownikach, wysyłania powiadomień o pisaniu i potwierdzeń odczytu. |
Rozpoczynanie wątku czatu
CreateChatThreadResult
to odpowiedź zwrócona podczas tworzenia wątku czatu.
Zawiera właściwość chatThread
, będącą obiektem ChatThreadProperties
. Ten obiekt zawiera identyfikator threadId, który można wykorzystać do uzyskania ChatThreadClient
w celu wykonywania operacji na utworzonym wątku, takich jak dodawanie uczestników, wysyłanie wiadomości itp.
Zastąp komentarz <CREATE A CHAT THREAD>
następującym fragmentem kodu:
let request = CreateChatThreadRequest(
topic: "Quickstart",
participants: [
ChatParticipant(
id: CommunicationUserIdentifier("<USER_ID>"),
displayName: "Jack"
)
]
)
var threadId: String?
chatClient.create(thread: request) { result, _ in
switch result {
case let .success(result):
threadId = result.chatThread?.id
case .failure:
fatalError("Failed to create thread.")
}
semaphore.signal()
}
semaphore.wait()
Zastąp <USER_ID>
prawidłowym identyfikatorem użytkownika usług Komunikacyjnych.
W tym miejscu używasz semafora, aby poczekać na funkcję zwrotną zanim będzie można kontynuować. W kolejnych krokach użyj elementu threadId
z odpowiedzi zwróconej do procedury obsługi uzupełniania.
Wyświetl wszystkie wątki czatu
Po utworzeniu wątku czatu możemy wyświetlić listę wszystkich wątków czatu, wywołując metodę listChatThreads
w pliku ChatClient
. Zastąp komentarz <LIST ALL CHAT THREADS>
następującym kodem:
chatClient.listThreads { result, _ in
switch result {
case let .success(threads):
guard let chatThreadItems = threads.pageItems else {
print("No threads returned.")
return
}
for chatThreadItem in chatThreadItems {
print("Thread id: \(chatThreadItem.id)")
}
case .failure:
print("Failed to list threads")
}
semaphore.signal()
}
semaphore.wait()
Pobierz klienta czatu
Metoda createClient
zwraca ChatThreadClient
dla wątku, który już istnieje. Może służyć do wykonywania operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp. threadId jest unikatowym identyfikatorem istniejącego wątku czatu.
Zastąp komentarz <GET A CHAT THREAD CLIENT>
następującym kodem:
let chatThreadClient = try chatClient.createClient(forThread: threadId!)
Wysyłanie wiadomości do wątku czatu
send
Użyj metody , aby wysłać komunikat do wątku zidentyfikowanego przez threadId.
SendChatMessageRequest
służy do opisywania żądania komunikatu:
- Użyj
content
do podania zawartości wiadomości na czacie. - Użyj
senderDisplayName
polecenia , aby określić nazwę wyświetlaną nadawcy - Użyj
type
polecenia , aby określić typ wiadomości, taki jak "tekst" lub "html" - Opcjonalnie użyj
metadata
polecenia , aby uwzględnić inne dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment:true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.
SendChatMessageResult
to odpowiedź zwrócona po wysłaniu wiadomości. Zawiera identyfikator, który jest unikatowy dla wiadomości.
Zastąp komentarz <SEND A MESSAGE>
następującym fragmentem kodu:
let message = SendChatMessageRequest(
content: "Hello!",
senderDisplayName: "Jack",
type: .text,
metadata: [
"hasAttachment": "true",
"attachmentUrl": "https://contoso.com/files/attachment.docx"
]
)
var messageId: String?
chatThreadClient.send(message: message) { result, _ in
switch result {
case let .success(result):
print("Message sent, message id: \(result.id)")
messageId = result.id
case .failure:
print("Failed to send message")
}
semaphore.signal()
}
semaphore.wait()
Wyślij potwierdzenie odczytu
sendReadReceipt
Użyj metody , aby opublikować zdarzenie potwierdzenia odczytu w wątku czatu w imieniu użytkownika.
messageId
jest unikatowym identyfikatorem odczytywanej wiadomości na czacie.
Zastąp komentarz <SEND A READ RECEIPT>
następującym kodem:
if let id = messageId {
chatThreadClient.sendReadReceipt(forMessage: id) { result, _ in
switch result {
case .success:
print("Read receipt sent")
case .failure:
print("Failed to send read receipt")
}
semaphore.signal()
}
semaphore.wait()
} else {
print("Cannot send read receipt without a message id")
}
Odbieranie wiadomości czatu z wątku czatu
Za pomocą sygnałów w czasie rzeczywistym można subskrybować nasłuchiwanie nowych przychodzących komunikatów i odpowiednio aktualizować bieżące komunikaty w pamięci. Usługi Azure Communication Services obsługują listę zdarzeń, do których można zasubskrybować.
Zastąp komentarz <RECEIVE MESSAGES>
następującym kodem. Po włączeniu powiadomień spróbuj wysłać nowe komunikaty, aby wyświetlić element ChatMessageReceivedEvents
.
chatClient.startRealTimeNotifications { result in
switch result {
case .success:
print("Real-time notifications started.")
case .failure:
print("Failed to start real-time notifications.")
}
semaphore.signal()
}
semaphore.wait()
chatClient.register(event: .chatMessageReceived, handler: { response in
switch response {
case let .chatMessageReceivedEvent(event):
print("Received a message: \(event.message)")
default:
return
}
})
Alternatywnie możesz pobrać wiadomości czatu, sondując metodę listMessages
w określonych odstępach czasu. Zobacz poniższy fragment kodu dla listMessages
chatThreadClient.listMessages { result, _ in
switch result {
case let .success(messagesResult):
guard let messages = messagesResult.pageItems else {
print("No messages returned.")
return
}
for message in messages {
print("Received message with id: \(message.id)")
}
case .failure:
print("Failed to receive messages")
}
semaphore.signal()
}
semaphore.wait()
Dodawanie użytkownika jako uczestnika do wątku czatu
Po utworzeniu wątku można dodawać i usuwać użytkowników. Dodając użytkowników, możesz przyznać im dostęp, aby mogli wysyłać wiadomości do wątku i dodawać/usuwać innego uczestnika. Przed wywołaniem add
upewnij się, że uzyskałeś nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik potrzebuje tokenu dostępu, aby zainicjować klienta czatu.
add
Użyj metody ChatThreadClient
, aby dodać co najmniej jednego uczestnika do wątku czatu. Poniżej przedstawiono obsługiwane atrybuty dla każdego uczestnika wątku:
-
id
, wymagane, jest tożsamością uczestnika wątku. -
displayName
, opcjonalnie, to nazwa wyświetlana uczestnika wątku. -
shareHistoryTime
, opcjonalnie, czas, z którego historia czatu jest udostępniana uczestnikowi.
Zastąp komentarz <ADD A USER>
następującym kodem:
let user = ChatParticipant(
id: CommunicationUserIdentifier("<USER_ID>"),
displayName: "Jane"
)
chatThreadClient.add(participants: [user]) { result, _ in
switch result {
case let .success(result):
if let errors = result.invalidParticipants, !errors.isEmpty {
print("Error adding participant")
} else {
print("Added participant")
}
case .failure:
print("Failed to add the participant")
}
semaphore.signal()
}
semaphore.wait()
Zastąp <USER_ID>
element identyfikatorem użytkownika usług komunikacyjnych, który ma zostać dodany.
Wylistuj użytkowników w wątku
Użyj metody listParticipants
, aby pobrać wszystkich uczestników dla określonego wątku czatu.
Zastąp komentarz <LIST USERS>
następującym kodem:
chatThreadClient.listParticipants { result, _ in
switch result {
case let .success(participantsResult):
guard let participants = participantsResult.pageItems else {
print("No participants returned.")
return
}
for participant in participants {
let user = participant.id as! CommunicationUserIdentifier
print("User with id: \(user.identifier)")
}
case .failure:
print("Failed to list participants")
}
semaphore.signal()
}
semaphore.wait()
Powiadomienia wypychane do aplikacji
Powiadomienia informują klientów o przychodzących wiadomościach w konwersacji czatowej, gdy aplikacja mobilna nie jest uruchomiona na pierwszym planie.
Obecnie wysyłanie powiadomień wypychanych do czatu za pomocą usługi Notification Hub jest obsługiwane w przypadku zestawu SDK systemu IOS w wersji 1.3.0.
Aby uzyskać więcej informacji, zobacz Włączanie powiadomień push w aplikacji czatu.
Uruchamianie kodu
W programie Xcode naciśnij przycisk Uruchom, aby skompilować i uruchomić projekt. W konsoli można wyświetlić wynik z kodu i wynik rejestratora z ChatClient.
Uwaga: ustaw Build Settings > Build Options > Enable Bitcode
na No
. Obecnie AzureCommunicationChat SDK dla systemu iOS nie obsługuje włączania kodu bitowego, a następujący problem w GitHub śledzi to zagadnienie.
Przykładowy kod
Znajdź sfinalizowany kod dla tego artykułu w przykładzie GitHub Add Chat to your application (Przykładowe dodawanie czatu do aplikacji w usłudze GitHub).
Wymagania wstępne
Konto platformy Azure z aktywną subskrypcją lub bezpłatne utworzenie konta platformy Azure.
Aktywny zasób usług Azure Communication Services lub utwórz zasób usług komunikacyjnych.
Aktywny zasób usługi Azure Logic Apps lub utwórz pustą aplikację logiki z wyzwalaczem, którego chcesz użyć. Obecnie interfejs czatu usług komunikacyjnych udostępnia tylko akcje, więc aplikacja logiki musi mieć przynajmniej jeden wyzwalacz.
Utwórz użytkownika
Wykonaj te kroki w usłudze Power Automate, otwierając przepływ usługi Power Automate w trybie edycji.
Aby dodać nowy krok w przepływie pracy, używając łącznika Tożsamości Usług Komunikacyjnych:
W projektancie, w kroku, gdzie chcesz dodać nową akcję, wybierz Nowy krok. Alternatywnie, aby dodać nową akcję między krokami, przenieś wskaźnik na strzałkę między tymi krokami, wybierz znak plus (+), a następnie wybierz pozycję Dodaj akcję.
W polu wyszukiwania wybierz operację, wprowadź tożsamość usług komunikacyjnych. Na liście akcji wybierz pozycję Utwórz użytkownika.
Wprowadź parametry połączenia. Aby uzyskać adres URL ciągu połączenia w portalu Azure, przejdź do zasobu Azure Communication Services. W menu zasobów wybierz pozycję Klucze, a następnie wybierz pozycję Parametry połączenia. Wybierz ikonę kopiowania, aby skopiować parametry połączenia.
Wprowadź nazwę połączenia.
Wybierz pozycję Pokaż opcje zaawansowane, a następnie wybierz zakres tokenu. Akcja generuje token dostępu i jego czas wygaśnięcia z określonym zakresem. Ta akcja generuje również identyfikator użytkownika, który jest tożsamością użytkownika usług Communication Services.
W pozycji Zakresy Tokenów wybierz chat.
Wybierz pozycję Utwórz. Wyświetlany jest identyfikator użytkownika i token dostępu.
Tworzenie wątku czatu
Dodaj nową akcję.
W polu wyszukiwania Wybierz operację wprowadź Komunikacyjne usługi czat. Na liście akcji wybierz pozycję Utwórz wątek czatu.
Wprowadź adres URL punktu końcowego usług komunikacyjnych. Aby uzyskać adres URL punktu końcowego w witrynie Azure Portal, przejdź do zasobu usług Azure Communication Services. W menu zasobów wybierz pozycję Klucze, a następnie wybierz pozycję Punkt końcowy.
Wprowadź nazwę połączenia.
Wybierz token dostępu wygenerowany w poprzedniej sekcji, a następnie dodaj opis tematu wątku czatu. Dodaj utworzonego użytkownika i wprowadź nazwę uczestnika.
Wysyłanie wiadomości
Dodaj nową akcję.
W polu wyszukiwania Wybierz operację wprowadź Czat usług komunikacyjnych. Na liście akcji wybierz pozycję Wyślij wiadomość do wątku czatu.
Wprowadź token dostępu, identyfikator wątku, zawartość i nazwę.
Lista wiadomości wątku czatu
Aby sprawdzić, czy wiadomość została wysłana poprawnie:
Dodaj nową akcję.
W polu wyszukiwania Wybierz operację wprowadź Czat usług komunikacyjnych. Na liście akcji wybierz pozycję Wyświetl wiadomości wątku czatu.
Wprowadź token dostępu i identyfikator wątku.
Testowanie aplikacji logiki
Aby ręcznie uruchomić przepływ pracy, na pasku narzędzi projektanta wybierz pozycję Uruchom. Przepływ pracy tworzy użytkownika, wystawia token dostępu dla tego użytkownika, a następnie usuwa token i usuwa użytkownika. Aby uzyskać więcej informacji, zobacz Jak uruchomić przepływ pracy.
Teraz wybierz pozycję Wyświetl wiadomości wątku czatu. W danych wyjściowych akcji sprawdź, czy wiadomość została wysłana.
Czyszczenie zasobów związanych z przepływem pracy
Aby wyczyścić przepływ pracy aplikacji logiki i powiązane zasoby, zobacz jak wyczyścić zasoby usługi Logic Apps.
Czyszczenie zasobów
Aby wyczyścić i usunąć subskrypcję usług Communication Services, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów. Aby uzyskać więcej informacji, zobacz oczyszczanie zasobów.
Następne kroki
W tym artykule opisano, jak:
- Tworzenie klienta czatu
- Tworzenie wątku z dwoma użytkownikami
- Wysyłanie wiadomości do wątku
- Odbieranie komunikatów z wątku
- Usuwanie użytkowników z wątku
Powiązane artykuły
- Rozpocznij korzystanie z UI Library.
- Dowiedz się więcej o pojęciach dotyczących czatów.
- Zapoznaj się z zestawem Chat SDK.
- Korzystanie z zestawu Chat SDK w aplikacji React Native.