EasyProctor - Component Documentation #

Introdução #

Este documento irá te auxiliar no processo de integração com o componente do EasyProctor.

Compatibilidade #

O EasyProctor tem compatibilidade com os seguintes browsers

Latest ✔	Latest ✔	Latest ❌

E tem compatibilidade com os seguintes sistemas operacionais

Latest ✔	Latest ✔

Observações:

• MacOS

O Firefox, Google Chrome e outros browser do tipo Chromium não permitem a checagem para verificação da quantidade de monitores. Logo, não é recomendado utilizar a checagem através do componente.

É recomendado a seguinte configuração:

• Se deseja utilizar o compartilhamento de tela, é necessário que o atributo allowOnlyFirstMonitor receba o valor true (O compartilhamento funciona apenas com uma tela/monitor)
• Se não for utilizar o compartilhamento de tela, para invalidar a checagem da quantidade de monitores, utilize o atributo allowMultipleMonitors com o valor true.

Sempre que for utilizar o atributo allowMultipleMonitors, colocar o atributo allowOnlyFirstMonitor para false, pois o Chrome não permite saber se é primeira ou segunda tela.

• Windows

O Firefox não permite a checagem para verificação da quantidade de monitores. Logo, não é recomendado utilizar a checagem através do componente. É recomendado a seguinte configuração: Se não for utilizar o compartilhamento de tela, para invalidar a checagem da quantidade de monitores, utilize o atributo allowMultipleMonitors com o valor true.

Visão Geral #

O EasyProctor é uma plataforma completa para autenticação de candidatos e monitoramento da execução de exames. Oferecemos uma solução de monitoramento combinando análise em tempo real baseada em Inteligência Artificial com análise humana. A tecnologia embarcada em nossa plataforma já monitorou dezenas de milhões de horas/ aula e exames, tendo gerado mais de 3 milhões de alertas de possibilidade de fraudes.

O SDK Web do EasyProctor permite a integração da sua plataforma de exames, de forma rápida e fácil. Nosso SDK Web utiliza os recursos nativos do HTML e JavaScript e funciona nos browsers modernos. Segue abaixo uma visão geral de como funciona o SDK.

• O usuário acessa a aplicação do exame.
• Através de nosso SDK, a aplicação do exame captura a face do usuário e realiza o login biométrico.
• A aplicação do exame recebe o JWT e passa a autenticar todas as próximas chamadas com esse token.
• A aplicação do exame inicializa uma sessão de proctoring passando como parâmetro o JWT Token, o client ID e o exam ID. O client ID é um identificador que é recebido pela aplicação para ‘assinar’ todas as sessões. O exam ID é o identificador do exame na aplicação do exame. Esses parâmetros são utilizados para acessar as informações da sessão em nosso backend.
• O nosso SDK retorna um identificador para a sessão de proctoring iniciada, esse identificador deve ser salvo no backend da aplicação do exame.
• Ao finalizar o exame, a aplicação do exame finaliza a sessão de proctoring.
• A finalização da sessão de proctoring envia um progresso do upload dos vídeos gravado para que a aplicação do exame aguarde o envio completo de todos os vídeos.

Instalação #

Para instalar o nosso SDK na sua aplicação do exame, disponibilizamos um pacote npm. Para a instalação, siga os seguintes passos:

npm install easyproctor

Como começar #

Para utilizar nossa API e nosso SDK você precisará utilizar um token JWT que será disponibilizado no processo de integração. Os usuários da aplicação do exame devem estar registrados no nosso backend para que posteriormente seja feito o cadastro biométrico. A nossa API está descrita em https://proctoring-api.easyproctor.tech/index.html.

Para cadastrar o usuário em nossa plataforma, o seguinte endpoint deverá ser utilizado, autenticado pelo JWT Token do cliente:

POST /api/User

Posteriormente, os usuários devem realizar o cadastro biométrico em nossa plataforma.

POST /api/User/face

Fluxo #

Iniciando o componente #

Para iniciar o componente é necessário usar o método useProctoring() que possui os seguintes parâmetros, proctoringOptions e enviromentConfig.

O proctoringOptions é composto pelos seguintes campos:

O método useProctoring() retorna alguns hooks que serão utilizados para a comunicação entre a aplicação de exame e o nosso componente. Os hooks disponibilizados são:

