Delen via

Chat toevoegen aan uw app

Voeg realtime chatten toe aan uw app met behulp van de Communication Services Chat SDK. In dit artikel wordt beschreven hoe u de Chat-SDK gebruikt om chatthreads te maken waarmee gebruikers gesprekken met elkaar kunnen voeren. Zie conceptuele documentatie voor chats voor meer informatie over chatconcepten.

Vereiste voorwaarden

  • Een Azure-account met een actief abonnement. Gratis een account maken

  • Een actieve Communication Services-resource en verbindingsreeks. Een Communication Services-resource maken.

  • Installeer Azure CLI.

  • Noteer uw Communication Services-resource-eindpunt. U kunt het eindpunt ophalen vanuit Azure Portal. U kunt ook de eindpunt-URL vinden in de verbindingsreeks. Het is de URL die erna endpoint= komt en begint met https://.

  • EenToken voor gebruikerstoegang. Zorg ervoor dat u het bereik instelt op chatten en noteer de tokentekenreeks en de user_id tekenreeks. U kunt ook de Azure CLI gebruiken en de volgende opdracht uitvoeren met uw verbindingsreeks om een gebruiker en een toegangstoken te maken.

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

    Zie Azure CLI gebruiken voor het maken en beheren van toegangstokens voor meer informatie.

Inrichten

De extensie toevoegen

Voeg de Azure Communication Services-extensie voor Azure CLI toe met behulp van de az extension opdracht.

az extension add --name communication

Aanmelden bij Azure CLI

U moet zich aanmelden bij Azure CLI. U kunt zich aanmelden door de az login opdracht uit te voeren vanuit de terminal en uw referenties op te geven.

(Optioneel) Azure CLI-identiteitsbewerkingen gebruiken zonder een eindpunt of toegangstoken door te geven

Uw eindpunt opslaan in een omgevingsvariabele

U kunt de AZURE_COMMUNICATION_ENDPOINT omgevingsvariabele configureren voor het gebruik van Azure CLI-chatbewerkingen zonder dat u het eindpunt hoeft door te --endpoint geven. Als u een omgevingsvariabele wilt configureren, opent u een consolevenster en selecteert u uw besturingssysteem op de volgende tabbladen. Vervang <yourEndpoint> door uw werkelijke eindpunt.

Open een consolevenster en voer de volgende opdracht in:

setx AZURE_COMMUNICATION_ENDPOINT "<yourEndpoint>"

Nadat u de omgevingsvariabele hebt toegevoegd, moet u mogelijk alle actieve programma's opnieuw opstarten die de omgevingsvariabele moeten lezen, inclusief het consolevenster. Als u Visual Studio bijvoorbeeld gebruikt als editor, start u Visual Studio opnieuw voordat u het voorbeeld uitvoert.

Uw toegangstoken opslaan in een omgevingsvariabele

U kunt de AZURE_COMMUNICATION_ACCESS_TOKEN omgevingsvariabele configureren voor het gebruik van Azure CLI-chatbewerkingen zonder dat u het toegangstoken hoeft door te --access-token geven. Als u een omgevingsvariabele wilt configureren, opent u een consolevenster en selecteert u uw besturingssysteem op de volgende tabbladen. Vervang <yourAccessToken> door uw werkelijke toegangstoken.

Open een consolevenster en voer de volgende opdracht in:

setx AZURE_COMMUNICATION_ACCESS_TOKEN "<yourAccessToken>"

Nadat u de omgevingsvariabele hebt toegevoegd, moet u mogelijk alle actieve programma's opnieuw opstarten die de omgevingsvariabele moeten lezen, inclusief het consolevenster. Als u Visual Studio bijvoorbeeld gebruikt als editor, start u Visual Studio opnieuw voordat u het voorbeeld uitvoert.

Bedrijfsvoering

Een chat-thread starten

Gebruik de thread create opdracht om een chatthread te maken.

az communication chat thread create --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"

Als u het eindpunt en het toegangstoken hebt opgeslagen in omgevingsvariabelen zoals eerder vermeld, hoeft u ze niet door te geven aan de opdracht.

az communication chat thread create --topic "<chatTopic>"
  • Gebruik <chatTopic> dit om de thread een onderwerp te geven. U kunt het onderwerp bijwerken nadat de chatthread is gemaakt met behulp van de thread update-topic opdracht.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Het onderwerp van een chatgesprek bijwerken

az communication chat thread update-topic --thread "<chatThreadId>" --topic "<chatTopic>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatthread-id.
  • Vervang <chatTopic> door het nieuwe chatonderwerp dat u wilt instellen.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Alle chatthreads weergeven

De thread list opdracht retourneert de lijst met chatthreads van een gebruiker.

az communication chat thread list --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
  • Optioneel: Gebruik <startTime> dit om het vroegste tijdstip op te geven om chatberichten op te halen.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Een bericht verzenden naar een chat-thread

Gebruik de message send opdracht om een bericht te verzenden naar een chatgesprek dat u hebt gemaakt, geïdentificeerd door threadId.

az communication chat message send --thread "<chatThreadId>" --display-name "<displayName>" --content "<content>" --message-type "<messageType>"  --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatthread-ID.
  • Gebruik <content> om de inhoud van het chatbericht te geven.
  • Gebruik <messageType> dit om het inhoudstype van het bericht op te geven. Mogelijke waarden zijn text en html. Als u geen waarde opgeeft, is de standaardwaarde text.
  • U kunt desgewenst <displayName> gebruiken om de weergavenaam van de afzender op te geven.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Chatberichten weergeven in een chatgesprek

De message list opdracht retourneert de lijst met chatberichten in een chatgesprek.

az communication chat message list --thread "<chatThreadId>" --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatdraad-ID.
  • Gebruik <startTime> optioneel om het vroegste tijdstip op te geven om chatberichten op te halen.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Een chatbericht ontvangen van een chatgesprek

U kunt chatberichten ophalen met behulp van de message list opdracht.

az communication chat message get --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatthread-id.
  • Vervang door <messageId> de id van het bericht dat u wilt ophalen.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Leesbevestiging verzenden

U gebruikt de message receipt send opdracht om een gebeurtenis met leesbevestiging te posten in een thread namens een gebruiker.

az communication chat message receipt send --thread "<chatThreadId>" --message-id "<messageId>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatdraad-ID.
  • Vervang <messageId> om de ID te specificeren van het meest recente bericht dat door de huidige gebruiker is gelezen.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Een gebruiker toevoegen als deelnemer aan de chatthread

Wanneer u een chat-thread maakt, kunt u er vervolgens gebruikers aan toevoegen en verwijderen. Door gebruikers toe te voegen, geeft u hen toegang om berichten naar de chatthread te verzenden en andere deelnemers toe te voegen of te verwijderen. Voordat u de participant add opdracht aanroept, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker hebt verkregen.

az communication chat participant add --thread "<chatThreadId>" --user "<userId>" --display-name "<displayName>" --start-time "<startTime>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatthread-ID.
  • Vervang <userId> door uw userId.
  • Optioneel kunt u de weergavenaam van de afzender opgeven.
  • Gebruik <startTime> optioneel om het vroegste tijdstip op te geven om chatberichten op te halen.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Deelnemers aan een chatreeks weergeven

Net als bij het toevoegen van een deelnemer kunt u ook deelnemers uit een thread vermelden.

Gebruik participant list de opdracht om de deelnemers aan de thread op te halen.

az communication chat participant list --thread "<chatThreadId>" --skip "<skip>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> door uw chatthread-id.
  • Gebruik <skip> optioneel om deelnemers over te slaan naar een opgegeven positie in het antwoord.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Een deelnemer verwijderen uit een chatgesprek

U kunt een chatdeelnemer verwijderen uit een chatgesprek met behulp van de opdracht Deelnemer verwijderen.

az communication chat participant remove --thread "<chatThreadId>" --user "<userId>" --endpoint "<endpoint>" --access-token "<token>"
  • Vervang <chatThreadId> met uw chatthread-id.
  • Vervang <userId> door de userId die u wilt verwijderen uit de chat-thread.
  • Vervang <endpoint> door uw Azure Communication Services-eindpunt.
  • Vervang <token> door het toegangstoken dat u eerder hebt verkregen door de opdracht uit te voeren identity token issue .

