Quickstart: Chat toevoegen aan uw app

Artikel
11/24/2021
51 minuten om te lezen

Ga aan de slag Azure Communication Services met 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.

Voorbeeldcode

Zoek de uiteindelijke 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 Node.js Active LTS- en Maintenance LTS-versies.
Maak een Azure Communication Services-resource. Zie Create an Azure Communication Services resource (Een Azure Communication Services maken) voor meer informatie. Voor deze quickstart moet u uw resource-eindpunt registreren.
Maak drie ACS-gebruikers en wijs ze een token gebruikerstoegang token toe. Zorg ervoor dat u het bereik in stelt op chat en noteer de tokenreeks en de userId-tekenreeks. De volledige demo maakt een thread met twee initiële deelnemers en voegt vervolgens een derde deelnemer toe aan de thread.

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 SDK Communication Services 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.

Het app-framework instellen

In deze snelstart wordt webpack gebruikt om de toepassingsassets te bundelen. Voer de volgende opdracht uit om de webpack-, webpack-CLI- en webpack-dev-server npm-pakketten te installeren en deze weer te geven als ontwikkelingsafhankelijkheden in uw package.json:

npm install webpack webpack-cli webpack-dev-server --save-dev

Maak een webpack.config.js bestand in de hoofdmap. Kopieer de volgende configuratie naar dit bestand:

module.exports = {
  entry: "./client.js",
  output: {
    filename: "bundle.js"
  },
  devtool: "inline-source-map",
  mode: "development"
}

Voeg een start script toe aan uw . We gebruiken dit voor het uitvoeren van de package.json app. Voeg in scripts de sectie van het volgende package.json toe:

"scripts": {
  "start": "webpack serve --config ./webpack.config.js"
}

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="./bundle.js"></script>
  </body>
</html>

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

Een chat-client maken

Als u een chatclient in uw web-app wilt maken, gebruikt u het Communications Service-eindpunt en het toegangs token 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 gaat niet over 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.

Gebruik client.js eindpunt en toegang token in de onderstaande code 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 = 'https://<RESOURCE_NAME>.communication.azure.com';
// 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 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 de toepassingshost op een lokale webserver te bundelen:

npm run start

Open uw browser en ga naar http://localhost:8080/. 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 maakt een instantie met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen, te verwijderen en u te abonneren op chatgebeurtenissen.
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/ontvangen/bijwerken/verwijderen, gebruikers toe te voegen/te verwijderen of te verzenden, getypte meldingen te verzenden en bevestigingen te lezen.

Een chat-thread starten

Gebruik de methode createThread om een chat-thread te maken.

createThreadRequest wordt gebruikt om de thread-aanvraag te beschrijven:

Gebruik topic 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 om de deelnemers weer te voegen aan de chat-thread.

Wanneer dit is opgelost, createChatThread retourneert de methode een CreateChatThreadResult . Dit model bevat een chatThread eigenschap waar u toegang hebt tot de van de zojuist gemaakte id thread. U kunt vervolgens de gebruiken id om een exemplaar van een op te ChatThreadClient halen. De kan vervolgens worden gebruikt om een bewerking binnen de thread uit ChatThreadClient te voeren, zoals het verzenden van berichten of het in een lijst bekijken 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>

Een lijst met alle chatthreads maken

De listChatThreads methode retourneert PagedAsyncIterableIterator een van het type ChatThreadItem . Deze kan worden gebruikt voor het in een lijst plaatsen van alle chat-threads. Een iterator van [ChatThreadItem] is het antwoord dat wordt geretourneerd door het in een lijst plaatsen van threads

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

Een bericht verzenden naar een chat-thread

Gebruik sendMessage de methode 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 chatbericht op te geven;

sendMessageOptions wordt gebruikt om de optionele bewerkingsparamen te beschrijven:

Gebruik senderDisplayName om de weergavenaam van de afzender op te geven.
Gebruik type om het berichttype op te geven, zoals 'text' of 'html';
Gebruik metadata eventueel om aanvullende gegevens op te nemen die u samen met het bericht wilt verzenden. Dit veld bevat een mechanisme voor ontwikkelaars 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 mogelijk 'hasAttachment:true' toevoegen aan metagegevens, zodat de toepassing van de ontvanger dienovereenkomstig kan parseren en weergeven.

