Snabbstart: Lägga till chatt i din app

Artikel
11/24/2021
47 minuter för att läsa

Kom igång med Azure Communication Services hjälp av Communication Services Chat SDK för att lägga till realtidschatt i ditt program. I den här snabbstarten använder vi Chat SDK för att skapa chatttrådar som gör att användare kan föra konversationer med varandra. Mer information om chattbegrepp finns i den konceptuella chattdokumentationen.

Exempelkod

Hitta den färdiga koden för den här snabbstarten på GitHub.

Förutsättningar

Innan du börjar bör du se till att:

Skapa ett Azure-konto med en aktiv prenumeration. Mer information finns i Skapa ett konto utan kostnad.
Installera Node.js Active LTS- och Maintenance LTS-versioner.
Skapa en Azure Communication Services resurs. Mer information finns i Skapa en Azure Communication Services resurs. Du måste registrera resursslutpunkten för den här snabbstarten.
Skapa tre ACS-användare och ge dem en användaråtkomsttoken för användaråtkomsttoken. Se till att ange omfånget för chatt och notera tokensträngen samt userId-strängen. Den fullständiga demon skapar en tråd med två inledande deltagare och lägger sedan till en tredje deltagare i tråden.

Inrätta

Skapa en ny webbapp

Öppna först terminalen eller kommandofönstret och skapa en ny katalog för din app och navigera till den.

mkdir chat-quickstart && cd chat-quickstart

Kör npm init -y för attpackage.jsen fil med standardinställningar.

npm init -y

Installera paketen

Använd kommandot npm install för att installera följande Communication Services-SDK:er för JavaScript.

npm install @azure/communication-common --save

npm install @azure/communication-identity --save

npm install @azure/communication-signaling --save

npm install @azure/communication-chat --save

Alternativet --save visar biblioteket som ett beroende i dittpackage.js på filen.

Konfigurera appramverket

Den här snabbstarten använder webpack för att paketera programtillgångarna. Kör följande kommando för att installera npm-paketen webpack, webpack-cli och webpack-dev-server och visa dem som utvecklingsberoenden i dinpackage.jspå:

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

Skapa en webpack.config.js fil i rotkatalogen. Kopiera följande konfiguration till den här filen:

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

Lägg till start ett skript i . Vi använder det för att köra package.json appen. I avsnittet scripts i lägger du till package.json följande:

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

Skapa en index.html-fil i rotkatalogen för projektet. Vi använder den här filen som en mall för att lägga till chattfunktioner med hjälp av Azure Communication Chat SDK för 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>

Skapa en fil i rotkatalogen i projektet med namnet client.js ska innehålla programlogiken för den här snabbstarten.

Skapa en chattklient

Om du vill skapa en chattklient i webbappen använder du kommunikationstjänstens slutpunkt och den åtkomsttoken som genererades som en del av de nödvändiga stegen.

Med användaråtkomsttoken kan du skapa klientprogram som autentiserar direkt Azure Communication Services. Den här snabbstarten omfattar inte att skapa en tjänstnivå för att hantera token för ditt chattprogram. Se chattbegrepp för mer information om chattarkitektur och token för användaråtkomst för mer information om åtkomsttoken.

I client.js du slutpunkten och åtkomsttoken i koden nedan för att lägga till chattfunktioner med hjälp av Azure Communication Chat SDK för 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!');

Ersätt endpointUrl med den Communication Services resursslutpunkten. Se Skapa en Azure Communication Services-resurs om du inte redan har gjort det.
Ersätt userAccessToken med den token som du har utfärdat.

Kör koden

Kör följande kommando för att paketa programvärden i på en lokal webbserver:

npm run start

Öppna din webbläsare och gå till http://localhost:8080/. I konsolen för utvecklingsverktyg i webbläsaren bör du se följande:

Azure Communication Chat client created!

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Chat SDK för JavaScript.

Name	Beskrivning
ChatClient	Den här klassen behövs för chattfunktionen. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta, ta bort trådar och prenumerera på chatthändelser.
ChatThreadClient	Den här klassen behövs för chatttrådsfunktionen. Du får en instans via ChatClient och använder den för att skicka/ta emot/uppdatera/ta bort meddelanden, lägga till/ta bort/hämta användare, skicka skrivningsmeddelanden och läskvitton.

Starta en chatttråd

Använd metoden createThread för att skapa en chatttråd.

createThreadRequest används för att beskriva trådbegäran:

Använd topic för att ge ett ämne till den här chatten. Ämnen kan uppdateras när chatttråden har skapats med hjälp av UpdateThread funktionen .
Använd participants för att lista de deltagare som ska läggas till i chatttråden.

När den har createChatThread lösts returnerar metoden CreateChatThreadResult en . Den här modellen innehåller chatThread en egenskap där du kan komma åt för den nyligen skapade id tråden. Du kan sedan använda för id att hämta en instans av en ChatThreadClient . kan ChatThreadClient sedan användas för att utföra åtgärder i tråden, till exempel skicka meddelanden eller visa deltagare.

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

När du uppdaterar webbläsarfliken bör du se följande i konsolen:

Thread created: <thread_id>

Hämta en chatttrådsklient

Metoden getChatThreadClient returnerar chatThreadClient en för en tråd som redan finns. Den kan användas för att utföra åtgärder på den skapade tråden: lägga till deltagare, skicka meddelande osv. threadId är det unika ID:t för den befintliga chatttråden.

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

Lägg till den här koden i stället för kommentaren iclient.js, uppdatera webbläsarfliken och kontrollera <CREATE CHAT THREAD CLIENT> konsolen. Du bör se: ****

Chat Thread client for threadId: <threadId>

Lista alla chatttrådar

Metoden listChatThreads returnerar en PagedAsyncIterableIterator av typen ChatThreadItem . Den kan användas för att visa en lista över alla chatttrådar. En iterator av [ChatThreadItem] är svaret som returneras från listan över trådar

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

Skicka ett meddelande till en chatttråd

Använd sendMessage metoden för att skicka ett meddelande till en tråd som identifieras av threadId.

sendMessageRequest används för att beskriva meddelandebegäran:

Använd content för att tillhandahålla innehållet i chattmeddelandet.

sendMessageOptions används för att beskriva åtgärden valfria params:

Använd senderDisplayName för att ange avsändarens visningsnamn.
Använd type för att ange meddelandetypen, till exempel "text" eller "html";
Om metadata du vill kan du inkludera ytterligare data som du vill skicka tillsammans med meddelandet. Det här fältet innehåller en mekanism för utvecklare för att utöka chattmeddelandefunktionen och lägga till anpassad information för ditt användningsfall. När du till exempel delar en fillänk i meddelandet kanske du vill lägga till "hasAttachment:true" i metadata så att mottagarens program kan parsa det och visa det.

SendChatMessageResult är svaret som returneras när ett meddelande skickas. Det innehåller ett ID, som är det unika ID:t för meddelandet.

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

Lägg till den här koden i stället <SEND MESSAGE TO A CHAT THREAD> för kommentarenclient.js, uppdatera webbläsarfliken och kontrollera konsolen.

Message sent!, message id:<number>

Ta emot chattmeddelanden från en chatttråd

Med realtidssignalering kan du prenumerera på att lyssna efter nya inkommande meddelanden och uppdatera de aktuella meddelandena i minnet därefter. Azure Communication Services stöder en lista över händelser som du kan prenumerera på.

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

Lägg till den här koden i stället <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD> för kommentaren iclient.js. Uppdatera webbläsarfliken. Du bör se ett meddelande i Notification chatMessageReceived konsolen.

Du kan också hämta chattmeddelanden genom att avssöka listMessages metoden vid angivna intervall.


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

Lägg till den här koden i stället för <LIST MESSAGES IN A CHAT THREAD> kommentaren iclient.js. Uppdatera fliken. I konsolen bör du hitta listan med meddelanden som skickas i den här chatttråden.

listMessages returnerar olika typer av meddelanden som kan identifieras av chatMessage.type .

Mer information finns i Meddelandetyper.

Lägga till en användare som en deltagare i chatttråden

När en chatttråd har skapats kan du lägga till och ta bort användare från den. Genom att lägga till användare ger du dem åtkomst att skicka meddelanden till chatttråden och lägga till/ta bort andra deltagare.

Innan du addParticipants anropar metoden ser du till att du har skaffat en ny åtkomsttoken och identitet för den användaren. Användaren behöver denna åtkomsttoken för att kunna initiera chattklienten.

addParticipantsRequest beskriver begärandeobjektet där listar participants de deltagare som ska läggas till i chatttråden.

id, obligatoriskt, är kommunikationsidentifieraren som ska läggas till i chatttråden.
displayName, valfritt, är visningsnamnet för tråddeltagaren.
shareHistoryTime, valfritt, är den tid som chatthistoriken delas med deltagaren. Om du vill dela historiken sedan chatttråden skapades anger du det datum som är lika med eller mindre än tiden för trådskapande. Om du inte vill dela någon historik före när deltagaren lades till anger du det aktuella datumet. Om du vill dela partiell historik anger du den till det datum du väljer.


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

await chatThreadClient.addParticipants(addParticipantsRequest);

Ersätt NEW_PARTICIPANT_USER_ID med ett nytt användar-ID Lägg till den här koden i stället för <ADD NEW PARTICIPANT TO THREAD> kommentaren i client.js

Visa en lista över användare i en chatttråd

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

Lägg till den här koden i stället för kommentaren iclient.js, uppdatera webbläsarfliken och kontrollera konsolen. Du bör <LIST PARTICIPANTS IN A THREAD> se information om användare i en tråd. ****

Ta bort användare från en chatttråd

På samma sätt som du lägger till en deltagare kan du ta bort deltagare från en chatttråd. För att kunna ta bort måste du spåraID:na för de deltagare som du har lagt till.

Använd removeParticipant metoden där är participant kommunikationsanvändaren som ska tas bort från tråden.


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

Ersätt PARTICIPANT_ID med ett användar-ID som användes i föregående steg (<NEW_PARTICIPANT_USER_ID>). Lägg till den här koden i stället <REMOVE PARTICIPANT FROM THREAD> för kommentaren iclient.js,

Exempelkod

Hitta den färdiga koden för den här snabbstarten på GitHub.

Förutsättningar

Innan du börjar bör du se till att:

Skapa ett Azure-konto med en aktiv prenumeration. Mer information finns i Skapa ett konto utan kostnad.
Installera Python.
Skapa en Azure Communication Services resurs. Mer information finns i Snabbstart: Skapa och hantera Communication Services resurser. Du måste registrera resursslutpunkten för den här snabbstarten.
En användaråtkomsttoken. Se till att ange omfånget chat till och anteckna token strängen samt userId strängen.

Inrätta

Skapa ett nytt Python-program

Öppna terminal- eller kommandofönstret, skapa en ny katalog för din app och gå till den.

mkdir chat-quickstart && cd chat-quickstart

Använd en textredigerare för att skapa en fil med start-chat.py i projektets rotkatalog. Lägg till strukturen för programmet, inklusive grundläggande undantagshantering. I följande avsnitt lägger du till all källkod för den här snabbstarten i den här filen.

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)

Installera SDK

Använd följande kommando för att installera SDK:


pip install azure-communication-chat

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Chat SDK för Python.

Name	Beskrivning
`ChatClient`	Den här klassen behövs för chattfunktionen. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta och ta bort trådar.
`ChatThreadClient`	Den här klassen behövs för chatttrådsfunktionen. Du får en instans via `ChatClient` och använder den för att skicka, ta emot, uppdatera och ta bort meddelanden. Du kan också använda den för att lägga till, ta bort och hämta användare, skicka meddelanden och läskvitton.

Skapa en chattklient

Om du vill skapa en chattklient använder du Communication Services slutpunkten och den åtkomsttoken som du genererade som en del av de nödvändiga stegen.

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

Den här snabbstarten omfattar inte att skapa en tjänstnivå för att hantera token för ditt chattprogram, men det rekommenderas. Mer information finns i avsnittet "Chattarkitektur" i Chattbegrepp.

Starta en chatttråd

Använd metoden create_chat_thread för att skapa en chatttråd.

Använd topic för att ge tråden ett ämne. Du kan uppdatera ämnet när chatttråden har skapats med hjälp av update_thread funktionen .
Använd thread_participants för att visa en lista över som ska läggas till i ChatParticipant chatttråden. ChatParticipanttar typen som CommunicationUserIdentifier user .

CreateChatThreadResult är resultatet som returneras när en tråd skapas. Du kan använda den för att hämta id för chatttråden som skapades. Detta id kan sedan användas för att hämta ett objekt med hjälp av metoden ChatThreadClient get_chat_thread_client . Du kan använda för ChatThreadClient att utföra andra chattåtgärder i den här chatttråden.

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)

Hämta en chatttrådsklient