Vereisten

  • Maak een Azure-account met een actief abonnement. Zie Gratis een account maken voor meer informatie.

  • Installeer Node.js Active LTS en Maintenance LTS-versies.

  • Maak een Azure Communication Services-resource. Zie Een Azure Communication Services-resource maken voor meer informatie. U moet uw resource-eindpunt en verbindingsreeks vastleggen voor dit artikel.

  • Maak drie Azure Communication Services-gebruikers en geef ze een token voor gebruikerstoegang uit. Zorg ervoor dat u het bereik instelt op chatten en noteer de tokentekenreeks en de user_id tekenreeks. De volledige demo maakt een thread met twee eerste deelnemers en voegt vervolgens een derde deelnemer toe aan de thread. U kunt ook de Azure CLI gebruiken en de volgende opdracht uitvoeren met uw verbindingsreeks om een gebruiker en een toegangstoken te maken.

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

    Zie Azure CLI gebruiken voor het maken en beheren van toegangstokens voor meer informatie.

Inrichten

Een nieuwe webtoepassing maken

Open eerst uw terminal of opdrachtvenster, maak een nieuwe map voor uw app en navigeer daarnaartoe.

mkdir chat-quickstart && cd chat-quickstart

Voer npm init -y uit om een package.json-bestand te maken met de standaardinstellingen.

npm init -y

De pakketten installeren

Gebruik de npm install opdracht om de volgende Communication Services SDK's voor JavaScript te installeren.

npm install @azure/communication-common --save

npm install @azure/communication-identity --save

npm install @azure/communication-signaling --save

npm install @azure/communication-chat --save

De optie --save geeft de bibliotheek weer als afhankelijkheid in het package.json-bestand.

Stel het app-framework in

In dit artikel wordt gebruikgemaakt van pakket om de toepassingsassets te bundelen. Voer de volgende opdracht uit om deze te installeren en weer te geven als een ontwikkelingsafhankelijkheid in uw package.json:

npm install parcel --save-dev

Maak een index. html-bestand in de hoofdmap van uw project. Gebruik dit bestand als sjabloon om chatmogelijkheden toe te voegen met behulp van de Azure Communication Chat SDK voor 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>

Maak een bestand in de hoofdmap van uw project met de naam client.js om de toepassingslogica voor dit artikel te bevatten.

Een chat-client maken

Als u een chatclient in uw web-app wilt maken, gebruikt u het Communications Service-eindpunt en het toegangstoken dat is gegenereerd als onderdeel van de vereiste stappen.

Met toegangstokens voor gebruikers kunt u clienttoepassingen maken die zich rechtstreeks verifiëren bij Azure Communication Services. Dit artikel heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing. Zie chatconcepten voor meer informatie over de chatarchitectuur. Zie tokens voor gebruikerstoegang voor meer informatie over toegangstokens.

In client.js het eindpunt en het toegangstoken in de volgende code gebruiken om chatmogelijkheden toe te voegen met behulp van de Azure Communication Chat SDK voor 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!');
  • Vervang endpointUrl door het Communication Services-resource-eindpunt. Zie Een Azure Communication Services-resource maken voor meer informatie.
  • Vervang userAccessToken door het token dat u hebt uitgegeven.

De code uitvoeren

Voer de volgende opdracht uit om uw toepassing uit te voeren:

npx parcel index.html

Open uw browser en navigeer naar http://localhost:1234/. In de console voor ontwikkelhulpprogramma's in uw browser ziet u het volgende:

Azure Communication Chat client created!

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Chat SDK voor JavaScript.

Name Beschrijving
ChatClient Deze klasse is vereist voor de chat-functionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, te ophalen, te verwijderen en u te abonneren op chat-gebeurtenissen.
ChatThreadClient Deze klasse is vereist voor de functionaliteit van de chat-thread. U verkrijgt een instantie via de ChatClient en gebruikt deze om berichten te verzenden, te ontvangen, bij te werken of te verwijderen, gebruikers toe te voegen, te verwijderen of op te halen, getypte meldingen te verzenden en bevestigingen te lezen.

Een chat-thread starten

De methode createThread gebruiken om een chat-thread te maken.

createThreadRequest wordt gebruikt om de thread-aanvraag te beschrijven:

  • Gebruik topic dit om een onderwerp aan deze chat te geven. Onderwerpen kunnen worden bijgewerkt nadat de chat-thread is gemaakt met behulp van de UpdateThread functie.
  • Gebruik participants dit om de deelnemers weer te geven die moeten worden toegevoegd aan de chat-thread.

Wanneer opgelost, retourneert de createChatThread methode een CreateChatThreadResult. Dit model bevat een chatThread eigenschap waarmee u toegang hebt tot de id van de zojuist gemaakte thread. Vervolgens kunt u het id gebruiken om een instantie van een ChatThreadClient te verkrijgen. De ChatThreadClient kan vervolgens worden gebruikt om bewerkingen uit te voeren binnen de thread, zoals het verzenden van berichten of het weergeven van deelnemers.

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

Wanneer u het browsertabblad vernieuwt, ziet u het volgende bericht in de console:

Thread created: <thread_id>

Een chat-thread-client ophalen

De methode getChatThreadClient retourneert een chatThreadClient voor een thread die al bestaat. Het kan worden gebruikt voor het uitvoeren van bewerkingen op de gemaakte thread: deelnemers toevoegen, bericht verzenden, enzovoort threadId is de unieke id van de bestaande chat-thread.

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

Voeg deze code toe in plaats van de opmerking <CREATE CHAT THREAD CLIENT> in client.js, vernieuw uw browsertabblad en controleer de console, waar u het volgende zou moeten zien:

Chat Thread client for threadId: <threadId>

Alle chatthreads weergeven

De listChatThreads-methode geeft een PagedAsyncIterableIterator van het type ChatThreadItem terug. Deze kan worden gebruikt voor het weergeven van alle chatthreads. Een iterator van [ChatThreadItem] is de reactie die wordt geretourneerd bij het opsommen van threads.

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

Een bericht verzenden naar een chat-thread

Gebruik de methode sendMessage om een bericht te verzenden naar een thread die wordt geïdentificeerd door threadId.

sendMessageRequest wordt gebruikt om de berichtaanvraag te beschrijven:

  • Gebruik content om de inhoud van het chat bericht te geven;

sendMessageOptions wordt gebruikt om de optionele parameters van de bewerking te beschrijven:

  • Gebruik senderDisplayName om de weergavenaam van de afzender op te geven;
  • Gebruik type deze indeling om het berichttype op te geven, zoals 'tekst' of 'html';
  • Gebruik eventueel metadata om elke andere gegevens die u samen met het bericht wilt verzenden op te nemen. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Als u bijvoorbeeld een bestandskoppeling in het bericht deelt, kunt u hasAttachment: true toevoegen in metagegevens, zodat de toepassing van de geadresseerde deze kan parseren en dienovereenkomstig kan weergeven.

SendChatMessageResult is het antwoord dat wordt geretourneerd van het verzenden van een bericht. Het bevat de unieke id van het bericht.

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

Voeg deze code toe in plaats van de opmerking <SEND MESSAGE TO A CHAT THREAD> in client.js, vernieuw uw browsertabblad en controleer de console.

Message sent!, message id:<number>

Chatberichten ontvangen van een chat-thread

Met realtime signalering kunt u zich abonneren om te luisteren naar nieuwe inkomende berichten en de huidige berichten dienovereenkomstig bij te werken in het geheugen. Azure Communication Services ondersteunt een lijst met gebeurtenissen waarop u zich kunt abonneren.

// open notifications channel
await chatClient.startRealtimeNotifications();
// subscribe to new notification
chatClient.on("chatMessageReceived", (e) => {
  console.log("Notification chatMessageReceived!");
  // your code here
});

Voeg deze code toe in plaats van de opmerking <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD> in client.js. Wanneer u uw browsertabblad vernieuwt, zou u in de console een bericht Notification chatMessageReceived moeten zien.

U kunt chatberichten ook ophalen door de methode listMessages op opgegeven intervallen te pollen.


const messages = chatThreadClient.listMessages();
for await (const message of messages) {
   // your code here
}

Voeg deze code toe in plaats van de opmerking <LIST MESSAGES IN A CHAT THREAD> in client.js. Vernieuw het tabblad, in de console vindt u de lijst met berichten die in deze chat-thread worden verzonden.

listMessages retourneert verschillende typen berichten die u kunt identificeren door de chatMessage.type.

Zie Berichttypen voor meer informatie.

Een gebruiker toevoegen als deelnemer aan de chatthread

Zodra u een chat-thread hebt gemaakt, kunt u gebruikers toevoegen en verwijderen. Door gebruikers toe te voegen, geeft u hen toegang om berichten naar de chatthread te verzenden en andere deelnemers toe te voegen/te verwijderen.

