Szybki start: dodawanie czatu do aplikacji

Rozpocznij pracę z usługami Azure Communication Services przy użyciu zestawu SDK czatu usług komunikacyjnych, aby dodać czat w czasie rzeczywistym do aplikacji. W tym przewodniku Szybki start użyjemy zestawu SDK czatu, aby utworzyć wątki czatu, które umożliwiają użytkownikom prowadzenie konwersacji ze sobą. Aby dowiedzieć się więcej na temat pojęć związanych z czatem, odwiedź dokumentację koncepcyjną czatu.

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 interfejs wiersza polecenia platformy Azure.

• Zanotuj punkt końcowy zasobów usług Communication Services. Punkt końcowy można pobrać z witryny Azure Portal. Możesz też znaleźć adres URL punktu końcowego w parametry połączenia. Jest to adres URL, który pojawia się po endpoint= i zaczyna się od https://.

• Token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

Konfigurowanie

Dodawanie rozszerzenia

Dodaj rozszerzenie Azure Communication Services dla interfejsu wiersza polecenia platformy az extension Azure przy użyciu polecenia .

az extension add --name communication

Logowanie do interfejsu wiersza polecenia platformy Azure

Musisz zalogować się do interfejsu wiersza polecenia platformy Azure. Możesz zalogować się, uruchamiając polecenie z poziomu terminalu az login i podając swoje poświadczenia.

(Opcjonalnie) Używanie operacji tożsamości interfejsu wiersza polecenia platformy Azure bez przekazywania punktu końcowego lub tokenu dostępu

Przechowywanie punktu końcowego w zmiennej środowiskowej

Zmienną AZURE_COMMUNICATION_ENDPOINT środowiskową można skonfigurować tak, aby korzystała z operacji czatu interfejsu wiersza polecenia platformy Azure bez konieczności przekazywania --endpoint do punktu końcowego. Aby skonfigurować zmienną środowiskową, otwórz okno konsoli i wybierz system operacyjny z poniższych kart. Zastąp <yourEndpoint> element rzeczywistym punktem końcowym.

Windows

Otwórz okno konsoli i wprowadź następujące polecenie:

setx AZURE_COMMUNICATION_ENDPOINT "<yourEndpoint>"

Po dodaniu zmiennej środowiskowej być może trzeba będzie ponownie uruchomić działające programy, które muszą odczytywać 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

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

export AZURE_COMMUNICATION_ENDPOINT="<yourEndpoint>"

Po dodaniu zmiennej środowiskowej uruchom polecenie source ~/.bash_profile z okna konsoli, aby zmiany zostały uwzględnione. Jeśli zmienna środowiskowa została utworzona przy otwartym środowisku IDE, może być konieczne zamknięcie i ponowne otwarcie edytora, środowiska IDE lub powłoki w celu uzyskania dostępu do zmiennej.

Przechowywanie tokenu dostępu w zmiennej środowiskowej

Zmienną AZURE_COMMUNICATION_ACCESS_TOKEN środowiskową można skonfigurować tak, aby korzystała z operacji czatu interfejsu wiersza polecenia platformy Azure bez konieczności przekazywania --access-token tokenu dostępu. Aby skonfigurować zmienną środowiskową, otwórz okno konsoli i wybierz system operacyjny z poniższych kart. Zastąp <yourAccessToken> element rzeczywistym tokenem dostępu.

Windows

Otwórz okno konsoli i wprowadź następujące polecenie:

setx AZURE_COMMUNICATION_ACCESS_TOKEN "<yourAccessToken>"

Po dodaniu zmiennej środowiskowej być może trzeba będzie ponownie uruchomić działające programy, które muszą odczytywać 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_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

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

export AZURE_COMMUNICATION_ACCESS_TOKEN="<yourAccessToken>"

Po dodaniu zmiennej środowiskowej uruchom polecenie source ~/.bash_profile z okna konsoli, aby zmiany zostały uwzględnione. Jeśli zmienna środowiskowa została utworzona przy otwartym środowisku IDE, może być konieczne zamknięcie i ponowne otwarcie edytora, środowiska IDE lub powłoki w celu uzyskania dostępu do zmiennej.

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 zostały zapisane w zmiennych środowiskowych zgodnie z powyższym opisem, 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> 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.

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

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 określ <startTime> najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie.
• 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.

Wysyłanie wiadomości do wątku czatu

Użyj polecenia , message send aby wysłać wiadomość do utworzonego wątku czatu zidentyfikowanego przez threadIdprogram .

az communication chat message send --thread "<chatThreadId>" --display-name "<displayName>" --content "<content>" --message-type "<messageType>"  --endpoint "<endpoint>" --access-token "<token>"

• 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.
• Opcjonalnie określ <displayName> nazwę wyświetlaną nadawcy.
• 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.

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.
• Opcjonalnie określ <startTime> najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie.
• 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.

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> ciąg identyfikatorem wiadomości, którą chcesz pobrać.
• 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.

Wysyłanie potwierdzenia odczytu

Polecenie służy message receipt send do publikowania zdarzenia potwierdzenia odczytu do wątku w imieniu użytkownika.

az communication chat message receipt send --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"

• 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> ciąg identyfikatorem userId.
• Opcjonalnie określ <displayName> nazwę wyświetlaną nadawcy.
• Opcjonalnie określ <startTime> najwcześniejszy punkt w czasie, aby uzyskać wiadomości na czacie.
• 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.

Wyświetlanie listy uczestników wątku w wątku czatu

Podobnie jak w przypadku dodawania uczestnika, można również wyświetlić listę uczestników z wątku.

Użyj participant list polecenia , aby pobrać uczestników wątku.

az communication chat participant list --thread "<chatThreadId>" --skip "<skip>" --endpoint "<endpoint>" --access-token "<token>"

• Zastąp <chatThreadId> element identyfikatorem wątku czatu.
• Opcjonalnie należy <skip> pominąć uczestników do określonej pozycji w odpowiedzi.
• 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.

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.
• Zastąp <userId> ciąg identyfikatorem userId, który chcesz usunąć z wątku czatu.
• 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.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

• Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.

• Zainstaluj wersje Node.js Active LTS i Maintenance LTS.

• Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.

• Utwórz trzech użytkowników usług Azure Communication Services i wystaw im token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Pełny pokaz tworzy wątek z dwoma początkowymi uczestnikami, a następnie dodaje trzeciego uczestnika do wątku. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

Konfigurowanie

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ć poniższe zestawy SDK usług Communication Services dla języka JavaScript.

npm install @azure/communication-common --save

npm install @azure/communication-identity --save

npm install @azure/communication-signaling --save

npm install @azure/communication-chat --save

Opcja --save wyświetla bibliotekę jako zależność w pliku package.json .

Konfigurowanie struktury aplikacji

Ten przewodnik Szybki start używa pakietu pakietu zasobów aplikacji. Uruchom następujące polecenie, aby go zainstalować i wyświetlić jako zależność programową w pliku package.json:

npm install parcel --save-dev

Utwórz plik index.html w katalogu głównym projektu. Użyjemy tego pliku jako szablonu, aby dodać możliwość czatu przy użyciu zestawu AZURE Communication Chat SDK dla języka JavaScript.

<!DOCTYPE html>
<html>
  <head>
    <title>Communication Client - Chat Sample</title>
  </head>
  <body>
    <h4>Azure Communication Services</h4>
    <h1>Chat Quickstart</h1>
    <script src="./client.js" type="module"></script>
  </body>
</html>

Utwórz plik w katalogu głównym projektu o nazwie client.js , aby zawierał logikę aplikacji dla tego przewodnika Szybki start.

Tworzenie klienta czatu

Aby utworzyć klienta czatu w aplikacji internetowej, użyjesz punktu końcowego usługi Communications Service i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych.

Tokeny dostępu użytkowników umożliwiają tworzenie aplikacji klienckich, które są bezpośrednio uwierzytelniane w usługach Azure Communication Services. Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu. Aby uzyskać więcej informacji na temat architektury czatu i tokenów dostępu użytkowników, zobacz pojęcia dotyczące czatów, aby uzyskać więcej informacji na temat tokenów dostępu.

Wewnątrz pliku client.js użyj punktu końcowego i tokenu dostępu w poniższym kodzie, aby dodać możliwość czatu przy użyciu zestawu SDK czatu komunikacji platformy Azure dla języka JavaScript.

import { ChatClient } from '@azure/communication-chat';
import { AzureCommunicationTokenCredential } from '@azure/communication-common';

// Your unique Azure Communication service endpoint
let endpointUrl = '<replace with your resource endpoint>';
// The user access token generated as part of the pre-requisites
let userAccessToken = '<USER_ACCESS_TOKEN>';

let chatClient = new ChatClient(endpointUrl, new AzureCommunicationTokenCredential(userAccessToken));
console.log('Azure Communication Chat client created!');

• Zastąp element endpointUrl punktem końcowym zasobów usług Communication Services, zobacz Tworzenie zasobu usług Azure Communication Services, jeśli jeszcze tego nie zrobiono.
• Zastąp wartość userAccessToken wystawionym tokenem.

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. Utwórz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania, usuwania wątków i subskrybowania zdarzeń czatu.
ChatThreadClient	Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz wystąpienie za pośrednictwem obiektu ChatClient i używasz go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń.

Rozpoczynanie wątku czatu

createThread Użyj metody , aby utworzyć wątek czatu.

createThreadRequest służy do opisywania żądania wątku:

• Użyj polecenia topic , aby przekazać temat do tego czatu. 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 chatThread właściwość, w której można uzyskać dostęp do id nowo utworzonego wątku. Następnie możesz użyć elementu , id aby uzyskać wystąpienie klasy ChatThreadClient. Następnie ChatThreadClient może służyć do wykonywania operacji w wątku, takich jak wysyłanie komunikatów lub wyświetlanie listy uczestników.

async function createChatThread() {
  const createChatThreadRequest = {
    topic: "Hello, World!"
  };
  const createChatThreadOptions = {
    participants: [
      {
        id: { communicationUserId: '<USER_ID>' },
        displayName: '<USER_DISPLAY_NAME>'
      }
    ]
  };
  const createChatThreadResult = await chatClient.createChatThread(
    createChatThreadRequest,
    createChatThreadOptions
  );
  const threadId = createChatThreadResult.chatThread.id;
  return threadId;
}

createChatThread().then(async threadId => {
  console.log(`Thread created:${threadId}`);
  // PLACEHOLDERS
  // <CREATE CHAT THREAD CLIENT>
  // <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD>
  // <SEND MESSAGE TO A CHAT THREAD>
  // <LIST MESSAGES IN A CHAT THREAD>
  // <ADD NEW PARTICIPANT TO THREAD>
  // <LIST PARTICIPANTS IN A THREAD>
  // <REMOVE PARTICIPANT FROM THREAD>
  });

Po odświeżeniu karty przeglądarki w konsoli powinny zostać wyświetlone następujące elementy:

Thread created: <thread_id>

Uzyskiwanie klienta wątku czatu

Metoda getChatThreadClient zwraca chatThreadClient element dla wątku, który już istnieje. Może służyć do wykonywania operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp. threadId jest unikatowym identyfikatorem istniejącego wątku czatu.

let chatThreadClient = chatClient.getChatThreadClient(threadId);
console.log(`Chat Thread client for threadId:${threadId}`);

Dodaj ten kod zamiast komentarza <CREATE CHAT THREAD CLIENT> w pliku 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 PagedAsyncIterableIterator typ ChatThreadItem. Może służyć do wyświetlania listy wszystkich wątków czatu. Iterator elementu [ChatThreadItem] to odpowiedź zwrócona z list wątków

const threads = chatClient.listChatThreads();
for await (const thread of threads) {
   // your code here
}

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 polecenia , aby podać zawartość 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 z wysyłania komunikatu, zawiera identyfikator, który jest unikatowym identyfikatorem komunikatu.

const sendMessageRequest =
{
  content: 'Please take a look at the attachment'
};
let sendMessageOptions =
{
  senderDisplayName : 'Jack',
  type: 'text',
  metadata: {
    'hasAttachment': 'true',
    'attachmentUrl': 'https://contoso.com/files/attachment.docx'
  }
};
const sendChatMessageResult = await chatThreadClient.sendMessage(sendMessageRequest, sendMessageOptions);
const messageId = sendChatMessageResult.id;
console.log(`Message sent!, message id:${messageId}`);

Dodaj ten kod zamiast komentarza <SEND MESSAGE TO A CHAT THREAD> w pliku 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 pliku 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 pliku client.js. Odśwież kartę w konsoli programu , aby znaleźć listę wiadomości wysłanych w tym wątku czatu.

listMessages zwraca różne typy komunikatów, które mogą być identyfikowane przez chatMessage.type.

Aby uzyskać więcej informacji, zobacz Typy komunikatów.

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 będzie potrzebował tego tokenu dostępu, aby zainicjować klienta czatu.

addParticipantsRequest opisuje obiekt żądania, w którym wymieniono participants uczestników do dodania do wątku czatu;

• id, wymagany jest identyfikator komunikacji, który ma zostać dodany do wątku czatu.
• displayName, opcjonalnie, to nazwa wyświetlana uczestnika wątku.
• shareHistoryTime, opcjonalnie, to czas, z którego historia czatu jest udostępniana uczestnikowi. Aby udostępnić historię od momentu utworzenia wątku czatu, ustaw tę właściwość na dowolną datę równą lub mniejszą niż czas tworzenia wątku. Aby udostępnić historię poprzednią do momentu dodania uczestnika, ustaw ją na bieżącą datę. Aby udostępnić historię częściową, ustaw ją na datę wyboru.

const addParticipantsRequest =
{
  participants: [
    {
      id: { communicationUserId: '<NEW_PARTICIPANT_USER_ID>' },
      displayName: 'Jane'
    }
  ]
};

await chatThreadClient.addParticipants(addParticipantsRequest);

Zastąp NEW_PARTICIPANT_USER_ID nowym identyfikatorem użytkownika Dodaj ten kod zamiast komentarza <ADD NEW PARTICIPANT TO THREAD> w pliku client.js

Wyświetlanie listy 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 pliku 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ąć, należy śledzić identyfikatory dodanych uczestników.

Użyj removeParticipant metody , w której participant użytkownik komunikacji ma zostać usunięty z wątku.

await chatThreadClient.removeParticipant({ communicationUserId: <PARTICIPANT_ID> });
await listParticipants();

Zastąp PARTICIPANT_ID identyfikatorem użytkownika używanym w poprzednim kroku (<NEW_PARTICIPANT_USER_ID>). Dodaj ten kod zamiast komentarza <REMOVE PARTICIPANT FROM THREAD> w pliku client.js.

Subskrybowanie stanu połączenia powiadomień w czasie rzeczywistym

Subskrypcja zdarzeń realTimeNotificationConnected i realTimeNotificationDisconnected umożliwia określenie, kiedy połączenie z serwerem połączeń jest aktywne.

// subscribe to realTimeNotificationConnected event
chatClient.on('realTimeNotificationConnected', () => {
  console.log("Real time notification is now connected!");
  // your code here
});
// subscribe to realTimeNotificationDisconnected event
chatClient.on('realTimeNotificationDisconnected', () => {
  console.log("Real time notification is now disconnected!");
  // your code here
});

Przykładowy kod

Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

• Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.

• Zainstaluj język Python w wersji 3.7 lub nowszej.

• Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Szybki start: tworzenie zasobów usług komunikacyjnych i zarządzanie nimi. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.

• Token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

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 dodasz do tego pliku cały kod źródłowy tego przewodnika Szybki start.

import os
# Add required SDK components from quickstart here

try:
    print('Azure Communication Services - Chat Quickstart')
    # Quickstart code goes here
except Exception as ex:
    print('Exception:')
    print(ex)

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. Utworzysz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania i usuwania wątków.
ChatThreadClient	Ta klasa jest wymagana w przypadku funkcji wątku czatu. Wystąpienie można uzyskać za pośrednictwem metody ChatClienti używać go do wysyłania, odbierania, aktualizowania i usuwania komunikatów. Można go również użyć do dodawania, usuwania i pobierania użytkowników oraz wysyłania powiadomień o wpisaniu i odczytywaniu paragonów.

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

Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, ale jest to zalecane. Aby uzyskać więcej informacji, zobacz sekcję "Architektura czatu " w temacie Pojęcia dotyczące czatu.

Rozpoczynanie wątku czatu

create_chat_thread Użyj metody , aby utworzyć wątek czatu.