SendChatMessageResult is het antwoord dat wordt geretourneerd door het verzenden van een bericht. Het bevat een id. Dit is 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 uw tabblad. In de console ziet u de lijst met berichten die in deze chat-thread zijn verzonden.

listMessages retourneert verschillende typen berichten die kunnen worden geïdentificeerd door chatMessage.type.

Zie Berichttypenvoor meer informatie.

Een gebruiker toevoegen als deelnemer aan de chat-thread

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

addParticipantsRequest beschrijft het aanvraagobject waarin de deelnemers worden vermeld participants die aan de chat-thread 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 voorafgaand aan het moment waarop 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 opmerking in <ADD NEW PARTICIPANT TO THREAD> client.js

Gebruikers in een chat-thread weergeven

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

Voeg deze code toe in plaats van de opmerking <LIST PARTICIPANTS IN A THREAD> in client.js, vernieuw uw browsertabblad en controleer de console, 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 uit een chatgesprek verwijderen. 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>). Voeg deze code toe in plaats van de opmerking <REMOVE PARTICIPANT FROM THREAD> in client.js.

Voorbeeldcode

Zoek de uiteindelijke 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 Python.
Maak een Azure Communication Services-resource. Zie Quickstart:Uw resources maken en beheren Communication Services meer informatie. Voor deze quickstart moet u het eindpunt van uw resource vastleggen.
Een token voor gebruikerstoegang. Zorg ervoor dat u het bereik in stelt op chat en noteer de token tekenreeks en de userId tekenreeks.

Instellen

Een nieuwe Python-toepassing maken

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

mkdir chat-quickstart && cd chat-quickstart

Gebruik een teksteditor om een bestand met de naam start-chat.py maken in de hoofdmap van het project. Voeg de structuur voor het programma toe, inclusief basisafhandeling 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 maakt een instantie 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 en gebruikt dit om berichten te `ChatClient` verzenden, te ontvangen, bij te werken en te verwijderen. U kunt deze ook gebruiken om gebruikers toe te voegen, te verwijderen en op te halen, en typmeldingen te verzenden en ontvangstbewijzen te lezen.

Een chat-client maken

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

pip install azure-communication-identity

from azure.communication.chat import ChatClient, CommunicationTokenCredential

endpoint = "https://<RESOURCE_NAME>.communication.azure.com"
chat_client = ChatClient(endpoint, CommunicationTokenCredential("<Access Token>"))

Deze quickstart gaat niet over het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, maar dat wordt wel aanbevolen. Zie de sectie 'Chatarchitectuur' van Chatconcepten voor meer informatie.

Een chat-thread starten

Gebruik de methode create_chat_thread om een chat-thread te maken.

Gebruik topic 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 om de weer te voegen aan de ChatParticipant chat-thread. De ChatParticipant heeft het type als CommunicationUserIdentifier user .

CreateChatThreadResult is het resultaat dat wordt geretourneerd door het maken van een thread. U kunt deze gebruiken om de op te id halen van de chat-thread die is gemaakt. Dit id kan vervolgens worden gebruikt om een object op te halen met behulp van de methode ChatThreadClient get_chat_thread_client . U kunt gebruiken ChatThreadClient om andere chatbewerkingen naar deze chat-thread uit te voeren.

topic="test topic"

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

Een chat-thread-client ophalen

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

U kunt gebruiken ChatThreadClient om andere chatbewerkingen naar deze chat-thread uit te voeren.

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

Een lijst met alle chatthreads maken

De list_chat_threads methode retourneert een iterator van het type ChatThreadItem .

Gebruik start_time om het vroegste tijdstip op te geven om chatthreads op te halen.
Gebruik results_per_page om het maximum aantal chatthreads op te geven dat per pagina wordt geretourneerd.

Een iterator van [ChatThreadItem] is het antwoord dat wordt geretourneerd door het in een lijst plaatsen 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 chatgesprek dat u zojuist hebt gemaakt, geïdentificeerd door thread_id .

Gebruik content om de inhoud van het chatbericht te geven.
Gebruik chat_message_type om het inhoudstype van het bericht op te geven. Mogelijke waarden zijn text en html . Als u geen waarde opgeeft, is de standaardwaarde text .
Gebruik sender_display_name om de weergavenaam van de afzender te geven.
Gebruik metadata eventueel om aanvullende gegevens op te nemen die u samen met het bericht wilt verzenden. Dit veld bevat een mechanisme voor ontwikkelaars 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 mogelijk 'hasAttachment:true' toevoegen aan metagegevens, zodat de toepassing van de ontvanger dienovereenkomstig kan parseren en weergeven.