Voordat u de addParticipants methode aanroept, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker hebt verkregen. De gebruiker heeft dat toegangstoken nodig om de chatclient te initialiseren.

addParticipantsRequest beschrijft het aanvraagobject waarin participants de deelnemers worden vermeld die aan de chatthread moeten worden toegevoegd;

  • id, vereist, is de communicatie-id die moet worden toegevoegd aan de chat-thread.
  • displayName, optioneel, is de weergavenaam voor de threaddeelnemer.
  • shareHistoryTime, optioneel, is het tijdstip waarop de chatgeschiedenis wordt gedeeld met de deelnemer. Als u de geschiedenis wilt delen sinds het begin van de chat-thread, stelt u deze eigenschap in op een willekeurige datum die gelijk is aan of kleiner is dan de aanmaaktijd van de thread. Als u geen geschiedenis wilt delen voordat de deelnemer is toegevoegd, stelt u deze in op de huidige datum. Om een deel van de geschiedenis te delen, stelt u de datum naar keuze in.

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

await chatThreadClient.addParticipants(addParticipantsRequest);

Vervang NEW_PARTICIPANT_USER_ID door een nieuwe gebruikers-id Voeg deze code toe in plaats van de opmerking in <ADD NEW PARTICIPANT TO THREAD> client.js

Gebruikers in een chat-thread weergeven

const participants = chatThreadClient.listParticipants();
for await (const participant of participants) {
   // your code here
}

Voeg deze code toe in plaats van de opmerking <LIST PARTICIPANTS IN A THREAD> in client.js, vernieuw uw browsertabblad en controleer de console. U ziet informatie over gebruikers in een thread.

Gebruiker verwijderen uit een chat-thread

Net als bij het toevoegen van een deelnemer kunt u deelnemers verwijderen uit een chatgesprek. Als u wilt verwijderen, moet u de id's van de deelnemers bijhouden die u hebt toegevoegd.

Gebruik de methode removeParticipant, waarbij participant de communicatiegebruiker is die uit de thread moet worden verwijderd.


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

Vervang PARTICIPANT_ID door een gebruikers-id die in de vorige stap (<NEW_PARTICIPANT_USER_ID>) is gebruikt. Voeg deze code toe in plaats van de opmerking <REMOVE PARTICIPANT FROM THREAD> in client.js.

Abonneren op de verbindingsstatus van realtime meldingen

Abonnement op gebeurtenissen realTimeNotificationConnected en realTimeNotificationDisconnected stelt u in staat te weten wanneer de verbinding met de aanroepserver actief is.

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

Voorbeeldcode

Zoek de voltooide code voor dit artikel in het GitHub-voorbeeld Chat toevoegen aan uw toepassing.

Vereisten

Instellen

Een nieuwe Python-toepassing maken

Open uw terminal of opdrachtvenster, maak een nieuwe map voor uw app en ga naar het venster.

mkdir chat-quickstart && cd chat-quickstart

Gebruik een teksteditor om een bestand met de naam start-chat.py te maken in de hoofdmap van het project. Voeg de structuur voor het programma toe, inclusief eenvoudige verwerking van uitzonderingen. Voeg in de volgende secties alle broncode voor dit artikel toe aan dit bestand.

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)

SDK installeren

Gebruik de volgende opdracht om de SDK te installeren:


pip install azure-communication-chat

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Chat SDK voor Python.

Name Beschrijving
ChatClient Deze klasse is nodig voor de chatfunctionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen en te verwijderen.
ChatThreadClient Deze klasse is nodig voor de functionaliteit van de chat-thread. U verkrijgt een exemplaar via ChatClienten gebruikt deze om berichten te verzenden, te ontvangen, bij te werken en te verwijderen. U kunt het ook gebruiken om gebruikers toe te voegen, te verwijderen en te krijgen, en om typmeldingen en leesbevestigingen te verzenden.

Een chat-client maken

Als u een chatclient wilt maken, gebruikt u het Communication Services-eindpunt en het toegangstoken dat u hebt gegenereerd als onderdeel van de vereiste stappen.

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

Dit artikel heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, maar het wordt aanbevolen. Zie de sectie 'Chatarchitectuur' van de chatconceptarchitectuur voor chatconcepten >voor meer informatie.

Een chat-thread starten

De methode create_chat_thread gebruiken om een chat-thread te maken.

  • Gebruik topic dit om de thread een onderwerp te geven. U kunt het onderwerp bijwerken nadat de chat-thread is gemaakt met behulp van de update_thread functie.
  • Gebruik thread_participants dit om de ChatParticipant lijst weer te geven die moet worden toegevoegd aan de chat-thread. De ChatParticipant gebruikt het CommunicationUserIdentifier type als user.

CreateChatThreadResult is het resultaat dat wordt teruggegeven bij het aanmaken van een thread. U kunt deze gebruiken om de id van de chatdraad op te halen die is gemaakt. Dit id kan vervolgens worden gebruikt om een ChatThreadClient object op te halen met behulp van de get_chat_thread_client methode. U kunt ChatThreadClient gebruiken om andere chatbewerkingen aan deze chatdraad uit te voeren.

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)

Een chat-thread-client ophalen

De methode get_chat_thread_client retourneert een thread-client voor een thread die al bestaat. U kunt deze gebruiken om bewerkingen uit te voeren op de gemaakte thread. U kunt bijvoorbeeld deelnemers toevoegen en berichten verzenden. thread_id is de unieke id van de bestaande chat-thread.

U kunt ChatThreadClient andere chatbewerkingen uitvoeren voor deze chat-thread.

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

Alle chatthreads weergeven

De list_chat_threads methode retourneert een iterator van het type ChatThreadItem.

  • Gebruik start_time om het vroegste tijdstip op te geven voor het ophalen van chatthreads.
  • Gebruik results_per_page om het maximaal aantal chatthreads op te geven dat per pagina wordt geretourneerd.

Een iterator van [ChatThreadItem] is het antwoord dat wordt geretourneerd bij het weergeven van threads.

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)

Een bericht verzenden naar een chat-thread

Gebruik de send_message methode om een bericht te verzenden naar een chatthread die u hebt gemaakt, geïdentificeerd door thread_id.

  • Gebruik content om de inhoud van het chatbericht te geven.
  • Gebruik chat_message_type dit om het inhoudstype van het bericht op te geven. Mogelijke waarden zijn text en html. Als u geen waarde opgeeft, is de standaardwaarde text.
  • Gebruik sender_display_name om de weergavenaam van de afzender te geven.
  • Gebruik metadata om eventueel andere gegevens die u samen met het bericht wilt verzenden op te nemen. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Wanneer u bijvoorbeeld een bestandskoppeling in het bericht deelt, kunt u hasAttachment:true toevoegen aan metagegevens, zodat de toepassing van de geadresseerde deze kan parseren en dienovereenkomstig kan weergeven.

SendChatMessageResult is het antwoord dat wordt geretourneerd van het verzenden van een bericht. Het bevat een ID, wat de unieke ID van het bericht is.

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)

Chatberichten ontvangen van een chat-thread

U kunt chatberichten ophalen door de methode list_messages op opgegeven intervallen te pollen.

  • Gebruik results_per_page om het maximum aantal berichten op te geven dat per pagina moet worden geretourneerd.
  • Gebruik start_time voor het vroegste tijdstip op te geven om berichten op te halen.

Een iterator van [ChatMessage] is het antwoord dat wordt geretourneerd bij het oplijsten van berichten.

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 retourneert de nieuwste versie van het bericht, inclusief eventuele bewerkingen of verwijderingen die zijn gebeurd met het bericht met behulp van update_message en delete_message. Voor verwijderde berichten ChatMessage.deleted_on wordt een datetime waarde geretourneerd die aangeeft wanneer dat bericht is verwijderd. Voor bewerkte berichten ChatMessage.edited_on wordt een datetime waarde geretourneerd die aangeeft wanneer het bericht is bewerkt. U kunt de oorspronkelijke tijd van het maken van een bericht openen met behulp van ChatMessage.created_on, die kan worden gebruikt voor het rangschikken van de berichten.

list_messages retourneert verschillende typen berichten, die u identificeert op basis van de ChatMessage.type.

Zie Berichttypen voor meer informatie.

Leesbevestiging verzenden

U gebruikt de send_read_receipt methode om namens een gebruiker een gebeurtenis met leesbevestiging te posten naar een thread.

  • Hiermee message_id geeft u de id op van het meest recente bericht dat wordt gelezen door de huidige gebruiker.
content='hello world'

send_message_result = chat_thread_client.send_message(content)
chat_thread_client.send_read_receipt(message_id=send_message_result.id)