• Użyj polecenia topic , aby nadać wątkowi temat. Temat można zaktualizować po utworzeniu wątku czatu update_thread przy użyciu funkcji .
• Użyj thread_participants polecenia , aby wyświetlić listę ChatParticipant elementów do dodania do wątku czatu. Parametr ChatParticipant przyjmuje CommunicationUserIdentifier typ jako user.

CreateChatThreadResult jest wynikiem zwróconym podczas tworzenia wątku. Możesz go użyć do pobrania id utworzonego wątku czatu. Następnie można go id użyć do pobrania ChatThreadClient obiektu przy użyciu get_chat_thread_client metody . Możesz użyć ChatThreadClient polecenia , aby wykonać inne operacje czatu w tym wątku czatu.

topic="test topic"

create_chat_thread_result = chat_client.create_chat_thread(topic)
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)

Uzyskiwanie klienta wątku 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 polecenia , aby wykonać inne operacje czatu w tym wątku czatu.

thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(thread_id)

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.
• Służy results_per_page do określania maksymalnej liczby wątków czatu zwracanych na stronę.

Iteratorem [ChatThreadItem] elementu jest odpowiedź zwrócona z list wątków.

from datetime import datetime, timedelta

start_time = datetime.utcnow() - timedelta(days=2)

chat_threads = chat_client.list_chat_threads(results_per_page=5, start_time=start_time)
for chat_thread_item_page in chat_threads.by_page():
    for chat_thread_item in chat_thread_item_page:
        print(chat_thread_item)
        print('Chat Thread Id: ', chat_thread_item.id)

Wysyłanie wiadomości do wątku czatu

send_message Użyj metody , aby wysłać wiadomość do właśnie 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ć wszelkie dodatkowe dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment:true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.

SendChatMessageResult to odpowiedź zwrócona z wysyłania komunikatu. Zawiera identyfikator, który jest unikatowym identyfikatorem wiadomości.

from azure.communication.chat import ChatMessageType

topic = "test topic"
create_chat_thread_result = chat_client.create_chat_thread(topic)
thread_id = create_chat_thread_result.chat_thread.id
chat_thread_client = chat_client.get_chat_thread_client(create_chat_thread_result.chat_thread.id)


content='Please take a look at the attachment'
sender_display_name='sender name'
metadata={
    'hasAttachment': 'true',
    'attachmentUrl': 'https://contoso.com/files/attachment.docx'
}

# specify chat message type with pre-built enumerations
send_message_result_w_enum = chat_thread_client.send_message(content=content, sender_display_name=sender_display_name, chat_message_type=ChatMessageType.TEXT, metadata=metadata)
print("Message sent: id: ", send_message_result_w_enum.id)

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 polecenia , aby określić najwcześniejszy punkt w czasie w celu pobrania komunikatów.

Iterator [ChatMessage] elementu to odpowiedź zwrócona z listy komunikatów.

from datetime import datetime, timedelta

start_time = datetime.utcnow() - timedelta(days=1)

chat_messages = chat_thread_client.list_messages(results_per_page=1, start_time=start_time)
for chat_message_page in chat_messages.by_page():
    for chat_message in chat_message_page:
        print("ChatMessage: Id=", chat_message.id, "; Content=", chat_message.content.message)

list_messages Zwraca najnowszą wersję komunikatu, w tym wszelkie zmiany lub usunięcia, które wystąpiły w komunikacie przy użyciu poleceń update_message i delete_message. W przypadku usuniętych komunikatów zwraca wartość wskazującądatetime, ChatMessage.deleted_on kiedy ten komunikat został usunięty. W przypadku edytowanych komunikatów zwraca wartość wskazującądatetime, ChatMessage.edited_on kiedy wiadomość została edytowana. Dostęp do oryginalnego czasu tworzenia komunikatów można uzyskać przy użyciu polecenia ChatMessage.created_on, który może służyć do zamawiania komunikatów.

list_messages zwraca różne typy komunikatów, które można zidentyfikować za pomocą ChatMessage.typepolecenia .

Aby uzyskać więcej informacji, zobacz Typy komunikatów.

Wysyłanie potwierdzenia odczytu

Metoda służy send_read_receipt do publikowania zdarzenia potwierdzenia odczytu do 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 masz nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik potrzebuje tego tokenu dostępu, aby zainicjować klienta czatu.

Możesz dodać co najmniej jednego użytkownika do wątku czatu przy użyciu add_participants metody , pod warunkiem, że dla wszystkich użytkowników jest dostępny nowy token dostępu i tożsamość.

Zwracany jest element A list(tuple(ChatParticipant, CommunicationError)) . Po pomyślnym dodaniu uczestnika oczekiwana jest pusta lista. Jeśli podczas dodawania uczestnika wystąpi błąd, lista zostanie wypełniona niepowodzeniem uczestników wraz z błędem, który wystąpił.

from azure.communication.identity import CommunicationIdentityClient
from azure.communication.chat import ChatParticipant
from datetime import datetime

# create 2 users
identity_client = CommunicationIdentityClient.from_connection_string('<connection_string>')
new_users = [identity_client.create_user() for i in range(2)]

# # conversely, you can also add an existing user to a chat thread; provided the user_id is known
# from azure.communication.identity import CommunicationUserIdentifier
#
# user_id = 'some user id'
# user_display_name = "Wilma Flinstone"
# new_user = CommunicationUserIdentifier(user_id)
# participant = ChatParticipant(
#     identifier=new_user,
#     display_name=user_display_name,
#     share_history_time=datetime.utcnow())

participants = []
for _user in new_users:
  chat_thread_participant = ChatParticipant(
    identifier=_user,
    display_name='Fred Flinstone',
    share_history_time=datetime.utcnow()
  ) 
  participants.append(chat_thread_participant) 

response = chat_thread_client.add_participants(participants)

def decide_to_retry(error, **kwargs):
    """
    Insert some custom logic to decide if retry is applicable based on error
    """
    return True

# verify if all users has been successfully added or not
# in case of partial failures, you can retry to add all the failed participants 
retry = [p for p, e in response if decide_to_retry(e)]
if retry:
    chat_thread_client.add_participants(retry)

Wyświetlanie listy uczestników wątku 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 polecenia 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 za python pomocą polecenia .

python start-chat.py

Przykładowy kod

Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie 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. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.

• Token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

Konfigurowanie

Tworzenie nowej aplikacji Java

Otwórz terminal lub okno polecenia i przejdź do katalogu, w którym chcesz utworzyć aplikację Java. Uruchom poniższe polecenie, aby wygenerować projekt Java z szablonu maven-archetype-quickstart.

mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Zauważysz, że cel "generate" utworzył katalog o takiej samej nazwie jak artifactId. W tym katalogu src/main/java directory plik zawiera kod źródłowy projektu, src/test/java katalog zawiera źródło testowe, a plik pom.xml jest projektem Project Object Model lub POM.

Zaktualizuj plik POM aplikacji, aby używać środowiska Java 8 lub nowszego:

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Dodawanie odwołań do pakietu dla zestawu Chat SDK

W pliku POM odwołaj azure-communication-chat się do pakietu za pomocą interfejsów API czatu:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-chat</artifactId>
    <version><!-- Please refer to https://search.maven.org/artifact/com.azure/azure-communication-chat for the latest version --></version>
</dependency>

Aby przeprowadzić uwierzytelnianie, klient musi odwoływać się azure-communication-common do pakietu:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-common</artifactId>
    <version><!-- Please refer to https://search.maven.org/artifact/com.azure/azure-communication-common for the latest version --></version>
</dependency>

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. Utworzysz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania i usuwania wątków.
ChatAsyncClient	Ta klasa jest wymagana w przypadku funkcji asynchronicznego czatu. Utworzysz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania i usuwania wątków.
ChatThreadClient	Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz wystąpienie za pośrednictwem obiektu ChatClient i używasz go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń.
ChatThreadAsyncClient	Ta klasa jest wymagana do asynchronicznej funkcjonalności wątku czatu. Wystąpienie można uzyskać za pośrednictwem klasy ChatAsyncClient i używać go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń.

Tworzenie klienta czatu