SendChatMessageResult is het antwoord dat wordt geretourneerd door het verzenden van een bericht. Deze bevat een id. Dit is 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 om het maximum aantal berichten op te geven dat per pagina moet worden geretourneerd.
Gebruik start_time om het vroegste tijdstip op te geven om berichten op te halen.

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

list_messages retourneert verschillende typen berichten, die kunnen worden geïdentificeerd door ChatMessage.type .

Zie Berichttypen voor meer informatie.

Ontvangstbewijs voor lezen verzenden

U gebruikt de methode om namens een gebruiker een ontvangstbewijsgebeurtenis te plaatsen in send_read_receipt een thread.

Gebruik message_id om de id op te geven van het meest recente bericht dat door de huidige gebruiker is gelezen.

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

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

U kunt een of meer gebruikers aan de chat-thread toevoegen met behulp van de methode , mits er een nieuw toegangsken en een nieuwe identiteit beschikbaar add_participants zijn voor alle gebruikers.

Er list(tuple(ChatParticipant, CommunicationError)) wordt een geretourneerd. Wanneer de deelnemer is toegevoegd, wordt een lege lijst verwacht. Als er een fout is opgetreden 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)

Threaddeelnemers in een chatgesprek op een lijst zetten

Net als bij het toevoegen van een deelnemer kunt u ook deelnemers uit een thread op een lijst zetten.

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

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

Een iterator van [ChatParticipant] is het antwoord dat wordt geretourneerd door deelnemers in een lijst.

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 op vanuit uw toepassingsmap met de opdracht python.

python start-chat.py

Voorbeeldcode

Zoek de uiteindelijke code voor deze quickstart op GitHub.

Vereisten

Een Azure-account met een actief abonnement. Gratis een account maken
Java Development Kit (JDK) versie 8 of hoger.
Apache Maven.
Een actieve Communication Services-resource en verbindingsreeks. Een Communication Services-resource maken.
EenToegangstoken voor gebruikers. Zorg ervoor dat u het bereik instelt op ‘chat’ en noteer de tokenreeks en ook de gebruikersId-reeks.

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>

De pakketverwijzingen voor de Chat-SDK toevoegen

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/ontvangen/bijwerken/verwijderen, gebruikers toe te voegen/te verwijderen of te verzenden, 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 = "https://<RESOURCE_NAME>.communication.azure.com";

        // 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 om de threaddeelnemers weer te voegen aan de thread. 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 chat-thread. Het bevat een methode die het -object retourneert dat kan worden gebruikt om de threadclient op te halen van waaruit u de kunt krijgen voor het uitvoeren van bewerkingen op de gemaakte thread: deelnemers toevoegen, bericht getChatThread() ChatThread ChatThreadClient verzenden, enzovoort. Het ChatThread -object bevat ook getId() de 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 op een lijst plaatsen

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 methode sendMessage om een bericht te verzenden naar de thread die u zojuist hebt gemaakt, geïdentificeerd door chatThreadId. sendChatMessageOptions wordt gebruikt om de aanvraag voor het chatbericht te beschrijven.

Gebruik content om de inhoud van het chatbericht te geven.
Gebruik type om het inhoudstype van het chatbericht, TEKST of HTML op te geven.
Gebruik senderDisplayName om de weergavenaam van de afzender te geven.
Gebruik metadata eventueel om eventuele aanvullende gegevens op te nemen die u samen met het bericht wilt verzenden. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Wanneer u bijvoorbeeld een bestandskoppeling in het bericht deelt, wilt u mogelijk 'hasAttachment:true' toevoegen aan metagegevens, zodat de toepassing van de ontvanger dienovereenkomstig kan parseren en 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 behulp van .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.

Ontvangstbewijs voor lezen verzenden

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

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

Chatdeelnemers op een lijst zetten

Gebruik listParticipants om een verzameling met pagina's op te halen met de deelnemers aan de chat-thread die is 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 chat-thread

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 chat-thread 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 methode addPartici methodolog aanroept, moet u ervoor zorgen dat u een nieuw toegangsteken en een nieuwe identiteit voor die gebruiker hebt verkregen. De gebruiker heeft dat toegangstoken nodig om zijn chat-client te initialiseren.

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