Een gebruiker toevoegen als deelnemer aan de chatthread

Wanneer u een chat-thread maakt, kunt u er vervolgens gebruikers aan toevoegen en verwijderen. Door gebruikers toe te voegen, geeft u hen toegang om berichten naar de chatthread te verzenden en andere deelnemers toe te voegen of te verwijderen. Voordat u de add_participants methode aanroept, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker hebt verkregen. De gebruiker heeft dat toegangstoken nodig om de chatclient te initialiseren.

U kunt een of meer gebruikers toevoegen aan de chatthread met behulp van de add_participants methode, als er een nieuw toegangstoken en een nieuwe identiteit beschikbaar is voor alle gebruikers.

Er wordt een list(tuple(ChatParticipant, CommunicationError)) geretourneerd. Zodra de deelnemer succesvol is toegevoegd, wordt er een lege lijst verwacht. Als er een fout optreedt tijdens het toevoegen van een deelnemer, wordt de lijst gevuld met de mislukte deelnemers en de fout die is opgetreden.

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)

Gespreksdeelnemers weergeven in een chatgesprek

Net als bij het toevoegen van een deelnemer kunt u ook deelnemers uit een thread vermelden.

Gebruik list_participants om de deelnemers aan de thread op te halen. Beide van de volgende opdrachten zijn optioneel:

  • Gebruik results_per_page om het maximum aantal deelnemers op te geven dat per pagina moet worden geretourneerd.
  • Gebruik skip om deelnemers tot een opgegeven positie in de respons over te slaan.

Een iterator van [ChatParticipant] is het antwoord dat wordt geretourneerd bij het opvragen van deelnemers.

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)

De code uitvoeren

Voer de toepassing uit vanuit uw toepassingsmap met de opdracht python.

python start-chat.py

Voorbeeldcode

Zoek de voltooide code voor dit artikel in het GitHub-voorbeeld Chat toevoegen aan uw toepassing.

Vereisten

Inrichten

Een nieuwe Java-toepassing maken

Open uw terminal- of opdrachtvenster en navigeer naar de map waarin u uw Java-toepassing wilt maken. Voer de volgende opdracht uit om het Java-project te genereren vanuit de maven-archetype-quickstart-sjabloon.

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

Het generate doel is een map met dezelfde naam als de artifactIdmap te maken. Onder deze map bevat de src/main/java directory projectbroncode, de src/test/java map de testbron en het pom.xml bestand is het Project Object Model van het project of POM van het project.

Het POM-bestand van uw toepassing bijwerken voor het gebruik van Java 8 of hoger:

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

Voeg de pakketverwijzingen voor de Chat-SDK toe

In uw POM-bestand verwijzen we naar het pakket azure-communication-chat met de chat-API's:

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

Voor verificatie moet uw client verwijzen naar het pakket azure-communication-common.

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

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Chat SDK voor Java.

Name Beschrijving
ChatClient Deze klasse is vereist voor de chat-functionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen en te verwijderen.
ChatAsyncClient Deze klasse is vereist voor de asynchrone chat-functionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen en te verwijderen.
ChatThreadClient Deze klasse is vereist voor de functionaliteit van de chat-thread. U verkrijgt een instantie via de ChatClient en gebruikt deze om berichten te verzenden, te ontvangen, bij te werken of te verwijderen, gebruikers toe te voegen, te verwijderen of op te halen, getypte meldingen te verzenden en bevestigingen te lezen.
ChatThreadAsyncClient Deze klasse is vereist voor de functionaliteit van de asynchrone chat-thread. U verkrijgt een instantie via de ChatAsyncClient en gebruikt deze om berichten te verzenden/ontvangen/bijwerken/verwijderen, gebruikers toe te voegen/te verwijderen of te verzenden, getypte meldingen te verzenden en bevestigingen te lezen.

Een chat-client maken

Als u een chatclient wilt maken, gebruikt u het communicatieservice-eindpunt en het toegangstoken dat is gegenereerd als onderdeel van de vereiste stappen. Met toegangstokens voor gebruikers kunt u clienttoepassingen maken die zich rechtstreeks verifiëren bij Azure Communication Services. Zodra u deze tokens op uw server hebt gegenereerd, geeft u ze terug op een clientapparaat. U moet de CommunicationTokenCredential-klasse van de Common SDK gebruiken om het token door te geven aan uw chatclient.

Meer informatie over chatarchitectuur

Bij het toevoegen van de importverklaringen moet u ervoor zorgen dat u alleen imports toevoegt vanuit de com.azure.communication.chat en com.azure.communication.chat.models naamruimten, en niet vanuit de com.azure.communication.chat.implementation naamruimte. In het bestand App.java dat is gegenereerd via Maven, kunt u de volgende code gebruiken om te beginnen met:

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

Een chat-thread starten

De methode createChatThread gebruiken om een chat-thread te maken. createChatThreadOptions wordt gebruikt om de thread-aanvraag te beschrijven.

  • Gebruik de topic parameter van de constructor om een onderwerp aan deze chat te geven; Het onderwerp kan worden bijgewerkt nadat de chat-thread is gemaakt met behulp van de UpdateThread functie.
  • Gebruik participants dit om de threaddeelnemers weer te geven die aan de thread moeten worden toegevoegd. ChatParticipant neemt de gebruiker die u hebt gemaakt in het token voor gebruikerstoegang.

CreateChatThreadResult is het antwoord dat wordt teruggegeven door het maken van een chatsessie. Het bevat een getChatThread() methode die het ChatThread object retourneert dat kan worden gebruikt om de threadclient op te halen waaruit u de ChatThreadClient bewerkingen voor het uitvoeren van bewerkingen op de gemaakte thread kunt ophalen: deelnemers toevoegen, bericht verzenden, enzovoort. Het ChatThread object bevat ook de getId() methode, waarmee de unieke id van de thread wordt opgehaald.

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

Chatgesprekken weergeven

Gebruik de listChatThreads methode om een lijst met bestaande chatthreads op te halen.

PagedIterable<ChatThreadItem> chatThreads = chatClient.listChatThreads();

chatThreads.forEach(chatThread -> {
    System.out.printf("ChatThread id is %s.\n", chatThread.getId());
});

Een chat-thread-client ophalen

De methode getChatThreadClient retourneert een thread-client voor een thread die al bestaat. Het kan worden gebruikt voor het uitvoeren van bewerkingen op de gemaakte thread: deelnemers toevoegen, bericht verzenden, enzovoort. chatThreadId is de unieke id van de bestaande chat-thread.

ChatThreadClient chatThreadClient = chatClient.getChatThreadClient(chatThreadId);

Een bericht verzenden naar een chat-thread

Gebruik de sendMessage methode om een bericht te verzenden naar de thread die u hebt gemaakt, geïdentificeerd door chatThreadId. sendChatMessageOptions wordt gebruikt om de aanvraag voor het chatbericht te beschrijven.

  • Gebruik content om de inhoud van het chatbericht te geven.
  • Gebruik type dit om het inhoudstype van het chatbericht op te geven, TEXT of HTML.
  • Gebruik senderDisplayName om de weergavenaam van de afzender te geven.
  • Gebruik metadata optioneel om eventuele andere gegevens mee te sturen met het bericht. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Wanneer u bijvoorbeeld een bestandskoppeling in het bericht deelt, wilt u misschien metagegevens toevoegen hasAttachment:true , zodat de toepassing van de geadresseerde deze kan parseren en dienovereenkomstig kan weergeven.

Het antwoord sendChatMessageResult bevat een id, dit is de unieke ID van het bericht.

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

Chatberichten ontvangen van een chat-thread

U kunt chatberichten ophalen door de methode listMessages op de chat-thread-client op bepaalde intervallen te pollen.

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

listMessages retourneert de meest recente versie van het bericht, inclusief eventuele bewerkingen of verwijderingen die zijn opgetreden in het bericht met .editMessage() en .deleteMessage(). Voor verwijderde berichten retourneert chatMessage.getDeletedOn() een datum/tijd-waarde die aangeeft wanneer dat bericht is verwijderd. Voor bewerkte berichten retourneert chatMessage.getEditedOn() een datum/tijd die aangeeft wanneer het bericht is bewerkt. De oorspronkelijke tijd van het maken van het bericht kan worden geopend met chatMessage.getCreatedOn() en kan worden gebruikt voor het sorteren van de berichten.

Lees hier meer over berichttypen: Berichttypen.

Leesbevestiging verzenden

Gebruik de sendReadReceipt methode om namens een gebruiker een evenement voor leesbevestiging te plaatsen in een chatthread. chatMessageId is de unieke id van het chatbericht dat is gelezen.

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