Aby utworzyć klienta czatu, użyjesz punktu końcowego usługi Communications Service i tokenu dostępu, który został wygenerowany w ramach kroków wymagań wstępnych. Tokeny dostępu użytkowników umożliwiają tworzenie aplikacji klienckich, które są bezpośrednio uwierzytelniane w usługach Azure Communication Services. Po wygenerowaniu tych tokenów na serwerze przekaż je z powrotem do urządzenia klienckiego. Aby przekazać token do klienta czatu, należy użyć klasy CommunicationTokenCredential z zestawu Common SDK.

Dowiedz się więcej o architekturze czatów

Podczas dodawania instrukcji importu pamiętaj, aby dodać importy tylko z przestrzeni nazw com.azure.communication.chat i com.azure.communication.chat.models, a nie z przestrzeni nazw com.azure.communication.chat.implementation. W pliku App.java, który został wygenerowany za pośrednictwem narzędzia Maven, możesz użyć następującego kodu, aby rozpocząć od:

package com.communication.quickstart;

import com.azure.communication.chat.*;
import com.azure.communication.chat.models.*;
import com.azure.communication.common.*;
import com.azure.core.http.rest.PagedIterable;

import java.io.*;
import java.util.*;

public class App
{
    public static void main( String[] args ) throws IOException
    {
        System.out.println("Azure Communication Services - Chat Quickstart");

        // Your unique Azure Communication service endpoint
        String endpoint = "<replace with your resource endpoint>";

        // User access token fetched from your trusted service
        String userAccessToken = "<USER_ACCESS_TOKEN>";

        // Create a CommunicationTokenCredential with the given access token, which is only valid until the token is valid
        CommunicationTokenCredential userCredential = new CommunicationTokenCredential(userAccessToken);

        // Initialize the chat client
        final ChatClientBuilder builder = new ChatClientBuilder();
        builder.endpoint(endpoint)
            .credential(userCredential);
        ChatClient chatClient = builder.buildClient();
    }
}

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 polecenia , aby wyświetlić listę uczestników wątku do dodania do wątku. ChatParticipantPobiera użytkownika utworzonego w przewodniku Szybki start dotyczący tokenu dostępu użytkownika.

CreateChatThreadResult to odpowiedź zwrócona podczas tworzenia wątku czatu. Zawiera metodę getChatThread() , która zwraca ChatThread obiekt, który może służyć do pobrania klienta wątku, z którego można uzyskać ChatThreadClient polecenie do wykonywania operacji w utworzonym wątku: dodać uczestników, wysłać komunikat itp. Obiekt ChatThread zawiera również metodę getId() , która pobiera unikatowy identyfikator wątku.

CommunicationUserIdentifier identity1 = new CommunicationUserIdentifier("<USER_1_ID>");
CommunicationUserIdentifier identity2 = new CommunicationUserIdentifier("<USER_2_ID>");

ChatParticipant firstThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity1)
    .setDisplayName("Participant Display Name 1");

ChatParticipant secondThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity2)
    .setDisplayName("Participant Display Name 2");

CreateChatThreadOptions createChatThreadOptions = new CreateChatThreadOptions("Topic")
    .addParticipant(firstThreadParticipant)
    .addParticipant(secondThreadParticipant);

CreateChatThreadResult result = chatClient.createChatThread(createChatThreadOptions);
String chatThreadId = result.getChatThread().getId();

Wyświetlanie listy 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());
});

Uzyskiwanie klienta wątku 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 polecenia , aby określić typ zawartości wiadomości czatu, TEKST lub HTML.
• Użyj senderDisplayName polecenia , aby określić nazwę wyświetlaną nadawcy.
• Opcjonalnie użyj metadata polecenia , aby uwzględnić wszelkie dodatkowe dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać hasAttachment:true metadane, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.

Odpowiedź sendChatMessageResult zawiera element id, który jest unikatowym identyfikatorem komunikatu.

Map<String, String> metadata = new HashMap<String, String>();
metadata.put("hasAttachment", "true");
metadata.put("attachmentUrl", "https://contoso.com/files/attachment.docx");

SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
    .setContent("Please take a look at the attachment")
    .setType(ChatMessageType.TEXT)
    .setSenderDisplayName("Sender Display Name")
    .setMetadata(metadata);

SendChatMessageResult sendChatMessageResult = chatThreadClient.sendMessage(sendChatMessageOptions);
String chatMessageId = sendChatMessageResult.getId();

Odbieranie wiadomości czatu z wątku czatu

Wiadomości czatu można pobrać, sondując metodę listMessages na kliencie wątku czatu w określonych odstępach czasu.

chatThreadClient.listMessages().forEach(message -> {
    System.out.printf("Message id is %s.\n", message.getId());
});

listMessages Zwraca najnowszą wersję komunikatu, w tym wszelkie zmiany lub usunięcia, które wystąpiły w komunikacie przy użyciu poleceń .editMessage() i .deleteMessage(). W przypadku usuniętych komunikatów zwraca wartość daty/godziny wskazującą, chatMessage.getDeletedOn() kiedy ten komunikat został usunięty. W przypadku edytowanych komunikatów chatMessage.getEditedOn() zwraca datę/godzinę wskazującą, kiedy wiadomość została edytowana. Do oryginalnego czasu tworzenia komunikatów można uzyskać dostęp przy użyciu polecenia chatMessage.getCreatedOn()i można go użyć do zamawiania komunikatów.

Przeczytaj więcej o typach komunikatów tutaj: Typy komunikatów.

Wysyłanie potwierdzenia odczytu

sendReadReceipt Użyj metody , aby opublikować zdarzenie potwierdzenia odczytu w wątku czatu w imieniu użytkownika. chatMessageId jest unikatowym identyfikatorem odczytywanej wiadomości na czacie.

String chatMessageId = message.getId();
chatThreadClient.sendReadReceipt(chatMessageId);

Wyświetlanie listy uczestników czatu

Służy listParticipants do pobierania kolekcji stronicowanej zawierającej uczestników wątku czatu zidentyfikowanego przez chatThreadId.

PagedIterable<ChatParticipant> chatParticipantsResponse = chatThreadClient.listParticipants();
chatParticipantsResponse.forEach(chatParticipant -> {
    System.out.printf("Participant id is %s.\n", ((CommunicationUserIdentifier) chatParticipant.getCommunicationIdentifier()).getId());
});

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 metody addParticipants upewnij się, że uzyskano nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik będzie potrzebował tego tokenu dostępu, aby zainicjować klienta czatu.

addParticipants Użyj metody , aby dodać uczestników do wątku.

• communicationIdentifier, wymagane, jest communicationIdentifier utworzony przez CommunicationIdentityClient w przewodniku Szybki start tokenu dostępu użytkownika.
• displayName, opcjonalnie, to nazwa wyświetlana uczestnika wątku.
• shareHistoryTime, opcjonalnie, to czas, z którego historia czatu jest udostępniana uczestnikowi. Aby udostępnić historię od momentu utworzenia wątku czatu, ustaw tę właściwość na dowolną datę równą lub mniejszą niż czas tworzenia wątku. Aby udostępnić historię poprzednią do momentu dodania uczestnika, ustaw ją na bieżącą datę. Aby udostępnić historię częściową, ustaw ją na wymaganą datę.

List<ChatParticipant> participants = new ArrayList<ChatParticipant>();

CommunicationUserIdentifier identity3 = new CommunicationUserIdentifier("<USER_3_ID>");
CommunicationUserIdentifier identity4 = new CommunicationUserIdentifier("<USER_4_ID>");

ChatParticipant thirdThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity3)
    .setDisplayName("Display Name 3");

ChatParticipant fourthThreadParticipant = new ChatParticipant()
    .setCommunicationIdentifier(identity4)
    .setDisplayName("Display Name 4");

participants.add(thirdThreadParticipant);
participants.add(fourthThreadParticipant);

chatThreadClient.addParticipants(participants);

Uruchamianie kodu

Przejdź do katalogu zawierającego plik pom.xml i skompiluj projekt przy użyciu następującego mvn polecenia.

mvn compile

Następnie skompiluj pakiet.

mvn package

Uruchom następujące mvn polecenie, aby wykonać aplikację.

mvn exec:java -Dexec.mainClass="com.communication.quickstart.App" -Dexec.cleanupDaemonThreads=false

Przykładowy kod

Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

• Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.

• Zainstaluj program Android Studio. Użyjemy programu Android Studio, aby utworzyć aplikację dla systemu Android dla przewodnika Szybki start w celu zainstalowania zależności.

• Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.

• Utwórz dwóch użytkowników usług komunikacyjnych i wydaj im token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu, i zanotuj ciąg tokenu i ciąg user_id. W tym przewodniku Szybki start utworzymy wątek z początkowym uczestnikiem, a następnie dodamy drugiego uczestnika do wątku. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

Konfigurowanie

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żyjemy narzędzia Gradle do zainstalowania niezbędnych zależności usług komunikacyjnych. W wierszu polecenia przejdź do katalogu ChatQuickstart głównego projektu. Otwórz plik build.gradle aplikacji i dodaj następujące zależności do ChatQuickstart elementu docelowego:

implementation 'com.azure.android:azure-communication-common:' + $azureCommunicationCommonVersion
implementation 'com.azure.android:azure-communication-chat:' + $azureCommunicationChatVersion
implementation 'org.slf4j:slf4j-log4j12:1.7.29'

Zapoznaj się z informacjami ihttps://search.maven.org/artifact/com.azure.android/azure-communication-chat, aby https://search.maven.org/artifact/com.azure.android/azure-communication-common uzyskać najnowsze numery wersji.

Wykluczanie metadanych w opcjach pakowania w katalogu głównym 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, zapoznaj się z integracją funkcji platformy Azure. Zdecydowanie zalecamy integrację z funkcją platformy Azure, aby uniknąć twardych parametrów aplikacji kodowania.

Konfigurowanie stałych 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 przewodniku Szybki start dodamy kod do MainActivityelementu i wyświetlimy dane wyjściowe w konsoli programu . Ten przewodnik Szybki start nie dotyczy tworzenia interfejsu użytkownika. W górnej części pliku zaimportuj biblioteki Azure Communication Commonsystemowe , Azure Communication Chati inne:

import com.azure.android.communication.chat.*;
import com.azure.android.communication.chat.models.*;
import com.azure.android.communication.common.*;

import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import com.jakewharton.threetenabp.AndroidThreeTen;

import java.util.ArrayList;
import java.util.List;

Skopiuj następujący kod do klasy MainActivity w pliku MainActivity.java:

    private ChatAsyncClient chatAsyncClient;

    private void log(String msg) {
        Log.i(TAG, msg);
        Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
    }
    
   @Override
    protected void onStart() {
        super.onStart();
        try {
            AndroidThreeTen.init(this);

            // Initialize application parameters if one of the conditions in '### Initialize Application Parameters' are met.

            // <CREATE A CHAT CLIENT>

            // <CREATE A CHAT THREAD>

            // <CREATE A CHAT THREAD CLIENT>

            // <SEND A MESSAGE>
            
            // <RECEIVE CHAT MESSAGES>

            // <ADD A USER>

            // <LIST USERS>

            // <REMOVE A USER>
            
            // <<SEND A TYPING NOTIFICATION>>
            
            // <<SEND A READ RECEIPT>>
               
            // <<LIST READ RECEIPTS>>
        } catch (Exception e){
            System.out.println("Quickstart failed: " + e.getMessage());
        }
    }

Inicjowanie parametrów aplikacji

Uwaga

Inicjowanie ApplicationConstants musi zostać dodane do MainActivity.java elementu , jeśli zostanie spełniony jeden z następujących warunków: 1. Funkcja powiadomień wypychanych nie jest włączona. 2. Wersja biblioteki czatów usługi Azure Communication dla systemu Android to < "2.0.0". W przeciwnym razie zapoznaj się z krokiem 11 w powiadomieniach wypychanych systemu Android. Zapoznaj się z przykładową aplikacją zestawu SDK używanej do celów referencyjnych.

ACS_ENDPOINTFIRST_USER_ID i FIRST_USER_ACCESS_TOKEN są zwracane z wywołania funkcji platformy Azure. Aby uzyskać szczegółowe informacje, zapoznaj się z integracją funkcji platformy Azure. Użyjemy odpowiedzi z wywołania funkcji platformy Azure, aby zainicjować listę parametrów:

• ACS_ENDPOINT: punkt końcowy zasobu usług komunikacyjnych.
• FIRST_USER_ID i SECOND_USER_ID: prawidłowe identyfikatory użytkowników usług komunikacyjnych wygenerowane przez zasób usług komunikacyjnych.
• FIRST_USER_ACCESS_TOKEN: token dostępu usług komunikacyjnych dla programu <FIRST_USER_ID>.

Blok kodu do inicjowania parametrów aplikacji przez wywołanie funkcji platformy Azure:

try {
        UserTokenClient userTokenClient = new UserTokenClient(AZURE_FUNCTION_URL);
        //First user context
        userTokenClient.getNewUserContext();
        ACS_ENDPOINT = userTokenClient.getACSEndpoint();
        FIRST_USER_ID = userTokenClient.getUserId();
        FIRST_USER_ACCESS_TOKEN = userTokenClient.getUserToken();
        COMMUNICATION_TOKEN_CREDENTIAL = new CommunicationTokenCredential(FIRST_USER_ACCESS_TOKEN);
        //Second user context
        userTokenClient.getNewUserContext();
        SECOND_USER_ID = userTokenClient.getUserId();
    } catch (Throwable throwable) {
        //Your handling code
        logger.logThrowableAsError(throwable);
    }

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. Utwórz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania, usuwania wątków i subskrybowania zdarzeń czatu.
ChatThreadClient/ChatThreadAsyncClient	Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz wystąpienie za pośrednictwem obiektu ChatClient i używasz go do wysyłania/odbierania/aktualizowania/usuwania komunikatów, dodawania/usuwania/pobierania użytkowników, wysyłania powiadomień do wpisywania i odczytywania potwierdzeń.

Rozpoczynanie wątku czatu

Użyjemy polecenia , ChatAsyncClient aby utworzyć nowy wątek z początkowym użytkownikiem.

Zastąp komentarz <CREATE A CHAT THREAD> następującym kodem:

// A list of ChatParticipant to start the thread with.
List<ChatParticipant> participants = new ArrayList<>();
// The display name for the thread participant.
String displayName = "initial participant";
participants.add(new ChatParticipant()
    .setCommunicationIdentifier(new CommunicationUserIdentifier(firstUserId))
    .setDisplayName(displayName));

// The topic for the thread.
final String topic = "General";
// Optional, set a repeat request ID.
final String repeatabilityRequestID = "";
// Options to pass to the create method.
CreateChatThreadOptions createChatThreadOptions = new CreateChatThreadOptions()
    .setTopic(topic)
    .setParticipants(participants)
    .setIdempotencyToken(repeatabilityRequestID);

CreateChatThreadResult createChatThreadResult =
    chatAsyncClient.createChatThread(createChatThreadOptions).get();
ChatThreadProperties chatThreadProperties = createChatThreadResult.getChatThreadProperties();
threadId = chatThreadProperties.getId();

Uzyskiwanie klienta wątku czatu

Po utworzeniu wątku czatu uzyskamy ChatThreadAsyncClient element do wykonywania operacji w wątku. Zastąp komentarz <CREATE A CHAT THREAD CLIENT> następującym kodem:

ChatThreadAsyncClient chatThreadAsyncClient = new ChatThreadClientBuilder()
    .endpoint(endpoint)
    .credential(new CommunicationTokenCredential(firstUserAccessToken))
    .addPolicy(new UserAgentPolicy(APPLICATION_ID, SDK_NAME, sdkVersion))
    .chatThreadId(threadId)
    .buildAsyncClient();

Wysyłanie wiadomości do wątku czatu

Teraz wyślemy wiadomość do tego wątku.

Zastąp komentarz <SEND A MESSAGE> następującym kodem:

// The chat message content, required.
final String content = "Please take a look at the attachment";

// The display name of the sender, if null (i.e. not specified), an empty name will be set.
final String senderDisplayName = "An important person";

// Use metadata optionally to include any additional data you want to send along with the message.
// This field provides a mechanism for developers to extend chat message functionality and add
// custom information for your use case. For example, when sharing a file link in the message, you
// might want to add 'hasAttachment:true' in metadata so that recipient's application can parse
// that and display accordingly.
final Map<String, String> metadata = new HashMap<String, String>();
metadata.put("hasAttachment", "true");
metadata.put("attachmentUrl", "https://contoso.com/files/attachment.docx");

