Migrar do Chat do Twilio Conversations para os Serviços de Comunicação do Azure

Pré-requisitos

• Conta do Azure: certifique-se de que a sua conta do Azure está ativa. Novos usuários podem criar uma conta gratuita no Microsoft Azure.
• Node.js 18: Certifique-se de que o Node.js 18 está instalado no seu sistema. Faça o download em Node.js.
• Recurso de Serviços de Comunicação: configure um Recurso de Serviços de Comunicação por meio do portal do Azure e anote sua cadeia de conexão.
• CLI do Azure: siga as instruções para instalar a CLI do Azure no Windows.
• Token de acesso de usuário: gere um token de acesso de usuário para instanciar o cliente de chat. Você pode criar um usando a CLI do Azure da seguinte maneira:

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

Para obter mais informações, consulte Usar a CLI do Azure para criar e gerenciar tokens de acesso.

Instalação

Instalar o SDK de Chat dos Serviços de Comunicação do Azure

Use o npm install comando para instalar o SDK dos Serviços de Comunicação do Azure para JavaScript.

npm install @azure/communication-chat --save

A --save opção adiciona a biblioteca como uma dependência em seu arquivo package.json .

Remover o SDK do Twilio do projeto

Você pode remover o SDK do Twilio do seu projeto desinstalando o pacote.

npm uninstall twilio-conversations

Modelo de objeto

As classes e interfaces a seguir lidam com alguns dos principais recursos do SDK de Chat dos Serviços de Comunicação do Azure para JavaScript.

Nome	Descrição
ChatClient	Esta classe é necessária para a função de chat. Instancie-o com suas informações de assinatura e use-o para criar, obter, excluir threads e assinar eventos de bate-papo.
ChatThreadClient	Esta classe é necessária para a função Chat Thread. Obtenha uma instância através do , e use-a ChatClientpara enviar/receber/atualizar/excluir mensagens, adicionar/remover/obter usuários, enviar notificações de digitação e ler confirmações.

Inicializar o cliente de bate-papo

Twilio

/* Initialization */
import { Client } from '@twilio/conversations';

const token = await fetch(token_url);
const client = new Client(token);
client.on('stateChanged', (state) => {
  if (state === 'failed') {
    // The client failed to initialize
    return;
  }

  if (state === 'initialized') {
    // Use the client
  }
});

Azure Communication Services

Semelhante ao Twilio, a primeira etapa é obter um token de acesso e o ponto de extremidade do Serviço de Comunicação que foi gerado como parte das etapas de pré-requisito. Substitua os espaços reservados no código.

import { ChatClient } from '@azure/communication-chat';
import { AzureCommunicationTokenCredential } from '@azure/communication-common';

// Your unique Azure Communication service endpoint
let endpointUrl = '<replace with your resource endpoint>';
// The user access token generated as part of the pre-requisites
let userAccessToken = '<USER_ACCESS_TOKEN>';

let chatClient = new ChatClient(endpointUrl, new AzureCommunicationTokenCredential(userAccessToken));
console.log('Azure Communication Chat client created!');

Iniciar um tópico de bate-papo

Twilio

Inicie um tópico de bate-papo no Twilio Conversations. Use FriendlyName para dar um nome legível por humanos a esta conversa.

let conversation = await client.createConversation({
    friendlyName: "Testing Chat"
});
await conversation.join();

Azure Communication Services

Use o createThread método para criar um thread de chat.

Use createThreadRequest para descrever a solicitação de thread:

• Use topic para dar um tópico a este bate-papo. Atualize topic depois de criar o thread de bate-papo usando a UpdateThread função.
• Use participants para listar os participantes a serem adicionados ao tópico de bate-papo.

Quando resolvido, createChatThread o método retorna um CreateChatThreadResultarquivo . Este modelo contém uma chatThread propriedade onde você pode acessar o id do thread recém-criado. Em seguida, use o id para obter uma instância de um ChatThreadClientarquivo . Em seguida, use o para executar a ChatThreadClient operação dentro do thread, como enviar mensagens ou listar participantes.

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

Obter um cliente de thread de chat

Twilio

Obtenha um tópico de bate-papo (conversa) em Twilio.

if (selectedConversation) {
      conversationContent = (
        <Conversation
          conversationProxy={selectedConversation}
          myIdentity={this.state.name}
        />
      );
    } else if (status !== "success") {
      conversationContent = "Loading your conversation!";
    } else {
      conversationContent = "";
    }

Azure Communication Services

O getChatThreadClient método retorna um chatThreadClient para um thread que já existe. Use-o para executar operações no thread criado: adicionar participantes, enviar mensagem e assim por diante. O threadId é o ID exclusivo do thread de bate-papo existente.

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

Adicione esse código no lugar do <CREATE CHAT THREAD CLIENT> comentário no client.js, atualize a guia do navegador e verifique o console. Deverá ver:

Chat Thread client for threadId: <threadId>

Adicionar um usuário como participante ao tópico de bate-papo

Depois de criar um thread de bate-papo, você pode adicionar e remover usuários dele. Ao adicionar usuários, você dá a eles acesso para enviar mensagens para o thread de bate-papo e adicionar/remover outros participantes.

Twilio

Adicione um participante a um tópico de chat.

// add chat participant to the conversation by its identity
await conversation.add('identity');

// adds yourself as a conversations sdk user to this conversation
// use after creating the conversation from the SDK
await conversation.join();

conversation.on('participantJoined', (participant) => {
  // fired when a participant has joined the conversation
});

Azure Communication Services

Antes de chamar o addParticipants método, certifique-se de adquirir um novo token de acesso e identidade para esse usuário. O usuário precisa desse token de acesso para inicializar seu cliente de chat.

addParticipantsRequest Descreve o objeto de solicitação em participants que lista os participantes a serem adicionados ao thread de chat:

• id, obrigatório, é o identificador de comunicação a ser adicionado ao thread de chat.
• displayName, opcional, é o nome para exibição do participante do thread.
• shareHistoryTime, opcional, é o momento a partir do qual o histórico de bate-papo é compartilhado com o participante. Para compartilhar o histórico desde o início do thread de chat, defina essa propriedade para qualquer data igual ou inferior ao tempo de criação do thread. Para não compartilhar nenhum histórico anterior ao momento em que o participante foi adicionado, defina-o para a data atual. Para partilhar o histórico parcial, defina-o para a data da sua escolha.

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

await chatThreadClient.addParticipants(addParticipantsRequest);

Substitua NEW_PARTICIPANT_USER_ID por um novo ID de usuário

Enviar uma mensagem para um tópico de chat

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm funções separadas para enviar mensagens de texto ou mídia.

Twilio

Para enviar uma mensagem de texto em Twilio.

// Send Text Message
await conversation
  .prepareMessage()
  .setBody('Hello!')
  .setAttributes({foo: 'bar'})
  .build()
  .send();

Para enviar mídia em Twilio.

 const file =
  await fetch("https://v.fastcdn.co/u/ed1a9b17/52533501-0-logo.svg");
const fileBlob = await file.blob();
// Send a media message
const sendMediaOptions = {
    contentType: file.headers.get("Content-Type"),
    filename: "twilio-logo.svg",
    media: fileBlob
};

await conversation
  .prepareMessage()
  .setBody('Here is some media!')
  .addMedia(sendMediaOptions);

Azure Communication Services

Use sendMessage o método para enviar uma mensagem para um thread identificado por threadId.

sendMessageRequest é usado para descrever a solicitação de mensagem:

• Use content para fornecer o conteúdo da mensagem de chat.

Use sendMessageOptions para descrever os parâmetros opcionais da operação:

• Use senderDisplayName para especificar o nome de exibição do remetente.
• Use type para especificar o tipo de mensagem, como text ou html.