communicationIdentifier, vereist, is de CommunicationIdentifier die u hebt gemaakt door de CommunicationIdentityClient in de quickstart Token voor gebruikerstoegang.
displayName, optioneel, is de weergavenaam voor de threaddeelnemer.
shareHistoryTime, optioneel, is het tijdstip waarop de chatgeschiedenis wordt gedeeld met de deelnemer. Als u de geschiedenis wilt delen sinds het begin van de chat-thread, stelt u deze eigenschap in op een willekeurige datum die gelijk is aan of kleiner is dan de aanmaaktijd van de thread. Als u geen geschiedenis wilt delen voorafgaand aan het moment waarop 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 uiteindelijke 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 Android Studio, we gebruiken Android Studio om een Android-toepassing te maken voor de quickstart om afhankelijkheden te installeren.
Maak een Azure Communication Services-resource. Zie Create an Azure Communication Services resource (Een Azure Communication Services maken) voor meer informatie. Voor deze quickstart moet u uw resource-eindpunt registreren.
Maak twee Communication Services gebruikers en wijs ze een token gebruikerstoegang token voor gebruikerstoegang toe. Zorg ervoor dat u het bereik in stelt op chat en noteer de tokenreeks en de userId-tekenreeks. In deze quickstart maken we een thread met een eerste deelnemer en voegen we vervolgens een tweede deelnemer toe aan de thread.

Instellen

Een nieuwe Android-toepassing maken

Open Android Studio en selecteer Create a new project .
Selecteer in het volgende venster Empty Activity als de projectsjabloon.
Wanneer u opties kiest, voert ChatQuickstart u in als de projectnaam.
Klik op Volgende en kies de map waarin u het project wilt maken.

De bibliotheken installeren

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

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

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

Metabestanden uitsluiten in pakketopties 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 in uw project wilt importeren met behulp van het Maven-buildsysteem, voegt u deze toe aan de sectie van het bestand van uw app, met de artefact-id en de versie die u dependencies wilt pom.xml 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>

De tijdelijke aanduidingen instellen

Open en bewerk het bestand MainActivity.java . In deze quickstart voegen we onze code toe aan MainActivity en bekijken we de uitvoer in de console. Deze snelstart is niet gericht op het bouwen van een gebruikersinterface. Importeer bovenaan het bestand de systeembibliotheken Communication common , en andere Communication chat 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 String endpoint = "https://<resource>.communication.azure.com";
    private String firstUserId = "<first_user_id>";
    private String secondUserId = "<second_user_id>";
    private String firstUserAccessToken = "<first_user_access_token>";
    private String threadId = "<thread_id>";
    private String chatMessageId = "<chat_message_id>";
    private final String sdkVersion = "<chat_sdk_version>";
    private static final String APPLICATION_ID = "Chat Quickstart App";
    private static final String SDK_NAME = "azure-communication-com.azure.android.communication.chat";
    private static final String TAG = "Chat Quickstart App";
    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);

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

Vervang <resource> door uw Communication Services resource.
Vervang <first_user_id> en door geldige Communication Services <second_user_id> gebruikers-ID's die zijn gegenereerd als onderdeel van de vereiste stappen.
Vervang <first_user_access_token> door het Communication Services-token voor <first_user_id> dat is gegenereerd als onderdeel van de vereiste stappen.
Vervang <chat_sdk_version> door de versie van de Azure Communication Chat SDK.

In de volgende stappen vervangen we de tijdelijke aanduidingen door voorbeeldcode met behulp van de Azure Communication Services Chat-bibliotheek.

Een chat-client maken

