Eventos do SDK da Web sem interface gráfica

O SDK da Web sem interface gráfica fornece eventos que podem ser detectados para processar ações ou atualizações específicas no seu aplicativo. É possível adicionar e remover listeners de eventos usando os métodos .on e .off.

const handleReady = () => {
  console.log("**** client is ready")
}

client.on("ready", handleReady)

// client.off("ready", handleReady)

Eventos gerais

Confira a seguir eventos gerais para o SDK

ready

Emitido quando o cliente está pronto para comunicação.

client.on("ready", () => {
})

authenticated

Emitido quando o cliente é autenticado com o token do usuário.

client.on("authenticated", () => {
})

Eventos de chat

Confira a seguir os eventos específicos da sessão de chat.

chat.ongoing

Emitido quando há um chat em andamento.

client.on("chat.ongoing", (chat) => {
  console.log(chat)
})

chat.updated

Emitido quando a instância do chat é atualizada.

client.on("chat.updated", (chat) => {
  // the `chat` property on `client` has updated
  console.log(chat)
})

chat.message

Emitido quando há uma nova mensagem.

client.on("chat.message", message => {
  console.log(message)
})

O tipo de mensagem:

interface MessageResponse {
  $index: number;
  $sid: string;
  $timestamp: Date;
  $userType: string;
  $userId: number;
  type: string;
  content?: string;
  event?: string;
  file?: File;

  // extra parameters
  [key: string]: unknown;
}

chat.memberJoined

Emitido quando um novo participante entra na conversa.

client.on("chat.memberJoined", (identity) => {
  console.log(identity)
})

chat.memberLeft

Emitido quando um membro sai da conversa.

client.on("chat.memberLeft", (identity) => {
  console.log(identity)
})

chat.connected

Emitido quando o chat é conectado ao provedor de conversas.

client.on("chat.connected", () => {
  console.log("connected")
})

Em casos raros, pode haver problemas de latência que fazem com que uma mensagem seja enviada em um chat antes que o SDK entre nele. Quando isso acontece, você pode usar fetchMessages para receber todas as mensagens de uma conversa depois que um chat é conectado. Confira o exemplo de código a seguir:

client.on("chat.connected", async () = {
  const messages = await
client.fetchMessages()
})

chat.disconnected

Emitido quando o chat é desconectado do provedor de conversas.

client.on("chat.disconnected", () => {
  console.log("disconnected")
})

chat.dismissed

Emitido quando o status do chat é alterado para dismissed.

client.on("chat.dismissed", () => {
  console.log("dismissed")
})

chat.timeout

Emitido quando o chat é encerrado, sendo o motivo timeout.

client.on("chat.timeout", () => {
  console.log("timeout")
})

chat.ended

Emitido quando o chat é encerrado.

client.on("chat.ended", () => {
  console.log("ended")
})

chat.destroyed

Emitido quando destroyChat é chamado.

client.on("chat.destroyed", () => {
  console.log("destroyed")
})

chat.checkInRequested

Emitido quando o chat pode ser feito check-in.

chat.checkInTimedOut

Emitido quando o check-in do chat expira.

Eventos de digitação

Quando um agente começa a digitar, o adaptador de chat envia um sinal que resulta no envio do evento typingStarted para o SDK da Web sem interface gráfica. Quando o agente para de digitar, um sinal é enviado após três segundos, resultando no envio de um evento typingEnded para o SDK da Web sem interface gráfica. O tempo limite de três segundos não é configurável.

Observação: o tempo limite de três segundos não é configurável.

chat.typingStarted

Emitido quando um membro começa a digitar.

client.on("chat.typingStarted", (identity) => {
  console.log(identity)
})

chat.typingEnded

Emitido quando um membro para de digitar.

client.on("chat.typingEnded", (identity) => {
  console.log(identity)
})

Eventos de check-in do chat

O check-in do chat pede que o usuário final confirme que está pronto antes de se conectar a um agente. Esta seção documenta os métodos do SDK da Web sem interface gráfica para implementar o check-in do chat. Para mais informações, consulte Check-in por chat.

