🔌 WebSocket Streaming¶

wss://ws.sadionline.com.br/v1/stream/

wss://ws.sadionline.com.br/v1/stream/?student_id={STUDENT_ID}&activity_id={ACTIVITY_ID}

// Recomendado: Autenticação e locale via headers (formato idêntico às requisições HTTP REST)
const ws = new WebSocket(
    'wss://ws.sadionline.com.br/v1/stream/?student_id=550e8400-e29b-41d4-a716-446655440000&activity_id=550e8400-e29b-41d4-a716-446655440001',
    [],
    {
        headers: {
            'Authorization': 'APIKey sk_abc123def456ghi789jkl012mno345pqr678',
            'Accept-Language': 'pt-br'
        }
    }
);

// Alternativa (compatibilidade): Autenticação via query string (menos seguro)
const ws = new WebSocket('wss://ws.sadionline.com.br/v1/stream/?student_id=550e8400-e29b-41d4-a716-446655440000&activity_id=550e8400-e29b-41d4-a716-446655440001&api_key=sk_abc123def456');

const ws = new WebSocket(url, [], {
    headers: {
        'Authorization': 'APIKey sk_sua_chave_api_aqui',
        'Accept-Language': 'pt-br'
    }
});

?api_key=sk_sua_chave_api_aqui

{
  "success": true,
  "message": "Conexão WebSocket estabelecida com sucesso",
  "data": {
    "session_id": "550e8400-e29b-41d4-a716-446655440003",
    "session_context_status": "required"
  },
  "response_type": "connection_established"
}

{
  "type": "session_context",
  "schema_version": 1,
  "completion_status": "completed",
  "additional_screens": {
    "status": "present",
    "locations": [
      "viewer_left",
      "viewer_right",
      "viewer_above",
      "viewer_below",
      "viewer_center"
    ]
  },
  "auxiliary_materials": {
    "status": "none",
    "items": [],
    "locations": []
  },
  "session_mode": "exercises",
  "camera_position": "center"
}

{
  "type": "session_context",
  "schema_version": 1,
  "completion_status": "skipped"
}

{
  "img_base64": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD...",
  "is_active_tab": true
}

// Capturar frame da câmera
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
// ... capturar frame da câmera ...
const imageData = canvas.toDataURL('image/jpeg', 0.8);

// Enviar via WebSocket
const message = {
    img_base64: imageData,
    is_active_tab: document.hasFocus() // Verifica se a aba está ativa
};

ws.send(JSON.stringify(message));

{
  "success": true,
  "message": "Frame enfileirado com sucesso",
  "data": {
    "session_id": "550e8400-e29b-41d4-a716-446655440003"
  },
  "response_type": "frame_processed"
}

{
  "success": false,
  "message": "Limite de taxa excedido. Aguarde 15.50 segundos antes de enviar outra mensagem.",
  "meta": {
    "retry_after": 15.5
  },
  "response_type": "rate_limited"
}

{
  "success": false,
  "message": "Falha na validação",
  "errors": {
    "frame_data": ["Campo obrigatório"],
    "timestamp": ["Formato de data inválido"]
  },
  "response_type": "validation_error"
}

{
  "success": false,
  "message": "Erro ao processar mensagem",
  "errors": "Formato de imagem não suportado",
  "response_type": "error"
}

{
  "success": false,
  "message": "Formato JSON inválido",
  "errors": {
    "json_error": "Expecting ',' delimiter: line 1 column 45 (char 44)"
  },
  "response_type": "invalid_json"
}

wss://ws.sadionline.com.br/v1/stream/?student_id={id}&activity_id={id}&session_id={session_id}

class SADIONLINEWebSocket {
    constructor(studentId, activityId, apiKey, locale = 'pt-br') {
        this.ws = null;
        this.sessionId = null;
        this.frameCounter = 0;

        const params = new URLSearchParams({
            student_id: studentId,
            activity_id: activityId
        });

        const url = `wss://ws.sadionline.com.br/v1/stream/?${params.toString()}`;

        this.connect(url, apiKey, locale);
    }

    connect(url, apiKey, locale) {
        this.ws = new WebSocket(url, [], {
            headers: {
                'Authorization': `APIKey ${apiKey}`,
                'Accept-Language': locale
            }
        });

        this.ws.onopen = () => {
            console.log('Conectado ao WebSocket');
        };

        this.ws.onmessage = (event) => {
            const data = JSON.parse(event.data);
            this.handleMessage(data);
        };

        this.ws.onclose = (event) => {
            console.log(`WebSocket fechado: ${event.code} - ${event.reason}`);
        };

        this.ws.onerror = (error) => {
            console.error('Erro no WebSocket:', error);
        };
    }