Vervang de opmerking <CREATE A CHAT CLIENT> door de volgende code (plaats de importin instructies 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 maakt een instantie met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen, te verwijderen en u te abonneren op chatgebeurtenissen.
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/ontvangen/bijwerken/verwijderen, gebruikers toe te voegen/te verwijderen of te verzenden, getypte meldingen te verzenden en bevestigingen te lezen.

Een chat-thread starten

We gebruiken onze om ChatAsyncClient 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 om bewerkingen ChatThreadAsyncClient 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 binnenkomende berichten en de huidige berichten dienovereenkomstig bijwerken in het geheugen. 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 importin instructies 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 de Chat-SDK niet. Mogelijk krijgt u een probleem met het oplossen van een afhankelijkheid. Terwijl we aan een oplossing werken, kunt u de functie voor realtimemeldingen uitschakelen door de volgende afhankelijkheidsinformatie toe te voegen aan het build.gradle-bestand van de app en in plaats daarvan de GetMessages-API te peilen om binnenkomende berichten weer te geven aan gebruikers.

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

Opmerking bij de bovenstaande update: als de toepassing een meldings-API zoals of probeert aan te chatAsyncClient.startRealtimeNotifications() chatAsyncClient.addEventHandler() raken, is er een runtimefout.

Pushmeldingen

Notitie

Momenteel worden pushmeldingen voor chat alleen ondersteund voor Android SDK in versie 1.1.0-beta.4.

Met pushmeldingen kunnen clients op de hoogte worden gesteld van binnenkomende berichten en andere bewerkingen die plaatsvinden in een chatgesprek in situaties waarin de mobiele app niet op de voorgrond wordt uitgevoerd. Azure Communication Services ondersteunt een lijst met gebeurtenissen waarop u zich kunt abonneren.

Firebase Cloud Messaging instellen met ChatQuickstart-project. Voltooi de Create a Firebase project stappen , , , en in Register your app with Firebase Add a Firebase configuration file Add Firebase SDKs to your app Edit your app manifest Firebase-documentatie.
Maak een Notification Hub binnen hetzelfde abonnement als uw Communication Services-resource, configureer uw Firebase Cloud Messaging-instellingen voor de hub en koppel de Notification Hub aan uw Communication Services resource. Zie Notification Hub inrichten.

Maak een nieuw bestand MyFirebaseMessagingService.java in hetzelfde pad van het bestand MainActivity.java . Kopieer de volgende code naar het bestand MyFirebaseMessagingService.java . U moet vervangen door <your_package_name> de pakketnaam die wordt gebruikt in MainActivity.java . U kunt uw eigen waarde gebruiken voor <your_intent_name> . Deze waarde wordt gebruikt in stap 6 hieronder.

   package <your_package_name>;

   import android.content.Intent;
   import android.util.Log;

   import androidx.localbroadcastmanager.content.LocalBroadcastManager;

   import com.azure.android.communication.chat.models.ChatPushNotification;
   import com.google.firebase.messaging.FirebaseMessagingService;
   import com.google.firebase.messaging.RemoteMessage;

   import java.util.concurrent.Semaphore;

   public class MyFirebaseMessagingService extends FirebaseMessagingService {
       private static final String TAG = "MyFirebaseMsgService";
       public static Semaphore initCompleted = new Semaphore(1);

       @Override
       public void onMessageReceived(RemoteMessage remoteMessage) {
           try {
               Log.d(TAG, "Incoming push notification.");

               initCompleted.acquire();

               if (remoteMessage.getData().size() > 0) {
                   ChatPushNotification chatPushNotification =
                       new ChatPushNotification().setPayload(remoteMessage.getData());
                   sendPushNotificationToActivity(chatPushNotification);
               }

               initCompleted.release();
           } catch (InterruptedException e) {
               Log.e(TAG, "Error receiving push notification.");
           }
       }

       private void sendPushNotificationToActivity(ChatPushNotification chatPushNotification) {
           Log.d(TAG, "Passing push notification to Activity: " + chatPushNotification.getPayload());
           Intent intent = new Intent("<your_intent_name>");
           intent.putExtra("PushNotificationPayload", chatPushNotification);
           LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
       }
   }

Voeg bovenaan het bestand MainActivity.java de volgende import toe:

   import android.content.BroadcastReceiver;
   import android.content.Context;
   import android.content.Intent;
   import android.content.IntentFilter;

   import androidx.localbroadcastmanager.content.LocalBroadcastManager;
   import com.azure.android.communication.chat.models.ChatPushNotification;
   import com.google.android.gms.tasks.OnCompleteListener;
   import com.google.android.gms.tasks.Task;
   import com.google.firebase.messaging.FirebaseMessaging;

Voeg de volgende code toe aan klasse MainActivity :

   private BroadcastReceiver firebaseMessagingReceiver = new BroadcastReceiver() {
       @Override
       public void onReceive(Context context, Intent intent) {
           ChatPushNotification pushNotification =
               (ChatPushNotification) intent.getParcelableExtra("PushNotificationPayload");

           Log.d(TAG, "Push Notification received in MainActivity: " + pushNotification.getPayload());

           boolean isHandled = chatAsyncClient.handlePushNotification(pushNotification);
           if (!isHandled) {
               Log.d(TAG, "No listener registered for incoming push notification!");
           }
       }
   };


   private void startFcmPushNotification() {
       FirebaseMessaging.getInstance().getToken()
           .addOnCompleteListener(new OnCompleteListener<String>() {
               @Override
               public void onComplete(@NonNull Task<String> task) {
                   if (!task.isSuccessful()) {
                       Log.w(TAG, "Fetching FCM registration token failed", task.getException());
                       return;
                   }

                   // Get new FCM registration token
                   String token = task.getResult();

                   // Log and toast
                   Log.d(TAG, "Fcm push token generated:" + token);
                   Toast.makeText(MainActivity.this, token, Toast.LENGTH_SHORT).show();

                   chatAsyncClient.startPushNotifications(token, new Consumer<Throwable>() {
                       @Override
                       public void accept(Throwable throwable) {
                           Log.w(TAG, "Registration failed for push notifications!", throwable);
                       }
                   });
               }
           });
   }

Werk de functie onCreate bij in klasse MainActivity .

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       LocalBroadcastManager
           .getInstance(this)
           .registerReceiver(
               firebaseMessagingReceiver,
               new IntentFilter("<your_intent_name>"));
   }