Chatdeelnemers vermelden

Gebruik listParticipants om een verzameling met paginering op te halen die de deelnemers van de chatdraad bevat, geïdentificeerd door chatThreadId.

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

Een gebruiker toevoegen als deelnemer aan de chatthread

Zodra u een chat-thread hebt gemaakt, kunt u gebruikers toevoegen en verwijderen. Door gebruikers toe te voegen, geeft u hen toegang om berichten naar de chatthread te verzenden en andere deelnemers toe te voegen/te verwijderen. U moet beginnen met het ophalen van een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker. Voordat u een methode aanroept addParticipants , moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker hebt verkregen. De gebruiker heeft dat toegangstoken nodig om de chatclient te initialiseren.

Gebruik de addParticipants methode om deelnemers toe te voegen aan de thread.

  • communicationIdentifier, vereist, is de CommunicationIdentifier die u hebt gemaakt met behulp van de CommunicationIdentityClient in het token voor gebruikerstoegang.
  • displayName, optioneel, is de weergavenaam voor de threaddeelnemer.
  • shareHistoryTime, optioneel, is het tijdstip waarop de chatgeschiedenis wordt gedeeld met de deelnemer. Als u de geschiedenis wilt delen sinds het begin van de chat-thread, stelt u deze eigenschap in op een willekeurige datum die gelijk is aan of kleiner is dan de aanmaaktijd van de thread. Als u geen geschiedenis wilt delen voordat de deelnemer is toegevoegd, stelt u deze in op de huidige datum. Als u gedeeltelijke geschiedenis wilt delen, stelt u deze in op de vereiste datum.
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);

De code uitvoeren

Navigeer naar de map met het pom.xml bestand en compileer het project met behulp van de volgende mvn opdracht.

mvn compile

Bouw vervolgens het pakket.

mvn package

Voer de volgende mvn-opdracht uit om de app uit te voeren.

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

Voorbeeldcode

Zoek de voltooide code voor dit artikel in het GitHub-voorbeeld Chat toevoegen aan uw toepassing.

Vereisten

  • Maak een Azure-account met een actief abonnement. Zie Gratis een account maken voor meer informatie.

  • Installeer Android Studio, we gebruiken Android Studio om een Android-toepassing te maken en afhankelijkheden te installeren.

  • Maak een Azure Communication Services-resource. Zie Een Azure Communication Services-resource maken voor meer informatie. U moet uw resource-eindpunt en verbindingsreeks vastleggen voor dit artikel.

  • Maak twee Communication Services-gebruikers en geef ze een token voor gebruikerstoegang uit. Zorg ervoor dat u het bereik instelt op chatten en noteer de tokentekenreeks en de user_id tekenreeks. In dit artikel maken we een thread met een eerste deelnemer en voegen we vervolgens een tweede deelnemer toe aan de thread. U kunt ook de Azure CLI gebruiken en de volgende opdracht uitvoeren met uw verbindingsreeks om een gebruiker en een toegangstoken te maken.

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

    Zie Azure CLI gebruiken voor het maken en beheren van toegangstokens voor meer informatie.

Inrichten

Een nieuwe Android-toepassing maken

  1. Open Android Studio en selecteer Create a new project.
  2. Selecteer Empty Activity in het volgende venster de projectsjabloon.
  3. Voer bij het kiezen van opties de ChatQuickstart naam van het project in.
  4. Klik op volgende en kies de map waarin u het project wilt maken.

De bibliotheken installeren

We gebruiken Gradle om de benodigde Communication Services-afhankelijkheden te installeren. Navigeer met de opdrachtregel naar de hoofdmap van het ChatQuickstart project. Open het bestand build.gradle van de app en voeg de volgende afhankelijkheden toe aan het ChatQuickstart doel:

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

Voor de meest recente versienummers, zie https://search.maven.org/artifact/com.azure.android/azure-communication-common en https://search.maven.org/artifact/com.azure.android/azure-communication-chat.

Metabestanden uitsluiten in verpakkingsopties in root 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")
    }
}

(Alternatief) Bibliotheken installeren via Maven

Als u de bibliotheek wilt importeren in uw project met behulp van het Maven-buildsysteem , voegt u deze toe aan de sectie van het dependencies bestand van uw app pom.xml , waarbij u de artefact-id en de versie opgeeft die u wilt gebruiken:

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

Een Azure-functie instellen

Zie Azure Function-integratie voor meer informatie. Het is raadzaam om te integreren met Azure Function om hardcoderingstoepassingsparameters te voorkomen.

Toepassingsconstanten instellen

Maak een klasse ApplicationConstants waarin alle toepassingsconstanten worden opgeslagen:

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

De tijdelijke aanduidingen instellen

Open het bestand MainActivity.javaen bewerk het. In dit artikel voegen we onze code toe aan MainActivityen bekijken we de uitvoer in de console. Dit artikel heeft geen betrekking op het bouwen van een gebruikersinterface. Importeer boven aan het bestand de Azure Communication Common, Azure Communication Chaten andere systeembibliotheken:

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;

Kopieer de volgende code naar klasse MainActivity in bestand 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());
        }
    }

Toepassingsparameters initialiseren

Notitie

Initialiseren van ApplicationConstants moet worden toegevoegd aan MainActivity.java als aan een van de volgende condities wordt voldaan: 1. De functie voor pushmeldingen is NIET ingeschakeld. 2. De versie voor de Azure Communication Chat-bibliotheek voor Android is < 2.0.0. Raadpleeg anders stap 11 in Android-pushmeldingen. Raadpleeg de voorbeeld-APP van de SDK-versie die u gebruikt voor referentie.

ACS_ENDPOINT, FIRST_USER_ID en FIRST_USER_ACCESS_TOKEN worden geretourneerd door het aanroepen van de Azure-functie. Zie Azure Function-integratie voor meer informatie. We gebruiken het antwoord van het aanroepen van Azure Function om de lijst met parameters te initialiseren:

  • ACS_ENDPOINT: het eindpunt van uw Communication Services-resource.
  • FIRST_USER_ID en SECOND_USER_ID: geldige Communication Services-gebruikers-id's die zijn gegenereerd door uw Communication Services-resource.
  • FIRST_USER_ACCESS_TOKEN: het Communication Services-toegangstoken voor <FIRST_USER_ID>.

Codeblok voor het initialiseren van toepassingsparameters door Azure Function aan te roepen:

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

Een chat-client maken

Vervang de opmerking <CREATE A CHAT CLIENT> door de volgende code (plaats de importinstructies boven aan het bestand):

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

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Chat SDK voor JavaScript.

Name Beschrijving
ChatClient/ChatAsyncClient Deze klasse is vereist voor de chat-functionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, te ophalen, te verwijderen en u te abonneren op chat-gebeurtenissen.
ChatThreadClient/ChatThreadAsyncClient Deze klasse is vereist voor de functionaliteit van de chat-thread. U verkrijgt een instantie via de ChatClient en gebruikt deze om berichten te verzenden, te ontvangen, bij te werken of te verwijderen, gebruikers toe te voegen, te verwijderen of op te halen, getypte meldingen te verzenden en bevestigingen te lezen.

Een chat-thread starten

Gebruik onze ChatAsyncClient om een nieuwe thread te maken met een initiële gebruiker.

Vervang de opmerking <CREATE A CHAT THREAD> door de volgende code:

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

Een chat-thread-client ophalen

Nu we een chat-thread hebben gemaakt, moeten we een ChatThreadAsyncClient verkrijgen om bewerkingen in de thread uit te voeren. Vervang de opmerking <CREATE A CHAT THREAD CLIENT> door de volgende code:

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

Een bericht verzenden naar een chat-thread

Verzend nu een bericht naar de chatthread.

Vervang de opmerking <SEND A MESSAGE> door de volgende code:

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

Chatberichten ontvangen van een chat-thread

Realtime meldingen

Met realtime signalering kunt u zich abonneren op nieuwe inkomende berichten en de huidige berichten in het geheugen dienovereenkomstig bijwerken. Azure Communication Services ondersteunt een lijst met gebeurtenissen waarop u zich kunt abonneren.

Vervang de opmerking <RECEIVE CHAT MESSAGES> door de volgende code (plaats de importinstructies boven aan het bestand):


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

Belangrijk