    handleMessage(data) {
        if (data.response_type === 'connection_established') {
            this.sessionId = data.data.session_id;
            console.log(`Sessão criada: ${this.sessionId}`);
        } else if (data.response_type === 'frame_processed') {
            console.log('Frame processado com sucesso');
        } else if (data.response_type === 'rate_limited') {
            console.warn(`Rate limit: aguarde ${data.meta.retry_after}s`);
        }
    }

    sendFrame(imageData, isActiveTab = true) {
        if (this.ws.readyState !== WebSocket.OPEN) {
            console.error('WebSocket não está conectado');
            return;
        }

        const message = {
            img_base64: imageData, // data:image/jpeg;base64,{base64_data}
            is_active_tab: isActiveTab
        };

        this.ws.send(JSON.stringify(message));
    }

    close() {
        if (this.ws) {
            this.ws.close();
        }
    }
}

// Uso - Organização Enterprise (API Key)
// Authorization: APIKey sk_... (formato idêntico às requisições HTTP REST)
// Accept-Language: pt-br (formato idêntico às requisições HTTP REST)
const stream = new SADIONLINEWebSocket(
    '550e8400-e29b-41d4-a716-446655440000', // student_id
    '550e8400-e29b-41d4-a716-446655440001', // activity_id
    'sk_abc123def456ghi789jkl012mno345pqr678', // API Key
    'pt-br' // locale (enviado via header Accept-Language)
);

// Enviar frame de uma câmera
navigator.mediaDevices.getUserMedia({ video: true })
    .then(stream => {
        const video = document.createElement('video');
        video.srcObject = stream;
        video.play();

        const canvas = document.createElement('canvas');
        const ctx = canvas.getContext('2d');

        setInterval(() => {
            canvas.width = video.videoWidth;
            canvas.height = video.videoHeight;
            ctx.drawImage(video, 0, 0);

            const imageData = canvas.toDataURL('image/jpeg', 0.8);
            const isActiveTab = document.hasFocus();
            stream.sendFrame(imageData, isActiveTab);
        }, 1000); // 1 frame por segundo
    });

import asyncio
import base64
import json
import time
import websockets
from datetime import datetime
import cv2

class SADIONLINEWebSocket:
    def __init__(self, student_id, activity_id, api_key, locale='pt-br'):
        self.student_id = student_id
        self.activity_id = activity_id
        self.api_key = api_key
        self.locale = locale
        self.session_id = None
        self.frame_counter = 0
        self.ws = None

    async def connect(self):
        url = f"wss://ws.sadionline.com.br/v1/stream/?student_id={self.student_id}&activity_id={self.activity_id}"

        headers = {
            'Authorization': f'APIKey {self.api_key}',
            'Accept-Language': self.locale
        }

        try:
            self.ws = await websockets.connect(
                url,
                extra_headers=headers,
                ping_interval=20,
                ping_timeout=10,
                close_timeout=10,
                max_size=10 * 1024 * 1024  # 10MB
            )

            # Aguardar mensagem de boas-vindas
            welcome = await asyncio.wait_for(self.ws.recv(), timeout=5.0)
            data = json.loads(welcome)

            if data.get('response_type') == 'connection_established':
                self.session_id = data['data']['session_id']
                print(f"Conectado! Sessão: {self.session_id}")
                return True
            else:
                print(f"Erro na conexão: {data}")
                return False

        except Exception as e:
            print(f"Erro ao conectar: {e}")
            return False

    async def send_frame(self, image_data, is_active_tab=True):
        if not self.ws:
            raise Exception("WebSocket não conectado")

        # Converter imagem para base64
        _, buffer = cv2.imencode('.jpg', image_data, [cv2.IMWRITE_JPEG_QUALITY, 80])
        image_base64 = base64.b64encode(buffer).decode('utf-8')
        frame_data = f"data:image/jpeg;base64,{image_base64}"

        message = {
            "img_base64": frame_data,
            "is_active_tab": is_active_tab
        }

        self.frame_counter += 1

        # Enviar JSON
        try:
            await self.ws.send(json.dumps(message))
            print(f"Frame {self.frame_counter} enviado com sucesso")
            return True
        except Exception as e:
            print(f"Erro enviando frame: {e}")
            return False

    async def close(self):
        if self.ws:
            await self.ws.close()

