Dodawanie czatu do aplikacji

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ę od https://.

• 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.

Windows

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.

macOS

.zshrcEdytuj zmienną środowiskową i dodaj zmienną środowiskową:

export AZURE_COMMUNICATION_ENDPOINT="<yourEndpoint>"

Po dodaniu zmiennej środowiskowej uruchom polecenie source ~/.zshrc 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.

Linux

Edytuj swój .bash_profile, 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.

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.

Windows

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.

macOS

Edytuj .zshrc, i dodaj zmienną środowiskową:

export AZURE_COMMUNICATION_ACCESS_TOKEN="<yourAccessToken>"

Po dodaniu zmiennej środowiskowej uruchom polecenie source ~/.zshrc 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.

Linux

Edytuj .bash_profile, a następnie 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.

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 czatu thread 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ą uruchomionego identity 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ą uruchomionego identity 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ą uruchomionego identity 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 to text i html. Jeśli nie określisz wartości, wartość domyślna to text.
• 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ą uruchomionego identity 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ą uruchomionego identity 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ą uruchomionego identity 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ą uruchomionego identity 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ą uruchomionego identity 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ą uruchomionego identity 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ą uruchomionego identity 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 czatu UpdateThread 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.

listMessagesZwraca 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 funkcji update_thread.
• Użyj thread_participants, aby wymienić ChatParticipant, które mają być dodane 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 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 to text i html. Jeśli nie określisz wartości, wartość domyślna to text.
• 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_messagesZwraca 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.

• Apache Maven.

• 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 czatu UpdateThread 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 lub HTML.
• 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

1. Otwórz program Android Studio i wybierz pozycję Create a new project.
2. W następnym oknie wybierz jako Empty Activity szablon projektu.
3. Podczas wybierania opcji wprowadź ChatQuickstart jako nazwę projektu.
4. 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 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());
        }
    }

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_IDi 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 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 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 funkcji UpdateTopic, po utworzeniu wątku czatu.
• Użyj 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, MicrosoftTeamsUserIdentifierlub PhoneNumberIdentifier. 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.CreatedOni 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.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ż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 ChatClienti 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:

1. 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ę.

2. W polu wyszukiwania wybierz operację, wprowadź tożsamość usług komunikacyjnych. Na liście akcji wybierz pozycję Utwórz użytkownika.

   

3. 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.

   

4. Wprowadź nazwę połączenia.

5. 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.

   

6. W pozycji Zakresy Tokenów wybierz chat.

   

7. Wybierz pozycję Utwórz. Wyświetlany jest identyfikator użytkownika i token dostępu.

Tworzenie wątku czatu

1. Dodaj nową akcję.

2. W polu wyszukiwania Wybierz operację wprowadź Komunikacyjne usługi czat. Na liście akcji wybierz pozycję Utwórz wątek czatu.

   

3. 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.

4. Wprowadź nazwę połączenia.

5. 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

1. Dodaj nową akcję.

2. W polu wyszukiwania Wybierz operację wprowadź Czat usług komunikacyjnych. Na liście akcji wybierz pozycję Wyślij wiadomość do wątku czatu.

   

3. 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:

1. Dodaj nową akcję.

2. W polu wyszukiwania Wybierz operację wprowadź Czat usług komunikacyjnych. Na liście akcji wybierz pozycję Wyświetl wiadomości wątku czatu.

   

3. 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

Wypróbuj aplikację Chat Hero

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.