SendChatMessageOptions chatMessageOptions = new SendChatMessageOptions()
    .setType(ChatMessageType.TEXT)
    .setContent(content)
    .setSenderDisplayName(senderDisplayName)
    .setMetadata(metadata);

// A string is the response returned from sending a message, it is an id, which is the unique ID
// of the message.
chatMessageId = chatThreadAsyncClient.sendMessage(chatMessageOptions).get().getId();

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: W przypadku używania zestawu ANDROID Chat i Calling SDK razem w tej samej aplikacji funkcja powiadomień w czasie rzeczywistym zestawu Chat SDK nie działa. Może wystąpić problem z rozwiązaniem zależności. Podczas pracy nad rozwiązaniem można wyłączyć funkcję powiadomień w czasie rzeczywistym, dodając następujące informacje o zależnościach w pliku build.gradle aplikacji, a zamiast tego sondować interfejs API GetMessages w celu wyświetlania przychodzących komunikatów do użytkowników.

implementation ("com.azure.android:azure-communication-chat:1.0.0") {
    exclude group: 'com.microsoft', module: 'trouter-client-android'
}
implementation 'com.azure.android:azure-communication-calling:1.0.0'

Pamiętaj o powyższej aktualizacji, jeśli aplikacja spróbuje dotknąć dowolnego interfejsu API powiadomień, takiego jak chatAsyncClient.startRealtimeNotifications() lub chatAsyncClient.addEventHandler(), wystąpi błąd środowiska uruchomieniowego.

Powiadomienia wypychane do aplikacji

Aby uzyskać szczegółowe informacje, zapoznaj się z powiadomieniami wypychanych 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);

Wyświetlanie listy 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

Teraz usuniemy drugiego użytkownika z wątku.

Zastąp komentarz <REMOVE A USER> następującym kodem:

// Using the unique ID of the participant.
chatThreadAsyncClient.removeParticipant(new CommunicationUserIdentifier(secondUserId)).get();

Wysyłanie powiadomienia o wpisywaniu

Zastąp komentarz <SEND A TYPING NOTIFICATION> następującym kodem:

chatThreadAsyncClient.sendTypingNotification().get();

Wysyłanie potwierdzenia odczytu

Wyślemy potwierdzenie przeczytania wiadomości wysłanej powyżej.

Zastąp komentarz <SEND A READ RECEIPT> następującym kodem:

chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();

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 programu można wyświetlić dane wyjściowe z kodu i danych wyjściowych rejestratora z obiektu ChatClient.

Przykładowy kod

Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

• Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.

• Zainstalować program Visual Studio

• Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Tworzenie zasobu usług Azure Communication Services. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.

• Token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

Konfigurowanie

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 ich do tworzenia, pobierania i usuwania wątków.
ChatThreadClient	Ta klasa jest wymagana w przypadku funkcji wątku czatu. Uzyskujesz wystąpienie za pośrednictwem obiektu ChatClient i używasz go do wysyłania/odbierania/aktualizowania/usuwania wiadomości, dodawania/usuwania/pobierania uczestników, wysyłania powiadomień wpisywania i odczytywania potwierdzeń.

Tworzenie klienta czatu

Aby utworzyć klienta czatu, użyjesz punktu końcowego usług komunikacyjnych i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych. Musisz użyć CommunicationIdentityClient klasy z zestawu Identity SDK, aby utworzyć użytkownika i wydać token do przekazania do klienta czatu.

Dowiedz się więcej o tokenach dostępu użytkowników.

Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, chociaż jest to zalecane. Dowiedz się więcej o architekturze czatów

Skopiuj następujące fragmenty kodu i wklej je do pliku źródłowego: Program.cs

using Azure;
using Azure.Communication;
using Azure.Communication.Chat;
using System;

namespace ChatQuickstart
{
    class Program
    {
        static async System.Threading.Tasks.Task Main(string[] args)
        {
            // Your unique Azure Communication service endpoint
            Uri endpoint = new Uri("<replace with your resource endpoint>");

            CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(<Access_Token>);
            ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);
        }
    }
}

Rozpoczynanie wątku czatu

createChatThread Użyj metody w czacieClient, aby utworzyć wątek czatu

• Użyj topic polecenia , aby przekazać temat do tego czatu; Temat można zaktualizować po utworzeniu wątku czatu UpdateTopic przy użyciu funkcji .
• 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, MicrosoftTeamsUserIdentifier lub PhoneNumberIdentifier. Aby na przykład uzyskać CommunicationIdentifier obiekt, musisz przekazać identyfikator dostępu, który został utworzony zgodnie z instrukcjami w celu utworzenia użytkownika

Obiekt odpowiedzi z createChatThread metody zawiera chatThread szczegóły. Aby wchodzić w interakcje z operacjami wątku czatu, takimi jak dodawanie uczestników, wysyłanie wiadomości, usuwanie wiadomości itp., chatThreadClient wystąpienie klienta musi utworzyć wystąpienie przy użyciu GetChatThreadClient metody na kliencie ChatClient .

var chatParticipant = new ChatParticipant(identifier: new CommunicationUserIdentifier(id: "<Access_ID>"))
{
    DisplayName = "UserDisplayName"
};
CreateChatThreadResult createChatThreadResult = await chatClient.CreateChatThreadAsync(topic: "Hello world!", participants: new[] { chatParticipant });
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: createChatThreadResult.ChatThread.Id);
string threadId = chatThreadClient.Id;

Uzyskiwanie klienta wątku 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: dodawanie elementów członkowskich, wysyłanie wiadomości itp. threadId jest unikatowym identyfikatorem istniejącego wątku czatu.

string threadId = "<THREAD_ID>";
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId: threadId);

Wyświetl wszystkie wątki czatu

Użyj GetChatThreads polecenia , aby pobrać wszystkie wątki czatu, do których należy użytkownik.

AsyncPageable<ChatThreadItem> chatThreadItems = chatClient.GetChatThreadsAsync();
await foreach (ChatThreadItem chatThreadItem in chatThreadItems)
{
    Console.WriteLine($"{ chatThreadItem.Id}");
}

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, jest wymagana.
• Użyj type dla typu zawartości wiadomości, takiej jak "Tekst" lub "Html". Jeśli nie zostanie określony, zostanie ustawiony tekst.
• 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 metadata polecenia , aby uwzględnić wszelkie dodatkowe dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment:true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.

SendChatMessageOptions sendChatMessageOptions = new SendChatMessageOptions()
{
    Content = "Please take a look at the attachment",
    MessageType = ChatMessageType.Text
};
sendChatMessageOptions.Metadata["hasAttachment"] = "true";
sendChatMessageOptions.Metadata["attachmentUrl"] = "https://contoso.com/files/attachment.docx";

SendChatMessageResult sendChatMessageResult = await chatThreadClient.SendMessageAsync(sendChatMessageOptions);

string messageId = sendChatMessageResult.Id;

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. Należy pamiętać, że komunikaty odebrane przed czasem przesunięcia, ale edytowane lub usunięte po jego powrocie również zostaną zwrócone.

GetMessages Zwraca najnowszą wersję komunikatu, w tym wszelkie zmiany lub usunięcia, które wystąpiły w komunikacie przy użyciu poleceń UpdateMessage i DeleteMessage. W przypadku usuniętych komunikatów zwraca wartość daty/godziny wskazującą, chatMessage.DeletedOn kiedy ten komunikat został usunięty. W przypadku edytowanych komunikatów chatMessage.EditedOn zwraca datę/godzinę wskazującą, kiedy wiadomość została edytowana. Do oryginalnego czasu tworzenia komunikatów można uzyskać dostęp przy użyciu polecenia chatMessage.CreatedOni można go użyć do zamawiania komunikatów.

GetMessages zwraca różne typy komunikatów, które można zidentyfikować za pomocą chatMessage.Typepolecenia . Są to następujące typy:

• Text: Zwykła wiadomość czatu wysłana przez członka wątku.

• Html: sformatowana wiadomość SMS. Należy pamiętać, że obecnie użytkownicy usług Communication Services nie mogą wysyłać komunikatów RichText. Ten typ komunikatu jest obsługiwany przez komunikaty wysyłane od użytkowników usługi Teams do użytkowników usługi Communication Services w scenariuszach międzyoperacyjności usługi Teams.

• TopicUpdated: Komunikat systemowy wskazujący, że temat został zaktualizowany. (tylko do odczytu)