{
  "status": "ALERT",
  "description": "Barulho detectado",
  "type": "audio_detection_on_stream"
}

{
  "status": "OK",
  "type": "face_detection_on_stream"
}

{
  "status": "ALERT",
  "description": "multiple_faces_detected",
  "type": "face_detection_on_stream"
}

{
  "status": "ALERT",
  "description": "no_face_detected",
  "type": "face_detection_on_stream"
}

{
  "status": "OK",
  "type": "mobile_detection_on_stream"
}

{
  "status": "ALERT",
  "description": "cellphone_detected",
  "type": "mobile_detection_on_stream"
}

{
  "status": "OK",
  "type": "person_detection_on_stream"
}

{
  "status": "ALERT",
  "description": "no_person_detected",
  "type": "person_detection_on_stream"
}

{
  "status": "ALERT",
  "description": "multiple_persons_detected",
  "type": "person_detection_on_stream"
}

{
  "status": "OK",
  "type": "person_detection_on_stream"
}

{
  "status": "ALERT",
  "description": "wrong_position_face_detected",
  "type": "person_detection_on_stream"
}

Segue abaixo um exemplo de código.

import { useProctoring } from "easyproctor";

const {
        start,
        finish,
        login,
        onFocus,
        onLostFocus,
        onRealtimeAlerts,
        onChangeDevices,
        onBufferSizeError,
        onStopSharingScreen,
        enumarateDevices,
        checkPermissions,
        checkIfhasMultipleMonitors,
        checkDevices,
        runCheckDevicesFlow,
        capturePhoto,
        signInTerms
    } = useProctoring(
    {
        examId: "0000001",
        clientId: "** INSERT CLIENT ID **",
        token: "** INSERT JWT TOKEN HERE **"
    },
        "prod"
    }
);

Janela com Termo de Consentimento #

Recomendamos que ao iniciar o uso do nosso componente seja chamada a função signInTerms() onde o termo de consentimento para coleta de informações biométricas é exibido.

Segue abaixo o link para Termo de Consentimento.

Uma tela prévia é exibida para que seja realizado o consentimento da coleta.

A imagem abaixo apresenta o exemplo de como o modal funciona:

Capturar foto para cadastro ou validação biométrica #

A função capturePhoto(title, subtitle), retorna um objeto com o base64 da foto capturada. Ela aceita dois parâmetros que são opcionais, sendo eles: o título, o subtítulo que serão apresentados no modal e a resolução da câmera.

import { capturePhoto } from "easyproctor";

const capture = await capturePhoto(
  "Cadastro de biometria facial",
  "Encaixe seu rosto no formato e clique no botão abaixo",
  { width: 1280, height: 720 }
);

console.log(capture.base64);

Uma tela prévia é exibida para que a captura seja realizada. Caso o usuário cancele a captura, é lançada a exceção 'User does not captured photo'.

Após a captura, é exibida uma tela para confirmar a captura ou realizar novamente.

A imagem abaixo apresenta o exemplo de como o modal funciona:

Verificar se tem múltiplos monitores conectados #

A função checkIfhasMultipleMonitors(), retorna um booleano para que possa ser checado previamente se o aluno está utilizando múltiplos monitores.

import { checkIfhasMultipleMonitors } from "easyproctor";

const hasMultipleMonitors = await checkIfhasMultipleMonitors();

Checar se as permissões de áudio e vídeo foram confirmadas #

A função checkPermissions(), retorna um booleano para que possa ser checado previamente se o aluno liberou a utilização dos dispositivos de mídia, como cameras e microfones.

import { checkPermissions } from "easyproctor";

const hasPermissions = await checkPermissions();

Listar os dispositivos #

A função enumarateDevices(), retorna um objeto contendo dois arrays, com os microfones e as cameras disponíveis do dispositivo.

import { enumarateDevices } from "easyproctor";

const devices = await enumarateDevices();

O objeto retornado, é como a interface de Devices, como apresentado no código abaixo:

type Device = { label: string; id: string };

interface Devices {
  cameras: Device[];
  microphones: Device[];
}

Iniciando uma sessão de proctoring #

Ao inicializar uma sessão de proctoring é necessário invocar o hook start(). Alguns parâmetros opcionais de configuração podem ser utilizados nesse método:

O trecho de código abaixo ilustra como iniciar uma sessão:

import { start } from "easyproctor";