Para recriar a propriedade "Media" em Twilio.

• Use metadata opcionalmente para incluir quaisquer outros dados que você deseja enviar junto com a mensagem. Este campo permite que os desenvolvedores estendam a função de mensagem de chat e adicionem informações personalizadas para o seu caso de uso. Por exemplo, ao compartilhar um link de arquivo na mensagem, talvez você queira adicionar hasAttachment: true metadados para que o aplicativo do destinatário possa analisá-los e exibi-los adequadamente. Para obter mais informações, consulte Compartilhamento de arquivos.

SendChatMessageResult é a resposta retornada do envio de uma mensagem. Ele contém um ID, que é o ID exclusivo da mensagem.

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

Receber mensagens de chat a partir de um tópico de chat

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm funções separadas para receber mensagens de texto ou mídia. Os Serviços de Comunicação do Azure usam a Grade de Eventos do Azure para manipular eventos. Para obter mais informações, consulte Tratamento de eventos.

Twilio

Para receber uma mensagem de texto em Twilio.

// Receive text message
 let paginator =
  await conversation.getMessages(
    30,0,"backwards"
  );

const messages = paginator.items;

Para receber mídia em Twilio.

// Receive media
// Return all media attachments (possibly empty array), without temporary urls
const media = message.attachedMedia;

// Get a temporary URL for the first media returned by the previous method
const mediaUrl = await media[0].getContentTemporaryUrl();

Azure Communication Services

Com sinalização em tempo real, você pode se inscrever para ouvir novas mensagens recebidas e atualizar as mensagens atuais na memória de acordo. Os Serviços de Comunicação do Azure dão suporte a uma lista de eventos que você pode assinar.

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

Como alternativa, você pode recuperar mensagens de bate-papo pesquisando o listMessages método em intervalos especificados.

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

listMessages Retorna diferentes tipos de mensagens que você pode identificar pelo chatMessage.type.

Para obter mais informações, consulte Tipos de mensagem.

Subscrever o estado da ligação de notificações em tempo real

Semelhante ao Twilio, os Serviços de Comunicação do Azure permitem que você assine notificações de eventos.

Subscrever eventos realTimeNotificationConnected e realTimeNotificationDisconnected informá-lo quando a ligação ao servidor de chamadas está ativa.

// subscribe to realTimeNotificationConnected event
chatClient.on('realTimeNotificationConnected', () => {
  console.log("Real time notification is now connected!");
  // your code here
});
// subscribe to realTimeNotificationDisconnected event
chatClient.on('realTimeNotificationDisconnected', () => {
  console.log("Real time notification is now disconnected!");
  // your code here
});

Pré-requisitos

• Crie uma conta do Azure com uma assinatura ativa. Para obter mais informações, consulte Criar uma conta gratuitamente.

• Instalar o Visual Studio.

• Criar um recurso do Azure Communication Services. Para obter mais informações, consulte Criar um recurso dos Serviços de Comunicação do Azure. Registre o ponto de extremidade do recurso e a cadeia de conexão.

• Um token de acesso de usuário. Certifique-se de definir o escopo para bate-papo e anote a cadeia de caracteres de token e user_id string. Você também pode usar a CLI do Azure e executar o seguinte comando com sua cadeia de conexão para criar um usuário e um token de acesso.

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

  Para obter mais informações, consulte Usar a CLI do Azure para criar e gerenciar tokens de acesso.

Diferença Conceptual

Tanto o Twilio Conversations quanto o Azure Communication Services Chat oferecem funções semelhantes, mas sua implementação difere devido aos ecossistemas circundantes e às filosofias de plataforma subjacentes. O Twilio Conversations fornece uma API de comunicação multicanal. O Chat dos Serviços de Comunicação do Azure é focado principalmente no chat dentro do ecossistema do Azure. Este guia de migração fornece um mapeamento básico entre operações comuns no Twilio e seus equivalentes no Chat dos Serviços de Comunicação do Azure, ajudando você a fazer a transição do seu código .NET.

Identidades

Twilio

O Twilio Conversations usa cadeias de caracteres de identidade diretamente.

Azure Communication Services

Os Serviços de Comunicação do Azure requerem a criação de utilizadores através do CommunicationIdentityClient.

Configuração

Instalar o pacote

Para iniciar a migração do chat do Twilio Conversations, a primeira etapa é instalar o SDK de Chat dos Serviços de Comunicação do Azure para .NET em seu projeto.

dotnet add package Azure.Communication.Chat

Modelo de objeto

As classes a seguir lidam com alguns dos principais recursos do SDK de Chat dos Serviços de Comunicação do Azure para C#.

Nome	Descrição
ChatClient	Esta classe é necessária para a funcionalidade de chat. Você o instancia com suas informações de assinatura e o usa para criar, obter e excluir threads.
ChatThreadClient	Esta classe é necessária para a funcionalidade Chat Thread. Você obtém uma instância por meio do ChatClient e a usa para enviar/receber/atualizar/excluir mensagens, adicionar/remover/obter participantes, enviar notificações de digitação e ler confirmações.

Criar um cliente de chat

Twilio

O Twilio requer que você configure o cliente Twilio usando suas credenciais de conta:

var twilio = new TwilioRestClient(accountSid, authToken);

Azure Communication Services

Para criar um cliente de chat nos Serviços de Comunicação do Azure, use seu ponto de extremidade dos Serviços de Comunicação e o token de acesso que foi gerado como parte das etapas de pré-requisito. Você precisa usar a CommunicationIdentityClient classe do SDK de identidade para criar um usuário e emitir um token para passar para seu cliente de chat.

Saiba mais sobre os Tokens de Acesso de Usuário.

// Your unique Azure Communication service endpoint
Uri endpoint = new Uri("<replace with your resource endpoint>");
CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(<Access_Token>);
ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);

Iniciar um tópico de bate-papo

Conversas Twilio

var conversation = ConversationResource.Create(
    friendlyName: "My Conversation",
    messagingServiceSid: "<MessagingServiceSid>"
);

Azure Communication Services

Nos Serviços de Comunicação do Azure, você cria um thread, que é equivalente a uma conversa no Twilio.

Para criar um thread de chat, use o createChatThread método no chatClient:

• Use topic para dar um tópico a este chat, você pode atualizar o depois que o tópico de bate-papo topic é criado usando a UpdateTopic função.
• Use participants a propriedade para passar uma lista de objetos a serem adicionados ao thread de ChatParticipant chat. Inicialize o ChatParticipant objeto com um CommunicationIdentifier objeto. CommunicationIdentifier pode ser do tipo CommunicationUserIdentifier, MicrosoftTeamsUserIdentifier, ou PhoneNumberIdentifier. Por exemplo, para obter um CommunicationIdentifier objeto, você precisa passar uma ID de acesso criada seguindo as instruções para Criar um usuário.

O objeto de resposta do createChatThread método contém os chatThread detalhes. Para interagir com as operações do thread de chat, como adicionar participantes, enviar uma mensagem, excluir uma mensagem e assim por diante, instancie uma chatThreadClient instância do cliente usando o GetChatThreadClient método no ChatClient cliente.

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;

Obter um cliente de thread de chat

Twilio

No Twilio Conversations, você interage diretamente com uma conversa usando o SID (identificador exclusivo) da conversa. Veja como normalmente obter uma conversa e interagir com ela:

var conversationSid = "<CONVERSATION_SID>";
var conversation = ConversationResource.Fetch(pathSid: conversationSid);

// Example: Fetching all messages in the conversation
var messages = MessageResource.Read(pathConversationSid: conversationSid);
foreach (var message in messages)
{
    Console.WriteLine(message.Body);
}

Azure Communication Services