Bekend probleem: wanneer u Android Chat en Calling SDK samen in dezelfde toepassing gebruikt, werkt de functie Chat SDK realtime meldingen niet. Mogelijk krijgt u een probleem met het oplossen van afhankelijkheid. U kunt de functie voor realtime meldingen uitschakelen door de volgende afhankelijkheidsgegevens toe te voegen aan het bestand van build.gradle de app en in plaats daarvan de GetMessages-API te peilen om binnenkomende berichten weer te geven aan gebruikers.

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'

Houd er rekening mee dat als de toepassing probeert contact op te nemen met de meldings-API met behulp van chatAsyncClient.startRealtimeNotifications() of chatAsyncClient.addEventHandler(), er een runtimefout wordt gegenereerd.

Pushmeldingen

Zie Android-pushmeldingen voor meer informatie.

Een gebruiker toevoegen als deelnemer aan de chatthread

Vervang de opmerking <ADD A USER> door de volgende code:

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

Gebruikers weergeven in een thread

Vervang de <LIST USERS> opmerking door de volgende code (plaats de importinstructies boven aan het bestand):

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

Gebruiker verwijderen uit een chat-thread

Verwijder de tweede gebruiker uit de thread.

Vervang de opmerking <REMOVE A USER> door de volgende code:

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

Een typmelding verzenden

Vervang de opmerking <SEND A TYPING NOTIFICATION> door de volgende code:

chatThreadAsyncClient.sendTypingNotification().get();

Een leesbevestiging verzenden

We verzenden leesbevestiging voor het eerder verzonden bericht.

Vervang de opmerking <SEND A READ RECEIPT> door de volgende code:

chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();

Leesbevestigingen weergeven

Vervang de opmerking <READ RECEIPTS> door de volgende code:

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

De code uitvoeren

Druk in Android Studio op de knop Uitvoeren om het project te bouwen en uit te voeren. In de console kunt u de uitvoer van de code en de loggeruitvoer van de ChatClient bekijken.

Voorbeeldcode

Zoek de voltooide code voor dit artikel in het GitHub-voorbeeld Chat toevoegen aan uw toepassing.

Vereisten

Inrichten

Een nieuwe C#-toepassing maken

Gebruik in een consolevenster (zoals cmd, PowerShell of Bash) de opdracht dotnet new om een nieuwe console-app te maken met de naam ChatQuickstart. Met deze opdracht maakt u een eenvoudig C#-project Hallo wereld met één bronbestand: Program.cs.

dotnet new console -o ChatQuickstart

Wijzig uw map in de zojuist gemaakte app-map en gebruik de opdracht dotnet build om uw toepassing te compileren.

cd ChatQuickstart
dotnet build

Het pakket installeren

De Azure Communication Chat SDK voor .NET installeren

dotnet add package Azure.Communication.Chat

Objectmodel

De volgende klassen verwerken enkele van de belangrijkste functies van de Azure Communication Services Chat SDK voor C#.

Name Beschrijving
ChatClient Deze klasse is vereist voor de chat-functionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen en te verwijderen.
ChatThreadClient Deze klasse is vereist voor de functionaliteit van de chat-thread. U verkrijgt een exemplaar via de ChatClient en gebruikt deze om berichten te verzenden/ontvangen/bij te werken/te verwijderen, deelnemers toe te voegen/te verwijderen/te verwijderen, typmeldingen en leesbevestigingen te verzenden.

Een chat-client maken

Als u een chatclient wilt maken, gebruikt u uw Communication Services-eindpunt en het toegangstoken dat is gegenereerd als onderdeel van de vereiste stappen. U moet de CommunicationIdentityClient klasse van de Identity SDK gebruiken om een gebruiker te maken en een token uit te geven dat moet worden doorgegeven aan uw chatclient.

Meer informatie over toegangstokens voor gebruikers.

Dit artikel heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, hoewel dit wordt aanbevolen. Zie Chatarchitectuur voor meer informatie.

Kopieer de volgende codefragmenten en plak deze in het Program.cs bronbestand.

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

Een chat-thread starten

Gebruik de createChatThread methode op de chatClient om een chat-thread te maken

  • Gebruik topic dit om een onderwerp aan deze chat te geven. U kunt het onderwerp bijwerken nadat u de chatthread hebt gemaakt met behulp van de UpdateTopic functie.
  • Gebruik de eigenschap participants om een lijst met ChatParticipant-objecten door te geven om aan de chat-thread toe te voegen. Het ChatParticipant-object wordt geïnitialiseerd met een CommunicationIdentifier-object. CommunicationIdentifier kan van het type CommunicationUserIdentifierzijn, MicrosoftTeamsUserIdentifierof PhoneNumberIdentifier. Als u bijvoorbeeld een CommunicationIdentifier object wilt ophalen, moet u een toegangs-id doorgeven die u hebt gemaakt door de instructies te volgen voor het maken van een gebruiker

Het antwoordobject van de createChatThread methode bevat de chatThread details. Om te communiceren met de bewerkingen in de chatthread, zoals het toevoegen van deelnemers, het verzenden van een bericht, het verwijderen van een bericht, enzovoort, moet een chatThreadClient clientexemplaar worden geïnstantieerd met behulp van de GetChatThreadClient methode op de ChatClient client.

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;

Een chat-thread-client ophalen

De methode GetChatThreadClient retourneert een thread-client voor een thread die al bestaat. U kunt deze gebruiken om bewerkingen uit te voeren op de gemaakte thread: leden toevoegen, bericht verzenden, enzovoort. threadId is de unieke id van de bestaande chat-thread.

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

Alle chatthreads weergeven

Gebruik GetChatThreads deze functie om alle chatthreads op te halen waarvan de gebruiker deel uitmaakt.

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

Een bericht verzenden naar een chat-thread

Gebruik SendMessage dit om een bericht naar een thread te verzenden.

  • Gebruik content om de inhoud van het bericht op te geven. Verplicht.
  • Gebruik type dit voor het inhoudstype van het bericht, zoals 'Tekst' of 'HTML'. Als dit niet is opgegeven, wordt 'Tekst' ingesteld.
  • Gebruik senderDisplayName om de weergavenaam van de afzender te geven. Als dit niet is opgegeven, wordt een lege tekenreeks ingesteld.
  • Optioneel: gebruik metadata deze optie om andere gegevens op te nemen die u samen met het bericht wilt verzenden. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Wanneer u bijvoorbeeld een bestandskoppeling in het bericht deelt, kunt u hasAttachment:true toevoegen aan metagegevens, zodat de toepassing van de geadresseerde deze kan parseren en dienovereenkomstig kan weergeven.
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;

Chatberichten ontvangen van een chat-thread

U kunt chatberichten ophalen door de methode GetMessages op de chat-thread-client op bepaalde intervallen te pollen.

AsyncPageable<ChatMessage> allMessages = chatThreadClient.GetMessagesAsync();
await foreach (ChatMessage message in allMessages)
{
    Console.WriteLine($"{message.Id}:{message.Content.Message}");
}

GetMessages maakt gebruik van een optionele DateTimeOffset-parameter. Als deze offset is opgegeven, ontvangt u berichten die erna zijn ontvangen, bijgewerkt of verwijderd. Berichten die zijn ontvangen vóór de offsettijd, maar daarna bewerkt of verwijderd, worden ook geretourneerd.

GetMessages retourneert de meest recente versie van het bericht, inclusief eventuele bewerkingen of verwijderingen die zijn opgetreden in het bericht met UpdateMessage en DeleteMessage. Voor verwijderde berichten retourneert chatMessage.DeletedOn een datum/tijd-waarde die aangeeft wanneer dat bericht is verwijderd. Voor bewerkte berichten retourneert chatMessage.EditedOn een datum/tijd die aangeeft wanneer het bericht is bewerkt. De oorspronkelijke tijd van het maken van het bericht kan worden benaderd met chatMessage.CreatedOn en kan worden gebruikt voor het sorteren van de berichten.

GetMessages retourneert verschillende typen berichten. U kunt het type identificeren aan de hand van chatMessage.Type. De typen zijn:

  • Text: Normaal chatbericht verzonden door een threadlid.

  • Html: Een opgemaakt tekstbericht. Communication Services-gebruikers kunnen momenteel geen RichText-berichten verzenden. Dit berichttype wordt ondersteund voor berichten die worden verzonden van Teams-gebruikers naar Communication Services-gebruikers in Teams Interop-scenario's.

  • TopicUpdated: Systeembericht dat aangeeft dat het onderwerp wordt bijgewerkt. (alleen-lezen)

  • ParticipantAdded: Systeembericht dat aangeeft dat een of meer deelnemers worden toegevoegd aan de chat-thread (gelezen).

  • ParticipantRemoved: Systeembericht dat aangeeft dat een deelnemer wordt verwijderd uit de chat-thread.

