Ta przeglądarka nie jest już obsługiwana.
Przejdź na przeglądarkę Microsoft Edge, aby korzystać z najnowszych funkcji, aktualizacji zabezpieczeń i pomocy technicznej.
Rozpocznij pracę z usługami Azure Communication Services przy użyciu zestawu SDK czatu usług komunikacyjnych, aby dodać czat w czasie rzeczywistym do aplikacji. W tym przewodniku Szybki start użyjemy zestawu SDK czatu, aby utworzyć wątki czatu, które umożliwiają użytkownikom prowadzenie konwersacji ze sobą. Aby dowiedzieć się więcej na temat pojęć związanych z czatem, odwiedź dokumentację koncepcyjną czatu.
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 interfejs wiersza polecenia platformy Azure.
Zanotuj punkt końcowy zasobów usług Communication Services. 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ę od https://.
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ć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry 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.
Dodaj rozszerzenie Azure Communication Services dla interfejsu wiersza polecenia platformy az extension Azure przy użyciu polecenia .
az extension add --name communication
Musisz zalogować się do interfejsu wiersza polecenia platformy Azure. Możesz zalogować się, uruchamiając polecenie z poziomu terminalu az login i podając swoje poświadczenia.
Zmienną AZURE_COMMUNICATION_ENDPOINT środowiskową można skonfigurować tak, aby korzystała z operacji czatu interfejsu wiersza polecenia platformy Azure bez konieczności przekazywania --endpoint do punktu końcowego. Aby skonfigurować zmienną środowiskową, otwórz okno konsoli i wybierz system operacyjny z poniższych kart. Zastąp <yourEndpoint> element rzeczywistym punktem końcowym.
.bash_profileEdytuj zmienną środowiskową i dodaj zmienną środowiskową:
export AZURE_COMMUNICATION_ENDPOINT="<yourEndpoint>"
Po dodaniu zmiennej środowiskowej uruchom polecenie source ~/.bash_profile z okna konsoli, aby zmiany zostały uwzględnione. Jeśli zmienna środowiskowa została utworzona przy otwartym środowisku IDE, może być konieczne zamknięcie i ponowne otwarcie edytora, środowiska IDE lub powłoki w celu uzyskania dostępu do zmiennej.
Zmienną AZURE_COMMUNICATION_ACCESS_TOKEN środowiskową można skonfigurować tak, aby korzystała z operacji czatu interfejsu wiersza polecenia platformy Azure bez konieczności przekazywania --access-token tokenu dostępu. Aby skonfigurować zmienną środowiskową, otwórz okno konsoli i wybierz system operacyjny z poniższych kart. Zastąp <yourAccessToken> element rzeczywistym tokenem dostępu.
.bash_profileEdytuj zmienną środowiskową i dodaj zmienną środowiskową:
export AZURE_COMMUNICATION_ACCESS_TOKEN="<yourAccessToken>"
Po dodaniu zmiennej środowiskowej uruchom polecenie source ~/.bash_profile z okna konsoli, aby zmiany zostały uwzględnione. Jeśli zmienna środowiskowa została utworzona przy otwartym środowisku IDE, może być konieczne zamknięcie i ponowne otwarcie edytora, środowiska IDE lub powłoki w celu uzyskania dostępu do zmiennej.
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 zostały zapisane w zmiennych środowiskowych zgodnie z powyższym opisem, nie musisz przekazywać ich do polecenia .
az communication chat thread create --topic "<chatTopic>"
<chatTopic> , aby nadać wątkowi temat. Temat można zaktualizować po utworzeniu wątku czatu thread update-topic za pomocą polecenia .<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.az communication chat thread update-topic --thread "<chatThreadId>" --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"
<chatThreadId> element identyfikatorem wątku czatu.<chatTopic> element nowym tematem czatu, który chcesz ustawić.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.Polecenie thread list zwraca listę wątków czatu użytkownika.
az communication chat thread list --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
<startTime> najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.Użyj polecenia , message send aby wysłać wiadomość do utworzonego wątku czatu zidentyfikowanego przez threadIdprogram .
az communication chat message send --thread "<chatThreadId>" --display-name "<displayName>" --content "<content>" --message-type "<messageType>" --endpoint "<endpoint>" --access-token "<token>"
<chatThreadId> element identyfikatorem wątku czatu.<content> , aby podać zawartość wiadomości czatu.<messageType> polecenia , aby określić typ zawartości wiadomości. Możliwe wartości to text i html. Jeśli nie określisz wartości, wartość domyślna to text.<displayName> nazwę wyświetlaną nadawcy.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.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>"
<chatThreadId> element identyfikatorem wątku czatu.<startTime> najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.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>"
<chatThreadId> element identyfikatorem wątku czatu.<messageId> ciąg identyfikatorem wiadomości, którą chcesz pobrać.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.Polecenie służy message receipt send do publikowania zdarzenia potwierdzenia odczytu do wątku w imieniu użytkownika.
az communication chat message receipt send --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"
<chatThreadId> element identyfikatorem wątku czatu.<messageId> element , aby określić identyfikator najnowszej wiadomości odczytanej przez bieżącego użytkownika.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.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>"
<chatThreadId> element identyfikatorem wątku czatu.<userId> ciąg identyfikatorem userId.<displayName> nazwę wyświetlaną nadawcy.<startTime> najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.Podobnie jak w przypadku dodawania uczestnika, można również wyświetlić listę uczestników z wątku.
Użyj participant list polecenia , aby pobrać uczestników wątku.
az communication chat participant list --thread "<chatThreadId>" --skip "<skip>" --endpoint "<endpoint>" --access-token "<token>"
<chatThreadId> element identyfikatorem wątku czatu.<skip> pominąć uczestników do określonej pozycji w odpowiedzi.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.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>"
<chatThreadId> element identyfikatorem wątku czatu.<userId> ciąg identyfikatorem userId, który chcesz usunąć z wątku czatu.<endpoint> element punktem końcowym usług Azure Communication Services.<token> element tokenem dostępu uzyskanym wcześniej za pomocą uruchomionego identity token issue polecenia.Przed rozpoczęciem upewnij się, że:
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj wersje Node.js Active LTS i Maintenance LTS.
Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.
Utwórz trzech użytkowników usług Azure Communication Services i wystaw im token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Pełny pokaz tworzy wątek z dwoma początkowymi uczestnikami, a następnie dodaje trzeciego uczestnika do wątku. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry 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.
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
Użyj polecenia , npm install aby zainstalować poniższe 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 .
Ten przewodnik Szybki start używa pakietu pakietu zasobów aplikacji. 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żyjemy 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 zawierający logikę aplikacji dla tego przewodnika Szybki start.
Aby utworzyć klienta czatu w aplikacji internetowej, użyjesz 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. Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu. Aby uzyskać więcej informacji na temat architektury czatu i tokenów dostępu użytkowników, zobacz pojęcia dotyczące czatów, aby uzyskać więcej informacji na temat tokenów dostępu.
Wewnątrz client.js użyj punktu końcowego i tokenu dostępu w poniższym kodzie, aby dodać możliwość 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!');
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!
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. Utwórz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania, usuwania wątków i subskrybowania zdarzeń czatu. |
| 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ń. |
createThread Użyj metody , aby utworzyć wątek czatu.
createThreadRequest służy do opisywania żądania wątku:
topic , aby przekazać temat do tego czatu. Tematy można zaktualizować po utworzeniu wątku czatu UpdateThread przy użyciu funkcji .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 chatThread właściwość, w której można uzyskać dostęp do id nowo utworzonego wątku. Następnie możesz użyć elementu , id aby uzyskać wystąpienie klasy 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 powinny zostać wyświetlone następujące elementy:
Thread created: <thread_id>
Metoda getChatThreadClient zwraca chatThreadClient element 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>
Metoda listChatThreads zwraca PagedAsyncIterableIterator typ 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
}
Użyj sendMessage metody , aby wysłać komunikat do wątku zidentyfikowanego przez threadId.
sendMessageRequest służy do opisywania żądania komunikatu:
content polecenia , aby podać zawartość wiadomości czatu;
sendMessageOptions służy do opisywania opcjonalnych parametrów operacji:
senderDisplayName polecenia , aby określić nazwę wyświetlaną nadawcy;type polecenia , aby określić typ wiadomości, taki jak "tekst" lub "html";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 unikatowym identyfikatorem komunikatu.
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>
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ę w konsoli programu , aby znaleźć listę wiadomości wysłanych w tym wątku czatu.
listMessages zwraca różne typy komunikatów, które mogą być identyfikowane przez chatMessage.type.
Aby uzyskać więcej informacji, zobacz Typy komunikatów.
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 będzie potrzebował 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 udostępnić historię poprzednią do momentu dodania uczestnika, ustaw ją na bieżącą datę. 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
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.
Podobnie jak w przypadku dodawania uczestnika, można usunąć uczestników z wątku czatu. Aby usunąć, należy śledzić identyfikatory dodanych uczestników.
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.
Subskrypcja zdarzeń realTimeNotificationConnected i realTimeNotificationDisconnected umożliwia określenie, kiedy połączenie z serwerem połączeń 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
});
Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.
Przed rozpoczęciem upewnij się, że:
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. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.
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ć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry 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.
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 dodasz do tego pliku cały kod źródłowy tego przewodnika Szybki start.
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)
Użyj następującego polecenia, aby zainstalować zestaw SDK:
pip install azure-communication-chat
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. 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. Wystąpienie można uzyskać za pośrednictwem metody ChatClienti używać go do wysyłania, odbierania, aktualizowania i usuwania komunikatów. Można go również użyć do dodawania, usuwania i pobierania użytkowników oraz wysyłania powiadomień o wpisaniu i odczytywaniu paragonów. |
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>"))
Ten przewodnik Szybki start nie obejmuje 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 Pojęcia dotyczące czatu.
create_chat_thread Użyj metody , aby utworzyć wątek czatu.
topic , aby nadać wątkowi temat. Temat można zaktualizować po utworzeniu wątku czatu update_thread przy użyciu funkcji .thread_participants polecenia , aby wyświetlić listę ChatParticipant elementów do dodania do wątku czatu. Parametr ChatParticipant przyjmuje CommunicationUserIdentifier typ jako user.
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 go id użyć do pobrania ChatThreadClient obiektu przy użyciu get_chat_thread_client metody . Możesz użyć ChatThreadClient polecenia , aby wykonać inne operacje czatu w tym wątku czatu.
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)
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 polecenia , aby wykonać inne operacje czatu w tym wątku czatu.
thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(thread_id)
Metoda list_chat_threads zwraca iterator typu ChatThreadItem.
start_time , aby określić najwcześniejszy punkt w czasie, aby uzyskać wątki czatu.results_per_page do określania maksymalnej liczby wątków czatu zwracanych na stronę.Iteratorem [ChatThreadItem] elementu jest odpowiedź zwrócona z list 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)
send_message Użyj metody , aby wysłać wiadomość do właśnie utworzonego wątku czatu zidentyfikowanego przez thread_id.
content , aby podać zawartość wiadomości czatu.chat_message_type polecenia , aby określić typ zawartości wiadomości. Możliwe wartości to text i html. Jeśli nie określisz wartości, wartość domyślna to text.sender_display_name polecenia , aby określić nazwę wyświetlaną nadawcy.metadata polecenia , aby uwzględnić wszelkie dodatkowe 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 unikatowym identyfikatorem 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)
Wiadomości czatu można pobrać, sondując metodę list_messages w określonych odstępach czasu.
results_per_page polecenia , aby określić maksymalną liczbę komunikatów, które mają być zwracane na stronę.start_time polecenia , 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ądatetime, ChatMessage.deleted_on kiedy ten komunikat został usunięty. W przypadku edytowanych komunikatów zwraca wartość wskazującądatetime, ChatMessage.edited_on 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ć za pomocą ChatMessage.typepolecenia .
Aby uzyskać więcej informacji, zobacz Typy komunikatów.
Metoda służy send_read_receipt do publikowania zdarzenia potwierdzenia odczytu do wątku w imieniu użytkownika.
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)
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 masz 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 , pod warunkiem, że 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 wraz z błędem, który wystąpił.
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)
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:
results_per_page polecenia , aby określić maksymalną liczbę uczestników do zwrócenia na stronę.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)
Uruchom aplikację z katalogu aplikacji za python pomocą polecenia .
python start-chat.py
Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.
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. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.
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ć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry 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.
Otwórz terminal lub okno polecenia i przejdź do katalogu, w którym chcesz utworzyć aplikację Java. Uruchom poniższe polecenie, aby wygenerować projekt Java z szablonu maven-archetype-quickstart.
mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
Zauważysz, że cel "generate" utworzył katalog o takiej samej nazwie jak artifactId. W tym katalogu src/main/java directory zawiera kod źródłowy projektu, src/test/java katalog zawiera źródło testowe, a plik pom.xml 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>
W pliku POM odwołaj azure-communication-chat się do pakietu za pomocą interfejsów 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ływać się azure-communication-common do pakietu:
<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>
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. Utworzysz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania 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. Wystąpienie można uzyskać za pośrednictwem klasy ChatAsyncClient i używać go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń. |
Aby utworzyć klienta czatu, użyjesz 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. 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();
}
}
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 czatu UpdateThread przy użyciu funkcji .participants polecenia , aby wyświetlić listę uczestników wątku do dodania do wątku.
ChatParticipantPobiera użytkownika utworzonego w przewodniku Szybki start dotyczący tokenu dostępu użytkownika.
CreateChatThreadResult to odpowiedź zwrócona podczas tworzenia wątku czatu.
Zawiera metodę getChatThread() , która zwraca ChatThread obiekt, który może służyć do pobrania klienta wątku, z którego można uzyskać ChatThreadClient polecenie do wykonywania operacji w utworzonym wątku: dodać uczestników, wysłać komunikat 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();
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());
});
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);
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.
content , aby podać zawartość wiadomości czatu.type polecenia , aby określić typ zawartości wiadomości czatu, TEKST lub HTML.senderDisplayName polecenia , aby określić nazwę wyświetlaną nadawcy.metadata polecenia , aby uwzględnić wszelkie dodatkowe 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ć hasAttachment:true metadane, aby aplikacja adresata mogła przeanalizować to 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();
Wiadomości czatu można pobrać, sondują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.
sendReadReceipt Użyj metody , 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);
Służy listParticipants do pobierania kolekcji stronicowanej zawierającej uczestników 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());
});
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 metody addParticipants upewnij się, że uzyskano nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik będzie potrzebował tego tokenu dostępu, aby zainicjować klienta czatu.
addParticipants Użyj metody , aby dodać uczestników do wątku.
communicationIdentifier, wymagane, jest communicationIdentifier utworzony przez CommunicationIdentityClient w przewodniku Szybki start tokenu 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 udostępnić historię poprzednią 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);
Przejdź do katalogu zawierającego plik pom.xml 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
Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.
Przed rozpoczęciem upewnij się, że:
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj program Android Studio. Użyjemy programu Android Studio, aby utworzyć aplikację dla systemu Android dla przewodnika Szybki start w celu zainstalowania 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. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.
Utwórz dwóch użytkowników usług komunikacyjnych i wydaj im token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu, i zanotuj ciąg tokenu i ciąg user_id. W tym przewodniku Szybki start 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ć poniższe polecenie za pomocą parametry 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.
Create a new project.Empty Activity szablon projektu.ChatQuickstart jako nazwę projektu.Użyjemy narzędzia Gradle do zainstalowania 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 następujące zależności do ChatQuickstart elementu docelowego:
implementation 'com.azure.android:azure-communication-common:' + $azureCommunicationCommonVersion
implementation 'com.azure.android:azure-communication-chat:' + $azureCommunicationChatVersion
implementation 'org.slf4j:slf4j-log4j12:1.7.29'
Zapoznaj się z informacjami ihttps://search.maven.org/artifact/com.azure.android/azure-communication-chat, aby https://search.maven.org/artifact/com.azure.android/azure-communication-common uzyskać najnowsze numery wersji.
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")
}
}
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>
Aby uzyskać szczegółowe informacje, zapoznaj się z integracją funkcji platformy Azure. Zdecydowanie zalecamy integrację z funkcją platformy Azure, aby uniknąć twardych parametrów aplikacji kodowania.
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;
}
Otwórz i zmodyfikuj plik MainActivity.java. W tym przewodniku Szybki start dodamy kod do MainActivityelementu i wyświetlimy dane wyjściowe w konsoli programu . Ten przewodnik Szybki start nie dotyczy tworzenia interfejsu użytkownika. W górnej części pliku zaimportuj biblioteki Azure Communication Commonsystemowe , Azure Communication Chati 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());
}
}
Uwaga
Inicjowanie ApplicationConstants musi zostać dodane do MainActivity.java elementu , jeśli zostanie spełniony jeden z następujących warunków: 1. Funkcja powiadomień wypychanych 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. Zapoznaj się z przykładową aplikacją zestawu SDK używanej do celów referencyjnych.
ACS_ENDPOINT
FIRST_USER_ID i FIRST_USER_ACCESS_TOKEN są zwracane z wywołania funkcji platformy Azure. Aby uzyskać szczegółowe informacje, zapoznaj się z integracją 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 i SECOND_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 do inicjowania 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);
}
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();
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. Utwórz wystąpienie z informacjami o subskrypcji i użyjesz ich 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ń. |
Użyjemy polecenia , ChatAsyncClient aby utworzyć nowy wątek z początkowym użytkownikiem.
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();
Po utworzeniu wątku czatu uzyskamy ChatThreadAsyncClient element do wykonywania operacji 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();
Teraz wyślemy wiadomość do tego wątku.
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();
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: W przypadku używania 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ązaniem zależności. Podczas pracy nad rozwiązaniem można wyłączyć funkcję powiadomień w czasie rzeczywistym, dodając następujące informacje o zależnościach w pliku build.gradle aplikacji, a zamiast tego sondować interfejs API GetMessages w celu wyświetlania przychodzących komunikatów do użytkowników.
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'
Pamiętaj o powyższej aktualizacji, jeśli aplikacja spróbuje dotknąć dowolnego interfejsu API powiadomień, takiego jak chatAsyncClient.startRealtimeNotifications() lub chatAsyncClient.addEventHandler(), wystąpi błąd środowiska uruchomieniowego.
Aby uzyskać szczegółowe informacje, zapoznaj się z powiadomieniami wypychanych systemu Android.
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);
<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
});
Teraz usuniemy 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();
Zastąp komentarz <SEND A TYPING NOTIFICATION> następującym kodem:
chatThreadAsyncClient.sendTypingNotification().get();
Wyślemy potwierdzenie przeczytania wiadomości wysłanej powyżej.
Zastąp komentarz <SEND A READ RECEIPT> następującym kodem:
chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();
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
});
W programie Android Studio naciśnij przycisk Uruchom, aby skompilować i uruchomić projekt. W konsoli programu można wyświetlić dane wyjściowe z kodu i danych wyjściowych rejestratora z obiektu ChatClient.
Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.
Przed rozpoczęciem upewnij się, że:
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. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.
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ć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry 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.
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 zestawu AZURE Communication Chat SDK dla platformy .NET
dotnet add package Azure.Communication.Chat
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 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 wiadomości, dodawania/usuwania/pobierania uczestników, wysyłania powiadomień wpisywania i odczytywania potwierdzeń. |
Aby utworzyć klienta czatu, użyjesz 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.
Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, chociaż jest to zalecane. Dowiedz się więcej o architekturze czatów
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);
}
}
}
createChatThread Użyj metody w czacieClient, aby utworzyć wątek czatu
topic polecenia , aby przekazać temat do tego czatu; Temat można zaktualizować po utworzeniu wątku czatu UpdateTopic przy użyciu funkcji .participants właściwości , aby przekazać listę ChatParticipant obiektów do dodania do wątku czatu. Obiekt ChatParticipant jest inicjowany za pomocą CommunicationIdentifier obiektu.
CommunicationIdentifier może być typu CommunicationUserIdentifier, MicrosoftTeamsUserIdentifier lub PhoneNumberIdentifier. Aby na przykład uzyskać CommunicationIdentifier obiekt, musisz przekazać identyfikator dostępu, który został utworzony zgodnie z instrukcjami w celu utworzenia użytkownikaObiekt odpowiedzi z createChatThread metody zawiera chatThread szczegóły. Aby wchodzić w interakcje z operacjami wątku czatu, takimi jak dodawanie uczestników, wysyłanie wiadomości, usuwanie wiadomości itp., chatThreadClient wystąpienie klienta musi utworzyć wystąpienie przy użyciu GetChatThreadClient metody 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;
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: dodawanie elementów członkowskich, wysyłanie wiadomości itp. threadId jest unikatowym identyfikatorem istniejącego wątku czatu.
string threadId = "<THREAD_ID>";
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: threadId);
Użyj GetChatThreads polecenia , 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}");
}
Użyj polecenia SendMessage , aby wysłać wiadomość do wątku.
content polecenia , aby podać zawartość komunikatu, jest wymagana.type dla typu zawartości wiadomości, takiej jak "Tekst" lub "Html". Jeśli nie zostanie określony, zostanie ustawiony tekst.senderDisplayName polecenia , aby określić nazwę wyświetlaną nadawcy. Jeśli nie zostanie określony, zostanie ustawiony pusty ciąg.metadata polecenia , aby uwzględnić wszelkie dodatkowe 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;
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. Należy pamiętać, że komunikaty odebrane przed czasem przesunięcia, ale edytowane lub usunięte po jego powrocie również zostaną zwrócone.
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.CreatedOni można go użyć do zamawiania komunikatów.
GetMessages zwraca różne typy komunikatów, które można zidentyfikować za pomocą chatMessage.Typepolecenia . Są to następujące typy:
Text: Zwykła wiadomość czatu wysłana przez członka wątku.
Html: sformatowana wiadomość SMS. Należy pamiętać, że obecnie użytkownicy usług Communication Services nie mogą wysyłać komunikatów RichText. Ten typ komunikatu jest obsługiwany przez komunikaty wysyłane 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 został dodany do wątku czatu. (tylko do odczytu)
ParticipantRemoved: Komunikat systemowy wskazujący, że uczestnik został usunięty z wątku czatu.
Aby uzyskać więcej informacji, zobacz Typy komunikatów.
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 AddParticipantspolecenia upewnij się, że uzyskano nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik będzie potrzebował 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);
Użyj polecenia 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}");
}
Użyj SendReadReceipt polecenia , aby powiadomić innych uczestników, że wiadomość jest odczytywana przez użytkownika.
await chatThreadClient.SendReadReceiptAsync(messageId: messageId);
Uruchom aplikację z katalogu aplikacji za dotnet run pomocą polecenia .
dotnet run
Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.
Przed rozpoczęciem upewnij się, że:
Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.
Zainstaluj programy Xcode i CocoaPods. Program Xcode służy do tworzenia aplikacji systemu iOS na potrzeby przewodnika Szybki start i aplikacji CocoaPods w celu zainstalowania 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. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.
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 czatu i zanotować ciąg tokenu, a także ciąg user_id. W tym przewodniku Szybki start utworzysz wątek z początkowym uczestnikiem, a następnie dodasz drugiego uczestnika do wątku. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry 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.
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 pozycję 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.
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. Należy pamiętać, że spowoduje to również utworzenie obszaru roboczego programu Xcode.
Po uruchomieniu pod installprogramu otwórz ponownie projekt w programie Xcode, wybierając nowo utworzony .xcworkspaceelement .
Otwórz obszar roboczy ChatQuickstart.xcworkspace w programie Xcode, a następnie otwórz plik ViewController.swift.
W tym przewodniku Szybki start dodasz kod do viewControllerpliku i wyświetlisz dane wyjściowe w konsoli programu Xcode. Ten przewodnik Szybki start nie dotyczy tworzenia interfejsu użytkownika w systemie iOS.
W górnej części viewController.swiftpliku 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żyjemy semafora do zsynchronizowania kodu. W poniższych krokach zastąpisz symbole zastępcze przykładowym kodem przy użyciu biblioteki Czat usług Azure Communication Services.
Aby utworzyć klienta czatu, użyjesz 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.
Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, chociaż jest to zalecane. Dowiedz się więcej o architekturze czatów
Zastąp komentarz <CREATE A CHAT CLIENT> poniższym 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> element punktem końcowym zasobu usług Azure Communication Services. Zastąp <ACCESS_TOKEN> prawidłowym tokenem dostępu usług komunikacyjnych.
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. Utwórz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania, usuwania wątków i subskrybowania zdarzeń czatu. |
ChatThreadClient |
Ta klasa jest wymagana w przypadku funkcji wątku czatu. Wystąpienie można uzyskać za pośrednictwem metody ChatClienti używać go do wysyłania, odbierania, aktualizowania i usuwania komunikatów. Można go również użyć do dodawania, usuwania i pobierania użytkowników, wysyłania powiadomień wpisywania i odczytywania paragonów. |
CreateChatThreadResult to odpowiedź zwrócona podczas tworzenia wątku czatu.
Zawiera chatThread właściwość, która jest obiektem ChatThreadProperties . Ten obiekt zawiera identyfikator threadId, który może służyć do wykonywania ChatThreadClient operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp.
Zastąp komentarz <CREATE A CHAT THREAD> poniższym 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 procedurę obsługi ukończenia przed kontynuowaniem. W kolejnych krokach użyjesz threadId elementu z odpowiedzi zwróconej do procedury obsługi uzupełniania.
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()
Metoda createClient zwraca ChatThreadClient element 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!)
send Użyj metody , aby wysłać komunikat do wątku zidentyfikowanego przez threadId.
SendChatMessageRequest służy do opisywania żądania komunikatu:
content polecenia , aby podać zawartość wiadomości czatusenderDisplayName polecenia , aby określić nazwę wyświetlaną nadawcytype polecenia , aby określić typ wiadomości, taki jak "tekst" lub "html"metadata polecenia , aby uwzględnić wszelkie dodatkowe 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 unikatowym identyfikatorem komunikatu.
Zastąp komentarz <SEND A MESSAGE> poniższym 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()
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> poniższym 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")
}
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> poniższym kodem. Po włączeniu powiadomień spróbuj wysłać nowe wiadomości, 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()
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 addpolecenia upewnij się, że uzyskano nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik będzie potrzebował tego 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.
listParticipants Użyj metody , 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 powiadamiają klientów o przychodzących wiadomościach w wątku czatu w sytuacjach, w których 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 IOS SDK w wersji 1.3.0. Aby uzyskać szczegółowe informacje, zapoznaj się z artykułem Włączanie powiadomień wypychanych w aplikacji czatu.
W programie Xcode naciśnij przycisk Uruchom, aby skompilować i uruchomić projekt. W konsoli programu można wyświetlić dane wyjściowe z kodu i danych wyjściowych rejestratora z obiektu ChatClient.
Uwaga: ustaw wartość NoBuild Settings > Build Options > Enable Bitcode . Obecnie zestaw AZURECommunicationChat SDK dla systemu iOS nie obsługuje włączania kodu bitowego. Następujący problem z usługą GitHub śledzi to.
Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.
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 łącznik czatu usług komunikacyjnych udostępnia tylko akcje, więc aplikacja logiki wymaga co najmniej wyzwalacza.
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 przy użyciu łącznika identity usług komunikacyjnych:
W projektancie w obszarze kroku, w którym chcesz dodać nową akcję, wybierz pozycję 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 parametry połączenia w witrynie Azure Portal, przejdź do zasobu usług 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 obszarze Element zakresów tokenu wybierz pozycję Czat.
Wybierz pozycję Utwórz. Wyświetlany jest identyfikator użytkownika i token dostępu.
Dodaj nową akcję.
W polu wyszukiwania Wybierz operację wprowadź komunikat Czat usług komunikacyjnych. 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.
Dodaj nową akcję.
W polu wyszukiwania Wybierz operację wprowadź komunikat 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ę.
Aby sprawdzić, czy wiadomość została wysłana poprawnie:
Dodaj nową akcję.
W polu wyszukiwania Wybierz operację wprowadź komunikat 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.
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.
Aby wyczyścić przepływ pracy aplikacji logiki i powiązane zasoby, przejrzyj sposób czyszczenia zasobów usługi Logic Apps.
Jeśli chcesz wyczyścić i usunąć subskrypcję usług Komunikacyjnych, 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. Dowiedz się więcej o czyszczeniu zasobów.
W tym przewodniku Szybki start pokazano, jak wykonać następujące działania:
Możesz również wykonać następujące czynności:
Szkolenie
Moduł
Add chat to a Microsoft Teams app by using the Teams JavaScript client library - Training
The Microsoft Teams JavaScript client library can help you integrate native Teams features right in your application. In this module, you'll learn how to integrate the Teams chat capability in your app by using the Teams JavaScript client library.
Dokumentacja
Przykładowy element Chat Hero - An Azure Communication Services sample overview
Omówienie przykładu hero czatu przy użyciu usług Azure Communication Services w celu umożliwienia deweloperom uzyskania dodatkowych informacji na temat działania wewnętrznego przykładu i dowiedz się, jak go modyfikować.
Dowiedz się więcej na temat pojęć związanych z czatem usług komunikacyjnych.
Dowiedz się więcej o zestawie SDK czatu usług Azure Communication Services.