Plaats de volgende code onder de opmerking <RECEIVE CHAT MESSAGES> :

   startFcmPushNotification();

   chatAsyncClient.addPushNotificationHandler(CHAT_MESSAGE_RECEIVED, (ChatEvent payload) -> {
       Log.i(TAG, "Push Notification CHAT_MESSAGE_RECEIVED.");
       ChatMessageReceivedEvent event = (ChatMessageReceivedEvent) payload;
       // You code to handle ChatMessageReceived event
   });

Een gebruiker toevoegen als deelnemer aan de chat-thread

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

Lijst met gebruikers in een thread

Vervang de <LIST USERS> opmerking door de volgende code (plaats de importin instructies 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 typemelding verzenden

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

chatThreadAsyncClient.sendTypingNotification().get();

Een ontvangstbewijs voor lezen verzenden

We verzenden een ontvangstbewijs voor lezen voor het bericht dat hierboven is verzonden.

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

chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();

Leesbevestigingen op een lijst zetten

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

Klik 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 uiteindelijke 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.
Visual Studio installeren
Maak een Azure Communication Services-resource. Zie Create an Azure Communication Services resource (Een Azure Communication Services maken) voor meer informatie. Voor deze quickstart moet u het eindpunt van uw resource vastleggen.
Een toegangstoken voor gebruikers. Zorg ervoor dat u het bereik instelt op ‘chat’ en noteer de tokenreeks en ook de gebruikersId-reeks.

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 Hallo wereld-C#-project 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 dit om berichten te verzenden/ontvangen/bijwerken/verwijderen, deelnemers toe te voegen/te verwijderen/op te halen, getypte meldingen te verzenden en ontvangstbewijzen te lezen.

Een chat-client maken

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

Meer informatie over tokens voor gebruikerstoegang.

Deze quickstart gaat niet over het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, hoewel dit wel 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("https://<RESOURCE_NAME>.communication.azure.com");

            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 CommunicationUserIdentifier of MicrosoftTeamsUserIdentifier PhoneNumberIdentifier zijn. Als u bijvoorbeeld een -object wilt op halen, moet u een toegangs-id doorgeven die u hebt gemaakt door de instructies te volgen CommunicationIdentifier voor Het maken van een gebruiker

Het antwoordobject van de createChatThread methode bevat de chatThread details. Voor interactie met de chat-threadbewerkingen, zoals het toevoegen van deelnemers, het verzenden van een bericht, het verwijderen van een bericht, enzovoort, moet een clientin exemplaar worden gemaakt met behulp van de methode op chatThreadClient GetChatThreadClient 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);

Een lijst met alle chatthreads maken

Gebruik GetChatThreads om alle chatthreads op te halen waar de gebruiker deel van 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 om een bericht naar een thread te verzenden.