const { cameraStream, _screenStream } = await start(
  {
    cameraId: selectedCamera,
    microphoneId: selectedMicrophone,
    allowMultipleMonitors: true,
    allowOnlyFirstMonitor: false,
    captureScreen: true,
    proctoringType: "IMAGE",
    onBufferSizeError: true,
  },
  {
    width: 1280,
    height: 720,
  }
);

Este método retorna um response que possui as seguintes informações:

Perca e Recuperação de foco da tela #

onLostFocus() #

A função onLostFocus() recebe como parametro uma função callback com parametro que será invocada quando o usuário perder o foco da aba onde o exame está sendo executado.

import { onLostFocus } from "easyproctor";
check;
onLostFocus(() => console.log("Perdeu o foco"));

onFocus() #

A função onFocus() recebe como parametro uma função callback com parametro que será invocada quando o usuário retomar o foco para a aba onde o exame está sendo executado.

import { onFocus } from "easyproctor";

onFocus(() => console.log("Voltou o foco"));

Verificar alertas no ambiente #

A função onRealtimeAlerts() recebe como parametro uma função callback com parametro que será invocada quando houver um alerta no ambiente.

O response do onRealtimeAlerts possui 3 atributos:

• status: campo que traz o status do alerta 'Alert' | 'Ok'
• description: campo que descreve o alerta ocorrido
• type: campo que retorna o tipo do alerta 'audio_detection_on_stream'

Exemplo:

Exemplo:

• status: 'Alert'
• description: "Barulho detectado"
• type: 'audio_detection_on_stream'

Obs: Para o alerta de ruído, o alerta será emitido quando o volume do ruído estiver acima do limite estabelecido.

Por padrão esse limite é de 40, em uma escala de 0 a 100, mas pode ser alterado por meio de configuração através da API.

import { onRealtimeAlerts } from "easyproctor";

onRealtimeAlerts((response: any) => console.log(response));

Verificar desconexão e conexão de periféricos #

A função onChangeDevices() passa-se uma função callback como parâmetro nomeada de status, onde ao usuário conectar ou desconectar algum dispositivo de camera ou microfone a função é executada.

import { onChangeDevices } from "easyproctor";

await onChangeDevices({
  status: (devices) => {
    console.log(devices);
  },
});

Verificar problema na gravação #

A função onBufferSizeError() recebe como parametro uma função callback com parametro que será invocada quando houver algum problema durante a gravação do exame.

Os problemas podem ser o congelamento da gravação ou a não gravação da tela ou câmera.

import { onBufferSizeError } from "easyproctor";

await onBufferSizeError(() => {
  console.log("Erro de gravação");
});

Verificar se o compartilhamento de tela foi interrompido #

A função onStopSharingScreen() recebe como parametro uma função callback que será invocada se o usuario interromper o compartilhamento de tela.

import { onStopSharingScreen } from "easyproctor";

onStopSharingScreen(() => console.log("Compartilhamento de tela interrompido"));

Finalizando uma sessão de proctoring #

Para finalizar uma sessão de proctoring, basta utilizar o hook finish(). Um parâmetro importante desse método é o callback de progresso de upload dos vídeos da sessão, onde para garantir o sucesso no envio é necessário que a sua aplicação aguarde até que o progresso seja concluído.

Segue abaixo um exemplo de codificação.

import { finish } from "easyproctor";

await finish({
  onProgress: (percentage) => {
    console.log(percentage);
  },
});

Testar o stream #

Iniciar teste #

Caso deseje testar os componentes de gravação, é possível utilizar a função checkDevices(). E ele irá retornar um modal com a camera e um volumetro para o usuário checar o funcionamento do seus devices.

import { checkDevices } from "easyproctor";

const { checkDevicesResult } = await checkDevices(
  {
    cameraId: selectedCamera,
    microphoneId: selectedMicrophone,
  },
  {
    width: 1280,
    height: 720,
    minWidth: 0,
    minHeight: 0,
  }
);

A função checkDevices retorna um objeto com os seguintes atributos:

• allowedAmbient: verifica se o ambiente em que o usuário está atende aos requisitos quanto ao ruído.
• allowedMicrophone: verifica se o microfone está funcional.
• allowedPositionFace: verifica se o rosto está na posição permitida.
• allowedResolution: verifica se a resolução testada está dentro do esperado, verifica-se a resolução está acima do mínimo exigido
• allowedSpyScan: verifica se tem algum dispositivo escondido. Para mais informações sobre o spy scan, acesse na documentação a seção do spy scan.
• cameraId: o id da camera selecionada no teste
• faceDetectionAlerts: alerta sobre a detecção de face.
• michophoneId: o id do microphone selecionado no teste
• result: booleano se clicou em continuar é true, caso clique em cancelar retorna false.
• volumeRange: a média do volume capturado pelo microphone

A imagem abaixo mostra o modal do checkDevices onde permite selecionar a camera e microfone e ver a alteração de volume.

Utilizar modal próprio para testar #

Caso deseje utilizar um modal próprio para testar os componentes de gravação, é possível utilizar a função runCheckDevicesFlow(). E ele irá retornar o stream da camera e ao final da execução o result, um objeto que trará informações sobre o teste e com elas você poderá escolher se vai prosseguir o exame ou interromper.

import { runCheckDevicesFlow } from "easyproctor";

const { cameraStream, result } = await runCheckDevicesFlow(
  {
    cameraId: selectedCamera,
    microphoneId: selectedMicrophone,
  },
  { 
    width: 1280, 
    height: 720, 
    minWidth: 1280, 
    minHeight: 720 
  },
  // Callback de confirmação
  (resolve) => {
    confirmButton.addEventListener('click', function() {
      //modal.classList.add('hidden'); ->  addicionar lógica para fechar seu modal
      resolve(); // Resolve a promise parando a execução da função e retornando o result
    }, { once: true });
  },
  // Callback de cancelamento
  (reject) => {
    cancelButton.addEventListener('click', function() {
      //modal.classList.add('hidden'); ->  addicionar lógica para fechar seu modal
      reject(); // Rejeita a promise parando a execução da função
    }, { once: true });
  },
  (feedback) => {
    // feedback é um objeto com informações sobre o teste
    console.log('Feedback em tempo real: ', feedback);
  }
);

A função runCheckDevicesFlow() irá receber 5 parâmetros:

1. options: um objeto com o cameraId e o microphoneId para passar os dispositivos selecionados.

2. Resolution: um objeto com as propriedades width, height, minWidth e minHeight. Para definir a largura e altura do vídeo que será gravado (lembre de respeitar o dimensionamento correto) e também configurar o mínimo aceitável para a gravação.

3. onConfirm: uma função callback que será executada quando o usuário clicar no botão de confirmação.

4. onCancel: uma função callback que será executada quando o usuário clicar no botão de cancelamento.

5. onUpdate: uma função callback que será executada a cada mudança de status do teste retornando o feedback que vem no formato do código asseguir.

Formato do feedback:

{
  allowedResolution: true,
  allowedPositionFace: false,
  allowedAmbient: false,
  allowedMicrophone: true,
  allowedSpyScan: true,
  faceDetectionAlerts: {
    status: "ALERT",
    description: "Nenhuma face encontrada",
    type: "face_detection_on_stream"
  }
}

Caso seja necessário fazer a mudança de algum dos dispositivos durante a verificação, deve ser chamado a seguinte função changeSelectedDevice(). Ela será responsável por mudar o dispositivos e retornar um novo stream para você atualizar na sua tag de vídeo.

import { changeSelectedDevice } from "easyproctor";

const { cameraStream } = await changeSelectedDevice({
  cameraId: "default",
  microphoneId: "default",
});

Onde tiver 'default' você pode passar o id da camera ou microfone que ele irá utilizar ela, caso seja passado como no código acima ele usará os dispositivos padrões do computador do utilizador.

Não se esqueça que você pode estar utilizando a função enumarateDevices() para estar listando os dispositivos disponíveis para uso.

Com essas funções você pode construir o modal da maneira que atenda as suas necessidades, aconselhamos que seu modal contenha os seguintes itens:

• Vídeo (utilizando os streams retornados)
• Seção de alertas, para indicar os alertas retornados
• Seleção para mudança de dispositivo
• Botão de confirmação
• Botão de cancelamento

Callback de mudança de status #

Após a realização do exame, a sessão será processada por nossos algoritmos de inteligência artificial e passará por alguns status durante o processamento. Você pode verificar o status da sessão de proctoring através de duas maneiras.

1. Atraves do endpoint /api/Proctoring/id

2. Cadastrando um webhook para receber todas as mudanças assim que elas ocorrerem. /api/Client/save-webhook