• ParticipantAdded: Komunikat systemowy wskazujący, że co najmniej jeden uczestnik został dodany do wątku czatu. (tylko do odczytu)

• ParticipantRemoved: Komunikat systemowy wskazujący, że uczestnik został usunięty z wątku czatu.

Aby uzyskać więcej informacji, zobacz Typy komunikatów.

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 AddParticipantspolecenia upewnij się, że uzyskano nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik będzie potrzebował tego tokenu dostępu, aby zainicjować klienta czatu.

Służy AddParticipants do dodawania co najmniej jednego uczestnika do wątku czatu. Poniżej przedstawiono obsługiwane atrybuty dla każdego uczestnika wątku:

• communicationUser, wymagane, jest tożsamością uczestnika wątku.
• displayName, opcjonalnie, to nazwa wyświetlana uczestnika wątku.
• shareHistoryTime, opcjonalnie, czas, z którego historia czatu jest udostępniana uczestnikowi.

var josh = new CommunicationUserIdentifier(id: "<Access_ID_For_Josh>");
var gloria = new CommunicationUserIdentifier(id: "<Access_ID_For_Gloria>");
var amy = new CommunicationUserIdentifier(id: "<Access_ID_For_Amy>");

var participants = new[]
{
    new ChatParticipant(josh) { DisplayName = "Josh" },
    new ChatParticipant(gloria) { DisplayName = "Gloria" },
    new ChatParticipant(amy) { DisplayName = "Amy" }
};

await chatThreadClient.AddParticipantsAsync(participants: participants);

Pobieranie uczestników wątku

Użyj polecenia GetParticipants , aby pobrać uczestników wątku czatu.

AsyncPageable<ChatParticipant> allParticipants = chatThreadClient.GetParticipantsAsync();
await foreach (ChatParticipant participant in allParticipants)
{
    Console.WriteLine($"{((CommunicationUserIdentifier)participant.User).Id}:{participant.DisplayName}:{participant.ShareHistoryTime}");
}

Wysyłanie potwierdzenia odczytu

Użyj SendReadReceipt polecenia , aby powiadomić innych uczestników, że wiadomość jest odczytywana przez użytkownika.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

Uruchamianie kodu

Uruchom aplikację z katalogu aplikacji za dotnet run pomocą polecenia .

dotnet run

Przykładowy kod

Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie GitHub.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

• Utwórz konto platformy Azure z aktywną subskrypcją. Aby uzyskać szczegółowe informacje, zobacz Tworzenie bezpłatnego konta.

• Zainstaluj programy Xcode i CocoaPods. Program Xcode służy do tworzenia aplikacji systemu iOS na potrzeby przewodnika Szybki start i aplikacji CocoaPods w celu zainstalowania zależności.

• Utwórz zasób usług Azure Communication Services. Aby uzyskać szczegółowe informacje, zobacz Szybki start: tworzenie zasobów usług komunikacyjnych i zarządzanie nimi. W tym przewodniku Szybki start musisz zarejestrować punkt końcowy zasobu i parametry połączenia.

• Utwórz dwóch użytkowników w usługach Azure Communication Services i wydaj im token dostępu użytkownika. Pamiętaj, aby ustawić zakres czatu i zanotować ciąg tokenu, a także ciąg user_id. W tym przewodniku Szybki start utworzysz wątek z początkowym uczestnikiem, a następnie dodasz drugiego uczestnika do wątku. Możesz również użyć interfejsu wiersza polecenia platformy Azure i uruchomić poniższe polecenie za pomocą parametry połączenia, aby utworzyć użytkownika i token dostępu.

  az communication identity token issue --scope chat --connection-string "yourConnectionString"
  

  Aby uzyskać szczegółowe informacje, zobacz Tworzenie tokenów dostępu za pomocą interfejsu wiersza polecenia platformy Azure i zarządzanie nimi.

Konfigurowanie

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 pozycję Storyboard jako interfejs, delegat aplikacji UIKit jako cykl życia i swift jako język.

Wybierz pozycję Dalej i wybierz katalog, w którym chcesz utworzyć projekt.

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. Należy pamiętać, że spowoduje to również utworzenie obszaru roboczego programu Xcode.

Po uruchomieniu pod installprogramu otwórz ponownie projekt w programie Xcode, wybierając nowo utworzony .xcworkspaceelement .

Konfigurowanie symboli zastępczych

Otwórz obszar roboczy ChatQuickstart.xcworkspace w programie Xcode, a następnie otwórz plik ViewController.swift.

W tym przewodniku Szybki start dodasz kod do viewControllerpliku i wyświetlisz dane wyjściowe w konsoli programu Xcode. Ten przewodnik Szybki start nie dotyczy tworzenia interfejsu użytkownika w systemie iOS.

W górnej części viewController.swiftpliku zaimportuj biblioteki AzureCommunication i AzureCommunicatonChat :

import AzureCommunicationCommon
import AzureCommunicationChat

Skopiuj następujący kod do viewDidLoad() metody :ViewController

override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.

        let semaphore = DispatchSemaphore(value: 0)
        DispatchQueue.global(qos: .background).async {
            do {
                // <CREATE A CHAT CLIENT>
                
                // <CREATE A CHAT THREAD>

                // <LIST ALL CHAT THREADS>

                // <GET A CHAT THREAD CLIENT>

                // <SEND A MESSAGE>

                // <SEND A READ RECEIPT >

                // <RECEIVE MESSAGES>

                // <ADD A USER>
                
                // <LIST USERS>
            } catch {
                print("Quickstart failed: \(error.localizedDescription)")
            }
        }
    }

W celach demonstracyjnych użyjemy semafora do zsynchronizowania kodu. W poniższych krokach zastąpisz symbole zastępcze przykładowym kodem przy użyciu biblioteki Czat usług Azure Communication Services.

Tworzenie klienta czatu

Aby utworzyć klienta czatu, użyjesz punktu końcowego usług komunikacyjnych i tokenu dostępu wygenerowanego w ramach kroków wymagań wstępnych.

Dowiedz się więcej o tokenach dostępu użytkowników.

Ten przewodnik Szybki start nie obejmuje tworzenia warstwy usługi do zarządzania tokenami dla aplikacji czatu, chociaż jest to zalecane. Dowiedz się więcej o architekturze czatów

Zastąp komentarz <CREATE A CHAT CLIENT> poniższym fragmentem kodu:

let endpoint = "<ACS_RESOURCE_ENDPOINT>"
let credential =
try CommunicationTokenCredential(
    token: "<ACCESS_TOKEN>"
)
let options = AzureCommunicationChatClientOptions()

let chatClient = try ChatClient(
    endpoint: endpoint,
    credential: credential,
    withOptions: options
)

Zastąp <ACS_RESOURCE_ENDPOINT> element punktem końcowym zasobu usług Azure Communication Services. Zastąp <ACCESS_TOKEN> prawidłowym tokenem dostępu usług komunikacyjnych.

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. Utwórz wystąpienie z informacjami o subskrypcji i użyjesz ich do tworzenia, pobierania, usuwania wątków i subskrybowania zdarzeń czatu.
ChatThreadClient	Ta klasa jest wymagana w przypadku funkcji wątku czatu. Wystąpienie można uzyskać za pośrednictwem metody ChatClienti używać go do wysyłania, odbierania, aktualizowania i usuwania komunikatów. Można go również użyć do dodawania, usuwania i pobierania użytkowników, wysyłania powiadomień wpisywania i odczytywania paragonów.

Rozpoczynanie wątku czatu

CreateChatThreadResult to odpowiedź zwrócona podczas tworzenia wątku czatu. Zawiera chatThread właściwość, która jest obiektem ChatThreadProperties . Ten obiekt zawiera identyfikator threadId, który może służyć do wykonywania ChatThreadClient operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp.

Zastąp komentarz <CREATE A CHAT THREAD> poniższym fragmentem kodu:

let request = CreateChatThreadRequest(
    topic: "Quickstart",
    participants: [
        ChatParticipant(
            id: CommunicationUserIdentifier("<USER_ID>"),
            displayName: "Jack"
        )
    ]
)

var threadId: String?
chatClient.create(thread: request) { result, _ in
    switch result {
    case let .success(result):
        threadId = result.chatThread?.id

    case .failure:
        fatalError("Failed to create thread.")
    }
    semaphore.signal()
}
semaphore.wait()