O GetChatThreadClient método retorna um cliente de thread para um thread que já existe. Você pode usá-lo para executar operações no thread criado: adicionar membros, enviar mensagem e assim por diante. threadId é o ID exclusivo do tópico de bate-papo existente.

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

Listar todos os tópicos de bate-papo

Twilio

No Twilio Conversations, você pode recuperar todas as conversas das quais um usuário participa consultando o UserConversations recurso. Este recurso fornece uma lista de conversas para um usuário específico.

/ Initialize Twilio Client
string accountSid = "<YOUR_ACCOUNT_SID>";
string authToken = "<YOUR_AUTH_TOKEN>";
TwilioClient.Init(accountSid, authToken);

// The identity of the user you're querying
string userIdentity = "user@example.com";

// Retrieve all conversations the user is part of
var userConversations = UserConversationResource.Read(pathUserSid: userIdentity);

foreach (var userConversation in userConversations)
{
    Console.WriteLine($"Conversation SID: {userConversation.ConversationSid}");
    // You can fetch more details about the conversation if needed
    var conversation = Twilio.Rest.Conversations.V1.ConversationResource.Fetch(pathSid: userConversation.ConversationSid);
    Console.WriteLine($"Conversation Friendly Name: {conversation.FriendlyName}");
}

Azure Communication Services

Use GetChatThreads para recuperar todos os tópicos de bate-papo dos quais o usuário faz parte.

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

Enviar uma mensagem para um tópico de chat

Twilio

O trecho de código a seguir mostra como enviar uma mensagem de texto.

var message = MessageResource.Create(
    body: "Hello, world!",
    from: "user@example.com",
    pathConversationSid: conversation.Sid
);

O trecho de código a seguir mostra como enviar um arquivo de mídia.

// The SID of the conversation you want to send the media message to
string conversationSid = "<CONVERSATION_SID>";

// The URL of the media file you want to send
var mediaUrl = new List<Uri>
{
    new Uri("https://example.com/path/to/media/file.jpg") // Replace with your actual media URL
};

// Send the media message
var message = MessageResource.Create(
    body: "Here is an image for you!",
    from: "user@example.com", // Sender's identity (optional)
    mediaUrl: mediaUrl,
    pathConversationSid: conversationSid
);

Azure Communication Services

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm uma função separada para enviar mensagens de texto ou mídia.

Use SendMessage para enviar uma mensagem para um thread.

• Use content, obrigatório, para fornecer o conteúdo da mensagem.
• Use type para o tipo de conteúdo da mensagem, como Text ou Html. Se não for especificado, Text é o padrão.
• Use senderDisplayName para especificar o nome de exibição do remetente. Se não for especificado, a cadeia de caracteres vazia será o padrão.
• Use metadata opcionalmente para incluir outros dados que você deseja enviar junto com a mensagem. Este campo fornece um mecanismo para os desenvolvedores estenderem a função de mensagem de chat e adicionarem informações personalizadas para o seu caso de uso. Por exemplo, ao compartilhar um link de arquivo na mensagem, talvez você queira adicionar hasAttachment:true os metadados para que o aplicativo do destinatário possa analisá-los e exibi-los adequadamente.

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;

Receber mensagens de chat a partir de um tópico de chat

Twilio

O Twilio normalmente usa webhooks para notificar seu servidor sobre mensagens recebidas:

O trecho de código a seguir mostra como receber uma mensagem de texto.

public IActionResult ReceiveMessage()
{
    var incomingMessage = Request.Form["Body"];
    // Process the incoming message
    return Ok();
}

O trecho de código a seguir mostra como receber um arquivo de mídia.

 for (var i = 0; i < numMedia; i++)
            {
                var mediaUrl = Request.Form[$"MediaUrl{i}"];
                Trace.WriteLine(mediaUrl);
                var contentType = Request.Form[$"MediaContentType{i}"];

                var filePath = GetMediaFileName(mediaUrl, contentType);
                await DownloadUrlToFileAsync(mediaUrl, filePath);
            }

Azure Communication Services

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm uma função separada para receber mensagens de texto ou mídia.

O Chat dos Serviços de Comunicação do Azure permite-lhe subscrever eventos diretamente na aplicação.

Você pode recuperar mensagens de bate-papo sondando o GetMessages método no cliente de thread de bate-papo em intervalos especificados.

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

GetMessages usa um parâmetro opcional DateTimeOffset . Se esse deslocamento for especificado, você receberá mensagens que foram recebidas, atualizadas ou excluídas depois dele. As mensagens recebidas antes do tempo de deslocamento, mas editadas ou removidas depois dele, também são retornadas.

GetMessages Retorna a versão mais recente da mensagem, incluindo quaisquer edições ou exclusões que aconteceram com a mensagem usando UpdateMessage e DeleteMessage. Para mensagens excluídas, chatMessage.DeletedOn retorna um valor datetime indicando quando essa mensagem foi excluída. Para mensagens editadas, chatMessage.EditedOn retorna uma data/hora indicando quando a mensagem foi editada. Você pode acessar a hora original de criação de mensagens usando chatMessage.CreatedOno , e usá-lo para ordenar as mensagens.

GetMessages Retorna diferentes tipos de mensagens, que você pode identificar por chatMessage.Type. Estes tipos são:

• Text: Mensagem de chat normal enviada por um membro do tópico.

• Html: Uma mensagem de texto formatada. Observe que os usuários dos Serviços de Comunicação atualmente não podem enviar RichText mensagens. Esse tipo de mensagem é suportado por mensagens enviadas de usuários do Teams para usuários do Serviços de Comunicação em cenários de interoperabilidade do Teams.

• TopicUpdated: Mensagem do sistema que indica que o tópico foi atualizado. (somente leitura)

• ParticipantAdded: Mensagem do sistema que indica que um ou mais participantes foram adicionados ao tópico de chat. (somente leitura)

• ParticipantRemoved: Mensagem do sistema que indica que um participante foi removido do tópico de chat.

Para obter mais informações, consulte Tipos de mensagem.

Adicionar um usuário como participante ao tópico de bate-papo

Twilio

var participant = ParticipantResource.Create(
    pathConversationSid: conversation.Sid,
    identity: "user@example.com"
);

Azure Communication Services

Nos Serviços de Comunicação do Azure, você adiciona participantes ao criar o thread de chat ou depois:

Depois de criar um thread, você pode adicionar e remover usuários. Adicionar usuários dá a eles acesso para enviar mensagens para o thread e adicionar/remover outros participantes. Antes de chamar AddParticipants, certifique-se de adquirir um novo token de acesso e identidade para esse usuário. O usuário precisa do token de acesso para inicializar seu cliente de chat.

Use AddParticipants para adicionar um ou mais participantes ao tópico de bate-papo. A seguir estão os atributos suportados para cada participante do thread:

• communicationUser, obrigatório, é a identidade do participante do thread.
• displayName, opcional, é o nome para exibição do participante do thread.
• shareHistoryTime, opcional, hora a partir da qual o histórico do chat é partilhado com o participante.

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

Obter participantes do tópico

Twilio

No Twilio Conversations, você usa o ConversationResource para recuperar os participantes de uma conversa específica. Em seguida, você pode listar todos os participantes associados a essa conversa.

// The SID of the conversation you want to retrieve participants from
string conversationSid = "<CONVERSATION_SID>";

// Retrieve all participants in the conversation
var participants = ParticipantResource.Read(pathConversationSid: conversationSid);

// Output details of each participant
foreach (var participant in participants)
{
    Console.WriteLine($"Participant SID: {participant.Sid}");
            
}

Azure Communication Services

Use GetParticipants para recuperar os participantes do tópico de bate-papo.

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

Enviar recibo de leitura

Twilio