O payload enviado para o webhook cadastrado segue o seguinte padrão

{
  (Id = "123123"),
    (Status = "STARTED" | "FINISHED" | "PROCESSING" | "AUDITING" | "AUDITED");
}

Auditoria #

Após a realização do exame, a sessão será processada por nossos algoritmos de inteligência artificial e em seguida a auditoria dessas sessões podem ser realizadas através do nosso painel de auditoria. Nossa plataforma disponibiliza uma documentação com as principais funcionalidades do painel de auditoria.

Um painel é disponibilizado através do site https://auditoria-proctoring.easyproctor.tech/ e pode ser acessado com as credenciais de admin.

Como acessar o Painel de Auditoria sem passar pela página de login #

O painel de auditoria dispõe da possibilidade de logar a partir do backend para ir a página de auditoria sem a necessidade de passar por uma nova página de login.

O diagrama abaixo exemplifica como é feito o fluxo para entrar logado no painel de auditoria.

• O admin acessa a aplicação do exame.
• Através da API do exame, é realizado o login na API do EasyProctor.
• A API do exame recebe o JWT e chama a API do EasyProctor para obter o token de acesso ao painel de auditoria.
• Ao receber esse token a API do exame deve concatená-lo a url do painel.

Para se conectar diretamente ao EasyProctor será necessário acessar a seguinte rota:

https://auditoria-proctoring.easyproctor.tech/redirect/{accessToken}/{proctoringId}/

O accessToken é o token gerado por nossa api.

O proctoringId é o id do proctoring que deseja visualizar, esse campo é opcional, caso não seja passado, será redirecionado para a página principal.

Tipos de alertas #

1. Audio (Valor do Enum: 1)
2. Video (Valor do Enum: 2)
3. Screen (Valor do Enum: 3)
4. Image (Valor do Enum: 4)
5. Environment (Valor do Enum: 5)

Categoria de alertas #

Os alertas abaixos se enquadrão nas categorias vídeo e imagem:

1. NoFace (Valor do Enum: 1) // Nenhuma face encontrada
2. MultipleFace (Valor do Enum: 2) // Múltiplas faces encontradas
3. OtherFace (Valor do Enum: 3) // Face de outra pessoa encontrada
4. ExtractFailed (Valor do Enum: 4) // Não foi possivel extrair informação biométrica
5. HeadUp (Valor do Enum: 10) // Cabeça para cima
6. HeadDown (Valor do Enum: 11) // Cabeça para baixo
7. HeadRight (Valor do Enum: 12) // Cabeça para direita
8. HeadLeft (Valor do Enum: 13) // cabeça para esquerda
9. HeadRolled (Valor do Enum: 14) // cabeça inclinada
10. NoGaze (Valor do Enum: 20) // Nenhum olhar detectado
11. GazeUp (Valor do Enum: 21) // Olhar direcionado para cima
12. GazeDown (Valor do Enum: 22) // Olhar direcionado para baixo
13. GazeLeft (Valor do Enum: 23) // Olhar direcionado para esquerda
14. GazeRight (Valor do Enum: 24) // Olhar direcionado para direita
15. CellPhone (Valor do Enum: 27) // Dispositivo de celular encontrado
16. ShortExam (Valor do Enum: 30) // Duracao do exame abaixo de 15min
17. VeryShortExam (Valor do Enum: 31) // Duração do exame abaixo de 10min

Os alertas abaixos se enquadrão na categoria tela:

1. FocusOff (Valor do Enum: 25) // Navegador está fora de foco

Os alertas abaixos se enquadrão na categoria ambiente:

1. EnvironmentMultiplePeople (Valor do Enum: 28) // Multiplas pessoas encontradas no ambiente
2. EnvironmentNoPeople (Valor do Enum: 29) // Nenhuma pessoa encontrada no ambiente
3. PotentialCamera = (Valor do Enum: 32), // Camera wifi detectada no ambiente
4. SpyDeviceDisconnected = (Valor do Enum: 33), // Dispositivo desconectado

Os alertas abaixos se enquadrão na categoria áudio:

1. Badword = (Valor do Enum: 96),
2. Speech = (Valor do Enum: 97),
3. Noise = (Valor do Enum: 98),
4. Audio (Valor do Enum: 99)