checkIn

Envia um sinal de confirmação ao servidor indicando que o usuário final está presente e pronto para se conectar com um agente durante o período de check-in. Atualiza o check_in_status do chat localmente depois que o servidor confirma. Use isso em resposta ao evento chat.checkInRequested.

Assinatura do método

checkIn(): Promise<CheckInResponse>

Valor de retorno

Retorna um objeto CheckInResponse.

Interfaces

interface CheckInResponse {
  chat_id: number;
  check_in_status: CheckInStatus;
  check_in_at?: string;
}
enum CheckInStatus {
  CONFIRMED = 'confirmed',
  EXITED = 'exited',
  PENDING = 'pending',
  REQUESTED = 'requested',
  SKIPPED = 'skipped',
  TIMED_OUT = 'timed_out',
}

Exemplo

try {
  const response = await client.checkIn()
} catch (error) {
  // handle error
}

exitCheckIn

Remove o usuário da fila de check-in.

Assinatura do método

exitCheckIn(): Promise<CheckInResponse>

Valor de retorno

Retorna um objeto CheckInResponse.

Interfaces

interface CheckInResponse {
  chat_id: number;
  check_in_status: CheckInStatus;
  check_in_at?: string;
}
enum CheckInStatus {
  CONFIRMED = 'confirmed',
  EXITED = 'exited',
  PENDING = 'pending',
  REQUESTED = 'requested',
  SKIPPED = 'skipped',
  TIMED_OUT = 'timed_out',
}

notifyCheckInState

Notifica o back-end sobre o estado de visibilidade da caixa de diálogo de check-in.

Assinatura do método

notifyCheckInState(data: CheckInVisibilityStateRequest): Promise<void>

Interfaces

interface CheckInVisibilityStateRequest {
  widget_minimized?: boolean;
  tab_inactive?: boolean;
}
**Example**

try {
  const visibilityState = {
    widget_minimized: true,
    tab_inactive: false,
  }
  await client.notifyCheckInState(visibilityState)
} catch (error) {
  // handle error
}

rejoinChat

Coloca o usuário de volta na fila depois que não é possível confirmar o check-in.

Assinatura do método

rejoinChat(): Promise<CheckInResponse>

Valor de retorno

Retorna um objeto CheckInResponse.

Interfaces

interface CheckInResponse {
  chat_id: number;
  check_in_status: CheckInStatus;
  check_in_at?: string;
}
enum CheckInStatus {
  CONFIRMED = 'confirmed',
  EXITED = 'exited',
  PENDING = 'pending',
  REQUESTED = 'requested',
  SKIPPED = 'skipped',
  TIMED_OUT = 'timed_out',
}

Exemplo

try {
  const response = await client.rejoinChat()
} catch (error) {
  // handle error

trackCheckInEvent

Envia um sinal ao back-end quando eventos de check-in são acionados pela UI. Isso é usado quando a caixa de diálogo de check-in é mostrada ao usuário final.

Assinatura do método

trackCheckInEvent(): Promise<void>

Exemplo

try {
  await client.trackCheckInEvent()
} catch (error) {
  // handle error

Navegação conjunta de eventos

Os eventos a seguir são específicos da navegação conjunta:

cobrowse.request

Emitido quando um usuário final ou agente solicita o início de uma sessão de navegação conjunta.

client.on("cobrowse.request", { from } => {
  console.log("request by", from)
})

cobrowse.loaded

Emitido quando uma sessão de navegação conjunta é carregada.

client.on("cobrowse.loaded", session => {
  console.log("cobrowse session", session)
})

cobrowse.updated

Emitido quando uma sessão de navegação conjunta é atualizada.

client.on("cobrowse.updated", session => {
  console.log("cobrowse session", session)
})

cobrowse.ended

Emitido quando uma sessão de navegação conjunta é encerrada.

client.on("cobrowse.ended", session => {
  console.log("cobrowse session", session)
})