Zie Berichttypen voor meer informatie.

Een gebruiker toevoegen als deelnemer aan de chatthread

Zodra u een thread hebt gemaakt, kunt u gebruikers toevoegen en verwijderen. Door gebruikers toe te voegen, geeft u hen toegang om berichten naar de thread te kunnen verzenden en andere deelnemers toe te voegen/te verwijderen. Voordat u aanroept AddParticipants, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker verkrijgt. De gebruiker heeft dat toegangstoken nodig om de chatclient te initialiseren.

Hiermee AddParticipants voegt u een of meer deelnemers toe aan de chatthread. Hieronder ziet u de ondersteunde kenmerken voor elke threaddeelnemer:

  • communicationUser, vereist, is de identiteit van de threaddeelnemer.
  • displayName, optioneel, is de weergavenaam voor de threaddeelnemer.
  • shareHistoryTime, optioneel, tijd vanaf waaruit de chatgeschiedenis wordt gedeeld met de deelnemer.
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);

Threaddeelnemers ophalen

Gebruik GetParticipants om de deelnemers aan de chatthread op te halen.

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

Leesbevestiging verzenden

Gebruik SendReadReceipt dit om andere deelnemers op de hoogte te stellen dat de gebruiker het bericht heeft gelezen.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

De code uitvoeren

Voer de toepassing uit vanuit uw toepassingsmap met de opdracht dotnet run.

dotnet run

Voorbeeldcode

Zoek de voltooide code voor dit artikel in het GitHub-voorbeeld Chat toevoegen aan uw toepassing.

Vereisten

  • Maak een Azure-account met een actief abonnement. Zie Gratis een account maken voor meer informatie.

  • Installeer Xcode en CocoaPods. U gebruikt Xcode om een iOS-toepassing voor dit artikel te maken en CocoaPods om afhankelijkheden te installeren.

  • Maak een Azure Communication Services-resource. Zie de quickstart: Communication Services-resources maken en beheren voor meer informatie. U moet uw resource-eindpunt en verbindingsreeks vastleggen voor dit artikel.

  • Maak twee gebruikers in Azure Communication Services en geef ze een token voor gebruikerstoegang. Zorg ervoor dat u het bereik instelt op chatten en noteer de tokentekenreeks en de user_id tekenreeks. In dit artikel maakt u een thread met een eerste deelnemer en voegt u vervolgens een tweede deelnemer toe aan de thread. U kunt ook de Azure CLI gebruiken en de volgende opdracht uitvoeren met uw verbindingsreeks om een gebruiker en een toegangstoken te maken.

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

    Zie Azure CLI gebruiken voor het maken en beheren van toegangstokens voor meer informatie.

Inrichten

Een nieuwe iOS-toepassing maken

Open Xcode en selecteer Een nieuw Xcode-project maken. Selecteer vervolgens iOS als het platform en de app voor de sjabloon.

Voer ChatQuickstart in als projectnaam. Selecteer vervolgens Storyboard als de interface, UIKit App Delegate als de levenscyclus en Swift als taal.

Selecteer Volgende en kies de map waarin u het project wilt maken.

De bibliotheken installeren

Gebruik CocoaPods om de benodigde Communication Services-afhankelijkheden te installeren.

Ga in de terminal naar de hoofdmap van het ChatQuickstart iOS-project. Maak een Podfile met de volgende opdracht: pod init.

Open het Podfile en voeg de volgende afhankelijkheden toe aan het ChatQuickstart doel:

pod 'AzureCommunicationChat', '~> 1.3.6'

Installeer de afhankelijkheden met de volgende opdracht: pod install Hiermee maakt u ook een Xcode-werkruimte.

Nadat het project is uitgevoerd pod install, opent u het project opnieuw in Xcode door het zojuist gemaakte .xcworkspaceproject te selecteren.

De plaatsaanduidingen instellen

Open de werkruimte ChatQuickstart.xcworkspace in Xcode en open ViewController.swift.

In dit artikel voegt u uw code toe aan viewControlleren bekijkt u de uitvoer in de Xcode-console. Dit artikel heeft geen betrekking op het bouwen van een gebruikersinterface in iOS.

Importeer bovenaan viewController.swift de AzureCommunication en AzureCommunicationChat bibliotheken.

import AzureCommunicationCommon
import AzureCommunicationChat

Kopieer de volgende code naar de viewDidLoad() methode van 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)")
            }
        }
    }

Voor demonstratiedoeleinden gebruiken we een semaphore om uw code te synchroniseren. In de volgende stappen vervangt u de tijdelijke aanduidingen door voorbeeldcode met behulp van de Azure Communication Services Chat-bibliotheek.

Een chat-client maken

Als u een chatclient wilt maken, gebruikt u uw Communication Services-eindpunt en het toegangstoken dat is gegenereerd als onderdeel van de vereiste stappen.

Meer informatie over toegangstokens voor gebruikers.

Dit artikel heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, maar we raden het aan. Meer informatie over chatarchitectuur

Vervang de opmerking <CREATE A CHAT CLIENT> door het volgende codefragment:

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
)

Vervang <ACS_RESOURCE_ENDPOINT> door het eindpunt van uw Azure Communication Services-resource. Vervang <ACCESS_TOKEN> door een geldig Communication Services-toegangstoken.

Objectmodel

De volgende klassen en interfaces verwerken enkele van de belangrijkste functies van de Azure Communication Services Chat SDK voor iOS.

Name Beschrijving
ChatClient Deze klasse is nodig voor de chatfunctionaliteit. U instantieert deze met uw abonnementsgegevens en gebruikt deze om threads te maken, te ophalen, te verwijderen en u te abonneren op chat-gebeurtenissen.
ChatThreadClient Deze klasse is nodig voor de functionaliteit van de chat-thread. U verkrijgt een exemplaar via ChatClienten gebruikt deze om berichten te verzenden, te ontvangen, bij te werken en te verwijderen. U kunt het ook gebruiken om gebruikers toe te voegen, te verwijderen en te krijgen, typmeldingen en leesbevestigingen te verzenden.

Een chat-thread starten

CreateChatThreadResult is de respons die wordt geretourneerd na het aanmaken van een chatthread. Het bevat een chatThread eigenschap die het ChatThreadProperties object is. Dit object bevat de threadId, die kan worden gebruikt om een ChatThreadClient te verkrijgen voor het uitvoeren van bewerkingen op de gemaakte thread: deelnemers toevoegen, bericht verzenden, enzovoort.

Vervang de opmerking <CREATE A CHAT THREAD> door het volgende codefragment:

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

Vervang <USER_ID> door een geldige gebruikers-id van Communication Services.

U gebruikt hier een semafoor om te wachten op de afrondingshandler voordat u verdergaat. Gebruik in latere stappen het threadId antwoord dat aan de voltooiingshandler is gegeven.

Alle chatthreads weergeven

Nadat u een chat-thread hebt gemaakt, kunnen we alle chatthreads vermelden door de listChatThreads methode aan te roepen.ChatClient Vervang de opmerking <LIST ALL CHAT THREADS> door de volgende code:

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

Een chat-thread-client ophalen

De methode createClient retourneert een ChatThreadClient voor een thread die al bestaat. Het kan worden gebruikt voor het uitvoeren van bewerkingen op de gemaakte thread: deelnemers toevoegen, bericht verzenden, enzovoort threadId is de unieke id van de bestaande chat-thread.

Vervang de opmerking <GET A CHAT THREAD CLIENT> door de volgende code:

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

Een bericht verzenden naar een chat-thread

Gebruik de send methode om een bericht te verzenden naar een thread die wordt geïdentificeerd door threadId.

SendChatMessageRequest wordt gebruikt om de berichtaanvraag te beschrijven:

  • Gebruiken content om de inhoud van het chatbericht op te geven
  • Gebruiken senderDisplayName om de weergavenaam van de afzender op te geven
  • Gebruiken type om het berichttype op te geven, zoals 'tekst' of 'html'
  • Gebruik optioneel metadata om eventuele andere gegevens toe te voegen die u samen met het bericht wilt verzenden. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Wanneer u bijvoorbeeld een bestandskoppeling in het bericht deelt, kunt u hasAttachment:true toevoegen aan metagegevens, zodat de toepassing van de geadresseerde deze kan parseren en dienovereenkomstig kan weergeven.

SendChatMessageResult is het antwoord dat wordt geretourneerd van het verzenden van een bericht. Het bevat een ID, de unieke ID van het bericht.

Vervang de opmerking <SEND A MESSAGE> door het volgende codefragment:

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

Een leesbevestiging verzenden