// Find your Account SID and Auth Token at twilio.com/console
        // and set the environment variables. See http://twil.io/secure
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
        string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");

        TwilioClient.Init(accountSid, authToken);

        var message = await MessageResource.FetchAsync(
            pathConversationSid: "CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
            pathSid: "IMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

        Console.WriteLine(message.Delivery);
    }

Azure Communication Services

Use SendReadReceipt para notificar outros participantes de que o usuário leu a mensagem.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

Pré-requisitos

• Conta do Azure: certifique-se de que a sua conta do Azure está ativa. Novos usuários podem criar uma conta gratuita no Microsoft Azure.
• Recurso de Serviços de Comunicação: configure um Recurso de Serviços de Comunicação por meio do portal do Azure e anote sua cadeia de conexão.
• CLI do Azure: siga as instruções para instalar a CLI do Azure no Windows.
• Token de acesso de usuário: gere um token de acesso de usuário para instanciar o cliente de chamada. Você pode criar um usando a CLI do Azure da seguinte maneira:

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

Para obter mais informações, consulte Usar a CLI do Azure para criar e gerenciar tokens de acesso.

Instalação

Instalar as bibliotecas

Para iniciar a migração do Chat de Conversas do Twilio, a primeira etapa é instalar o SDK de Chat dos Serviços de Comunicação do Azure para iOS em seu projeto. Você pode configurar esses parâmetros usando CocoaPodso .

1. Crie um Podfile para a sua aplicação. Abra o terminal, navegue até a pasta do projeto e execute:

pod init

2. Adicione o seguinte código ao Podfile e salve (certifique-se de que "target" corresponde ao nome do seu projeto):

pod 'AzureCommunicationChat', '~> 1.3.5'

3. Configure o .xcworkspace projeto:

pod install

4. Abra o .xcworkspace criado pelo pod install com o Xcode.

Autenticando no SDK

Para usar o SDK de Chat dos Serviços de Comunicação do Azure, você precisa autenticar usando um token de acesso.

Twilio

Os trechos de código a seguir presumem a disponibilidade de um token de acesso válido para os Serviços Twilio.

static func getTokenUrlFromDefaults(identity: String, password: String) -> URL? {
        // Get token service absolute URL from settings
        guard let tokenServiceUrl = UserDefaults.standard.string(forKey: "ACCESS_TOKEN_SERVICE_URL"), !tokenServiceUrl.isEmpty else {
            return nil
        }
        return constructLoginUrl(tokenServiceUrl, identity: identity, password: password)
    }

Azure Communication Services

Os trechos de código a seguir exigem um token de acesso válido para iniciar um CallClientarquivo .

Você precisa de um token válido. Para obter mais informações, consulte Criar e gerenciar tokens de acesso.

// Create an instance of CallClient 
let callClient = CallClient() 
 
// A reference to the call agent, it will be initialized later 
var callAgent: CallAgent? 
 
// Embed the token in a CommunicationTokenCredential object 
let userCredential = try? CommunicationTokenCredential(token: "<USER_TOKEN>") 
 
// Create a CallAgent that will be used later to initiate or receive calls 
callClient.createCallAgent(userCredential: userCredential) { callAgent, error in 
 if error != nil { 
        // Raise the error to the user and return 
 } 
 self.callAgent = callAgent         
} 

Inicializar cliente de bate-papo

Twilio

O trecho de código a seguir inicializa o cliente de chat no Twilio.

func fetchAccessTokenAndInitializeClient() {
        let identity = "user_identity" // Replace with actual user identity
        let urlString = "http://localhost:3000/token?identity=\(identity)"
        
        guard let url = URL(string: urlString) else { return }
        
        let task = URLSession.shared.dataTask(with: url) { data, response, error in
            guard let data = data, error == nil else {
                print("Error fetching token: \(String(describing: error))")
                return
            }
            
            do {
                if let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
                   let token = json["token"] as? String {
                    self.initializeConversationsClient(withToken: token)
                }
            } catch {
                print("Error parsing token JSON: \(error)")
            }
        }
        
        task.resume()
    }