Alertas do tipo áudio, vem com a categoria Audio e a transcrição do que foi captado.

Motor de regras #

Para acelerar o processo de auditoria, disponibilizamos a configuração de um motor de regras específico para que os alertas sejam auditados automaticamente seguindo essas regras.

As regras são cadastradas de acordo com:

• Tipo do Alerta
• Classificação do Alerta
• Quantidade de ocorrências
• Duração de cada ocorrência
• Descrição da ocorrência*
• Intervalo mínimo entre as ocorrências**

*válido apenas para o tipo AUDIO e BADWORD **válido apenas para o tipo VIDEO

Alguns exemplos de regras:

• Classificar como 'Indicio de Fraude' qualquer ocorrência da palavra 'questão'.

Tipo de Alerta: Audio (1) Classificação do Alerta: Audio (99) Quantidade de ocorrências: 1 Descrição da ocorrência: "questão"

• Classificar como 'Indicio de Fraude' quando existir pelo menos 2 ocorrências do alerta EnvironmentMultiplePeople para o tipo de alerta de ambiente.

Tipo de Alerta: Environment (5) Classificação do Alerta: EnvironmentMultiplePeople (28) Quantidade de ocorrências: 2

• Classificar como 'Indicio de Fraude' quando existir pelo menos 1 ocorrência do alerta NoFace para o tipo de alerta de vídeo com a duração minima de 2 segundos.

Tipo de Alerta: Video (2) Classificação do Alerta: NoFace (1) Quantidade de ocorrências: 1 Duração da ocorrências: 2000 Intervalo mínimo entre as ocorrências: 60000

O motor de regras pode ser cadastrado através da API com o seguinte endpoint:

POST /api/Client/rules

Exemplo de payload:

  [
     {
        "Category":99,
        "Type":1,
        "Quantity": 1,
        "Description":"questão"
    },
    {
        "Category":28,
        "Type":5,
        "Quantity": 2
    },
    {
        "Category":1,
        "Type":2,
        "Quantity": 1,
        "Duration": 2000,
        "Interval": 60000
    }
]

Para obter informações do motor de regras, usar o endpoint GET abaixo:

GET /api/Client/rules

Exemplo de resposta:

[
    {
        "id": "a121b9a0-b00c-4963-87b2-4ddc21aa12d9",
        "category": "Audio",
        "type": "Audio",
        "quantity": 1,
        "duration": 0,
        "description": "questão"
    },
    {
        "id": "73b0bffc-98e0-4896-a323-6dac5ae1135a",
        "category": "EnvironmentMultiplePeople",
        "type": "Environment",
        "quantity": 2,
        "duration": 0
    }
    {
        "id": "208549dc-220e-42cb-b061-05bf4e5b99bd",
        "category": "NoFace",
        "type": "Video",
        "quantity": 1,
        "duration": 2000,
        "interval": 60000
    }
]

Para cadastrar uma regra isolada, basta utilizar o seguinte endpoint:

POST /api/Client/rules/add

Exemplo de payload:

    {
        "Category":99,
        "Type":1,
        "Quantity": 1,
        "Description":"prova"
    }

Para deletar uma regra isolada, usar o endpoint:

DELETE /api/Client/rules/{ruleId}

Caso deseje utilizar nosso dashboard, na parte superior disponibilizamos a configuração do motor de regras atráves do ícone

Ao clicar nele, as regras serão exibidas e você pode deletar regras existentes ou adicionar novas regras.

Verificação de dispositivo espião #

O EasyProctor possui um módulo opcional que pode ser utilizado para realizar a auditoria de ambientes procurando por câmeras espiãs.

Para utilizar esta funcionalidade, é necessário conectar o dispositivo de hardware ao computador e executar a aplicação do EasyProctor Spy Scan.

Usando o Spy Scan no checkDevices #

No tópico de Testar o stream é ilustrado como realizar a verificação do dispositivo utilizando o checkDevices. No modal onde aparecem os dispositivos conectados ao computador é possível checar o funcionamento do dispositivo e ter uma análise prévia do estado atual do ambiente do usuário.

Para a utilização do Spy Scan, basta ter o dispositivo conectado ao computador e passar o parâmetro 'useSpyScan: true' na função checkDevices, como retratado no exemplo abaixo.

import { checkDevices } from "easyproctor";

const { checkDevicesResult } = await checkDevices(
  {
    cameraId: selectedCamera,
    microphoneId: selectedMicrophone,
    useSpyScan: true,
  },
  {
    width: 1280,
    height: 720,
    minWidth: 0,
    minHeight: 0,
  }
);

Sem o dispositivo conectado, não será possível utilizar fazer a varredura na ambiente e o retorno sempre será o valor false. Então, é de suma importância tê-lo conectado para que a aplicação funcione corretamente.

Ao ativar a flag useSpyScan no modal será exibida uma nova opção de "Verificação de Spy Cam". Caso a indicação seja na cor verde, significa que o dispositivo está funcionando corretamente e não foi encontrado nenhum dispositivo espião, caso fique na cor vermelha, significa que o dispositivo não está funcionando corretamente ou foi encontrado algum dispositivo escondido. Por fim, ao finalizar a execução do checkDevices, será possível visualizar o resultado do Spy Scan por meio do item no retorno chamado allowedSpyScan.

Caso o allowedSpyScan seja true, significa que o dispositivo está funcionando corretamente e não foi encontrado nenhum dispositivo escondido. Caso seja false, significa que o dispositivo não está funcionando corretamente ou foi encontrado algum dispositivo escondido.

Usando o Spy Scan no runCheckDevicesFlow #

Além do checkDevices, também é possível utilizar o Spy Scan no runCheckDevicesFlow, que irá dispor os itens para a construção de uma modal própria como mostrado anteriormente. Para isso, basta passar o parâmetro 'useSpyScan: true' na função runCheckDevicesFlow, como retratado no exemplo abaixo.

import { runCheckDevicesFlow } from "easyproctor";

const { cameraStream, result } = await runCheckDevicesFlow(
  {
    cameraId: selectedCamera,
    microphoneId: selectedMicrophone,
    useSpyScan: true,
  },
  { 
    width: 1280, 
    height: 720, 
    minWidth: 1280, 
    minHeight: 720 
  },
  // Callback de confirmação
  (resolve) => {
    confirmButton.addEventListener('click', function() {
      //modal.classList.add('hidden'); ->  addicionar lógica para fechar seu modal
      resolve(); // Resolve a promise parando a execução da função e retornando o result
    }, { once: true });
  },
  // Callback de cancelamento
  (reject) => {
    cancelButton.addEventListener('click', function() {
      //modal.classList.add('hidden'); ->  addicionar lógica para fechar seu modal
      reject(); // Rejeita a promise parando a execução da função
    }, { once: true });
  },
  (feedback) => {
    // feedback é um objeto com informações sobre o teste
    console.log('Feedback em tempo real: ', feedback);
  }
);

O 'allowedSpyScan' também estará disponível no retorno do objeto result. mas também para que seja possível atualizar o estado do modal em tempo real, ele também será passado como parâmetro para a função de callback de feedback. Assim, é possivel atualizar o estado do modal enquanto se tem as atualizações do dispositivo de Spy Scan.

Usando o Spy Scan no start #

Por fim, também é possível utilizar o Spy Scan no start, anteriormente visto no tópico de Iniciando uma sessão de proctoring. Para isso, basta passar o parâmetro 'useSpyScan: true' na função start, como retratado no exemplo abaixo.

import { start } from "easyproctor";

const { cameraStream, _screenStream } = await start(
  {
    cameraId: selectedCamera,
    microphoneId: selectedMicrophone,
    allowMultipleMonitors: true,
    allowOnlyFirstMonitor: false,
    captureScreen: true,
    proctoringType: "IMAGE",
    onBufferSizeError: true,
    useSpyScan: true,
  },
  {
    width: 1280,
    height: 720,
  }
);

Com o 'useSSpyScan: true', será feito a checagem se o dispositivo está conectado e em seguida periodicamente durante o exame será feita uma checagem utilizando o dispositivo para detectar se há algum dispositivo escondido no ambiente do usuário.

Toda essas checagens serão feitas em segundo plano, sem que o usuário perceba, e visa garantir que o dispositivo esteja funcionando corretamente e que não haja nenhum dispositivo escondido no ambiente e que o exame seja concluído com sucesso sem que haja fraude durante a execução.

Caso durante a execução do exame seja detectado algum dispositivo escondido, será disparado um alerta por meio da função onRealtimeAlerts conforme explicado anteriormente, assim como um alerta será gerado na sessão de proctoring iniciada.