Gebruik de sendReadReceipt methode om namens een gebruiker een leesbevestiging te plaatsen in een chatgesprek. messageId is de unieke id van het chatbericht dat is gelezen.

Vervang de opmerking <SEND A READ RECEIPT> door de volgende code:

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

Chatberichten ontvangen van een chat-thread

Met realtime signalering kunt u zich abonneren om te luisteren naar nieuwe inkomende berichten en de huidige berichten dienovereenkomstig bij te werken in het geheugen. Azure Communication Services ondersteunt een lijst met gebeurtenissen waarop u zich kunt abonneren.

Vervang de opmerking <RECEIVE MESSAGES> door de volgende code. Zet meldingen aan en probeer vervolgens nieuwe berichten te verzenden om de ChatMessageReceivedEvents te zien.

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

U kunt chatberichten ook ophalen door de methode listMessages op opgegeven intervallen te pollen. Zie het volgende codefragment voor 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()

Een gebruiker toevoegen als deelnemer aan de chatthread

Zodra u een thread hebt gemaakt, kunt u gebruikers toevoegen en verwijderen. Door gebruikers toe te voegen, geeft u hen toegang om berichten naar de thread te kunnen verzenden en andere deelnemers toe te voegen/te verwijderen. Voordat u aanroept add, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit voor die gebruiker hebt verkregen. De gebruiker heeft het toegangstoken nodig om de chatclient te initialiseren.

Gebruik de add-methode van ChatThreadClient om een of meer deelnemers toe te voegen aan de chatdraad. Hieronder ziet u de ondersteunde kenmerken voor elke threaddeelnemer:

  • id, vereist, is de identiteit van de threaddeelnemer.
  • displayName, optioneel, is de weergavenaam voor de threaddeelnemer.
  • shareHistoryTime, optioneel, tijd vanaf waaruit de chatgeschiedenis wordt gedeeld met de deelnemer.

Vervang de opmerking <ADD A USER> door de volgende code:

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

Vervang <USER_ID> door de Communication Services-gebruikers-id van de gebruiker die moet worden toegevoegd.

Gebruikers weergeven in een thread

Gebruik de listParticipants methode om alle deelnemers op te halen voor een bepaalde chat-thread.

Vervang de opmerking <LIST USERS> door de volgende code:

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

Pushmeldingen

Via pushmeldingen worden clients op de hoogte gesteld van binnenkomende berichten in een chat-thread in situaties waarin de mobiele app niet op de voorgrond wordt uitgevoerd.

Momenteel wordt het verzenden van chatpushmeldingen met Notification Hub ondersteund voor IOS SDK in versie 1.3.0.

Zie Pushmeldingen inschakelen in uw chat-app voor meer informatie.

De code uitvoeren

Druk in Xcode op de knop Uitvoeren om het project te bouwen en uit te voeren. In de console kunt u de uitvoer van de code en de loggeruitvoer van de ChatClient bekijken.

Opmerking: ingesteld Build Settings > Build Options > Enable Bitcode op No. Momenteel biedt de AzureCommunicationChat SDK voor iOS geen ondersteuning voor het inschakelen van bitcode. Het volgende GitHub-probleem houdt het probleem bij.

Voorbeeldcode

Zoek de voltooide code voor dit artikel in het GitHub-voorbeeld Chat toevoegen aan uw toepassing.

Vereisten

Gebruiker maken

Voer deze stappen uit in Power Automate terwijl uw Power Automate-stroom is geopend in de bewerkingsmodus.

Ga als volgt te werk om een nieuwe stap in uw werkstroom toe te voegen met behulp van de Communication Services Identity-connector:

  1. Selecteer nieuwe stap in de ontwerpfunctie onder de stap waar u de nieuwe actie wilt toevoegen. Als u de nieuwe actie wilt toevoegen tussen stappen, verplaatst u de aanwijzer over de pijl tussen deze stappen, selecteert u het plusteken (+) en selecteert u vervolgens Een actie toevoegen.

  2. In het zoekvak Kies een bewerking voert u Communication Services Identity in. Selecteer Een gebruiker maken in de lijst met acties.

    Schermopname van de actie Gebruiker maken in de Azure Communication Services Identity Connector.

  3. Voer de verbindingsreeks in. Als u de verbindingsreeks-URL in Azure Portal wilt ophalen, gaat u naar de Azure Communication Services-resource. Selecteer sleutels in het resourcemenu en selecteer vervolgens Verbindingsreeks. Selecteer het kopieerpictogram om de verbindingsreeks te kopiëren.

    Schermopname van het deelvenster Sleutels voor een Azure Communication Services-resource.

  4. Geef een naam op voor de verbinding.

  5. Selecteer Geavanceerde opties weergeven en selecteer vervolgens het tokenbereik. De actie genereert een toegangstoken en de verlooptijd ervan met het opgegeven bereik. Met deze actie wordt ook een gebruikers-id gegenereerd die een Communication Services-gebruikersidentiteit is.

    Schermopname van de opties voor gebruikersactie maken in de Azure Communication Services Identity-connector.

  6. In Tokenbereikitem selecteer chat.

    Schermopname van de geavanceerde opties voor de Chatconnector van Azure Communication Services.

  7. Selecteer Creëer. De gebruikers-id en een toegangstoken worden weergegeven.

Een chatthread maken

  1. Voeg een nieuwe actie toe.

  2. Voer in het zoekvak Kies een bewerking in, voer Communication Services Chat in. Selecteer Chatthread maken in de lijst met acties.

    Schermopname van de Chatconnector van Azure Communication Services: een chatthreadactie maken.

  3. Voer de URL van het Communication Services-eindpunt in. Als u de eindpunt-URL in Azure Portal wilt ophalen, gaat u naar de Azure Communication Services-resource. Selecteer Sleutels in het resourcemenu en selecteer vervolgens Eindpunt.

  4. Geef een naam op voor de verbinding.

  5. Selecteer het toegangstoken dat is gegenereerd in de vorige sectie en voeg vervolgens een beschrijving van het chatthreadonderwerp toe. Voeg de gemaakte gebruiker toe en voer een naam in voor de deelnemer.

    Schermopname die het actie venster

Een bericht verzenden

  1. Voeg een nieuwe actie toe.

  2. Voer in het zoekvak Kies een bewerking in, voer Communication Services Chat in. Selecteer in de lijst met acties de optie Bericht verzenden naar chat-thread.

    Schermopname van de actie Chatbericht verzenden van de Azure Communication Services-chatconnector.

  3. Voer het toegangstoken, de thread-id, de inhoud en de naam in.

    Schermopname van het dialoogvenster Chatbericht verzenden in de Azure Communication Services-chatconnector.

Chatthreadberichten weergeven

Ga als volgende te werk om te controleren of u een bericht correct hebt verzonden:

  1. Voeg een nieuwe actie toe.

  2. Voer in het zoekvak Kies een bewerking in, voer Communication Services Chat in. Selecteer Chatthreadberichten weergeven in de lijst met acties.

    Schermopname die de actie Lijst chatberichten van de Azure Communication Services Chat-connector toont.

  3. Voer het toegangstoken en de thread-id in.

    Schermopname van het dialoogvenster Actie lijst met chatberichten van de Azure Communication Services Chatconnector.

Uw Logic App testen

Als u uw werkstroom handmatig wilt starten, selecteert u Uitvoeren op de werkbalk van de ontwerpfunctie. De werkstroom maakt een gebruiker, geeft een toegangstoken voor die gebruiker uit en verwijdert vervolgens het token en verwijdert de gebruiker. Zie Uw werkstroom uitvoeren voor meer informatie.

Nu Chatthreadberichten weergeven selecteren. Controleer in de uitvoer van de actie op het bericht dat is verzonden.

Schermopname die de resultaten toont van de actie Chatbericht versturen in de Azure Communication Services-chatconnector.

Werkstroombronnen opschonen

Als u de werkstroom en gerelateerde resources van uw logische app wilt opschonen, raadpleegt u hoe u Logic Apps-resources opschoont.

Middelen opschonen

Om een abonnement op Communicatie Services op te schonen en te verwijderen, kunt u de resource of de resourcegroep verwijderen. Als u de resourcegroep verwijdert, worden ook alle bijbehorende resources verwijderd. Voor meer informatie, zie resources opruimen.

Volgende stappen

Dit artikel beschrijft hoe je:

  • Een chat-client maken
  • Een gesprek met twee gebruikers maken
  • Verzend een bericht naar de draad
  • Berichten ontvangen van een draad
  • Gebruikers verwijderen uit een discussie

De Chat Hero App proberen