Metoden get_chat_thread_client returnerar en trådklient för en tråd som redan finns. Du kan använda den för att utföra åtgärder på den skapade tråden. Du kan till exempel lägga till deltagare och skicka meddelanden. thread_id är det unika ID:t för den befintliga chatttråden.

Du kan använda för ChatThreadClient att utföra andra chattåtgärder i den här chatttråden.

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

Lista alla chatttrådar

Metoden list_chat_threads returnerar en iterator av typen ChatThreadItem .

Använd start_time för att ange den tidigaste tidpunkten för att hämta chatttrådar.
Använd results_per_page för att ange det maximala antalet chatttrådar som returneras per sida.

En iterator av [ChatThreadItem] är svaret som returneras från listtrådarna.

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)

Skicka ett meddelande till en chatttråd

Använd metoden send_message för att skicka ett meddelande till en chatttråd som du precis har skapat och som identifieras av thread_id .

Använd content för att tillhandahålla innehållet i chattmeddelandet.
Använd chat_message_type för att ange meddelandeinnehållstyp. Möjliga värden är text och html . Om du inte anger något värde är standardvärdet text .
Använd sender_display_name för att ange avsändarens visningsnamn.
Om metadata du vill kan du inkludera ytterligare data som du vill skicka tillsammans med meddelandet. Det här fältet innehåller en mekanism som utvecklare kan använda för att utöka funktionerna för chattmeddelanden och lägga till anpassad information för ditt användningsfall. När du till exempel delar en fillänk i meddelandet kanske du vill lägga till "hasAttachment:true" i metadata så att mottagarens program kan parsa det och visa det.

SendChatMessageResult är svaret som returnerades när ett meddelande skickades. Den innehåller ett ID, vilket är det unika ID:t för meddelandet.

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)

Ta emot chattmeddelanden från en chatttråd

Du kan hämta chattmeddelanden genom att avssöka list_messages metoden vid angivna intervall.

Använd results_per_page för att ange det maximala antalet meddelanden som ska returneras per sida.
Använd start_time för att ange den tidigaste tidpunkten för att hämta meddelanden.

En iterator av [ChatMessage] är svaret som returneras från listan med meddelanden.

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 returnerar den senaste versionen av meddelandet, inklusive eventuella ändringar eller borttagningar som har skett i meddelandet med hjälp av update_message och delete_message . För borttagna meddelanden ChatMessage.deleted_on returnerar ett datetime värde som anger när meddelandet togs bort. För redigerade meddelanden ChatMessage.edited_on returnerar datetime ett värde som anger när meddelandet redigerades. Du kan komma åt den ursprungliga tiden då meddelandet skapades med hjälp av ChatMessage.created_on , som kan användas för att ordna meddelanden.

list_messages returnerar olika typer av meddelanden, som kan identifieras av ChatMessage.type .

Mer information finns i Meddelandetyper.

Skicka läskvitton

Du använder metoden send_read_receipt för att skicka en händelse för läskvitto till en tråd för en användares räkning.

Använd message_id för att ange ID för det senaste meddelandet som lästs av den aktuella användaren.

content='hello world'

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

Lägga till en användare som deltagare i chatttråden

När du skapar en chatttråd kan du sedan lägga till och ta bort användare från den. Genom att lägga till användare ger du dem åtkomst för att kunna skicka meddelanden till chatttråden och lägga till eller ta bort andra deltagare. Innan du add_participants anropar metoden måste du se till att du har skaffat en ny åtkomsttoken och identitet för den användaren. Användaren behöver denna åtkomsttoken för att initiera chattklienten.

Du kan lägga till en eller flera användare i chatttråden med hjälp av metoden , förutsatt att en ny åtkomsttoken och identitet add_participants är tillgänglig för alla användare.

En list(tuple(ChatParticipant, CommunicationError)) returneras. När deltagaren har lagts till förväntas en tom lista. Om du stöter på ett fel när du lägger till en deltagare fylls listan i med de misslyckade deltagarna, tillsammans med det fel som påträffades.

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)

Lista tråddeltagare i en chatttråd

På samma sätt som du lägger till en deltagare kan du även visa deltagare från en tråd.

Använd list_participants för att hämta deltagarna i tråden. Båda följande kommandon är valfria:

Använd results_per_page för att ange det maximala antalet deltagare som ska returneras per sida.
Använd skip för att hoppa över deltagarna upp till en angiven position i svaret.

En iterator av [ChatParticipant] är svaret som returneras från listdeltagarna.

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)

Kör koden

Kör programmet från programkatalogen med python kommandot .

python start-chat.py

Exempelkod

Hitta den färdiga koden för den här snabbstarten på GitHub.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
Java Development Kit (JDK) version 8 eller senare.
Apache Maven.
En distribuerad Communication Services resurs och anslutningssträng. Skapa en Communication Services resurs.
En token för användaråtkomst. Se till att ange omfånget till "chat" och notera tokensträngen samt userId-strängen.

Inrätta

Skapa ett nytt Java-program

Öppna terminal- eller kommandofönstret och navigera till den katalog där du vill skapa Java-programmet. Kör kommandot nedan för att generera Java-projektet från mallen maven-archetype-quickstart.

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

Du ser att målet "generera" skapade en katalog med samma namn som artifactId. Under den här katalogen innehåller projektets källkod, innehåller katalogen testkällan och src/main/java directory pom.xml-filen är projektets Project src/test/java Object Model eller POM.

Uppdatera programmets POM-fil för att använda Java 8 eller senare:

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

Lägga till paketreferenser för Chat SDK

I POM-filen refererar du till azure-communication-chat paketet med chat-API:erna:

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

För autentisering måste klienten referera till azure-communication-common paketet:

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Chat SDK för Java.

Name	Beskrivning
ChatClient	Den här klassen behövs för chattfunktionen. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta och ta bort trådar.
ChatAsyncClient	Den här klassen behövs för funktionen för asynkron chatt. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta och ta bort trådar.
ChatThreadClient	Den här klassen behövs för chatttrådsfunktionen. Du får en instans via ChatClient och använder den för att skicka/ta emot/uppdatera/ta bort meddelanden, lägga till/ta bort/hämta användare, skicka skrivmeddelanden och läskvitton.
ChatThreadAsyncClient	Den här klassen behövs för funktionen för asynkron chatttråd. Du får en instans via ChatAsyncClient och använder den för att skicka/ta emot/uppdatera/ta bort meddelanden, lägga till/ta bort/hämta användare, skicka skrivmeddelanden och läskvitton.

Skapa en chattklient