# Exemplo de uso
async def stream_video():
    # Inicializar WebSocket
    # Authorization: APIKey sk_... (formato idêntico às requisições HTTP REST)
    # Accept-Language: pt-br (formato idêntico às requisições HTTP REST)
    ws_client = SADIONLINEWebSocket(
        student_id="550e8400-e29b-41d4-a716-446655440000",
        activity_id="550e8400-e29b-41d4-a716-446655440001",
        api_key="sk_abc123def456ghi789jkl012mno345pqr678",
        locale="pt-br"
    )

    if not await ws_client.connect():
        return

    # Capturar vídeo da webcam
    cap = cv2.VideoCapture(0)

    try:
        while True:
            ret, frame = cap.read()
            if not ret:
                break

            # Redimensionar frame se necessário
            frame = cv2.resize(frame, (640, 480))

            # Enviar frame (assumindo que a aba está ativa)
            await ws_client.send_frame(frame, is_active_tab=True)

            # Aguardar 1 segundo (1 FPS)
            await asyncio.sleep(1.0)

    except KeyboardInterrupt:
        print("Interrompido pelo usuário")
    finally:
        cap.release()
        await ws_client.close()

# Executar
if __name__ == "__main__":
    asyncio.run(stream_video())

const WebSocket = require('ws');
const fs = require('fs');

class SADIONLINEWebSocket {
    constructor(studentId, activityId, apiKey, locale = 'pt-br') {
        this.studentId = studentId;
        this.activityId = activityId;
        this.apiKey = apiKey;
        this.locale = locale;
        this.sessionId = null;
        this.frameCounter = 0;
        this.ws = null;

        this.connect();
    }

    connect() {
        const url = `wss://ws.sadionline.com.br/v1/stream/?student_id=${this.studentId}&activity_id=${this.activityId}`;

        this.ws = new WebSocket(url, {
            headers: {
                'Authorization': `APIKey ${this.apiKey}`,
                'Accept-Language': this.locale
            },
            perMessageDeflate: false,
            maxPayload: 10 * 1024 * 1024 // 10MB
        });

        this.ws.on('open', () => {
            console.log('Conectado ao WebSocket');
        });

        this.ws.on('message', (data) => {
            const message = JSON.parse(data.toString());
            this.handleMessage(message);
        });

        this.ws.on('close', (code, reason) => {
            console.log(`WebSocket fechado: ${code} - ${reason}`);
        });

        this.ws.on('error', (error) => {
            console.error('Erro no WebSocket:', error);
        });
    }

    handleMessage(data) {
        if (data.response_type === 'connection_established') {
            this.sessionId = data.data.session_id;
            console.log(`Sessão criada: ${this.sessionId}`);
        } else if (data.response_type === 'frame_processed') {
            console.log('Frame processado com sucesso');
        } else if (data.response_type === 'rate_limited') {
            console.warn(`Rate limit: aguarde ${data.meta.retry_after}s`);
        }
    }

    async sendFrame(imagePath, isActiveTab = true) {
        if (this.ws.readyState !== WebSocket.OPEN) {
            throw new Error('WebSocket não está conectado');
        }

        // Ler imagem e converter para base64
        const imageBuffer = fs.readFileSync(imagePath);
        const imageBase64 = imageBuffer.toString('base64');
        const frameData = `data:image/jpeg;base64,${imageBase64}`;

        const message = {
            img_base64: frameData,
            is_active_tab: isActiveTab
        };

        return new Promise((resolve, reject) => {
            this.ws.send(JSON.stringify(message), (error) => {
                if (error) {
                    reject(error);
                } else {
                    resolve();
                }
            });
        });
    }

    close() {
        if (this.ws) {
            this.ws.close();
        }
    }
}

// Uso
// Authorization: APIKey sk_... (formato idêntico às requisições HTTP REST)
// Accept-Language: pt-br (formato idêntico às requisições HTTP REST)
const stream = new SADIONLINEWebSocket(
    '550e8400-e29b-41d4-a716-446655440000', // student_id
    '550e8400-e29b-41d4-a716-446655440001', // activity_id
    'sk_abc123def456ghi789jkl012mno345pqr678', // api_key
    'pt-br' // locale (enviado via header Accept-Language)
);

// Enviar frames de imagens
setTimeout(async () => {
    try {
        await stream.sendFrame('./frame1.jpg', true); // true = aba ativa
        console.log('Frame enviado');
    } catch (error) {
        console.error('Erro:', error);
    }
}, 2000);