Gebruik content om de inhoud voor het bericht op te geven. Dit is vereist.
Gebruik type voor het inhoudstype van het bericht, zoals 'Tekst' of 'Html'. Als dit niet wordt opgegeven, wordt 'Text' ingesteld.
Gebruik senderDisplayName om de weergavenaam van de afzender te geven. Als dit niet wordt opgegeven, wordt een lege tekenreeks ingesteld.
Gebruik metadata eventueel om aanvullende gegevens op te nemen die u samen met het bericht wilt verzenden. Dit veld bevat een mechanisme voor ontwikkelaars 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 mogelijk 'hasAttachment:true' toevoegen aan metagegevens, zodat de toepassing van de ontvanger dienovereenkomstig kan parseren en 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 die offset wordt opgegeven, ontvangt u berichten die daarna 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 thread-lid.
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 Berichttypenvoor meer informatie.

Een gebruiker toevoegen als deelnemer aan de chat-thread

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 dat toegangstoken nodig om zijn chat-client te initialiseren.

Gebruik AddParticipants om een of meer deelnemers aan de chat-thread toe te voegen. Hier volgen 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 van 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 krijgen

Gebruik GetParticipants 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}");
}

Ontvangstbewijs voor lezen verzenden

Gebruik SendReadReceipt om andere deelnemers te informeren dat het bericht wordt gelezen door de gebruiker.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

De code uitvoeren

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

dotnet run

Voorbeeldcode

Zoek de uiteindelijke 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 Quickstart:Uw resources maken en beheren Communication Services meer informatie. Voor deze quickstart moet u uw resource-eindpunt registreren.
Maak twee gebruikers in Azure Communication Services en wijs ze een token voor gebruikerstoegang toe. Zorg ervoor dat u het bereik in stelt op chat en noteer de token tekenreeks en de userId tekenreeks. In deze quickstart maakt u een thread met een eerste deelnemer en voegt u vervolgens een tweede deelnemer toe aan de thread.

Instellen

Een nieuwe iOS-toepassing maken

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

Voer ChatQuickstart in als projectnaam. Selecteer vervolgens Storyboard als interface, UIKit App Delegate als 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 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 'AzureCommunicationCommon', '~> 1.0.2'
pod 'AzureCommunicationChat', '~> 1.1.0-beta.2'

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

Nadat u pod install hebt uitgevoerd, opent u het project opnieuw in Xcode door de zojuist gemaakte te .xcworkspace selecteren.

De tijdelijke aanduidingen instellen

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

In deze quickstart voegt u uw code toe aan viewController en bekijkt u de uitvoer in de Xcode-console. Deze snelstart gaat niet over het bouwen van een gebruikersinterface in iOS.

Importeer bovenaan viewController.swift de bibliotheken en AzureCommunication AzureCommunicatonChat :

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 semafoor 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 toegangs token dat is gegenereerd als onderdeel van de vereiste stappen.

Meer informatie over tokens voor gebruikerstoegang.

Deze quickstart gaat niet over het maken van een servicelaag voor het beheren van tokens voor uw chattoepassing, hoewel dit wel 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-toegangs token.

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 maakt een instantie met uw abonnementsgegevens en gebruikt deze om threads te maken, op te halen, te verwijderen en u te abonneren op chatgebeurtenissen.
`ChatThreadClient`	Deze klasse is nodig voor de functionaliteit van de chat-thread. U verkrijgt een exemplaar via en gebruikt dit om berichten te `ChatClient` verzenden, te ontvangen, bij te werken en te verwijderen. U kunt deze ook gebruiken om gebruikers toe te voegen, te verwijderen en op te halen, typemeldingen te verzenden en ontvangstbewijzen te lezen.

Een chat-thread starten

CreateChatThreadResult is het antwoord dat wordt geretourneerd door het maken van een chat-thread. Deze bevat een chatThread eigenschap die het object ChatThreadProperties is. Dit object bevat de threadId die kan worden gebruikt om een op te halen voor het uitvoeren van bewerkingen op de gemaakte ChatThreadClient 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 <USER_ID> door een geldige Communication Services-id.

U gebruikt hier een semafoor om te wachten op de voltooiings-handler voordat u doorgaat. In latere stappen gebruikt u de uit het threadId antwoord dat is geretourneerd naar de voltooiings-handler.

Een lijst met alle chatthreads maken

Nadat we een chat-thread hebben gemaakt, kunnen we alle chatthreads op een lijst plaatsen door de listChatThreads methode aan te roepen op 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
Gebruik senderDisplayName om de weergavenaam van de afzender op te geven
Gebruik type om het berichttype op te geven, zoals 'text' of 'html'
Gebruik metadata eventueel om eventuele aanvullende gegevens op te nemen die u samen met het bericht wilt verzenden. Dit veld biedt ontwikkelaars een mechanisme om de functionaliteit van chatberichten uit te breiden en aangepaste informatie toe te voegen voor uw use-case. Wanneer u bijvoorbeeld een bestandskoppeling in het bericht deelt, wilt u mogelijk hasAttachment:true toevoegen aan metagegevens, zodat de toepassing van de ontvanger dienovereenkomstig kan parseren en weergeven.

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

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 ontvangstbewijs voor lezen verzenden

Gebruik de methode om namens een gebruiker een ontvangstbewijsgebeurtenis te plaatsen in een sendReadReceipt 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

Vervang de opmerking <RECEIVE MESSAGES> door de onderstaande code. Nadat u meldingen hebt inschakelen, 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 chat-thread

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 dat toegangstoken nodig om zijn chat-client te initialiseren.

Gebruik de add methode van om een of meer deelnemers aan de ChatThreadClient chat-thread toe te voegen. Hier volgen 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):
        (result.invalidParticipants != nil) ? print("Added participant") : print("Error adding participant")
    case .failure:
        print("Failed to add the participant")
    }
    semaphore.signal()
}
semaphore.wait()

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

Lijst met gebruikers in een thread

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

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

De code uitvoeren

Klik 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: Stel Build Settings > Build Options > Enable Bitcode in op No . Momenteel biedt de AzureCommunicationChat SDK voor iOS geen ondersteuning voor het inschakelen van bitcode. De volgende GitHub probleem is dit bij te houden.

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 quickstart hebt u de volgende zaken geleerd:

Een chatruimte 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:

Meer informatie over chatconcepten
Vertrouwd raken met chat-SDK

Quickstart: Chat toevoegen aan uw app

Beoordeel uw ervaring

Voorbeeldcode

Vereisten

Instellen

Een nieuwe webtoepassing maken

De pakketten installeren

Het app-framework instellen

Een chat-client maken

De code uitvoeren

Objectmodel

Een chat-thread starten

Een chat-thread-client ophalen

Een lijst met alle chatthreads maken

Een bericht verzenden naar een chat-thread

Chatberichten ontvangen van een chat-thread

Een gebruiker toevoegen als deelnemer aan de chat-thread

Gebruikers in een chat-thread weergeven

Gebruiker verwijderen uit een chat-thread

Voorbeeldcode

Vereisten

Instellen

Een nieuwe Python-toepassing maken

SDK installeren

Objectmodel

Een chat-client maken

Een chat-thread starten

Een chat-thread-client ophalen

Een lijst met alle chatthreads maken

Een bericht verzenden naar een chat-thread

Chatberichten ontvangen van een chat-thread

Ontvangstbewijs voor lezen verzenden

Een gebruiker toevoegen als deelnemer aan de chat-thread

Threaddeelnemers in een chatgesprek op een lijst zetten

De code uitvoeren

Voorbeeldcode

Vereisten

Instellen

Een nieuwe Java-toepassing maken

De pakketverwijzingen voor de Chat-SDK toevoegen

Objectmodel

Een chat-client maken

Een chat-thread starten

Chatthreads op een lijst plaatsen

Een chat-thread-client ophalen

Een bericht verzenden naar een chat-thread

Chatberichten ontvangen van een chat-thread

Ontvangstbewijs voor lezen verzenden

Chatdeelnemers op een lijst zetten

Een gebruiker toevoegen als deelnemer aan de chat-thread

De code uitvoeren

Voorbeeldcode

Vereisten

Instellen

Een nieuwe Android-toepassing maken

De bibliotheken installeren

Metabestanden uitsluiten in pakketopties in root build.gradle

(Alternatief) Bibliotheken installeren via Maven

De tijdelijke aanduidingen instellen

Een chat-client maken

Objectmodel

Een chat-thread starten

Een chat-thread-client ophalen

Een bericht verzenden naar een chat-thread

Chatberichten ontvangen van een chat-thread

Realtime-meldingen

Pushmeldingen

Een gebruiker toevoegen als deelnemer aan de chat-thread

Lijst met gebruikers in een thread

Gebruiker verwijderen uit een chat-thread

Een typemelding verzenden

Een ontvangstbewijs voor lezen verzenden

Leesbevestigingen op een lijst zetten

De code uitvoeren

Voorbeeldcode

Vereisten

Instellen

Een nieuwe C#-toepassing maken

Het pakket installeren

Objectmodel