Zastąp <USER_ID> prawidłowym identyfikatorem użytkownika usług Komunikacyjnych.

W tym miejscu używasz semafora, aby poczekać na procedurę obsługi ukończenia przed kontynuowaniem. W kolejnych krokach użyjesz threadId elementu z odpowiedzi zwróconej do procedury obsługi uzupełniania.

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

Uzyskiwanie klienta wątku czatu

Metoda createClient zwraca ChatThreadClient element dla wątku, który już istnieje. Może służyć do wykonywania operacji na utworzonym wątku: dodawanie uczestników, wysyłanie wiadomości itp. threadId jest unikatowym identyfikatorem istniejącego wątku czatu.

Zastąp komentarz <GET A CHAT THREAD CLIENT> następującym kodem:

let chatThreadClient = try chatClient.createClient(forThread: threadId!)

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 polecenia , aby podać zawartość wiadomości czatu
• 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ć wszelkie dodatkowe dane, które chcesz wysłać wraz z komunikatem. To pole udostępnia deweloperom mechanizm rozszerzania funkcji wiadomości czatu i dodawania niestandardowych informacji dla twojego przypadku użycia. Na przykład podczas udostępniania linku do pliku w komunikacie możesz dodać ciąg "hasAttachment:true" w metadanych, aby aplikacja adresata mogła przeanalizować to i wyświetlić odpowiednio.

SendChatMessageResult to odpowiedź zwrócona z wysyłania komunikatu, zawiera identyfikator, który jest unikatowym identyfikatorem komunikatu.

Zastąp komentarz <SEND A MESSAGE> poniższym fragmentem kodu:

let message = SendChatMessageRequest(
                        content: "Hello!",
                        senderDisplayName: "Jack",
                        type: .text,
                        metadata: [
                            "hasAttachment": "true",
                            "attachmentUrl": "https://contoso.com/files/attachment.docx"
                        ]
                    )

var messageId: String?

chatThreadClient.send(message: message) { result, _ in
    switch result {
    case let .success(result):
        print("Message sent, message id: \(result.id)")
        messageId = result.id
    case .failure:
        print("Failed to send message")
    }
    semaphore.signal()
}
semaphore.wait()

Wysyłanie potwierdzenia 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> poniższym kodem:

if let id = messageId {
    chatThreadClient.sendReadReceipt(forMessage: id) { result, _ in
        switch result {
        case .success:
            print("Read receipt sent")
        case .failure:
            print("Failed to send read receipt")
        }
        semaphore.signal()
    }
    semaphore.wait()
} else {
    print("Cannot send read receipt without a message id")
}

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> poniższym kodem. Po włączeniu powiadomień spróbuj wysłać nowe wiadomości, aby wyświetlić element ChatMessageReceivedEvents.

chatClient.startRealTimeNotifications { result in
    switch result {
    case .success:
        print("Real-time notifications started.")
    case .failure:
        print("Failed to start real-time notifications.")
    }
    semaphore.signal()
}
semaphore.wait()

chatClient.register(event: .chatMessageReceived, handler: { response in
    switch response {
    case let .chatMessageReceivedEvent(event):
        print("Received a message: \(event.message)")
    default:
        return
    }
})

Alternatywnie możesz pobrać wiadomości czatu, sondując metodę listMessages w określonych odstępach czasu. Zobacz poniższy fragment kodu dla listMessages

chatThreadClient.listMessages { result, _ in
    switch result {
    case let .success(messagesResult):
        guard let messages = messagesResult.pageItems else {
            print("No messages returned.")
            return
        }

        for message in messages {
            print("Received message with id: \(message.id)")
        }

    case .failure:
        print("Failed to receive messages")
    }
    semaphore.signal()
}
semaphore.wait()

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 addpolecenia upewnij się, że uzyskano nowy token dostępu i tożsamość dla tego użytkownika. Użytkownik będzie potrzebował tego tokenu dostępu, aby zainicjować klienta czatu.

add Użyj metody ChatThreadClient , aby dodać co najmniej jednego uczestnika do wątku czatu. Poniżej przedstawiono obsługiwane atrybuty dla każdego uczestnika wątku:

• id, wymagane, jest tożsamością uczestnika wątku.
• displayName, opcjonalnie, to nazwa wyświetlana uczestnika wątku.
• shareHistoryTime, opcjonalnie, czas, z którego historia czatu jest udostępniana uczestnikowi.

Zastąp komentarz <ADD A USER> następującym kodem:

let user = ChatParticipant(
    id: CommunicationUserIdentifier("<USER_ID>"),
    displayName: "Jane"
)

chatThreadClient.add(participants: [user]) { result, _ in
    switch result {
    case let .success(result):
        if let errors = result.invalidParticipants, !errors.isEmpty {
            print("Error adding participant")
        } else {
            print("Added participant")
        }
    case .failure:
        print("Failed to add the participant")
    }
    semaphore.signal()
}
semaphore.wait()

Zastąp <USER_ID> element identyfikatorem użytkownika usług komunikacyjnych, który ma zostać dodany.

Wyświetlanie listy użytkowników w wątku

listParticipants Użyj metody , aby pobrać wszystkich uczestników dla określonego wątku czatu.

Zastąp komentarz <LIST USERS> następującym kodem:

chatThreadClient.listParticipants { result, _ in
    switch result {
    case let .success(participantsResult):
        guard let participants = participantsResult.pageItems else {
            print("No participants returned.")
            return
        }

        for participant in participants {
            let user = participant.id as! CommunicationUserIdentifier
            print("User with id: \(user.identifier)")
        }
    case .failure:
        print("Failed to list participants")
    }
    semaphore.signal()
}
semaphore.wait()

Powiadomienia wypychane do aplikacji

Powiadomienia wypychane powiadamiają klientów o przychodzących wiadomościach w wątku czatu w sytuacjach, w których aplikacja mobilna nie jest uruchomiona na pierwszym planie. Obecnie wysyłanie powiadomień wypychanych do czatu za pomocą usługi Notification Hub jest obsługiwane w przypadku zestawu IOS SDK w wersji 1.3.0. Aby uzyskać szczegółowe informacje, zapoznaj się z artykułem Włączanie powiadomień wypychanych w aplikacji czatu.

Uruchamianie kodu

W programie Xcode naciśnij przycisk Uruchom, aby skompilować i uruchomić projekt. W konsoli programu można wyświetlić dane wyjściowe z kodu i danych wyjściowych rejestratora z obiektu ChatClient.

Uwaga: ustaw wartość NoBuild Settings > Build Options > Enable Bitcode . Obecnie zestaw AZURECommunicationChat SDK dla systemu iOS nie obsługuje włączania kodu bitowego. Następujący problem z usługą GitHub śledzi to.

Przykładowy kod

Znajdź sfinalizowany kod dla tego przewodnika Szybki start w witrynie 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 łącznik czatu usług komunikacyjnych udostępnia tylko akcje, więc aplikacja logiki wymaga co najmniej wyzwalacza.

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 przy użyciu łącznika identity usług komunikacyjnych:

1. W projektancie w obszarze kroku, w którym chcesz dodać nową akcję, wybierz pozycję Nowy krok. Alternatywnie, aby dodać nową akcję między krokami, przenieś wskaźnik na strzałkę między tymi krokami, wybierz znak plus (+), a następnie wybierz pozycję Dodaj akcję.

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 parametry połączenia w witrynie Azure Portal, przejdź do zasobu usług Azure Communication Services. W menu zasobów wybierz pozycję Klucze, a następnie wybierz pozycję ciąg Połączenie ion. 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 obszarze Element zakresów tokenu wybierz pozycję Czat.

   

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ź komunikat Czat usług komunikacyjnych. 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ź komunikat 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ę.

   

Wyświetlanie listy 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ź komunikat 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 przepływu pracy

Aby wyczyścić przepływ pracy aplikacji logiki i powiązane zasoby, przejrzyj sposób czyszczenia zasobów usługi Logic Apps.

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Komunikacyjnych, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów. Dowiedz się więcej o czyszczeniu zasobów.

Następne kroki

W tym przewodniku Szybki start pokazano, jak wykonać następujące działania:

• 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

Możesz również wykonać następujące czynności:

• Wprowadzenie do biblioteki interfejsu użytkownika
• 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 .