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

}

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

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 muda 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 termina.

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

chat.destroyed

Emitido quando destroyChat é chamado.

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

Check-in do chat

Confira a seguir os eventos de check-in do chat.

checkIn

Confirma a presença do usuário final na fila.

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 após falha na confirmação do 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

Eventos de navegação conjunta

Estes são eventos 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)
})