Om du vill skapa en chattklient använder du kommunikationstjänstens slutpunkt och den åtkomsttoken som genererades som en del av de nödvändiga stegen. Med token för användaråtkomst kan du skapa klientprogram som autentiserar direkt Azure Communication Services. När du har genererat dessa token på servern skickar du tillbaka dem till en klientenhet. Du måste använda klassen CommunicationTokenCredential från Common SDK för att skicka token till chattklienten.

Läs mer om chattarkitektur

När du lägger till importutsatserna måste du bara lägga till importer från namnrymderna com.azure.communication.chat och com.azure.communication.chat.models och inte från namnområdet com.azure.communication.chat.implementation. I filen App.java som genererades via Maven kan du börja med följande kod:

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

Starta en chatttråd

Använd metoden createChatThread för att skapa en chatttråd. createChatThreadOptions används för att beskriva trådbegäran.

Använd topic -parametern för konstruktorn för att ge ett ämne till den här chatten. Ämnet kan uppdateras när chatttråden har skapats med hjälp av UpdateThread funktionen .
Använd participants för att lista tråddeltagarna som ska läggas till i tråden. ChatParticipant tar den användare som du skapade i snabbstarten för användaråtkomsttoken.

CreateChatThreadResult är svaret som returneras när en chatttråd skapas. Den innehåller en -metod som returnerar objektet som kan användas för att hämta trådklienten som du kan hämta för att utföra åtgärder på den skapade tråden: lägga till getChatThread() ChatThread ChatThreadClient deltagare, skicka meddelande osv. -objektet ChatThread innehåller också metoden som hämtar getId() trådens unika ID.

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

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

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

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

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

Lista chatttrådar

Använd metoden listChatThreads för att hämta en lista över befintliga chatttrådar.

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

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

Hämta en chatttrådsklient

Metoden getChatThreadClient returnerar en trådklient för en tråd som redan finns. Den kan användas för att utföra åtgärder på den skapade tråden: lägga till deltagare, skicka meddelande osv. chatThreadId är det unika ID:t för den befintliga chatttråden.

ChatThreadClient chatThreadClient = chatClient.getChatThreadClient(chatThreadId);

Skicka ett meddelande till en chatttråd

Använd metoden sendMessage för att skicka ett meddelande till den tråd som du nyss skapade, identifierad av chatThreadId. sendChatMessageOptions används för att beskriva begäran om chattmeddelanden.

Använd content för att tillhandahålla innehållet i chattmeddelandet.
Använd type för att ange innehållstyp för chattmeddelanden, TEXT eller HTML.
Använd senderDisplayName för att ange avsändarens visningsnamn.
Om metadata du vill kan du inkludera ytterligare data som du vill skicka tillsammans med meddelandet. Det här fältet innehåller en mekanism som utvecklare kan använda för att utöka funktionerna för chattmeddelanden och lägga till anpassad information för ditt användningsfall. När du till exempel delar en fillänk i meddelandet kanske du vill lägga till "hasAttachment:true" i metadata så att mottagarens program kan parsa det och visa det.

Svaret innehåller sendChatMessageResult ett , som är det unika id ID:t för meddelandet.

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

Ta emot chattmeddelanden från en chatttråd

Du kan hämta chattmeddelanden genom att avssöka listMessages metoden på chatttrådklienten vid angivna intervall.

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

listMessages returnerar den senaste versionen av meddelandet, inklusive eventuella ändringar eller borttagningar som har inträffat med hjälp av .editMessage() och .deleteMessage(). För borttagna meddelanden chatMessage.getDeletedOn() returnerar ett datetime-värde som anger när meddelandet togs bort. För redigerade meddelanden chatMessage.getEditedOn() returnerar ett datetime-värde som anger när meddelandet redigerades. Den ursprungliga tiden då meddelandet skapades kan nås med hjälp av chatMessage.getCreatedOn() , och den kan användas för att ordna meddelanden.

Läs mer om meddelandetyper här: Meddelandetyper.

Skicka läskvitton

Använd metoden sendReadReceipt för att publicera en mottagningshändelse för läsning i en chatttråd för en användares räkning. chatMessageId är det unika ID:t för det chattmeddelande som lästes.

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

Lista chattdeltagare

Använd listParticipants för att hämta en sidad samling som innehåller deltagarna i chatttråden som identifieras av chatThreadId.

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

Lägga till en användare som deltagare i chatttråden

När en chatttråd har skapats kan du lägga till och ta bort användare från den. Genom att lägga till användare ger du dem åtkomst till att skicka meddelanden till chatttråden och lägger till/tar bort andra deltagare. Du måste börja med att hämta en ny åtkomsttoken och identitet för den användaren. Innan du anropar metoden addParticipants måste du se till att du har skaffat en ny åtkomsttoken och identitet för den användaren. Användaren behöver denna åtkomsttoken för att kunna initiera chattklienten.

Använd metoden addParticipants för att lägga till deltagare i tråden.

communicationIdentifier, krävs, är den CommunicationIdentifier som du har skapat av CommunicationIdentityClient i snabbstarten för användaråtkomsttoken.
displayName, valfritt, är visningsnamnet för tråddeltagaren.
shareHistoryTime, valfritt, är den tid som chatthistoriken delas med deltagaren. Om du vill dela historik sedan chatttråden startades anger du det datum som är lika med eller mindre än tiden då tråden skapades. Om du inte vill dela någon historik före när deltagaren lades till anger du det aktuella datumet. Om du vill dela partiell historik anger du det datum som krävs.

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

Kör koden

Gå till katalogen som innehåller pom.xml och kompilera projektet med hjälp av följande mvn kommando.

mvn compile

Skapa sedan paketet.

mvn package

Kör följande mvn kommando för att köra appen.

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

Exempelkod

Hitta den färdiga koden för den här snabbstarten på GitHub.

Förutsättningar

Innan du börjar bör du se till att:

Skapa ett Azure-konto med en aktiv prenumeration. Mer information finns i Skapa ett konto utan kostnad.
Installera Android Studiokommer vi att använda Android Studio för att skapa ett Android-program för snabbstarten för att installera beroenden.
Skapa en Azure Communication Services resurs. Mer information finns i Skapa en Azure Communication Services resurs. Du måste registrera resursslutpunkten för den här snabbstarten.
Skapa två Communication Services användare och ge dem en användaråtkomsttoken för användaråtkomsttoken. Se till att ställa in omfånget på chatt och notera tokensträngen och userId-strängen. I den här snabbstarten skapar vi en tråd med en inledande deltagare och lägger sedan till en andra deltagare i tråden.

Inrätta

Skapa ett nytt Android-program

Öppna Android Studio och välj Create a new project .
I nästa fönster väljer du Empty Activity som projektmall.
När du väljer alternativ anger ChatQuickstart du som projektnamn.
Klicka på Nästa och välj den katalog där du vill att projektet ska skapas.

Installera biblioteken

Vi använder Gradle för att installera Communication Services beroenden. Från kommandoraden navigerar du i rotkatalogen för ChatQuickstart projektet. Öppna appens build.gradle-fil och lägg till följande beroenden i ChatQuickstart målet:

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

Se och för https://search.maven.org/artifact/com.azure.android/azure-communication-common https://search.maven.org/artifact/com.azure.android/azure-communication-chat de senaste versionsnummer.

Undanta metafiler i paketeringsalternativ i 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")
    }
}

(Alternativ) Installera bibliotek via Maven

Om du vill importera biblioteket till ditt projekt med hjälp av Maven-byggsystemet lägger du till det i avsnittet i appens -fil, anger dess artefakt-ID och den dependencies version som du vill pom.xml använda:

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

Konfigurera platshållarna

Öppna och redigera filen MainActivity.java . I den här snabbstarten lägger vi till vår kod MainActivity i och visar utdata i konsolen. Den här snabbstarten går inte ut på att skapa ett användargränssnitt. Längst upp i filen importerar du Communication common , Communication chat och andra systembibliotek:

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;

Kopiera följande kod till klassen MainActivity i filen 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());
        }
    }

Ersätt <resource> med Communication Services resurs.
Ersätt <first_user_id> och med Communication Services <second_user_id> användar-ID:t som genererades som en del av de nödvändiga stegen.
Ersätt <first_user_access_token> med Communication Services åtkomsttoken för <first_user_id> som genererades som en del av de nödvändiga stegen.
Ersätt <chat_sdk_version> med versionen av Azure Communication Chat SDK.

I följande steg ersätter vi platshållarna med exempelkod med hjälp av Azure Communication Services Chat.

Skapa en chattklient

Ersätt kommentaren <CREATE A CHAT CLIENT> med följande kod (placera import-uttrycken överst i filen):

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Chat SDK för JavaScript.

Name	Beskrivning
ChatClient/ChatAsyncClient	Den här klassen behövs för chattfunktionen. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta, ta bort trådar och prenumerera på chatthändelser.
ChatThreadClient/ChatThreadAsyncClient	Den här klassen behövs för chatttrådsfunktionen. Du får en instans via ChatClient och använder den för att skicka/ta emot/uppdatera/ta bort meddelanden, lägga till/ta bort/hämta användare, skicka skrivmeddelanden och läskvitton.

Starta en chatttråd

Vi använder vår för ChatAsyncClient att skapa en ny tråd med en inledande användare.

Ersätt kommentaren <CREATE A CHAT THREAD> med följande kod:

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

Hämta en chatttrådsklient

Nu när vi har skapat en chatttråd hämtar vi en ChatThreadAsyncClient för att utföra åtgärder i tråden. Ersätt kommentaren <CREATE A CHAT THREAD CLIENT> med följande kod:

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

Skicka ett meddelande till en chatttråd

Vi skickar ett meddelande till den tråden nu.

Ersätt kommentaren <SEND A MESSAGE> med följande kod:

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

Ta emot chattmeddelanden från en chatttråd

Realtidsmeddelanden

Med realtidssignalering kan du prenumerera på nya inkommande meddelanden och uppdatera de aktuella meddelandena i minnet på motsvarande sätt. Azure Communication Services stöder en lista över händelser som du kan prenumerera på.

Ersätt kommentaren <RECEIVE CHAT MESSAGES> med följande kod (placera import-uttrycken överst i filen):


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

Viktigt

Känt problem: När du använder Android Chat och Calling SDK tillsammans i samma program fungerar inte Chat SDK:s funktion för realtidsmeddelanden. Du kan få ett beroende som löser problemet. Medan vi arbetar med en lösning kan du inaktivera funktionen för realtidsmeddelanden genom att lägga till följande beroendeinformation i appens build.gradle-fil och i stället avse GetMessages-API:et för att visa inkommande meddelanden för användare.

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'

Observera med ovanstående uppdatering, om programmet försöker röra något av meddelande-API:et som eller chatAsyncClient.startRealtimeNotifications() , kommer det att finnas ett chatAsyncClient.addEventHandler() körningsfel.

Push-meddelanden

Anteckning

För närvarande stöds endast chatt-push-meddelanden för Android SDK i version 1.1.0-beta.4.

Med push-meddelanden kan klienter meddelas om inkommande meddelanden och andra åtgärder som sker i en chatttråd i situationer där mobilappen inte körs i förgrunden. Azure Communication Services stöder en lista över händelser som du kan prenumerera på.

Konfigurera Firebase Cloud Messaging med ChatQuickstart-projekt. Slutför stegen Create a Firebase project , , , och i Register your app with Firebase Add a Firebase configuration file Add Firebase SDKs to your app Edit your app manifest Firebase-dokumentationen.
Skapa en Meddelandehubb i samma prenumeration som din Communication Services-resurs, konfigurera Firebase Cloud Messaging-inställningarna för hubben och länka Notification Hub till din Communication Services resurs. Se Notification Hub-etablering.

Skapa en ny fil MyFirebaseMessagingService.java med samma sökväg som filen MainActivity.java . Kopiera följande kod till filen MyFirebaseMessagingService.java . Du måste ersätta med <your_package_name> det paketnamn som används i MainActivity.java . Du kan använda ditt eget värde för <your_intent_name> . Det här värdet används i steg 6 nedan.

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

Längst upp i filen MainActivity.java lägger du till följande import:

   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;

Lägg till följande kod i klassen 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);
                       }
                   });
               }
           });
   }

Funktionen Update onCreate i klassen 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>"));
   }

Lägg till följande kod nedan <RECEIVE CHAT MESSAGES> kommentar:

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

Lägga till en användare som deltagare i chatttråden

Ersätt kommentaren <ADD A USER> med följande kod:

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

Visa en lista över användare i en tråd

Ersätt <LIST USERS> kommentaren med följande kod (placera import-uttrycken överst i filen):

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

Ta bort användare från en chatttråd

Vi tar bort den andra användaren från tråden nu.

Ersätt kommentaren <REMOVE A USER> med följande kod:

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

Skicka ett skrivmeddelande

Ersätt kommentaren <SEND A TYPING NOTIFICATION> med följande kod:

chatThreadAsyncClient.sendTypingNotification().get();

Skicka ett kvitto för läsning

Vi skickar ett läskvitto för meddelandet som skickades ovan.

Ersätt kommentaren <SEND A READ RECEIPT> med följande kod:

chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();

Visa läskvitton

Ersätt kommentaren <READ RECEIPTS> med följande kod:

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

Kör koden

I Android Studio du på knappen Kör för att skapa och köra projektet. I -konsolen kan du visa utdata från koden och loggarens utdata från ChatClient.

Exempelkod

Hitta den färdiga koden för den här snabbstarten på GitHub.

Förutsättningar

Innan du börjar bör du se till att:

Skapa ett Azure-konto med en aktiv prenumeration. Mer information finns i Skapa ett konto utan kostnad.
Installera Visual Studio
Skapa en Azure Communication Services resurs. Mer information finns i Skapa en Azure Communication Services resurs. Du måste registrera resursslutpunkten för den här snabbstarten.
En token för användaråtkomst. Se till att ange omfånget till "chat" och notera tokensträngen samt userId-strängen.

Inrätta

Skapa ett nytt C#-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du kommandot för att skapa en dotnet new ny konsolapp med namnet ChatQuickstart . Det här kommandot skapar ett enkelt "Hello World" C#-projekt med en enda källfil: Program.cs.

dotnet new console -o ChatQuickstart

Ändra katalogen till den nyligen skapade appmappen och använd kommandot dotnet build för att kompilera ditt program.

cd ChatQuickstart
dotnet build

Installera paketet

Installera Azure Communication Chat SDK för .NET

dotnet add package Azure.Communication.Chat

Objektmodell

Följande klasser hanterar några av de viktigaste funktionerna i Azure Communication Services Chat SDK för C#.

Name	Beskrivning
ChatClient	Den här klassen behövs för chattfunktionen. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta och ta bort trådar.
ChatThreadClient	Den här klassen behövs för chatttrådsfunktionen. Du får en instans via ChatClient och använder den för att skicka/ta emot/uppdatera/ta bort meddelanden, lägga till/ta bort/hämta deltagare, skicka meddelanden som skriver och läskvitton.

Skapa en chattklient

Om du vill skapa en chattklient använder du din Communication Services slutpunkt och den åtkomsttoken som genererades som en del av de nödvändiga stegen. Du måste använda klassen från Identity SDK för att skapa en användare och utfärda CommunicationIdentityClient en token som ska överföras till chattklienten.

Läs mer om token för användaråtkomst.

Den här snabbstarten omfattar inte att skapa en tjänstnivå för att hantera token för ditt chattprogram, även om det rekommenderas. Läs mer om chattarkitektur

Kopiera följande kodfragment och klistra in i källfilen: 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);
        }
    }
}

Starta en chatttråd

Använd metoden createChatThread på chatClient för att skapa en chatttråd

Använd topic för att ge ett ämne till den här chatten; Ämnet kan uppdateras när chatttråden har skapats med hjälp av UpdateTopic funktionen .
Använd participants egenskapen för att skicka en lista över objekt som ska läggas till i ChatParticipant chatttråden. Objektet ChatParticipant initieras med ett CommunicationIdentifier -objekt. CommunicationIdentifier kan vara av typen CommunicationUserIdentifier , MicrosoftTeamsUserIdentifier eller PhoneNumberIdentifier . Om du till exempel vill hämta ett -objekt måste du skicka ett åtkomst-ID som du har skapat genom att följa anvisningarna CommunicationIdentifier för att skapa en användare

Svarsobjektet från createChatThread metoden innehåller chatThread informationen. För att interagera med chatttrådsåtgärder som att lägga till deltagare, skicka ett meddelande, ta bort ett meddelande osv. måste en klientinstans instansieras med hjälp av metoden chatThreadClient GetChatThreadClient på ChatClient klienten.

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;

Hämta en chatttrådsklient

Metoden GetChatThreadClient returnerar en trådklient för en tråd som redan finns. Den kan användas för att utföra åtgärder på den skapade tråden: lägga till medlemmar, skicka meddelande osv. threadId är det unika ID:t för den befintliga chatttråden.

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

Lista alla chatttrådar

Använd GetChatThreads för att hämta alla chatttrådar som användaren ingår i.

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

Skicka ett meddelande till en chatttråd

Använd SendMessage för att skicka ett meddelande till en tråd.

Använd content för att ange innehållet för meddelandet, det är obligatoriskt.
Använd type för innehållstypen för meddelandet, till exempel "Text" eller "Html". Om inget anges anges "Text".
Använd senderDisplayName för att ange avsändarens visningsnamn. Om inget anges anges en tom sträng.
Om metadata du vill kan du inkludera ytterligare data som du vill skicka tillsammans med meddelandet. Det här fältet innehåller en mekanism som utvecklare kan använda för att utöka funktionerna för chattmeddelanden och lägga till anpassad information för ditt användningsfall. När du till exempel delar en fillänk i meddelandet kanske du vill lägga till "hasAttachment:true" i metadata så att mottagarens program kan parsa det och visa det.

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;

Ta emot chattmeddelanden från en chatttråd

Du kan hämta chattmeddelanden genom att avssöka GetMessages metoden på chatttrådklienten vid angivna intervall.

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

GetMessages tar en valfri DateTimeOffset parameter. Om den förskjutningen anges får du meddelanden som har tagits emot, uppdaterats eller tagits bort efter den. Observera att meddelanden som tas emot före förskjutningstiden men som redigeras eller tas bort efter det också returneras.

GetMessages returnerar den senaste versionen av meddelandet, inklusive eventuella redigeringar eller borttagningar som inträffat i meddelandet med UpdateMessage hjälp av och DeleteMessage . För borttagna meddelanden chatMessage.DeletedOn returnerar ett datetime-värde som anger när meddelandet togs bort. För redigerade meddelanden chatMessage.EditedOn returnerar ett datetime-värde som anger när meddelandet redigerades. Den ursprungliga tiden då meddelandet skapades kan nås med hjälp av chatMessage.CreatedOn , och den kan användas för att ordna meddelanden.

GetMessages returnerar olika typer av meddelanden som kan identifieras av chatMessage.Type . Dessa typer är:

Text: Vanligt chattmeddelande som skickas av en trådmedlem.
Html: Ett formaterat textmeddelande. Observera att Communication Services användare för närvarande inte kan skicka RichText-meddelanden. Den här meddelandetypen stöds av meddelanden som skickas från Teams till Communication Services användare i Teams Interop-scenarier.
TopicUpdated: Systemmeddelande som anger att ämnet har uppdaterats. (skrivskyddade)
ParticipantAdded: Systemmeddelande som anger att en eller flera deltagare har lagts till i chatttråden. (skrivskyddade)
ParticipantRemoved: Systemmeddelande som anger att en deltagare har tagits bort från chatttråden.

Mer information finns i Meddelandetyper.

Lägga till en användare som deltagare i chatttråden

När en tråd har skapats kan du lägga till och ta bort användare från den. Genom att lägga till användare ger du dem åtkomst för att kunna skicka meddelanden till tråden och lägga till/ta bort andra deltagare. Innan du AddParticipants anropar bör du kontrollera att du har skaffat en ny åtkomsttoken och identitet för den användaren. Användaren behöver denna åtkomsttoken för att kunna initiera chattklienten.

Använd AddParticipants för att lägga till en eller flera deltagare i chatttråden. Följande är attribut som stöds för varje tråddeltagare:

communicationUser, obligatoriskt, är tråddeltagarens identitet.
displayName, valfritt, är visningsnamnet för tråddeltagaren.
shareHistoryTime, valfri, tid då chatthistoriken delas med deltagaren.

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

Hämta tråddeltagare

Använd GetParticipants för att hämta deltagarna i chatttråden.

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

Skicka läskvitton

Använd SendReadReceipt för att meddela andra deltagare att meddelandet läses av användaren.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

Kör koden

Kör programmet från programkatalogen med dotnet run kommandot .

dotnet run

Exempelkod

Hitta den färdiga koden för den här snabbstarten på GitHub.

Förutsättningar

Innan du börjar bör du se till att:

Skapa ett Azure-konto med en aktiv prenumeration. Mer information finns i Skapa ett konto utan kostnad.
Installera Xcode och CocoaPods. Du använder Xcode för att skapa ett iOS-program för snabbstarten och CocoaPods för att installera beroenden.
Skapa en Azure Communication Services resurs. Mer information finns i Snabbstart: Skapa och hantera Communication Services resurser. För den här snabbstarten behöver du registrera din resursslutpunkt.
Skapa två användare i Azure Communication Services och utfärda en token för användaråtkomst. Se till att ange omfånget chat till och anteckna token strängen samt userId strängen. I den här snabbstarten skapar du en tråd med en första deltagare och lägger sedan till en andra deltagare i tråden.

Inrätta

Skapa ett nytt iOS-program

Öppna Xcode och välj Skapa ett nytt Xcode-projekt. Välj sedan iOS som plattform och App för mallen.

Som projektnamn anger du ChatQuickstart. Välj sedan Storyboard som gränssnitt, UIKit App Delegate som livscykel och Swift som språk.

Välj Nästa och välj den katalog där du vill att projektet ska skapas.

Installera biblioteken

Använd CocoaPods för att installera Communication Services beroenden.

Från kommandoraden går du in i rotkatalogen för ChatQuickstart iOS-projektet. Skapa en podfile med följande kommando: pod init .

Öppna podfilen och lägg till följande beroenden i ChatQuickstart målet:

pod 'AzureCommunicationCommon', '~> 1.0.2'
pod 'AzureCommunicationChat', '~> 1.1.0-beta.2'

Installera beroendena med följande kommando: pod install . Observera att detta även skapar en Xcode-arbetsyta.

När du pod install har kört öppnar du projektet i Xcode igen genom att välja den nyligen skapade .xcworkspace .

Konfigurera platshållarna

Öppna arbetsytan ChatQuickstart.xcworkspace i Xcode och öppna sedan ViewController.swift .

I den här snabbstarten lägger du till koden viewController i och visar utdata i Xcode-konsolen. Den här snabbstarten handlar inte om att skapa ett användargränssnitt i iOS.

Längst upp i viewController.swift importerar du AzureCommunication biblioteken och AzureCommunicatonChat :

import AzureCommunicationCommon
import AzureCommunicationChat

Kopiera följande kod till viewDidLoad() metoden för 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)")
            }
        }
    }

I demonstrationssyfte använder vi en semaphore för att synkronisera koden. I följande steg ersätter du platshållarna med exempelkod med hjälp av Azure Communication Services Chat-biblioteket.

Skapa en chattklient

Om du vill skapa en chattklient använder du din Communication Services slutpunkt och den åtkomsttoken som genererades som en del av de nödvändiga stegen.

Läs mer om token för användaråtkomst.

Den här snabbstarten omfattar inte att skapa en tjänstnivå för att hantera token för ditt chattprogram, även om det rekommenderas. Läs mer om chattarkitektur

Ersätt kommentaren <CREATE A CHAT CLIENT> med kodfragmentet nedan:

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
)

Ersätt <ACS_RESOURCE_ENDPOINT> med slutpunkten för Azure Communication Services resurs. Ersätt <ACCESS_TOKEN> med en giltig Communication Services åtkomsttoken.

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Azure Communication Services Chat SDK för iOS.

Name	Beskrivning
`ChatClient`	Den här klassen behövs för chattfunktionen. Du instansierar den med din prenumerationsinformation och använder den för att skapa, hämta, ta bort trådar och prenumerera på chatthändelser.
`ChatThreadClient`	Den här klassen behövs för chatttrådsfunktionen. Du får en instans via `ChatClient` och använder den för att skicka, ta emot, uppdatera och ta bort meddelanden. Du kan också använda den för att lägga till, ta bort och hämta användare, skicka meddelanden om att skriva och läsa kvitton.

Starta en chatttråd

CreateChatThreadResult är svaret som returnerades när en chatttråd skapas. Den innehåller en chatThread egenskap som är ChatThreadProperties -objektet. Det här objektet innehåller threadId som kan användas för att få en för att utföra åtgärder på den skapade ChatThreadClient tråden: lägga till deltagare, skicka meddelande osv.

Ersätt kommentaren <CREATE A CHAT THREAD> med kodfragmentet nedan:

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

Ersätt <USER_ID> med ett giltigt Communication Services användar-ID.

Du använder en semaphore här för att vänta på slutförandehanteraren innan du fortsätter. I senare steg använder du från svaret threadId som returnerades till slutförandehanteraren.

Lista alla chatttrådar

När vi har skapat en chatttråd kan vi lista alla chatttrådar genom att anropa listChatThreads metoden på ChatClient . Ersätt kommentaren <LIST ALL CHAT THREADS> med följande kod:

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

Hämta en chatttrådsklient

Metoden createClient returnerar en ChatThreadClient för en tråd som redan finns. Den kan användas för att utföra åtgärder på den skapade tråden: lägga till deltagare, skicka meddelande osv. threadId är det unika ID:t för den befintliga chatttråden.

Ersätt kommentaren <GET A CHAT THREAD CLIENT> med följande kod:

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

Skicka ett meddelande till en chatttråd

Använd metoden send för att skicka ett meddelande till en tråd som identifieras av threadId.

SendChatMessageRequest används för att beskriva meddelandebegäran:

Använd content för att tillhandahålla chattmeddelandeinnehåll
Använd senderDisplayName för att ange avsändarens visningsnamn
Använd type för att ange meddelandetypen, till exempel "text" eller "html"
Om metadata du vill kan du inkludera ytterligare data som du vill skicka tillsammans med meddelandet. Det här fältet innehåller en mekanism för utvecklare för att utöka funktionerna för chattmeddelanden och lägga till anpassad information för ditt användningsfall. När du till exempel delar en fillänk i meddelandet kanske du vill lägga till "hasAttachment:true" i metadata så att mottagarens program kan parsa det och visa det.

SendChatMessageResult är det svar som returneras när ett meddelande skickas. Det innehåller ett ID, vilket är det unika ID:t för meddelandet.

Ersätt kommentaren <SEND A MESSAGE> med kodfragmentet nedan:

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

Skicka ett kvitto för läsning

Använd metoden sendReadReceipt för att publicera en mottagningshändelse för läsning i en chatttråd för en användares räkning. messageId är det unika ID:t för det chattmeddelande som lästes.

Ersätt kommentaren <SEND A READ RECEIPT> med koden nedan:

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

Ta emot chattmeddelanden från en chatttråd

Ersätt kommentaren <RECEIVE MESSAGES> med koden nedan. När du har aktivera meddelanden kan du försöka skicka nya meddelanden för att se ChatMessageReceivedEvents.

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

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

Du kan också hämta chattmeddelanden genom att avssöka listMessages metoden vid angivna intervall. Se följande kodfragment för 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()

Lägga till en användare som deltagare i chatttråden

När en tråd har skapats kan du lägga till och ta bort användare från den. Genom att lägga till användare ger du dem åtkomst för att kunna skicka meddelanden till tråden och lägga till/ta bort andra deltagare. Innan du add anropar bör du kontrollera att du har skaffat en ny åtkomsttoken och identitet för den användaren. Användaren behöver denna åtkomsttoken för att kunna initiera chattklienten.

Använd metoden add för för att lägga till en eller flera deltagare i ChatThreadClient chatttråden. Följande är attribut som stöds för varje tråddeltagare:

id, obligatoriskt, är tråddeltagarens identitet.
displayName, valfritt, är visningsnamnet för tråddeltagaren.
shareHistoryTime, valfri, tid då chatthistoriken delas med deltagaren.

Ersätt kommentaren <ADD A USER> med följande kod:

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

Ersätt <USER_ID> med Communication Services användar-ID för den användare som ska läggas till.

Visa en lista över användare i en tråd

Använd metoden listParticipants för att hämta alla deltagare för en viss chatttråd.

Ersätt kommentaren <LIST USERS> med följande kod:

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

Kör koden

I Xcode trycker du på knappen Kör för att skapa och köra projektet. I -konsolen kan du visa utdata från koden och loggarens utdata från ChatClient.

Obs! Ange Build Settings > Build Options > Enable Bitcode till No . AzureCommunicationChat SDK för iOS stöder för närvarande inte aktivering av bitkod. Följande problem GitHub spårar detta.

Rensa resurser

Om du vill rensa och ta bort en Communication Services prenumeration kan du ta bort resursen eller resursgruppen. Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort. Läs mer om att rensa resurser.

Nästa steg

I den här snabbstarten har du lärt dig att:

Skapa en chattklient
Skapa en tråd med två användare
Skicka ett meddelande till tråden
Ta emot meddelanden från en tråd
Ta bort användare från en tråd

Testa Chatthjältappen

Du kanske också vill:

Lär dig mer om chattbegrepp
Bekanta dig med Chat SDK

Snabbstart: Lägga till chatt i din app

Betygsätta din upplevelse

Exempelkod

Förutsättningar

Inrätta

Skapa en ny webbapp

Installera paketen

Konfigurera appramverket

Skapa en chattklient

Kör koden

Objektmodell

Starta en chatttråd

Hämta en chatttrådsklient

Lista alla chatttrådar

Skicka ett meddelande till en chatttråd

Ta emot chattmeddelanden från en chatttråd

Lägga till en användare som en deltagare i chatttråden

Visa en lista över användare i en chatttråd

Ta bort användare från en chatttråd

Exempelkod

Förutsättningar

Inrätta

Skapa ett nytt Python-program

Installera SDK

Objektmodell

Skapa en chattklient

Starta en chatttråd

Hämta en chatttrådsklient

Lista alla chatttrådar

Skicka ett meddelande till en chatttråd

Ta emot chattmeddelanden från en chatttråd

Skicka läskvitton

Lägga till en användare som deltagare i chatttråden

Lista tråddeltagare i en chatttråd

Kör koden

Exempelkod

Förutsättningar

Inrätta

Skapa ett nytt Java-program

Lägga till paketreferenser för Chat SDK

Objektmodell

Skapa en chattklient

Starta en chatttråd

Lista chatttrådar

Hämta en chatttrådsklient

Skicka ett meddelande till en chatttråd

Ta emot chattmeddelanden från en chatttråd

Skicka läskvitton

Lista chattdeltagare

Lägga till en användare som deltagare i chatttråden

Kör koden

Exempelkod

Förutsättningar

Inrätta

Skapa ett nytt Android-program

Installera biblioteken

Undanta metafiler i paketeringsalternativ i root build.gradle

(Alternativ) Installera bibliotek via Maven

Konfigurera platshållarna

Skapa en chattklient

Objektmodell

Starta en chatttråd

Hämta en chatttrådsklient

Skicka ett meddelande till en chatttråd

Ta emot chattmeddelanden från en chatttråd

Realtidsmeddelanden

Push-meddelanden

Lägga till en användare som deltagare i chatttråden

Visa en lista över användare i en tråd

Ta bort användare från en chatttråd

Skicka ett skrivmeddelande

Skicka ett kvitto för läsning

Visa läskvitton

Kör koden

Exempelkod

Förutsättningar

Inrätta

Skapa ett nytt C#-program

Installera paketet

Objektmodell