```m = TwilioVideoSDK.connect(options: connectOptions, delegate: self)

Azure Communication Services

Para criar um cliente de chat, use o ponto de extremidade dos Serviços de Comunicação e o token de acesso gerado como parte das etapas de pré-requisito.

Substitua <ACS_RESOURCE_ENDPOINT> pelo ponto de extremidade do seu recurso dos Serviços de Comunicação do Azure. Substitua <ACCESS_TOKEN> por um token de acesso válido dos Serviços de Comunicação.

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
)

Modelo de objeto

As classes e interfaces a seguir lidam com alguns dos principais recursos do SDK de Chat dos Serviços de Comunicação do Azure para iOS.

Nome	Descrição
ChatClient	Esta classe é necessária para a função de chat. Você o instancia com suas informações de assinatura e o usa para criar, obter, excluir threads e se inscrever em eventos de bate-papo.
ChatThreadClient	Esta classe é necessária para a função de thread de chat. Você obtém uma instância via ChatCliente a usa para enviar, receber, atualizar e excluir mensagens. Você também pode usá-lo para adicionar, remover, obter usuários e enviar notificações de digitação e confirmações de leitura.

Iniciar um tópico de bate-papo

Twilio

O trecho de código a seguir permite que você crie um novo thread de bate-papo.

    // the unique name of the conversation you create
    private let uniqueConversationName = "general"

    // For the quickstart, this will be the view controller
    weak var delegate: QuickstartConversationsManagerDelegate?

    // MARK: Conversations variables
    private var client: TwilioConversationsClient?
    private var conversation: TCHConversation?
    private(set) var messages: [TCHMessage] = []
    private var identity: String?

    func conversationsClient(_ client: TwilioConversationsClient, synchronizationStatusUpdated status: TCHClientSynchronizationStatus) {
        guard status == .completed else {
            return
        }

        checkConversationCreation { (_, conversation) in
           if let conversation = conversation {
               self.joinConversation(conversation)
           } else {
               self.createConversation { (success, conversation) in
                   if success, let conversation = conversation {
                       self.joinConversation(conversation)
                   }
               }
           }
        }

Azure Communication Services

A resposta retornada da criação de um thread de bate-papo é CreateChatThreadResult. Ele contém uma chatThread propriedade, que é o ChatThreadProperties objeto. Este objeto contém o threadId, que você pode usar para obter um ChatThreadClient para executar operações no thread criado: adicionar participantes, enviar mensagem e assim por diante.

Substitua o comentário <CREATE A CHAT THREAD> pelo seguinte trecho de código:

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

Substitua <USER_ID> por um ID de usuário válido dos Serviços de Comunicação.

Você está usando um semáforo aqui para aguardar o manipulador de conclusão antes de continuar. Em etapas posteriores, use o threadId da resposta retornada para o manipulador de conclusão.

Obter um cliente de thread de chat

Twilio

O trecho de código a seguir mostra como obter um cliente de thread de bate-papo no Twilio.

func conversationsClient(_ client: TwilioConversationsClient, synchronizationStatusUpdated status: TCHClientSynchronizationStatus) {
        guard status == .completed else {
            return
        }

        checkConversationCreation { (_, conversation) in
           if let conversation = conversation {
               self.joinConversation(conversation)
           } else {
               self.createConversation { (success, conversation) in
                   if success, let conversation = conversation {
                       self.joinConversation(conversation)
                   }
               }
           }
        }
    }

Azure Communication Services

O createClient método retorna um ChatThreadClient para um thread que já existe. Você pode usá-lo para executar operações no thread criado: adicionar participantes, enviar mensagem e assim por diante.

O threadId é o ID exclusivo do thread de bate-papo existente.

Substitua o comentário <GET A CHAT THREAD CLIENT> pelo código seguinte:

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

Enviar uma mensagem para um tópico de chat

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm função separada para enviar mensagens de texto ou mídia.

Twilio

Envie uma mensagem de texto normal em Twilio.

    func sendMessage(_ messageText: String,
                     completion: @escaping (TCHResult, TCHMessage?) -> Void) {

        let messageOptions = TCHMessageOptions().withBody(messageText)
        conversation?.sendMessage(with: messageOptions, completion: { (result, message) in
            completion(result, message)
        })

    }

Enviar mídia em Twilio:

/ The data for the image you would like to send
let data = Data()

// Prepare the message and send it
self.conversation.prepareMessage
    .addMedia(data: data, contentType: "image/jpeg", filename: "image.jpg", listener: .init(onStarted: {
        // Called when upload of media begins.
        print("Media upload started")
    }, onProgress: { bytes in
        // Called as upload progresses, with the current byte count.
        print("Media upload progress: \(bytes)")
    }, onCompleted: { sid in
        // Called when upload is completed, with the new mediaSid if successful.
        // Full failure details will be provided through sendMessage's completion.
        print("Media upload completed")
    }, onFailed: { error in
        // Called when upload is completed, with the new mediaSid if successful.
        // Full failure details will be provided through sendMessage's completion.
        print("Media upload failed with error: \(error)")
    }))
    .buildAndSend { result, message in
        if !result.isSuccessful {
            print("Creation failed: \(String(describing: result.error))")
        } else {
            print("Creation successful")
        }
    }

Azure Communication Services

Use o send método para enviar uma mensagem para um thread identificado por threadId.

Use SendChatMessageRequest para descrever a solicitação de mensagem:

• Use content para fornecer o conteúdo da mensagem de chat.
• Use senderDisplayName para especificar o nome de exibição do remetente.
• Use type para especificar o tipo de mensagem, como text ou html.
• Use metadata opcionalmente para incluir qualquer informação que você deseja enviar junto com a mensagem. Este campo fornece um mecanismo para os desenvolvedores estenderem a funcionalidade de mensagens de chat e adicionarem informações personalizadas para o seu caso de uso. Por exemplo, ao compartilhar um link de arquivo na mensagem, talvez você queira adicionar hasAttachment:true metadados para que o aplicativo do destinatário possa analisá-los e exibi-los adequadamente.

A resposta retornada do envio de uma mensagem éSendChatMessageResult. Ele contém um ID, que é o ID exclusivo da mensagem.

Substitua o comentário <SEND A MESSAGE> pelo seguinte trecho de código:

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

Receber mensagens de chat a partir de um tópico de chat

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm uma função separada para receber mensagens de texto ou mídia.

Twilio

O trecho de código a seguir mostra como receber uma mensagem de texto no Twilio.

// Called whenever a conversation we've joined receives a new message
    func conversationsClient(_ client: TwilioConversationsClient, conversation: TCHConversation,
                    messageAdded message: TCHMessage) {
        messages.append(message)

        // Changes to the delegate should occur on the UI thread
        DispatchQueue.main.async {
            if let delegate = self.delegate {
                delegate.reloadMessages()
                delegate.receivedNewMessage()
            }
        }
    }

Receba mídia em Twilio:

conversationsClient.getTemporaryContentUrlsForMedia(message.attachedMedia) { result, mediaSidToUrlMap in
    guard result.isSuccessful else {
        print("Couldn't get temporary urls with error: \(String(describing: result.error))")
        return
    }

    for (sid, url) in sidToUrlMap {
        print("\(sid) -> \(url)")
    }
}

Azure Communication Services

Com sinalização em tempo real, você pode se inscrever para ouvir novas mensagens recebidas e atualizar as mensagens atuais na memória de acordo. Os Serviços de Comunicação do Azure dão suporte a uma lista de eventos que você pode assinar.

Substitua o comentário <RECEIVE MESSAGES> pelo código seguinte. Depois de ativar as notificações, tente enviar novas mensagens para ver o 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
    }
})

Como alternativa, você pode recuperar mensagens de bate-papo pesquisando o listMessages método em intervalos especificados. Consulte o seguinte trecho de código para 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()

Notificações push

À semelhança do Twilio, os Serviços de Comunicação do Azure suportam notificações push. As notificações por push notificam os clientes sobre mensagens recebidas em um thread de bate-papo se o aplicativo móvel não estiver sendo executado em primeiro plano.

Atualmente, o envio de notificações por push de chat com o Hub de Notificação é compatível com o SDK do iOS na versão 1.3.0.

Para obter mais informações, consulte Ativar notificação por push em seu aplicativo de bate-papo.

Pré-requisitos

• Crie uma conta do Azure com uma assinatura ativa. Para obter detalhes, consulte Criar uma conta gratuitamente.

• Instalar o Visual Studio.

• Criar um recurso do Azure Communication Services. Para obter detalhes, consulte Criar um recurso dos Serviços de Comunicação do Azure. Registre o ponto de extremidade do recurso e a cadeia de conexão.

• Um token de acesso de usuário. Certifique-se de definir o escopo para bate-papo e anote a cadeia de caracteres de token e user_id string. Você também pode usar a CLI do Azure e executar o seguinte comando com sua cadeia de conexão para criar um usuário e um token de acesso.

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

  Para obter mais informações, consulte Usar a CLI do Azure para criar e gerenciar tokens de acesso.

Diferença Conceptual

Tanto o Twilio Conversations quanto o Azure Communication Services Chat oferecem funções semelhantes, mas sua implementação difere devido aos ecossistemas circundantes e às filosofias de plataforma subjacentes. O Twilio Conversations fornece uma API de comunicação multicanal. O Chat dos Serviços de Comunicação do Azure é focado principalmente no chat dentro do ecossistema do Azure. Este guia de migração fornece um mapeamento básico entre operações comuns no Twilio e seus equivalentes no Chat dos Serviços de Comunicação do Azure, ajudando você a fazer a transição do seu código .NET.

Identidades

Twilio

O Twilio Conversations usa cadeias de caracteres de identidade diretamente.

Azure Communication Services

Os Serviços de Comunicação do Azure requerem a criação de utilizadores através do CommunicationIdentityClient.

Configuração

Instalar o pacote

Para iniciar a migração do chat do Twilio Conversations, a primeira etapa é instalar o SDK de Chat dos Serviços de Comunicação do Azure para .NET em seu projeto.

dotnet add package Azure.Communication.Chat

Modelo de objeto

As classes a seguir lidam com alguns dos principais recursos do SDK de Chat dos Serviços de Comunicação do Azure para C#.

Nome	Descrição
ChatClient	Esta classe é necessária para a funcionalidade de chat. Você o instancia com suas informações de assinatura e o usa para criar, obter e excluir threads.
ChatThreadClient	Esta classe é necessária para a funcionalidade Chat Thread. Você obtém uma instância por meio do ChatClient e a usa para enviar/receber/atualizar/excluir mensagens, adicionar/remover/obter participantes, enviar notificações de digitação e ler confirmações.

Criar um cliente de chat

Twilio

O Twilio requer que você configure o cliente Twilio usando suas credenciais de conta:

var twilio = new TwilioRestClient(accountSid, authToken);

Azure Communication Services

Para criar um cliente de chat nos Serviços de Comunicação do Azure, use seu ponto de extremidade dos Serviços de Comunicação e o token de acesso que foi gerado como parte das etapas de pré-requisito. Você precisa usar a CommunicationIdentityClient classe do SDK de identidade para criar um usuário e emitir um token para passar para seu cliente de chat.

Saiba mais sobre os Tokens de Acesso de Usuário.

// Your unique Azure Communication service endpoint
Uri endpoint = new Uri("<replace with your resource endpoint>");
CommunicationTokenCredential communicationTokenCredential = new CommunicationTokenCredential(<Access_Token>);
ChatClient chatClient = new ChatClient(endpoint, communicationTokenCredential);

Iniciar um tópico de bate-papo

Conversas Twilio

var conversation = ConversationResource.Create(
    friendlyName: "My Conversation",
    messagingServiceSid: "<MessagingServiceSid>"
);

Azure Communication Services

Nos Serviços de Comunicação do Azure, você cria um thread, que é equivalente a uma conversa no Twilio.

Para criar um thread de chat, use o createChatThread método no chatClient:

• Use topic para dar um tópico a este chat, você pode atualizar o depois que o tópico de bate-papo topic é criado usando a UpdateTopic função.
• Use participants a propriedade para passar uma lista de objetos a serem adicionados ao thread de ChatParticipant chat. Inicialize o ChatParticipant objeto com um CommunicationIdentifier objeto. CommunicationIdentifier pode ser do tipo CommunicationUserIdentifier, MicrosoftTeamsUserIdentifier, ou PhoneNumberIdentifier. Por exemplo, para obter um CommunicationIdentifier objeto, você precisa passar uma ID de acesso criada seguindo as instruções para Criar um usuário.

O objeto de resposta do createChatThread método contém os chatThread detalhes. Para interagir com as operações do thread de chat, como adicionar participantes, enviar uma mensagem, excluir uma mensagem e assim por diante, instancie uma chatThreadClient instância do cliente usando o GetChatThreadClient método no ChatClient cliente.

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;

Obter um cliente de thread de chat

Twilio

No Twilio Conversations, você interage diretamente com uma conversa usando o SID (identificador exclusivo) da conversa. Veja como normalmente obter uma conversa e interagir com ela:

var conversationSid = "<CONVERSATION_SID>";
var conversation = ConversationResource.Fetch(pathSid: conversationSid);

// Example: Fetching all messages in the conversation
var messages = MessageResource.Read(pathConversationSid: conversationSid);
foreach (var message in messages)
{
    Console.WriteLine(message.Body);
}

Azure Communication Services

O GetChatThreadClient método retorna um cliente de thread para um thread que já existe. Você pode usá-lo para executar operações no thread criado: adicionar membros, enviar mensagem e assim por diante. threadId é o ID exclusivo do tópico de bate-papo existente.

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

Listar todos os tópicos de bate-papo

Twilio

No Twilio Conversations, você pode recuperar todas as conversas das quais um usuário participa consultando o UserConversations recurso. Este recurso fornece uma lista de conversas para um usuário específico.

/ Initialize Twilio Client
string accountSid = "<YOUR_ACCOUNT_SID>";
string authToken = "<YOUR_AUTH_TOKEN>";
TwilioClient.Init(accountSid, authToken);

// The identity of the user you're querying
string userIdentity = "user@example.com";

// Retrieve all conversations the user is part of
var userConversations = UserConversationResource.Read(pathUserSid: userIdentity);

foreach (var userConversation in userConversations)
{
    Console.WriteLine($"Conversation SID: {userConversation.ConversationSid}");
    // You can fetch more details about the conversation if needed
    var conversation = Twilio.Rest.Conversations.V1.ConversationResource.Fetch(pathSid: userConversation.ConversationSid);
    Console.WriteLine($"Conversation Friendly Name: {conversation.FriendlyName}");
}

Azure Communication Services

Use GetChatThreads para recuperar todos os tópicos de bate-papo dos quais o usuário faz parte.

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

Enviar uma mensagem para um tópico de chat

Twilio

O trecho de código a seguir mostra como enviar uma mensagem de texto.

var message = MessageResource.Create(
    body: "Hello, world!",
    from: "user@example.com",
    pathConversationSid: conversation.Sid
);

O trecho de código a seguir mostra como enviar um arquivo de mídia.

// The SID of the conversation you want to send the media message to
string conversationSid = "<CONVERSATION_SID>";

// The URL of the media file you want to send
var mediaUrl = new List<Uri>
{
    new Uri("https://example.com/path/to/media/file.jpg") // Replace with your actual media URL
};

// Send the media message
var message = MessageResource.Create(
    body: "Here is an image for you!",
    from: "user@example.com", // Sender's identity (optional)
    mediaUrl: mediaUrl,
    pathConversationSid: conversationSid
);

Azure Communication Services

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm uma função separada para enviar mensagens de texto ou mídia.

Use SendMessage para enviar uma mensagem para um thread.

• Use content para fornecer o conteúdo da mensagem, é necessário.
• Use type para o tipo de conteúdo da mensagem, como Text ou Html. Se não for especificado, Text é o padrão.
• Use senderDisplayName para especificar o nome de exibição do remetente. Se não for especificado, a cadeia de caracteres vazia será o padrão.
• Use metadata opcionalmente para incluir quaisquer outros dados que você deseja enviar junto com a mensagem. Este campo fornece um mecanismo para os desenvolvedores estenderem a função de mensagem de chat e adicionarem informações personalizadas para o seu caso de uso. Por exemplo, ao compartilhar um link de arquivo na mensagem, talvez você queira adicionar hasAttachment:true os metadados para que o aplicativo do destinatário possa analisá-los e exibi-los adequadamente.

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;

Receber mensagens de chat a partir de um tópico de chat

Twilio

O Twilio normalmente usa webhooks para notificar seu servidor sobre mensagens recebidas:

O trecho de código a seguir mostra como receber uma mensagem de texto.

public IActionResult ReceiveMessage()
{
    var incomingMessage = Request.Form["Body"];
    // Process the incoming message
    return Ok();
}

O trecho de código a seguir mostra como receber um arquivo de mídia.

 for (var i = 0; i < numMedia; i++)
            {
                var mediaUrl = Request.Form[$"MediaUrl{i}"];
                Trace.WriteLine(mediaUrl);
                var contentType = Request.Form[$"MediaContentType{i}"];

                var filePath = GetMediaFileName(mediaUrl, contentType);
                await DownloadUrlToFileAsync(mediaUrl, filePath);
            }

Azure Communication Services

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm uma função separada para receber mensagens de texto ou mídia.

O Chat dos Serviços de Comunicação do Azure permite-lhe subscrever eventos diretamente na aplicação.

Você pode recuperar mensagens de bate-papo sondando o GetMessages método no cliente de thread de bate-papo em intervalos especificados.

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

GetMessages usa um parâmetro opcional DateTimeOffset . Se esse deslocamento for especificado, você receberá mensagens que foram recebidas, atualizadas ou excluídas depois dele. As mensagens recebidas antes do tempo de deslocamento, mas editadas ou removidas depois dele, também são retornadas.

GetMessages Retorna a versão mais recente da mensagem, incluindo quaisquer edições ou exclusões que aconteceram com a mensagem usando UpdateMessage e DeleteMessage. Para mensagens excluídas, chatMessage.DeletedOn retorna um valor datetime indicando quando essa mensagem foi excluída. Para mensagens editadas, chatMessage.EditedOn retorna uma data/hora indicando quando a mensagem foi editada. Você pode acessar a hora original de criação de mensagens usando chatMessage.CreatedOno , e usá-lo para ordenar as mensagens.

GetMessages Retorna diferentes tipos de mensagens, que podem ser identificadas pelo chatMessage.Type. Estes tipos são:

• Text: Mensagem de chat normal enviada por um membro do tópico.

• Html: Uma mensagem de texto formatada. Atualmente, os usuários dos Serviços de Comunicação não podem enviar RichText mensagens. Esse tipo de mensagem é suportado por mensagens enviadas de usuários do Teams para usuários do Serviços de Comunicação em cenários de interoperabilidade do Teams.

• TopicUpdated: Mensagem do sistema que indica que o tópico foi atualizado. (somente leitura)

• ParticipantAdded: Mensagem do sistema que indica que um ou mais participantes foram adicionados ao tópico de chat. (somente leitura)

• ParticipantRemoved: Mensagem do sistema que indica que um participante foi removido do tópico de chat.

Para obter mais informações, consulte Tipos de mensagem.

Adicionar um usuário como participante ao tópico de bate-papo

Twilio

var participant = ParticipantResource.Create(
    pathConversationSid: conversation.Sid,
    identity: "user@example.com"
);

Azure Communication Services

Nos Serviços de Comunicação do Azure, você adiciona participantes ao criar o thread de chat ou depois:

Depois de criar um thread, você pode adicionar e remover usuários. Adicionar usuários dá a eles acesso para enviar mensagens para o thread e adicionar/remover outros participantes. Antes de chamar AddParticipants, certifique-se de adquirir um novo token de acesso e identidade para esse usuário. O usuário precisa do token de acesso para inicializar seu cliente de chat.

Use AddParticipants para adicionar um ou mais participantes ao tópico de bate-papo. A seguir estão os atributos suportados para cada participante do thread:

• communicationUser, obrigatório, é a identidade do participante do thread.
• displayName, opcional, é o nome para exibição do participante do thread.
• shareHistoryTime, opcional, hora a partir da qual o histórico do chat é partilhado com o participante.

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

Obter participantes do tópico

Twilio

No Twilio Conversations, você usa o ConversationResource para recuperar os participantes de uma conversa específica. Em seguida, você pode listar todos os participantes associados a essa conversa.

// The SID of the conversation you want to retrieve participants from
string conversationSid = "<CONVERSATION_SID>";

// Retrieve all participants in the conversation
var participants = ParticipantResource.Read(pathConversationSid: conversationSid);

// Output details of each participant
foreach (var participant in participants)
{
    Console.WriteLine($"Participant SID: {participant.Sid}");
            
}

Azure Communication Services

Use GetParticipants para recuperar os participantes do tópico de bate-papo.

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

Enviar recibo de leitura

Twilio

// Find your Account SID and Auth Token at twilio.com/console
        // and set the environment variables. See http://twil.io/secure
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
        string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");

        TwilioClient.Init(accountSid, authToken);

        var message = await MessageResource.FetchAsync(
            pathConversationSid: "CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
            pathSid: "IMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

        Console.WriteLine(message.Delivery);
    }

Azure Communication Services

Use SendReadReceipt para notificar outros participantes de que o usuário leu a mensagem.

await chatThreadClient.SendReadReceiptAsync(messageId: messageId);

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.

• Java Development Kit (JDK) versão 8 ou superior.

• Apache Maven.

• Criar um recurso do Azure Communication Services. Para obter detalhes, consulte Criar um recurso dos Serviços de Comunicação do Azure. Você precisa registrar o ponto de extremidade do recurso e a cadeia de conexão.

• Um token de acesso de usuário. Certifique-se de definir o escopo para bate-papo e anote a cadeia de caracteres de token e a cadeia de caracteres de user_id. Você também pode usar a CLI do Azure e executar o seguinte comando com sua cadeia de conexão para criar um usuário e um token de acesso.

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

  Para obter detalhes, consulte Usar a CLI do Azure para criar e gerenciar tokens de acesso.

Configuração

Adicionar as referências de pacote para o SDK de bate-papo

Twilio

Para usar as APIs do Twilio Conversations Chat em seu aplicativo Java, adicione a seguinte dependência em seu pom.xml:

<dependencies>
    <!-- Twilio Java SDK -->
    <dependency>
        <groupId>com.twilio.sdk</groupId>
        <artifactId>twilio</artifactId>
        <version>8.31.1</version>
    </dependency>
</dependencies>

Azure Communication Services

No seu arquivo POM, faça referência ao azure-communication-chat pacote com as APIs de bate-papo:

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

Para autenticação, seu cliente precisa fazer referência ao azure-communication-common pacote:

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

Modelo de objeto

As classes e interfaces a seguir lidam com alguns dos principais recursos do SDK de Chat dos Serviços de Comunicação do Azure para Java.

Nome	Descrição
ChatClient	Esta classe é necessária para a função de chat. Instancie-o com suas informações de assinatura e use-o para criar, obter e excluir threads.
ChatAsyncClient	Esta classe é necessária para a função de bate-papo assíncrono. Instancie-o com suas informações de assinatura e use-o para criar, obter e excluir threads.
ChatThreadClient	Esta classe é necessária para a função Chat Thread. Você obtém uma instância por meio do ChatClient, e a usa para enviar/receber/atualizar/excluir mensagens, adicionar/remover/obter usuários, enviar notificações de digitação e ler confirmações.
ChatThreadAsyncClient	Esta classe é necessária para a função assíncrona Chat Thread. Você obtém uma instância por meio do ChatAsyncClient, e a usa para enviar/receber/atualizar/excluir mensagens, adicionar/remover/obter usuários, enviar notificações de digitação e ler confirmações.

Importar

Twilio

import com.twilio.Twilio;
import com.twilio.rest.conversations.v1.Conversation;

Azure Communication Services

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

Criar um cliente de chat

Twilio

No Twilio, você inicializa o cliente usando o SID da conta e o token de autenticação. Veja como você normalmente inicializa um cliente.

String accountSid = "<YOUR_ACCOUNT_SID>";
String authToken = "<YOUR_AUTH_TOKEN>";
        
// Initialize Twilio client
Twilio.init(accountSid, authToken);

Azure Communication Services

Para criar um cliente de chat, use o ponto de extremidade do Serviço de Comunicações e o token de acesso que foi gerado como parte das etapas de pré-requisito. Os tokens de acesso de usuário permitem que você crie aplicativos cliente que se autenticam diretamente nos Serviços de Comunicação do Azure. Depois de gerar esses tokens em seu servidor, passe-os de volta para um dispositivo cliente. Você precisa usar a CommunicationTokenCredential classe do SDK comum para passar o token para seu cliente de chat.

Saiba mais sobre a arquitetura de bate-papo

Ao adicionar as instruções import, certifique-se de adicionar apenas importações dos com.azure.communication.chat namespaces e com.azure.communication.chat.models e não do com.azure.communication.chat.implementation namespace. App.java No arquivo que foi gerado via Maven, você pode usar o seguinte código para iniciar:

// Your unique Azure Communication service endpoint
String endpoint = "<replace with your resource endpoint>";

// User access token fetched from your trusted service
String userAccessToken = "<USER_ACCESS_TOKEN>";

// Create a CommunicationTokenCredential with the given access token, which is only valid until the token is valid
CommunicationTokenCredential userCredential = new CommunicationTokenCredential(userAccessToken);

// Initialize the chat client
final ChatClientBuilder builder = new ChatClientBuilder();
    builder.endpoint(endpoint)
        .credential(userCredential);
    ChatClient chatClient = builder.buildClient();

Iniciar um tópico de bate-papo

Twilio

Criar uma conversa no Twilio é simples usando o Conversation.creator() método.

Use o para dar um tópico a este bate-papo setFriendlyName .

// Create a new conversation
        Conversation conversation = Conversation.creator().setFriendlyName("New Conversation").create();
        System.out.println(conversation.getSid());

Azure Communication Services

Use o createChatThread método para criar um thread de chat.

• UsecreateChatThreadOptions para descrever a solicitação de thread.
• Use o topic parâmetro do construtor para dar um tópico a este chat, atualize 'topic' depois que o thread de chat for criado usando a UpdateThread função.
• Use participants para listar os participantes do thread a serem adicionados ao thread. ChatParticipantleva o usuário criado no início rápido do Token de Acesso do Usuário.

CreateChatThreadResult é a resposta retornada da criação de um thread de chat. Ele contém um getChatThread() método, que retorna o ChatThread objeto que pode ser usado para obter o cliente de thread do qual você pode obter o ChatThreadClient para executar operações no thread criado: adicionar participantes, enviar mensagem e assim por diante.

O ChatThread objeto também contém o getId() método, que recupera a ID exclusiva do thread.

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

Listar tópicos de bate-papo

Twilio

Para listar todas as conversas no Twilio usando Java:

public static void main(String[] args) {
        // List all conversations
        ResourceSet<Conversation> conversations = Conversation.reader().read();

        for (Conversation conversation : conversations) {
            System.out.println("Conversation SID: " + conversation.getSid());
            System.out.println("Friendly Name: " + conversation.getFriendlyName());
            System.out.println("Date Created: " + conversation.getDateCreated());
        }
    }

Azure Communication Services

Use o método para recuperar uma lista de threads de bate-papo listChatThreads existentes.

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

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

Obter um cliente de thread de chat

Twilio

Veja como você pode recuperar e interagir com uma conversa específica no Twilio usando Java:

// Retrieve a specific conversation by its SID
Conversation conversation = Conversation.fetcher(conversationSid).fetch();
System.out.println("Retrieved Conversation SID: " + conversation.getSid());
System.out.println("Friendly Name: " + conversation.getFriendlyName())

Azure Communication Services

O getChatThreadClient método retorna um cliente de thread para um thread que já existe. Use-o para executar operações no thread criado: adicionar participantes, enviar mensagem e assim por diante. chatThreadId é o ID exclusivo do tópico de bate-papo existente.

ChatThreadClient chatThreadClient = chatClient.getChatThreadClient(chatThreadId);

Enviar uma mensagem para um tópico de chat

Twilio

Enviar uma mensagem no Twilio usa o Message.creator() método.

import com.twilio.rest.conversations.v1.conversation.Message;

Message message = Message.creator(conversationSid)
    .setBody("Hello, World!")
    .create();
System.out.println("Message SID: " + message.getSid());

Twilio permite que você envie arquivos de mídia fornecendo um URL de mídia ao enviar uma mensagem.

List<URI> mediaUrls = Arrays.asList(URI.create("https://example.com/image.jpg"));
Message message = Message.creator(conversationSid)
    .setBody("Check out this image!")
    .setMediaUrl(mediaUrls)
    .create();
System.out.println("Message SID: " + message.getSid());

Azure Communication Services

Ao contrário do Twilio, os Serviços de Comunicação do Azure não têm funções separadas para enviar mídia. Use o sendMessage método para enviar uma mensagem para o thread que você criou, identificado por chatThreadId.

Use sendChatMessageOptions para descrever a solicitação de mensagem de chat.

• Use content para fornecer o conteúdo da mensagem de chat.
• Use type para especificar o tipo de conteúdo da mensagem de chat: TEXT ou HTML.
• Use senderDisplayName para especificar o nome de exibição do remetente.
• Use metadata opcionalmente para incluir quaisquer dados que você deseja enviar com a mensagem. Este campo permite que os desenvolvedores estendam a função de mensagem de chat e adicionem informações personalizadas para o seu caso de uso. Por exemplo, ao compartilhar um link de arquivo na mensagem, talvez você queira adicionar hasAttachment:true metadados para que o aplicativo do destinatário possa analisá-los e exibi-los adequadamente.

A resposta sendChatMessageResult contém um id, que é o ID exclusivo da mensagem.

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

Receber mensagens de chat a partir de um tópico de chat

Twilio

O Twilio Conversations usa webhooks para receber mensagens. Normalmente, você configura uma URL de webhook no console do Twilio.

// This would be handled by a servlet or similar in a Java web application
public void handleIncomingMessage(HttpServletRequest request, HttpServletResponse response) {
    String body = request.getParameter("Body");
    System.out.println("Received message: " + body);
}

Para receber o arquivo de mídia no Twilio.

private static final Logger logger = Logger.getLogger(TwilioWebhookServlet.class.getName());

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // Get the number of media items attached to the message
        String numMedia = request.getParameter("NumMedia");

        int mediaCount = Integer.parseInt(numMedia);

        if (mediaCount > 0) {
            // Loop through each media file received
            for (int i = 0; i < mediaCount; i++) {
                // Get the media URL from the request
                String mediaUrl = request.getParameter("MediaUrl" + i);
                String mediaContentType = request.getParameter("MediaContentType" + i);

                logger.info("Received media file: " + mediaUrl + " with content type: " + mediaContentType);

                // Process the media file (e.g., download, store, etc.)
                // Example: Download and save the file, or send it to another service
            }
        } else {
            // Handle a message with no media
            String messageBody = request.getParameter("Body");
            logger.info("Received text message: " + messageBody);
        }

Azure Communication Services

Você pode recuperar mensagens de bate-papo sondando o listMessages método no cliente de thread de bate-papo em intervalos especificados.

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

listMessages Retorna a versão mais recente da mensagem, incluindo quaisquer edições ou exclusões que aconteceram com a mensagem usando .editMessage() e .deleteMessage(). Para mensagens excluídas, chatMessage.getDeletedOn() retorna um datetime valor que indica quando essa mensagem foi excluída. Para mensagens editadas, chatMessage.getEditedOn() retorna uma data/hora indicando quando a mensagem foi editada. A hora original de criação da mensagem pode ser acessada usando chatMessage.getCreatedOn()o , e pode ser usada para ordenar as mensagens.

Leia mais sobre os tipos de mensagem aqui: Tipos de mensagem.

Enviar recibo de leitura

Twilio

O Twilio Conversations não tem uma API direta para enviar confirmações de leitura. O Twilio Conversations gerencia confirmações de leitura automaticamente.

Azure Communication Services

Use o método para postar um evento de confirmação de leitura em um thread de bate-papo sendReadReceipt , em nome de um usuário.

chatMessageId é o ID exclusivo da mensagem de chat que foi lida.

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

Listar participantes do bate-papo

Twilio

Para recuperar participantes de uma conversa do Twilio:

ResourceSet<Participant> participants = Participant.reader(conversationSid).read();

for (Participant participant : participants) {
    System.out.println("Participant SID: " + participant.getSid());
}

Azure Communication Services

Use listParticipants para recuperar uma coleção paginada contendo os participantes do thread de bate-papo identificados por chatThreadId.

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

Adicionar um usuário como participante ao tópico de bate-papo

Twilio

Adicione participantes a uma conversa usando o método Participant.creator().

import com.twilio.rest.conversations.v1.conversation.Participant;

Participant participant = Participant.creator(conversationSid)
    .setIdentity("user@example.com")
    .create();
System.out.println("Participant SID: " + participant.getSid());

Azure Communication Services

Depois que um thread de bate-papo é criado, você pode adicionar e remover usuários dele. Ao adicionar usuários, você dá a eles acesso para enviar mensagens para o histórico de bate-papo e adicionar/remover outros participantes. Comece obtendo um novo token de acesso e identidade para esse usuário. Antes de chamar o addParticipants método, verifique se você adquiriu um novo token de acesso e identidade para esse usuário. O usuário precisa desse token de acesso para inicializar seu cliente de chat.

Use o addParticipants método para adicionar participantes ao thread.

• communicationIdentifier, obrigatório, é o CommunicationIdentifier que você criou usando CommunicationIdentityClient o início rápido do Token de Acesso do Usuário .
• displayName, opcional, é o nome para exibição do participante do thread.
• shareHistoryTime, opcional, é o momento a partir do qual o histórico de bate-papo é compartilhado com o participante. Para compartilhar o histórico desde o início do thread de chat, defina essa propriedade para qualquer data igual ou inferior ao tempo de criação do thread. Para não compartilhar nenhum histórico anterior ao momento em que o participante foi adicionado, defina-o para a data atual. Para compartilhar o histórico parcial, defina-o para a data desejada.

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