Quickstart: Chat toevoegen aan uw app

  • Artikel

Ga aan de slag met Azure Communication Services met behulp van de Communication Services Chat SDK om realtime chat toe te voegen aan uw toepassing. In deze quickstart gebruiken we de Chat-SDK om chatthreads te maken waarmee gebruikers gesprekken met elkaar kunnen voeren. Raadpleeg Conceptuele documentatie voor chat voor meer informatie over Chatconcepten.

Vereisten

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

Instellen

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 bij het uitvoeren van de az login opdracht vanuit de terminal en uw referenties opgeven.

(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 het besturingssysteem op de onderstaande 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 actieve programma's die de omgevingsvariabele moeten lezen, opnieuw starten. Start ook het consolevenster opnieuw. 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 het besturingssysteem op de onderstaande 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 actieve programma's die de omgevingsvariabele moeten lezen, opnieuw starten. Start ook het consolevenster opnieuw. Als u Visual Studio bijvoorbeeld gebruikt als editor, start u Visual Studio opnieuw voordat u het voorbeeld uitvoert.

Operations

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 hierboven vermeld, hoeft u deze 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 door <chatThreadId> 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>"
  • 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 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 door <chatThreadId> 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 <displayName> kunt desgewenst de weergavenaam van de afzender opgeven.
  • 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 door <chatThreadId> uw chatthread-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 door <chatThreadId> 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 door <chatThreadId> uw chatthread-id.
  • Vervang <messageId> de id van het meest recente bericht dat wordt gelezen door de huidige gebruiker.
  • 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 door <chatThreadId> uw chatthread-id.
  • Vervang <userId> door uw userId.
  • U <displayName> kunt desgewenst 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 .

Gespreksdeelnemers weergeven in een chatgesprek

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

Voordat u aan de slag gaat, moet u het volgende doen:

  • 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 vastleggen en verbindingsreeks voor deze quickstart.

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

Instellen

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 onderstaande 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 deze quickstart wordt pakket gebruikt 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. We gebruiken 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 deze snelstart te bevatten.

Een chat-client maken

Als u een chatclient wilt maken in uw web-app, 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. Deze quickstart 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 en tokens voor gebruikerstoegang voor meer informatie over toegangstokens.

In client.js wordt het eindpunt en het toegangstoken in de onderstaande code gebruikt 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 als u dit nog niet hebt gedaan.
  • 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 ontwikkelaarshulpprogramma’s in uw browser zou u het volgende moeten zien:

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.

Naam 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 deze is opgelost, createChatThread retourneert de methode een CreateChatThreadResult. Dit model bevat een chatThread eigenschap waar u toegang hebt tot de id zojuist gemaakte thread. Vervolgens kunt u de opdracht id gebruiken om een exemplaar van een ChatThreadClient. 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 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 retourneert een PagedAsyncIterableIterator type ChatThreadItem. Deze kan worden gebruikt voor het weergeven van alle chatthreads. Een iterator van [ChatThreadItem] is het antwoord dat wordt geretourneerd uit het weergeven 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 metadata eventueel alle andere gegevens 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. 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 een id, 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 kunnen worden geïdentificeerd door 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 het toegangstoken nodig om hun chat-client 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. Als u een deel van de geschiedenis wilt delen, stelt u de eigenschap in op de gewenste datum.

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 <ADD NEW PARTICIPANT TO THREAD> opmerking in 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, waar u informatie over gebruikers in een thread zou moeten zien.

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 bijhouden van de deelnemers 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 geeft u de mogelijkheid om 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 deze quickstart op GitHub.

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

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. In de volgende secties voegt u alle broncode voor deze quickstart 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.

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

Deze quickstart heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, maar dat wordt aanbevolen. Zie de sectie 'Chatarchitectuur' van 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 neemt het CommunicationUserIdentifier type als user.

CreateChatThreadResult is het resultaat dat wordt geretourneerd door het maken van een thread. U kunt deze gebruiken om de id chatthread 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 andere chatbewerkingen uitvoeren voor deze chat-thread.

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 dit om het vroegste tijdstip op te geven om chatthreads op te halen.
  • Gebruik results_per_page dit diagram om het maximum aantal chatthreads op te geven dat per pagina wordt geretourneerd.

Een iterator van [ChatThreadItem] is het antwoord dat wordt geretourneerd uit 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 zojuist 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.
  • U metadata kunt eventueel aanvullende gegevens opnemen 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.

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 dit diagram om het maximum aantal berichten op te geven dat per pagina moet worden geretourneerd.
  • Gebruik start_time dit om het vroegste tijdstip op te geven om berichten op te halen.

Een iterator is [ChatMessage] het antwoord dat wordt geretourneerd uit het weergeven 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 berichten openen met behulp ChatMessage.created_onvan , die kan worden gebruikt voor het ordenen van de berichten.

list_messages retourneert verschillende typen berichten, die kunnen worden geïdentificeerd door 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, mits er een nieuw toegangstoken en een nieuwe identiteit beschikbaar is voor alle gebruikers.

Er wordt een list(tuple(ChatParticipant, CommunicationError)) geretourneerd. Wanneer de deelnemer 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, samen met 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 dit om de deelnemers aan de thread op te halen. Beide van de volgende opdrachten zijn optioneel:

  • Gebruik results_per_page dit diagram om het maximum aantal deelnemers op te geven dat per pagina moet worden geretourneerd.
  • Gebruik skip dit om deelnemers naar een opgegeven positie in het antwoord over te slaan.

Een iterator van [ChatParticipant] is het antwoord dat wordt geretourneerd van het weergeven 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 deze quickstart op GitHub.

Vereisten

Instellen

Een nieuwe Java-toepassing maken

Open uw terminal- of opdrachtvenster en navigeer naar de map waarin u uw Java-toepassing wilt maken. Voer de onderstaande opdracht uit om het Java-project te genereren op basis van de maven-archetype-snelstart-sjabloon.

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

U ziet dat het doel 'genereren' een map heeft gemaakt met dezelfde naam als de artifactId. De src/main/java directory in deze map bevat de broncode van het project, de map src/test/java bevat de testbron en het bestand pom.xml is het Project Object Model van het project of POM.

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 het pakket azure-communication-common verwijzen :

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

Naam Beschrijving
ChatClient Deze klasse is vereist voor de chat-functionaliteit. U instantieert deze klasse met uw abonnementsgegevens en gebruikt deze om threads te maken, krijgen en verzenden.
ChatAsyncClient Deze klasse is vereist voor de asynchrone chat-functionaliteit. U instantieert deze klasse met uw abonnementsgegevens en gebruikt deze om threads te maken, krijgen en verzenden.
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 chat-client 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. 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 importinstructies, moet u ervoor zorgen dat u alleen importbewerkingen toevoegt vanuit de com.azure.communication.chat en com.azure.communication.chat.models naamspaties en niet vanuit de com.azure.communication.chat.implementation naamspatie. 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 u de gebruiker die u hebt gemaakt in de Snelstart Toegangstoken voor gebruikers.

CreateChatThreadResult is het antwoord dat wordt geretourneerd door het maken van een chatgesprek. 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();

Chatthreads vermelden

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.
  • Hiermee type geeft u het inhoudstype van het chatbericht, TEKST of HTML op.
  • Gebruik senderDisplayName om de weergavenaam van de afzender te geven.
  • U metadata kunt eventueel aanvullende gegevens opnemen 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, 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 bestellen van de berichten.

Lees hier meer over berichttypen: Berichttypen.

Leesbevestiging verzenden

Gebruik de sendReadReceipt methode om namens een gebruiker een leesbevestigingsevenement te posten in een chatgesprek. chatMessageId is de unieke id van het chatbericht dat is gelezen.

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

Chatdeelnemers vermelden

Hiermee listParticipants haalt u een gepaginade verzameling op die de deelnemers aan de chatthreadId bevat die zijn 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 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 het toegangstoken nodig om hun chat-client te initialiseren.

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

  • communicationIdentifier, vereist, is de CommunicationIdentifier die u hebt gemaakt door communicationIdentityClient in de quickstart user access token .
  • 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 die het bestand pom.xml bevat 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 deze quickstart op GitHub.

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

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

  • Android Studio installeren, we gebruiken Android Studio om een Android-toepassing te maken voor de quickstart om afhankelijkheden te installeren.

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

  • 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 deze quickstart 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 onderstaande 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.

Instellen

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 vanaf de opdrachtregel in 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'

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

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

Bekijk de integratie van Azure Function voor meer informatie. We raden u ten zeerste aan 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 deze quickstart voegen we onze code toe aan MainActivityen bekijken we de uitvoer in de console. Deze snelstartgids 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 ApplicationConstants moet worden toegevoegd MainActivity.java als aan een van de volgende voorwaarden 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 ter referentie.

ACS_ENDPOINTen FIRST_USER_IDFIRST_USER_ACCESS_TOKEN worden geretourneerd van het aanroepen van De Azure-functie. Bekijk de integratie van Azure Function 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.

Naam 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

We gebruiken 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, krijgen we een ChatThreadAsyncClient chatgesprek 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

We sturen nu een bericht naar die thread.

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 voor realtime meldingen van chat-SDK niet. Mogelijk krijgt u een probleem met het oplossen van afhankelijkheid. Terwijl we aan een oplossing werken, kunt u de functie voor realtime meldingen uitschakelen door de volgende afhankelijkheidsgegevens toe te voegen aan het build.gradle-bestand van de app en in plaats daarvan de GetMessages-API te peilen om binnenkomende berichten aan gebruikers weer te geven.

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 met de bovenstaande update, als de toepassing een van de meldings-API's probeert aan te raken, zoals chatAsyncClient.startRealtimeNotifications() of chatAsyncClient.addEventHandler(), wordt er een runtimefout weergegeven.

Pushmeldingen

Bekijk 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

We verwijderen nu 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 melding voor typen verzenden

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

chatThreadAsyncClient.sendTypingNotification().get();

Een leesbevestiging verzenden

We sturen een leesbevestiging voor het bericht dat hierboven is verzonden.

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 deze quickstart op GitHub.

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

Instellen

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

Naam Beschrijving
ChatClient Deze klasse is vereist voor de chat-functionaliteit. U instantieert deze klasse met uw abonnementsgegevens en gebruikt deze om threads te maken, krijgen en verzenden.
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.

Deze quickstart heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, hoewel dit wordt aanbevolen. Meer informatie over chatarchitectuur

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

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

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

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

Een chat-thread starten

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

  • Gebruik topic om een onderwerp te geven aan deze chat. Het onderwerp kan worden bijgewerkt nadat de chat-thread is gemaakt met behulp van de functie UpdateTopic.
  • 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, MicrosoftTeamsUserIdentifier of 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. Als u wilt communiceren met de chatthreadbewerkingen, zoals het toevoegen van deelnemers, het verzenden van een bericht, het verwijderen van een bericht, enzovoort, moet een chatThreadClient clientexemplaren 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. Het kan worden gebruikt voor het uitvoeren van bewerkingen op de gemaakte thread: leden toevoegen, bericht verzenden, enz. 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 dit om de inhoud voor het bericht op te geven. Dit is vereist.
  • 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.
  • U metadata kunt eventueel aanvullende gegevens opnemen 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 vóór de offset-tijd zijn ontvangen maar daarna zijn 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 geopend met chatMessage.CreatedOn en kan worden gebruikt voor het bestellen van de berichten.

GetMessages retourneert verschillende typen berichten die kunnen worden geïdentificeerd door chatMessage.Type. Deze typen zijn:

  • Text: Normaal chatbericht verzonden door een threadlid.

  • Html: Een opgemaakt tekstbericht. Houd er rekening mee dat Communication Services-gebruikers momenteel geen RTF-berichten kunnen verzenden. Dit berichttype wordt ondersteund voor berichten die Teams-gebruikers verzenden naar Communication Services-gebruikers in Teams Interop-scenario's.

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

  • ParticipantAdded: Systeembericht dat aangeeft dat een of meer deelnemers zijn toegevoegd aan de chat-thread. (alleen-lezen)

  • ParticipantRemoved: Systeembericht dat aangeeft dat een deelnemer is 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 AddParticipants aanroept, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit hebt verkregen voor die gebruiker. De gebruiker heeft het toegangstoken nodig om hun chat-client te initialiseren.

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

  • 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 dit om de deelnemers aan de chat-thread 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 het bericht wordt gelezen door de gebruiker.

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 deze quickstart op GitHub.

Vereisten

Voordat u aan de slag gaat, moet u het volgende doen:

  • 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 te maken voor de quickstart 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 vastleggen en verbindingsreeks voor deze quickstart.

  • 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 deze quickstart 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 onderstaande 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.

Instellen

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 vanaf de opdrachtregel 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.4'

Installeer de afhankelijkheden met de volgende opdracht: pod install Houd er rekening mee dat hiermee ook een Xcode-werkruimte wordt gemaakt.

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

De tijdelijke aanduidingen instellen

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

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

Importeer de AzureCommunication en AzureCommunicatonChat bibliotheken bovenaanviewController.swift:

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.

Deze quickstart heeft geen betrekking op het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, hoewel dit wordt aanbevolen. Meer informatie over chatarchitectuur

Vervang de opmerking <CREATE A CHAT CLIENT> door het onderstaande 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.

Naam 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 het antwoord dat wordt geretourneerd door het maken van een chatgesprek. Het bevat een chatThread eigenschap die het ChatThreadProperties object is. Dit object bevat de threadId die kan worden gebruikt om bewerkingen ChatThreadClient uit te voeren op de gemaakte thread: deelnemers toevoegen, bericht verzenden, enzovoort.

Vervang de opmerking <CREATE A CHAT THREAD> door het onderstaande 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 door <USER_ID> een geldige Communication Services-gebruikers-id.

U gebruikt hier eenemafore om te wachten op de voltooiingshandler voordat u doorgaat. In latere stappen gebruikt u het threadId antwoord dat wordt geretourneerd naar de voltooiingshandler.

Alle chatthreads weergeven

Nadat u een chatgesprek 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'
  • U metadata kunt eventueel aanvullende gegevens opnemen 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 onderstaande 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 leesbevestigingsevenement te posten in een chatgesprek. messageId is de unieke id van het chatbericht dat is gelezen.

Vervang de opmerking <SEND A READ RECEIPT> door de onderstaande 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 onderstaande code. Nadat u meldingen hebt ingeschakeld, kunt u nieuwe berichten 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 add aanroept, moet u ervoor zorgen dat u een nieuw toegangstoken en een nieuwe identiteit hebt verkregen voor die gebruiker. De gebruiker heeft het toegangstoken nodig om hun chat-client te initialiseren.

Gebruik de add methode om ChatThreadClient een of meer deelnemers toe te voegen aan de chat-thread. Hieronder ziet u de ondersteunde kenmerken voor elke threaddeelnemer(s):

  • 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. Het verzenden van chatpushmeldingen met Notification Hub wordt momenteel ondersteund voor IOS SDK in versie 1.3.0. Raadpleeg het artikel 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 dit bij.

Voorbeeldcode

Zoek de voltooide code voor deze quickstart op GitHub.

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. Voer in het zoekvak Een bewerking kiezen de Communication Services-identiteit in. Selecteer Een gebruiker maken in de lijst met acties.

    Screenshot that shows the Azure Communication Services Identity connector Create user action.

  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 Verbinding maken iontekenreeks. Selecteer het kopieerpictogram om de verbindingsreeks te kopiëren.

    Screenshot that shows the Keys pane for an 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.

    Screenshot that shows the Azure Communication Services Identity connector Create user action options.

  6. Selecteer chat in tokenbereikitem.

    Screenshot that shows the Azure Communication Services Chat connector advanced options.

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

    Screenshot that shows the Azure Communication Services Chat connector Create a chat thread action.

  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.

    Screenshot that shows the Azure Communication Services Chat connector Create chat thread action dialog.

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.

    Screenshot that shows the Azure Communication Services Chat connector Send chat message action.

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

    Screenshot that shows the Azure Communication Services Chat connector Send chat message action dialog.

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.

    Screenshot that shows the Azure Communication Services Chat connector List chat messages action.

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

    Screenshot that shows the Azure Communication Services Chat connector List chat messages action dialog.

Uw logische 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 Hoe u uw werkstroom uitvoert voor meer informatie.

Selecteer nu Chatthreadberichten weergeven. Controleer in de uitvoer van de actie op het bericht dat is verzonden.

Screenshot that shows the Azure Communication Services Chat connector Send chat message action results.

Werkstroombronnen opschonen

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

Resources opschonen

Als u een Communication Services-abonnement wilt opschonen en verwijderen, kunt u de resource of resourcegroep verwijderen. Als u de resourcegroep verwijdert, worden ook alle bijbehorende resources verwijderd. Meer informatie over het opschonen van resources.

Volgende stappen

In deze Snelstart hebt u de volgende zaken geleerd:

  • Een chat-client maken
  • Een gesprek met twee gebruikers maken
  • Een bericht naar een gesprek verzenden
  • Berichten van een gesprek ontvangen
  • Gebruikers verwijderen uit een gesprek

De Chat Hero App proberen

U wilt mogelijk ook: