Rychlý Start: Přidání chatu do aplikace

  • Článek
  • 44 min ke čtení

Začněte s komunikačními službami Azure pomocí služby Communications Chat SDK a přidejte do své aplikace chat v reálném čase. V tomto rychlém startu budeme k vytváření chatovacích vláken, která umožňují uživatelům navzájem komunikovat, použít sadu Chat SDK. Další informace o konceptech chatu najdete v Koncepční dokumentaci k chatu.

Příklad kódu

Finalizovaný kód pro tento rychlý start najdete na GitHub.

Požadavky

Než začnete, nezapomeňte:

  • Vytvořte účet Azure s aktivním předplatným. Podrobnosti najdete v tématu Vytvoření účtu zdarma.
  • Nainstalujte Node.js VERZE LTS a Údržby LTS.
  • Vytvořte prostředek Azure Communication Services. Podrobnosti najdete v tématu Vytvoření prostředku Azure Communication Services . Pro tento rychlý start budete muset zaznamenat koncový bod prostředku.
  • Vytvořte tři uživatele služby ACS a vydejte jim přístupový token uživatele Přístupový token uživatele. Nezapomeňte nastavit rozsah pro chat a poznamenejte si řetězec tokenu a také řetězec userId . Úplná ukázka vytvoří vlákno se dvěma počátečními účastníky a pak do vlákna přidá třetí účastník.

Nastavení

Vytvoření nové webové aplikace

Nejprve otevřete terminál nebo příkazové okno a vytvořte nový adresář pro vaši aplikaci a přejděte do něj.

mkdir chat-quickstart && cd chat-quickstart

Spuštěním npm init -y vytvořte souborpackage.js s výchozím nastavením.

npm init -y

Instalace balíčků

Pomocí příkazu npm install nainstalujte následující sady SDK Communication Services 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

Možnost --save vypíše knihovnu jako závislost v souborupackage.js on.

Nastavení architektury aplikace

V tomto rychlém startu se k vytvoření sady prostředků aplikace používá webpack. Spuštěním následujícího příkazu nainstalujte balíčky npm webpack, webpack-cli a webpack-dev-server a vypište je jako vývojové závislosti ve vašem package.jsna:

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

Vytvořte soubor webpack.config.js v kořenovém adresáři. Do tohoto souboru zkopírujte následující konfiguraci:

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

Přidejte start do souboru skript , který package.json použijeme ke spuštění aplikace. Do scripts části souboru package.json přidejte následující:

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

Vytvořte soubor index.html v kořenovém adresáři projektu. Tento soubor použijeme jako šablonu pro přidání možností chatu pomocí sady SDK služby Azure Communication Chat pro 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>

V kořenovém adresáři projektu vytvořte soubor s názvem client.js, který bude obsahovat logiku aplikace pro tento rychlý start.

Vytvoření chatovací klienta

K vytvoření chatového klienta ve webové aplikaci použijete koncový bod služby Communications Service a přístupový token vygenerovaný v rámci požadovaných kroků.

Přístupové tokeny uživatelů umožňují vytvářet klientské aplikace, které se ověřují přímo Azure Communication Services. Tento rychlý start nepokryje vytvoření úrovně služby pro správu tokenů pro chatovací aplikaci. Další informace o architektuře chatu a přístupových tokenech uživatelů najdete v tématu Koncepty chatu, ve které najdete další informace o přístupových tokenech.

Uvnitř client.js pomocí koncového bodu a přístupového tokenu v následujícím kódu přidejte možnosti chatu pomocí sady SDK služby Azure Communication Chat pro 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!');
  • Adresu endpointUrl nahraďte koncovým bodem Communication Services prostředku. Pokud jste to ještě neudělali, Azure Communication Services vytvoření prostředku koncového bodu.
  • Nahraďte userAccessToken tokenem, který jste vydali.

Spuštění kódu

Spuštěním následujícího příkazu zabalte hostitele aplikace na místním webovém serveru:

npm run start

Otevřete prohlížeč a přejděte na http://localhost:8080/ . V konzole vývojářských nástrojů v prohlížeči by se mělo zobrazit toto:

Azure Communication Chat client created!

Objektový model

Následující třídy a rozhraní zvládá některé hlavní funkce sady SDK Azure Communication Services Chat pro JavaScript.

Název Description
ChatClient Tato třída je nutná pro funkci chatu. Vytvoříte instanci s informacemi o předplatném a použijete ji k vytváření, získání, odstraňování vláken a přihlášení k odběru událostí chatu.
ChatThreadClient Tato třída je potřebná pro funkčnost vlákna chatu. Instanci získáte přes ChatClient a použijete ji k odesílání, příjmu, aktualizaci nebo odstraňování zpráv, přidávání, odebírání a získávání uživatelů, posílání oznámení a čtení účtenek.

Spuštění vlákna chatu

K vytvoření createThread vlákna chatu použijte metodu .

createThreadRequest se používá k popisu požadavku vlákna:

  • Pomocí topic můžete tomuto chatu poskytnout téma. Témata lze aktualizovat po vytvoření vlákna chatu pomocí UpdateThread funkce .
  • Slouží participants k zobrazení seznamu účastníků, kteří mají být přidáni do vlákna chatu.

Po vyřešení createChatThread vrátí metoda CreateChatThreadResult . Tento model obsahuje vlastnost , ve které máte přístup k nově chatThread id vytvořenému vláknu. Pak můžete použít id k získání instance ChatThreadClient . Pak ChatThreadClient lze použít k provedení operace v rámci vlákna, jako je odesílání zpráv nebo výpis účastníků.

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

Když aktualizujete kartu prohlížeče, měla by se v konzole zobrazit následující:

Thread created: <thread_id>

Získání klienta vlákna chatu

Metoda getChatThreadClient vrátí pro chatThreadClient vlákno, které již existuje. Lze ji použít k provádění operací s vytvořeným vláknem: přidání účastníků, odeslání zprávy atd. threadId je jedinečné ID existujícího vlákna chatu.

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

Přidejte tento kód místo komentáře vclient.js, aktualizujte kartu prohlížeče a zkontrolujte <CREATE CHAT THREAD CLIENT> konzolu. Měli byste vidět: ****

Chat Thread client for threadId: <threadId>

Zobrazení seznamu všech vláken chatu

Metoda listChatThreads vrátí PagedAsyncIterableIterator typ ChatThreadItem . Můžete ji použít k výpisu všech vláken chatu. Iterátor je [ChatThreadItem] odpověď vrácená z výpisu vláken.

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

Odeslání zprávy do vlákna chatu

Metoda sendMessage slouží k odeslání zprávy do vlákna identifikované threadId.

sendMessageRequest se používá k popisu žádosti o zprávu:

  • Slouží content k poskytnutí obsahu zprávy chatu.

sendMessageOptions se používá k popisu volitelného parametru operace:

  • Pomocí senderDisplayName můžete zadat zobrazované jméno odesílatele.
  • Slouží type k zadání typu zprávy, například text nebo html.
  • Volitelně můžete do zprávy zahrnout i další data, která metadata chcete odeslat. Toto pole poskytuje vývojářům mechanismus, jak rozšířit funkce chatovací zprávy a přidat vlastní informace pro váš případ použití. Například při sdílení odkazu na soubor ve zprávě můžete do metadat přidat hasAttachment:true, aby ho aplikace příjemce mohla parsovat a odpovídajícím způsobem zobrazit.

SendChatMessageResult je odpověď vrácená odesláním zprávy, která obsahuje ID, což je jedinečné ID zprávy.

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

Přidejte tento kód místo komentáře <SEND MESSAGE TO A CHAT THREAD> v client.js, aktualizujte kartu prohlížeče a zkontrolujte konzolu.

Message sent!, message id:<number>

Příjem zpráv chatu z vlákna chatu

Díky signálu v reálném čase se můžete přihlásit k odběru, abyste mohli naslouchat novým příchozím zprávám a odpovídajícím způsobem aktualizovat aktuální zprávy v paměti. Azure Communication Services podporuje seznam událostí, které můžete přihlásit k odběru.

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

Přidejte tento kód místo <RECEIVE A CHAT MESSAGE FROM A CHAT THREAD> komentáře do client.js. Aktualizujte kartu prohlížeče. V konzole by se měla zobrazit zpráva Notification chatMessageReceived ;

Případně můžete zprávy chatu načíst dotazem na listMessages metodu v zadaných intervalech.


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

Tento kód přidejte místo komentáře <LIST MESSAGES IN A CHAT THREAD> doclient.js. **** Aktualizujte kartu. V konzole byste měli najít seznam zpráv odeslaných v tomto vlákně chatu.

listMessages vrací různé typy zpráv, které lze identifikovat pomocí chatMessage.type .

Další podrobnosti najdete v tématu Typy zpráv.

Přidání uživatele jako účastníka do vlákna chatu

Po vytvoření vlákna chatu z něj můžete přidávat a odebírat uživatele. Přidáním uživatelů jim dáte přístup k odesílání zpráv do vlákna chatu a přidávání a odebírání dalších účastníků.

Před voláním metody se ujistěte, že jste pro tohoto uživatele získali nový addParticipants přístupový token a identitu. Uživatel bude tento přístupový token potřebovat k inicializaci chatového klienta.

addParticipantsRequest popisuje objekt požadavku, kde participants vypíše účastníky, kteří mají být přidáni do vlákna chatu.

  • id, required je identifikátor komunikace, který se má přidat do vlákna chatu.
  • displayName, volitelné, je zobrazovaný název účastníka vlákna.
  • shareHistoryTime, nepovinné je čas, ze kterého se historie chatu sdílí s účastníkem. Pokud chcete sdílet historii od okamžiku vzniku vlákna chatu, nastavte tuto vlastnost na libovolné datum, které se rovná nebo je menší než čas vytvoření vlákna. Pokud chcete sdílet žádnou historii před přidáním účastníka, nastavte ji na aktuální datum. Pokud chcete sdílet částečnou historii, nastavte ji na datum podle vašeho výběru.

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

await chatThreadClient.addParticipants(addParticipantsRequest);

Nahraďte NEW_PARTICIPANT_USER_ID novým ID uživatele. Místo komentáře v souboru přidejte tento <ADD NEW PARTICIPANT TO THREAD> kód client.js

Zobrazení seznamu uživatelů ve vlákně chatu

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

Přidejte tento kód místo komentáře vclient.js, aktualizujte kartu prohlížeče a zkontrolujte konzolu. Měli byste vidět informace o <LIST PARTICIPANTS IN A THREAD> uživatelích ve **** vlákně.

Odebrání uživatele z vlákna chatu

Podobně jako při přidání účastníka můžete odebrat účastníky z vlákna chatu. Abyste je mohli odebrat, budete muset sledovat ID přidaných účastníků.

Použijte removeParticipant metodu participant , kde je uživatel komunikace, který má být odebrán z vlákna.


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

Nahraďte PARTICIPANT_ID ID uživatele, které jste použili v předchozím kroku (<NEW_PARTICIPANT_USER_ID>). Přidejte tento kód místo komentáře <REMOVE PARTICIPANT FROM THREAD> v client.js,

Příklad kódu

Vyhledejte finální kód pro tento rychlý Start v GitHub.

Požadavky

Než začnete, nezapomeňte:

Nastavení

Vytvoření nové aplikace v Pythonu

Otevřete okno terminálu nebo příkaz, pro svou aplikaci vytvořte nový adresář a přejděte na něj.

mkdir chat-quickstart && cd chat-quickstart

Pomocí textového editoru vytvořte soubor s názvem Start-chat.py v kořenovém adresáři projektu. Přidejte strukturu pro program, včetně základního zpracování výjimek. V následujících částech budete do tohoto souboru přidávat veškerý zdrojový kód pro tento rychlý Start.

import os
# Add required SDK components from quickstart here

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

Instalace sady SDK

K instalaci sady SDK použijte následující příkaz:


pip install azure-communication-chat

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce služby Azure Communications Chat SDK pro Python.

Název Popis
ChatClient Tato třída je potřebná pro funkci chatu. Vytvoří se jeho instance s informacemi o předplatném a použije se k vytváření, získávání a odstraňování vláken.
ChatThreadClient Tato třída je potřebná pro funkci konverzačního vlákna. Získáte instanci prostřednictvím ChatClient a použijete ji k posílání, přijímání, aktualizaci a odstraňování zpráv. Můžete ho taky použít k přidání, odebrání a získání uživatelů a posílání oznámení o zápisu a čtení.

Vytvoření chatového klienta

Chcete-li vytvořit chatovacího klienta, použijte koncový bod komunikačních služeb a přístupový token, který jste vygenerovali jako součást požadovaných kroků.

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

Tento rychlý Start nezahrnuje vytvoření vrstvy služby pro správu tokenů pro vaši aplikaci chatu, ale doporučuje se to. Další informace najdete v části "architektura chatu" v tématu koncepce chatu.

Spustit chatovací vlákno

Použijte create_chat_thread metodu k vytvoření vlákna chatu.

  • Slouží topic k poskytnutí tématu vlákna. Můžete aktualizovat téma po vytvoření vlákna konverzace pomocí update_thread funkce.
  • Slouží thread_participants k vypsání seznamu, který se má ChatParticipant Přidat do konverzačního vlákna. ChatParticipantTyp přebírá CommunicationUserIdentifier jako user .

CreateChatThreadResult je výsledek pro vytvoření vlákna vrácen. Můžete ji použít k načtení id vytvořeného vlákna chatu. idPak lze použít k načtení ChatThreadClient objektu pomocí get_chat_thread_client metody. Můžete použít ChatThreadClient k provádění dalších operací chatu do tohoto konverzačního vlákna.

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)

Získat klienta vlákna chatu

get_chat_thread_clientMetoda vrací klienta vlákna pro vlákno, které již existuje. Můžete ji použít k provádění operací na vytvořeném vlákně. Můžete například přidat účastníky a odesílat zprávy. thread_id je jedinečné ID existujícího konverzačního vlákna.

Můžete použít ChatThreadClient k provádění dalších operací chatu do tohoto konverzačního vlákna.

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

Zobrazit seznam všech vláken chatu

list_chat_threadsMetoda vrátí iterátor typu ChatThreadItem .

  • Použijte start_time k určení nejstaršího bodu v čase, který slouží k získání vláken chatu.
  • Slouží results_per_page k určení maximálního počtu vláken konverzace vrácených na stránku.

Iterátorem [ChatThreadItem] je odpověď vrácená z výpisů vláken.

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)

Odeslání zprávy do konverzačního vlákna

Použijte send_message metodu k odeslání zprávy do vlákna chatu, které jste právě vytvořili a které identifikoval thread_id .

  • Slouží content k zadání obsahu zprávy chatu.
  • Slouží chat_message_type k určení typu obsahu zprávy. Možné hodnoty jsou text a html . Pokud nezadáte hodnotu, výchozí hodnota je text .
  • Slouží sender_display_name k zadání zobrazovaného jména odesílatele.
  • Použijte metadata volitelně k zahrnutí dalších dat, která chcete odeslat spolu se zprávou. Toto pole poskytuje mechanismus pro vývojáře, který rozšiřuje funkce zpráv chatu a přidává vlastní informace pro váš případ použití. Například při sdílení odkazu na soubor ve zprávě můžete chtít přidat ' hasAttachment: true ' v metadatech, aby aplikace příjemce mohla analyzovat a odpovídajícím způsobem zobrazit.

SendChatMessageResult je odpověď vrácená z odeslání zprávy. Obsahuje ID, které je jedinečným ID zprávy.

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)

Příjem zpráv chatu z konverzačního vlákna

Můžete načíst zprávy chatu pomocí cyklického dotazování list_messages metody v určených intervalech.

  • Slouží results_per_page k určení maximálního počtu zpráv, které se mají vrátit na stránku.
  • Slouží start_time k zadání nejdřívějšího bodu v čase, kdy se mají zprávy získat.

Iterátorem [ChatMessage] je odpověď vrácená z výpisu zpráv.

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 Vrátí nejnovější verzi zprávy, včetně všech úprav nebo odstranění, ke kterým došlo u zprávy pomocí update_message a delete_message . Pro odstraněné zprávy ChatMessage.deleted_on vrátí datetime hodnotu, která indikuje, kdy se tato zpráva odstranila. U upravených zpráv ChatMessage.edited_on vrátí datetime hodnotu, která indikuje, kdy se zpráva upravovala. K původnímu času vytvoření zprávy můžete přistupovat pomocí nástroje ChatMessage.created_on , který lze použít k řazení zpráv.

list_messages vrátí různé typy zpráv, které mohou být identifikovány pomocí ChatMessage.type .

Další informace najdete v tématu typy zpráv.

Odeslat oznámení pro čtení

Metodu můžete použít send_read_receipt k odeslání události přijetí pro čtení do vlákna jménem uživatele.

  • Slouží message_id k zadání ID poslední přečtené zprávy aktuálním uživatelem.
content='hello world'

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

Přidat uživatele jako účastníka do konverzačního vlákna

Při vytváření konverzačního vlákna můžete z něj přidat uživatele nebo je z něj odebrat. Přidáním uživatelů udělíte jim přístup, aby bylo možné odesílat zprávy do konverzačního vlákna a přidávat nebo odebírat další účastníky. Před voláním add_participants metody se ujistěte, že jste pro tohoto uživatele získali nový přístupový token a identitu. Uživatel potřebuje k inicializaci chatovacího klienta přístupový token.

Do vlákna chatu můžete přidat jednoho nebo více uživatelů pomocí add_participants metody za předpokladu, že je k dispozici nový přístupový token a identita pro všechny uživatele.

list(tuple(ChatParticipant, CommunicationError))Je vrácen. Po úspěšném přidání účastníka se očekává prázdný seznam. Pokud při přidávání účastníka dojde k chybě, seznam se naplní neúspěšnými účastníky spolu s chybou, ke které došlo.

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)

Výpis účastníků vlákna ve vlákně chatu

Podobně jako při přidávání účastníka můžete také vypisovat účastníky z vlákna.

Použijte list_participants k načtení účastníků vlákna. Oba následující příkazy jsou volitelné:

  • Slouží results_per_page k určení maximálního počtu účastníků vrácených na jednu stránku.
  • Použijte skip k přeskočení účastníků až do zadané pozice v odpovědi.

Iterátorem [ChatParticipant] je odpověď vrácená při výpisu účastníků.

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)

Spuštění kódu

Spusťte aplikaci z adresáře aplikace pomocí python příkazu.

python start-chat.py

Příklad kódu

Vyhledejte finální kód pro tento rychlý Start v GitHub.

Požadavky

Nastavení

Vytvoření nové aplikace Java

Otevřete okno terminálu nebo příkaz a přejděte do adresáře, kam chcete vytvořit aplikaci Java. Spuštěním následujícího příkazu vygenerujte projekt Java ze šablony Maven-Archetype-Starter.

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

Všimněte si, že cíl "Generate" vytvořil adresář se stejným názvem, jako má artifactId. v tomto adresáři src/main/java directory obsahuje zdrojový kód projektu, src/test/java adresář obsahuje zdroj testu a pom.xml soubor je Model Project objektu projektu nebo POM.

Aktualizujte soubor POM vaší aplikace tak, aby používal jazyk Java 8 nebo novější:

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

Přidat odkazy na balíček pro sadu Chat SDK

V souboru POM se na balíček odkazuje azure-communication-chat pomocí rozhraní API pro chat:

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

Pro ověřování musí klient odkazovat na azure-communication-common balíček:

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

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce služby Azure Communications Chat SDK pro jazyk Java.

Název Description
ChatClient Tato třída je potřebná pro funkci chatu. Vytvoří se jeho instance s informacemi o předplatném a použije se k vytváření, získávání a odstraňování vláken.
ChatAsyncClient Tato třída je potřebná pro funkci asynchronního chatu. Vytvoří se jeho instance s informacemi o předplatném a použije se k vytváření, získávání a odstraňování vláken.
ChatThreadClient Tato třída je potřebná pro funkci konverzačního vlákna. Získáte instanci prostřednictvím ChatClient a použijete ji k posílání, přijímání, aktualizaci a odstraňování zpráv, přidávání, odebírání a získávání uživatelů, posílání oznámení a čtení.
ChatThreadAsyncClient Tato třída je potřebná pro funkci asynchronního zřetězení chatu. Získáte instanci prostřednictvím ChatAsyncClient a použijete ji k posílání, přijímání, aktualizaci a odstraňování zpráv, přidávání, odebírání a získávání uživatelů, posílání oznámení a čtení.

Vytvoření chatového klienta

Chcete-li vytvořit chatovacího klienta, použijte koncový bod komunikační služby a přístupový token, který byl vygenerován jako součást požadavků. Tokeny přístupu uživatele umožňují vytvářet klientské aplikace, které se přímo ověřují na komunikačních službách Azure. Po vygenerování těchto tokenů na serveru je předejte zpátky do klientského zařízení. Je nutné použít třídu CommunicationTokenCredential ze společné sady SDK k předání tokenu klientovi chatu.

Další informace o architektuře chatu

Při přidávání příkazů importu nezapomeňte přidat pouze importy z modelu COM. Azure. Communications. chat a com. Azure. Communications. chat. Models Namespaces, a ne z oboru názvů com. Azure. Communication. chat. Implements. V souboru App. Java, který byl vygenerován prostřednictvím Maven, můžete použít následující kód, který začíná na:

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

Spustit chatovací vlákno

Použijte createChatThread metodu k vytvoření vlákna chatu. createChatThreadOptions slouží k popisu požadavku vlákna.

  • Použijte topic parametr konstruktoru k poskytnutí tématu tomuto chatu; Téma lze aktualizovat poté, co je vlákno konverzace vytvořeno pomocí UpdateThread funkce.
  • Slouží participants k vypsání účastníků vlákna, které mají být přidány do vlákna. ChatParticipant převezme uživatele, kterého jste vytvořili v rychlém startu tokenu přístupu uživatele .

CreateChatThreadResult je odpověď vrácená z vytváření konverzačního vlákna. Obsahuje getChatThread() metodu, která vrátí ChatThread objekt, který lze použít k získání klienta vlákna, ze kterého můžete získat ChatThreadClient operaci pro provádění operací ve vytvořeném vlákně: Přidat účastníky, poslat zprávu atd. ChatThread Objekt obsahuje také metodu, getId() která NAČTE jedinečné ID vlákna.

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

Vypsat vlákna chatu

Použijte listChatThreads metodu pro načtení seznamu existujících vláken chatu.

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

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

Získat klienta vlákna chatu

getChatThreadClientMetoda vrací klienta vlákna pro vlákno, které již existuje. Dá se použít k provádění operací na vytvořeném vlákně: Přidat účastníky, poslat zprávu atd. chatThreadId je jedinečné ID existujícího konverzačního vlákna.

ChatThreadClient chatThreadClient = chatClient.getChatThreadClient(chatThreadId);

Odeslání zprávy do konverzačního vlákna

Použijte sendMessage metodu k odeslání zprávy do vlákna, které jste právě vytvořili, identifikovaných pomocí chatThreadId. sendChatMessageOptions slouží k popisu žádosti o zprávu chatu.

  • Slouží content k zadání obsahu zprávy chatu.
  • Slouží type k určení typu obsahu zprávy chat, text nebo HTML.
  • Slouží senderDisplayName k zadání zobrazovaného jména odesílatele.
  • Použijte metadata volitelně k zahrnutí dalších dat, která chcete odeslat spolu se zprávou. Toto pole poskytuje mechanismus pro vývojáře, který rozšiřuje funkce zpráv chatu a přidává vlastní informace pro váš případ použití. Například při sdílení odkazu na soubor ve zprávě můžete chtít přidat ' hasAttachment: true ' v metadatech, aby aplikace příjemce mohla analyzovat a odpovídajícím způsobem zobrazit.

Odpověď sendChatMessageResult obsahuje id jedinečný identifikátor zprávy.

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

Příjem zpráv chatu z konverzačního vlákna

Můžete načíst zprávy chatu pomocí cyklického dotazování listMessages metody v klientovi vlákna konverzace v zadaných intervalech.

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

listMessages Vrátí nejnovější verzi zprávy, včetně všech úprav nebo odstranění, ke kterým došlo u zprávy pomocí. editMessage () a. deleteMessage (). Pro odstraněné zprávy chatMessage.getDeletedOn() vrátí hodnotu DateTime, která indikuje, kdy se tato zpráva odstranila. U upravených zpráv chatMessage.getEditedOn() vrátí hodnotu DateTime, která indikuje, kdy byla zpráva upravena. Původní čas vytvoření zprávy lze chatMessage.getCreatedOn() využít pomocí a lze jej použít k řazení zpráv.

Další informace o typech zpráv naleznete zde: typy zpráv.

Odeslat oznámení pro čtení

Použijte sendReadReceipt metodu pro odeslání události přijetí pro čtení do konverzačního vlákna jménem uživatele. chatMessageId je jedinečné ID zprávy chatu, která byla přečtena.

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

Seznam účastníků chatu

Slouží listParticipants k načtení stránkované kolekce obsahující účastníky vlákna chatu identifikovaného pomocí chatThreadId.

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

Přidat uživatele jako účastníka do konverzačního vlákna

Po vytvoření vlákna chatu můžete z něj přidat uživatele nebo je z něj odebrat. Přidáním uživatelů udělíte jim přístup k posílání zpráv do konverzačního vlákna a k přidání nebo odebrání dalších účastníků. Musíte začít získáním nového přístupového tokenu a identity pro tohoto uživatele. Před voláním metody addParticipants se ujistěte, že jste pro tohoto uživatele získali nový přístupový token a identitu. Uživatel bude potřebovat přístupový token, aby mohl inicializovat svého chatového klienta.

Použijte addParticipants metodu pro přidání účastníků do vlákna.

  • communicationIdentifierje povinné, je CommunicationIdentifier, které jste vytvořili pomocí CommunicationIdentityClient v rychlém startu pro uživatelský přístup tokenu .
  • displayNamevolitelné, je zobrazované jméno účastníka vlákna.
  • shareHistoryTimevolitelné, je čas, od kterého je historie chatu sdílena s účastníkem. Chcete-li sdílet historii od vytvoření vlákna chatu, nastavte tuto vlastnost na jakékoli datum, které je rovno nebo menší než čas vytvoření vlákna. Pokud chcete sdílet žádnou historii předchozí až po přidání účastníka, nastavte ho na aktuální datum. Chcete-li sdílet částečnou historii, nastavte ji na požadované 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);

Spuštění kódu

Přejděte do adresáře obsahujícího soubor pom.xml a zkompilujte projekt pomocí následujícího mvn příkazu.

mvn compile

Pak Sestavte balíček.

mvn package

Spusťte následující mvn příkaz, který aplikaci spustí.

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

Příklad kódu

Vyhledejte finální kód pro tento rychlý Start v GitHub.

Požadavky

Než začnete, nezapomeňte:

  • Vytvořte si účet Azure s aktivním předplatným. Podrobnosti najdete v článku o Vytvoření účtu zdarma.
  • Nainstalovat Android Studio, budeme pomocí Android Studio vytvořit aplikaci pro Android, která pro rychlý Start spustí instalaci závislostí.
  • Vytvořte prostředek služby Azure Communication Services. Podrobnosti najdete v tématu vytvoření prostředku služby Azure Communication Services. Pro tento rychlý Start budete muset zaznamenat koncový bod prostředku .
  • Vytvořte dva uživatele komunikačních služeb a vydejte jim token přístupu uživatelek přístupovému tokenu uživatele. Nezapomeňte nastavit rozsah pro chat a Poznamenejte si řetězec tokenu a řetězec userId. V tomto rychlém startu vytvoříme vlákno s počátečním účastníkem a potom do tohoto vlákna přidá druhý účastník.

Nastavení

Vytvoření nové aplikace pro Android

  1. Otevřete Android Studio a vyberte Create a new project .
  2. V dalším okně vyberte Empty Activity jako šablonu projektu.
  3. Při volbě možnosti zadejte ChatQuickstart název projektu.
  4. Klikněte na tlačítko Další a vyberte adresář, ve kterém chcete vytvořit projekt.

Instalace knihoven

K instalaci nezbytných závislostí komunikačních služeb použijeme Gradle. Z příkazového řádku přejděte do kořenového adresáře ChatQuickstart projektu. Otevřete soubor Build. Gradle aplikace a přidejte následující závislosti do ChatQuickstart cíle:

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

https://search.maven.org/artifact/com.azure.android/azure-communication-common https://search.maven.org/artifact/com.azure.android/azure-communication-chat Nejnovější čísla verzí najdete v tématu a.

Vyloučit meta soubory v možnostech balení v kořenovém sestavení. 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")
    }
}

Jiné Instalace knihoven pomocí Maven

Pokud chcete knihovnu importovat do projektu pomocí sestavovacího systému Maven , přidejte ji do dependencies oddílu souboru vaší aplikace pom.xml , zadejte ID artefaktu a verzi, kterou chcete použít:

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

Nastavení zástupných symbolů

Otevřete soubor a upravte ho MainActivity.java . V tomto rychlém startu přidáme náš kód do a MainActivity zobrazíme výstup v konzole. Tento rychlý Start neřeší sestavování uživatelského rozhraní. V horní části souboru importujte Communication common , Communication chat a další systémové knihovny:

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;

Zkopírujte následující kód do třídy MainActivity v souboru 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());
        }
    }
  1. Nahraďte <resource> prostředkem komunikačních služeb.
  2. Nahraďte <first_user_id> a <second_user_id> platnými ID uživatelů komunikačních služeb, které byly vygenerovány jako součást požadovaných kroků.
  3. Nahraďte <first_user_access_token> přístupovým tokenem komunikačních služeb <first_user_id> , který se vygeneroval jako součást požadovaných kroků.
  4. Nahraďte <chat_sdk_version> verzí sady Azure Communications Chat SDK.

V následujících krocích nahradíme zástupné symboly ukázkovým kódem pomocí knihovny chatu služby Azure Communications.

Vytvoření chatového klienta

Nahraďte komentář <CREATE A CHAT CLIENT> následujícím kódem (vložte příkazy import do horní části souboru):

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

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce služby Azure Communications Chat SDK pro JavaScript.

Název Description
ChatClient/ChatAsyncClient Tato třída je potřebná pro funkci chatu. Vytvoří se jeho instance s informacemi o předplatném a použije se k vytváření, získávání, odstraňování vláken a přihlášení k odběru událostí chatu.
ChatThreadClient/ChatThreadAsyncClient Tato třída je potřebná pro funkci konverzačního vlákna. Získáte instanci prostřednictvím ChatClient a použijete ji k posílání, přijímání, aktualizaci a odstraňování zpráv, přidávání, odebírání a získávání uživatelů, posílání oznámení a čtení.

Spustit chatovací vlákno

Pomocí naší ChatAsyncClient služby vytvoříme nové vlákno s počátečním uživatelem.

Nahraďte komentář <CREATE A CHAT THREAD> následujícím kódem:

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

Získat klienta vlákna chatu

Teď, když jsme vytvořili chatovací vlákno, získáte ChatThreadAsyncClient k provádění operací v rámci tohoto vlákna. Nahraďte komentář <CREATE A CHAT THREAD CLIENT> následujícím kódem:

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

Odeslání zprávy do konverzačního vlákna

Do tohoto vlákna se teď pošle zpráva.

Nahraďte komentář <SEND A MESSAGE> následujícím kódem:

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

Příjem zpráv chatu z konverzačního vlákna

Oznámení v reálném čase

Díky signalizaci v reálném čase se můžete přihlásit k odběru nových příchozích zpráv a podle toho aktualizovat aktuální zprávy v paměti. Komunikační služby Azure podporují seznam událostí, ke kterým se můžete přihlásit.

Nahraďte komentář <RECEIVE CHAT MESSAGES> následujícím kódem (vložte příkazy import do horní části souboru):


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

Důležité

Známý problém: při použití chatu pro Android a volání sady SDK v rámci stejné aplikace nefunguje funkce oznámení sady Chat SDK v reálném čase. Můžete obdržet problém s řešením závislosti. Při práci na řešení můžete vypnout funkci oznámení v reálném čase přidáním následujících informací o závislostech do souboru buildu. Gradle aplikace a místo toho spustit dotaz rozhraní API GetMessages pro zobrazení příchozích zpráv uživatelům.

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'

Všimněte si, že pokud se aplikace pokusí o dotykové rozhraní API pro oznámení, jako chatAsyncClient.startRealtimeNotifications() nebo chatAsyncClient.addEventHandler() , dojde k chybě za běhu.

Nabízená oznámení

Poznámka

V současné době se nabízená oznámení chatu podporují jenom pro Android SDK verze 1.1.0-beta. 4.

Nabízená oznámení umožňují klientům upozorňování na příchozí zprávy a další operace, ke kterým dochází ve vlákně chatu v situacích, kdy mobilní aplikace neběží v popředí. Komunikační služby Azure podporují seznam událostí, ke kterým se můžete přihlásit.

  1. Nastavte Firebase cloudového zasílání zpráv pomocí projektu ChatQuickstart. Proveďte kroky Create a Firebase project ,,, Register your app with Firebase Add a Firebase configuration file Add Firebase SDKs to your app a Edit your app manifest v dokumentaci k Firebase.

  2. Vytvořte centrum oznámení v rámci stejného předplatného jako prostředek komunikačních služeb, nakonfigurujte nastavení zasílání zpráv Firebase do cloudu pro centrum a propojte centrum oznámení s vaším prostředkem komunikačních služeb. Viz zřizování centra oznámení.

  3. Vytvoří nový soubor MyFirebaseMessagingService.java ve stejné cestě k souboru MainActivity.java . Zkopírujte následující kód do souboru MyFirebaseMessagingService.java . Je nutné nahradit <your_package_name> názvem balíčku použitým v MainActivity.java . Pro můžete použít vlastní hodnotu <your_intent_name> . Tato hodnota se použije v kroku 6 níže.

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

  4. V horní části souboru MainActivity.java přidejte následující 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;

  5. Do třídy přidejte následující kód 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);
                       }
                   });
               }
           });
   }

  6. Funkce Update onCreate ve třídě 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>"));
   }

  7. Pod komentář vložte následující kód <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
   });

Přidat uživatele jako účastníka do konverzačního vlákna

Nahraďte komentář <ADD A USER> následujícím kódem:

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

Výpis uživatelů ve vlákně

Nahraďte <LIST USERS> Komentář následujícím kódem (vložte příkazy import do horní části souboru):

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

Odebrání uživatele z konverzačního vlákna

V tuto chvíli odebereme druhého uživatele z tohoto vlákna.

Nahraďte komentář <REMOVE A USER> následujícím kódem:

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

Odeslat oznámení o zápisu

Nahraďte komentář <SEND A TYPING NOTIFICATION> následujícím kódem:

chatThreadAsyncClient.sendTypingNotification().get();

Odeslat účtenku pro čtení

Pošleme vám oznámení o přečtení pro zprávu odeslanou výše.

Nahraďte komentář <SEND A READ RECEIPT> následujícím kódem:

chatThreadAsyncClient.sendReadReceipt(chatMessageId).get();

Seznam potvrzení čtení

Nahraďte komentář <READ RECEIPTS> následujícím kódem:

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

Spuštění kódu

V Android Studio stisknutím tlačítka Run (Spustit) sestavte a spusťte projekt. V konzole můžete zobrazit výstup z kódu a výstupu protokolovacího nástroje z ChatClient.

Příklad kódu

Vyhledejte finální kód pro tento rychlý Start v GitHub.

Požadavky

Než začnete, nezapomeňte:

Nastavení

Vytvoření nové aplikace v C#

V okně konzoly (například cmd, PowerShell nebo bash) použijte dotnet new příkaz k vytvoření nové aplikace konzoly s názvem ChatQuickstart . Tento příkaz vytvoří jednoduchý projekt C# "Hello World" s jedním zdrojovým souborem: program. cs.

dotnet new console -o ChatQuickstart

Změňte adresář na nově vytvořenou složku aplikace a použijte dotnet build příkaz pro zkompilování aplikace.

cd ChatQuickstart
dotnet build

Instalace balíčku

Instalace sady Azure Communications Chat SDK pro .NET

dotnet add package Azure.Communication.Chat

Objektový model

Následující třídy zpracovávají některé hlavní funkce služby Azure Communications Chat SDK pro jazyk C#.

Název Description
ChatClient Tato třída je potřebná pro funkci chatu. Vytvoří se jeho instance s informacemi o předplatném a použije se k vytváření, získávání a odstraňování vláken.
ChatThreadClient Tato třída je potřebná pro funkci konverzačního vlákna. Získáte instanci prostřednictvím ChatClient a použijete ji k posílání, přijímání, aktualizaci a odstraňování zpráv, přidávání, odebírání a získávání účastníků, odesílání oznámení o přečtení a čtení.

Vytvoření chatového klienta

Chcete-li vytvořit chatovacího klienta, použijte koncový bod komunikačních služeb a přístupový token, který byl vygenerován jako součást požadovaných kroků. Chcete-li CommunicationIdentityClient vytvořit uživatele a vystavit token, který bude předat klientovi chat, je nutné použít třídu ze sady identity SDK.

Přečtěte si další informace o tokenech přístupu uživatele.

V tomto rychlém startu se nezabývá vytvořením vrstvy služby pro správu tokenů pro aplikaci Chat, i když se doporučuje. Další informace o architektuře chatu

Zkopírujte následující fragmenty kódu a vložte je do zdrojového souboru: 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);
        }
    }
}

Spustit chatovací vlákno

Pomocí createChatThread metody v chatClient vytvořte vlákno chatu.

  • Použijte topic k poskytnutí tématu tomuto chatu; Téma lze aktualizovat poté, co je vlákno konverzace vytvořeno pomocí UpdateTopic funkce.
  • Pomocí participants vlastnosti můžete předat seznam ChatParticipant objektů, které mají být přidány do konverzačního vlákna. ChatParticipantObjekt je inicializován s CommunicationIdentifier objektem. CommunicationIdentifier může být typu CommunicationUserIdentifier MicrosoftTeamsUserIdentifier nebo PhoneNumberIdentifier . Například pro získání CommunicationIdentifier objektu budete muset předat ID přístupu, které jste vytvořili pomocí pokynů pro Vytvoření uživatele .

Objekt Response z createChatThread metody obsahuje chatThread Podrobnosti. Pro interakci s operacemi vlákna chatu, jako je přidání účastníků, odeslání zprávy, odstranění zprávy atd. chatThreadClient instance klienta musí být vytvořena pomocí GetChatThreadClient metody v ChatClient klientovi.

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;

Získat klienta vlákna chatu

GetChatThreadClientMetoda vrací klienta vlákna pro vlákno, které již existuje. Dá se použít k provádění operací na vytvořeném vlákně: přidat členy, poslat zprávu atd. IDvlákna je jedinečné ID existujícího konverzačního vlákna.

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

Zobrazit seznam všech vláken chatu

Použijte GetChatThreads k načtení všech vláken chatu, které je uživatel součástí.

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

Odeslání zprávy do konverzačního vlákna

Slouží SendMessage k odeslání zprávy do vlákna.

  • Slouží content k zadání obsahu zprávy, která je povinná.
  • Používá type se pro typ obsahu zprávy, například text nebo HTML. Není-li tento parametr zadán, bude nastavena hodnota "text".
  • Slouží senderDisplayName k zadání zobrazovaného jména odesílatele. Pokud není zadán, bude nastaven prázdný řetězec.
  • Použijte metadata volitelně k zahrnutí dalších dat, která chcete odeslat spolu se zprávou. Toto pole poskytuje mechanismus pro vývojáře, který rozšiřuje funkce zpráv chatu a přidává vlastní informace pro váš případ použití. Například při sdílení odkazu na soubor ve zprávě můžete chtít přidat ' hasAttachment: true ' v metadatech, aby aplikace příjemce mohla analyzovat a odpovídajícím způsobem zobrazit.
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;

Příjem zpráv chatu z konverzačního vlákna

Můžete načíst zprávy chatu pomocí cyklického dotazování GetMessages metody v klientovi vlákna konverzace v zadaných intervalech.

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

GetMessages převezme volitelný DateTimeOffset parametr. Pokud je zadaný posun, dostanete po něm zprávy, které byly přijaty, aktualizovány nebo odstraněny. Všimněte si, že zprávy přijaté před časem posunutí, ale upravené nebo odebrané, budou vráceny také.

GetMessages Vrátí nejnovější verzi zprávy, včetně všech úprav nebo odstranění, ke kterým došlo u zprávy pomocí UpdateMessage a DeleteMessage . Pro odstraněné zprávy chatMessage.DeletedOn vrátí hodnotu DateTime, která indikuje, kdy se tato zpráva odstranila. U upravených zpráv chatMessage.EditedOn vrátí hodnotu DateTime, která indikuje, kdy byla zpráva upravena. Původní čas vytvoření zprávy lze chatMessage.CreatedOn využít pomocí a lze jej použít k řazení zpráv.

GetMessages vrátí různé typy zpráv, které mohou být identifikovány pomocí chatMessage.Type . Tyto typy:

  • Text: Běžná zpráva chatu odeslaná členem vlákna.

  • Html: Naformátovaná textová zpráva. Všimněte si, že uživatelé komunikačních služeb aktuálně nemůžou odesílat zprávy RTF. tento typ zprávy je podporován zprávami odesílanými od Teams uživatelů ke komunikaci uživatelů v Teams scénářích spolupráce.

  • TopicUpdated: Systémová zpráva, která indikuje, že téma bylo aktualizováno. ReadOnly

  • ParticipantAdded: Systémová zpráva, která indikuje, že jeden nebo více účastníků bylo přidáno do konverzačního vlákna. ReadOnly

  • ParticipantRemoved: Systémová zpráva, která indikuje, že účastník byl odebrán z konverzačního vlákna.

Další podrobnosti najdete v tématu typy zpráv.

Přidat uživatele jako účastníka do konverzačního vlákna

Po vytvoření vlákna můžete z něj přidat a odebrat uživatele. Přidáním uživatelů udělíte jim přístup, aby bylo možné odesílat zprávy do vlákna a přidat nebo odebrat jiného účastníka. Před voláním AddParticipants se ujistěte, že jste pro tohoto uživatele získali nový přístupový token a identitu. Uživatel bude potřebovat přístupový token, aby mohl inicializovat svého chatového klienta.

Slouží AddParticipants k přidání jednoho nebo více účastníků do konverzačního vlákna. Následující jsou podporované atributy pro každého účastníka vlákna:

  • communicationUser, požadováno, je identita účastníka vlákna.
  • displayNamevolitelné, je zobrazované jméno účastníka vlákna.
  • shareHistoryTime, volitelné, čas, ze kterého je historie chatu sdílena s účastníkem.
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);

Získat účastníky vlákna

Slouží GetParticipants k načtení účastníků konverzačního vlákna.

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

Odeslat oznámení pro čtení

Slouží SendReadReceipt k oznámení ostatním účastníkům, že uživatel přečte zprávu.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

Spuštění kódu

Spusťte aplikaci z adresáře aplikace pomocí dotnet run příkazu.

dotnet run

Příklad kódu

Vyhledejte finální kód pro tento rychlý Start v GitHub.

Požadavky

Než začnete, nezapomeňte:

  • Vytvořte si účet Azure s aktivním předplatným. Podrobnosti najdete v článku o Vytvoření účtu zdarma.
  • Nainstalujte Xcode a CocoaPods. Xcode použijete k vytvoření aplikace pro iOS pro rychlý Start a CocoaPods k instalaci závislostí.
  • Vytvořte prostředek služby Azure Communication Services. Podrobnosti najdete v tématu rychlý Start: vytvoření a Správa prostředků komunikačních služeb. V tomto rychlém startu je potřeba zaznamenat koncový bod prostředku.
  • Vytvořte dva uživatele v komunikačních službách Azure a vydejte jim token přístupu uživatele. Nezapomeňte nastavit obor na chat a poznamenat si token řetězec a také userId řetězec. V tomto rychlém startu vytvoříte vlákno s počátečním účastníkem a potom do vlákna přidáte druhého účastníka.

Nastavení

Vytvoření nové aplikace pro iOS

Otevřete Xcode a vyberte vytvořit nový projekt Xcode. Pak jako platformu a aplikaci pro šablonu vyberte iOS .

Jako název projektu zadejte ChatQuickstart. Pak jako životní cyklus vyberte jako rozhraní, UIKit aplikaci delegáta a jako jazyk.

Vyberte Další a vyberte adresář, ve kterém chcete vytvořit projekt.

Instalace knihoven

Pomocí CocoaPods nainstalujte nezbytné závislosti komunikačních služeb.

Z příkazového řádku, pokračujte v kořenovém adresáři ChatQuickstart projektu iOS. Vytvořte souboru podfile pomocí následujícího příkazu: pod init .

Otevřete souboru podfile a přidejte následující závislosti do ChatQuickstart cíle:

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

Nainstalujte závislosti pomocí následujícího příkazu: pod install . Všimněte si, že se tím také vytvoří pracovní prostor Xcode.

Po spuštění pod install znovu otevřete projekt v Xcode tak, že vyberete nově vytvořený .xcworkspace .

Nastavení zástupných symbolů

Otevřete pracovní prostor ChatQuickstart.xcworkspace v Xcode a pak otevřete ViewController.swift .

V tomto rychlém startu přidáte svůj kód do a viewController zobrazíte výstup v konzole Xcode. Tento rychlý Start neřeší sestavování uživatelského rozhraní v iOS.

V horní části viewController.swift , importujte AzureCommunication AzureCommunicatonChat knihovny a:

import AzureCommunicationCommon
import AzureCommunicationChat

Zkopírujte následující kód do viewDidLoad() metody ViewController :

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

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

                // <LIST ALL CHAT THREADS>

                // <GET A CHAT THREAD CLIENT>

                // <SEND A MESSAGE>

                // <SEND A READ RECEIPT >

                // <RECEIVE MESSAGES>

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

Pro demonstrační účely budeme k synchronizaci kódu použít semafor. V následujících krocích nahradíte zástupné symboly ukázkovým kódem pomocí knihovny chatu služby Azure Communications.

Vytvoření chatového klienta

Chcete-li vytvořit chatovacího klienta, použijte koncový bod komunikačních služeb a přístupový token, který byl vygenerován jako součást požadovaných kroků.

Přečtěte si další informace o tokenech přístupu uživatele.

V tomto rychlém startu se nezabývá vytvořením vrstvy služby pro správu tokenů pro aplikaci Chat, i když se doporučuje. Další informace o architektuře chatu

Nahraďte komentář <CREATE A CHAT CLIENT> následujícím fragmentem kódu:

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
)

Nahraďte <ACS_RESOURCE_ENDPOINT> koncovým bodem prostředku služby Azure Communication Services. Nahraďte <ACCESS_TOKEN> platným přístupovým tokenem komunikační služby.

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce služby Azure Communications Chat SDK pro iOS.

Název Description
ChatClient Tato třída je potřebná pro funkci chatu. Vytvoří se jeho instance s informacemi o předplatném a použije se k vytváření, získávání, odstraňování vláken a přihlášení k odběru událostí chatu.
ChatThreadClient Tato třída je potřebná pro funkci konverzačního vlákna. Získáte instanci prostřednictvím ChatClient a použijete ji k posílání, přijímání, aktualizaci a odstraňování zpráv. Můžete ho taky použít k přidání, odebrání a získání uživatelů, posílání oznámení o zápisu a čtení.

Spustit chatovací vlákno

CreateChatThreadResult je odpověď vrácená z vytváření konverzačního vlákna. Obsahuje vlastnost, chatThread která je ChatThreadProperties objektem. Tento objekt obsahuje IDvlákna, který se dá použít k získání ChatThreadClient pro provádění operací ve vytvořeném vlákně: Přidat účastníky, poslat zprávu atd.

Nahraďte komentář <CREATE A CHAT THREAD> následujícím fragmentem kódu:

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

Nahraďte <USER_ID> platným ID uživatele komunikační služby.

Semafor se tady používá pro čekání na obslužnou rutinu dokončení, než budete pokračovat. V pozdějších krocích použijete threadId odpověď z odpovědi vrácené do obslužné rutiny dokončení.

Zobrazit seznam všech vláken chatu

Po vytvoření konverzačního vlákna můžeme vypsat všechny podprocesy chatu voláním listChatThreads metody on ChatClient . Nahraďte komentář <LIST ALL CHAT THREADS> následujícím kódem:

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

Získat klienta vlákna chatu

createClientMetoda vrátí ChatThreadClient pro vlákno, které již existuje. Dá se použít k provádění operací na vytvořeném vlákně: Přidat účastníky, poslat zprávu atd. IDvlákna je jedinečné ID existujícího konverzačního vlákna.

Nahraďte komentář <GET A CHAT THREAD CLIENT> následujícím kódem:

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

Odeslání zprávy do konverzačního vlákna

Použijte send metodu k odeslání zprávy do vlákna identifikovaného pomocí IDvlákna.

SendChatMessageRequest slouží k popisu žádosti o zprávu:

  • Slouží content k zadání obsahu zprávy chatu.
  • Slouží senderDisplayName k zadání zobrazovaného jména odesílatele.
  • Slouží type k určení typu zprávy, jako je "text" nebo "HTML"
  • Použijte metadata volitelně k zahrnutí dalších dat, která chcete odeslat spolu se zprávou. Toto pole poskytuje mechanismus pro vývojáře, který rozšiřuje funkce zpráv chatu a přidává vlastní informace pro váš případ použití. Například při sdílení odkazu na soubor ve zprávě můžete chtít přidat ' hasAttachment: true ' v metadatech, aby aplikace příjemce mohla analyzovat a odpovídajícím způsobem zobrazit.

SendChatMessageResult je odpověď vrácená z odeslání zprávy, obsahuje ID, což je jedinečné ID zprávy.

Nahraďte komentář <SEND A MESSAGE> následujícím fragmentem kódu:

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

Odeslat účtenku pro čtení

Použijte sendReadReceipt metodu pro odeslání události přijetí pro čtení do konverzačního vlákna jménem uživatele. messageId je jedinečné ID zprávy chatu, která byla přečtena.

Nahraďte komentář následujícím <SEND A READ RECEIPT> kódem:

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

Příjem zpráv chatu z konverzačního vlákna

Díky signalizaci v reálném čase se můžete přihlásit k odběru nových příchozích zpráv a aktualizovat aktuální zprávy v paměti odpovídajícím způsobem. Komunikační služby Azure podporují seznam událostí, ke kterým se můžete přihlásit.

Nahraďte komentář <RECEIVE MESSAGES> následujícím kódem. Po povolení oznámení zkuste odeslat nové zprávy, abyste viděli 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
    }
})

Alternativně můžete načíst zprávy konverzace pomocí cyklického dotazování listMessages metody v určených intervalech. Podívejte se na následující fragment kódu pro 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()

Přidat uživatele jako účastníka do konverzačního vlákna

Po vytvoření vlákna můžete z něj přidat a odebrat uživatele. Přidáním uživatelů udělíte jim přístup, aby bylo možné odesílat zprávy do vlákna a přidat nebo odebrat jiného účastníka. Před voláním add se ujistěte, že jste pro tohoto uživatele získali nový přístupový token a identitu. Uživatel bude potřebovat přístupový token, aby mohl inicializovat svého chatového klienta.

Použijte add metodu ChatThreadClient pro přidání jednoho nebo více účastníků do konverzačního vlákna. Následující jsou podporované atributy pro každého účastníka vlákna:

  • id, required je identita účastníka vlákna.
  • displayName, nepovinné je zobrazovaný název účastníka vlákna.
  • shareHistoryTime, volitelné, čas, ze kterého se historie chatu sdílí s účastníkem.

Nahraďte komentář <ADD A USER> následujícím kódem:

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

Nahraďte <USER_ID> Communication Services ID uživatele, který chcete přidat.

Zobrazení seznamu uživatelů ve vlákně

Pomocí metody listParticipants získejte všechny účastníky pro konkrétní vlákno chatu.

Nahraďte komentář <LIST USERS> následujícím kódem:

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

Spuštění kódu

V Xcode stiskněte tlačítko Spustit a sestavte a spusťte projekt. V konzole můžete zobrazit výstup z kódu a protokolovacího výstupu z ChatClient.

Poznámka: Nastavte Build Settings > Build Options > Enable Bitcode na No . Sada AzureCommunicationChat SDK pro iOS v současné době nepodporuje povolení bitového kódu, následující GitHub problém tento problém sleduje.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné služby Communications Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené. Přečtěte si další informace o vyčištění prostředků.

Další kroky

V tomto rychlém startu jste se dozvěděli, jak:

  • Vytvoření chatového klienta
  • Vytvoření vlákna se dvěma uživateli
  • Odeslat zprávu do vlákna
  • Přijímání zpráv z vlákna
  • Odebrání uživatelů z vlákna

Vyzkoušet aplikaci Chat Hero

Můžete také chtít: