WebSocket-Echtzeit

# WebSocket connections require a WebSocket client
# Using websocat for testing:
websocat "$WS_URL/ws?token=YOUR_ACCESS_TOKEN"

const ws = new WebSocket('$WS_URL/ws?token=' + accessToken)

ws.onopen = () => {
  console.log('Connected to Cliqer WebSocket')
}

ws.onmessage = (event) => {
  const message = JSON.parse(event.data)
  console.log('Received:', message)
}

ws.onerror = (error) => {
  console.error('WebSocket error:', error)
}

import websocket
import json

ws = websocket.WebSocketApp(
    f"$WS_URL/ws?token={access_token}",
    on_message=lambda ws, msg: print(json.loads(msg)),
    on_error=lambda ws, err: print(f"Error: {err}"),
    on_open=lambda ws: print("Connected")
)
ws.run_forever()

import (
    "github.com/gorilla/websocket"
)

url := "$WS_URL/ws?token=" + accessToken
conn, _, err := websocket.DefaultDialer.Dial(url, nil)
if err != nil {
    log.Fatal("dial:", err)
}
defer conn.Close()

for {
    _, message, err := conn.ReadMessage()
    if err != nil {
        break
    }
    fmt.Printf("Received: %s\n", message)
}

use WebSocket\Client;

$client = new Client("$WS_URL/ws?token={$accessToken}");

while (true) {
    $message = $client->receive();
    $data = json_decode($message, true);
    print_r($data);
}

use tokio_tungstenite::{connect_async, tungstenite::Message};
use futures_util::{StreamExt, SinkExt};

let url = format!("$WS_URL/ws?token={}", access_token);
let (mut ws_stream, _) = connect_async(&url).await?;

while let Some(msg) = ws_stream.next().await {
    match msg? {
        Message::Text(text) => {
            let data: serde_json::Value = serde_json::from_str(&text)?;
            println!("Received: {:?}", data);
        }
        _ => {}
    }
}

# One connection: wait for `connected`, join as an API client, give the host a
# moment to set it up, then send commands. Replies print as they arrive.
( sleep 2
  echo '{"type":"joinRoom","payload":{"room":"ABC123","presenterName":"Show control","api":true}}'
  sleep 3
  echo '{"type":"webAction","payload":{"action":"next","id":"a1"}}'
  sleep 1
  echo '{"type":"webAction","payload":{"action":"prev","id":"a2"}}'
  sleep 1 ) | websocat "$WS_URL/ws?token=YOUR_SESSION_TOKEN"

const ws = new WebSocket('$WS_URL/ws?token=' + accessToken)
const send = (message: object) => ws.send(JSON.stringify(message))
let ready = false

ws.onmessage = (event) => {
  if (event.data === 'pong') return
  const msg = JSON.parse(event.data)
  if (msg.type === 'connected') {
    send({ type: 'joinRoom', payload: { room: 'ABC123', presenterName: 'Show control', api: true } })
    setInterval(() => ws.send('ping'), 15000) // keeps the connection open
  }
  if (msg.type === 'clicksEnabled' && msg.payload === true && !ready) {
    ready = true
    send({ type: 'webAction', payload: { action: 'next', id: 'a1' } })
    // Also: { action: 'prev' }, { action: 'first' }, { action: 'last' },
    // { action: 'goto', slide: 5 }, { action: 'blackout', on: true }
  }
  if (msg.type === 'controls') console.log('Commands this host supports:', ['next', 'prev', ...msg.payload.nav])
  if (msg.type === 'webActionResult') console.log(`${msg.payload.action} delivered to ${msg.payload.hosts} host(s)`)
  if (msg.type === 'slide') console.log('Slide:', msg.payload?.number ?? 'no deck open')
  if (msg.type === 'error') console.error(msg.error, msg.payload?.message)
}

import json
import threading
import time
import websocket

ready = False

def send(ws, message):
    ws.send(json.dumps(message))

def keepalive(ws):  # keeps the connection open
    while ws.sock and ws.sock.connected:
        time.sleep(15)
        ws.send("ping")

def on_message(ws, message):
    global ready
    if message == "pong":
        return
    msg = json.loads(message)
    if msg["type"] == "connected":
        send(ws, {"type": "joinRoom", "payload": {"room": "ABC123", "presenterName": "Show control", "api": True}})
        threading.Thread(target=keepalive, args=(ws,), daemon=True).start()
    elif msg["type"] == "clicksEnabled" and msg["payload"] is True and not ready:
        ready = True
        send(ws, {"type": "webAction", "payload": {"action": "next", "id": "a1"}})
        # Also: {"action": "goto", "slide": 5}, {"action": "blackout", "on": True}, ...
    elif msg["type"] == "webActionResult":
        print(f"{msg['payload']['action']} delivered to {msg['payload']['hosts']} host(s)")
    elif msg["type"] == "slide":
        print("Slide:", msg["payload"]["number"] if msg["payload"] else "no deck open")
    elif msg["type"] == "error":
        print("Error:", msg["error"], msg["payload"]["message"])

ws = websocket.WebSocketApp(f"$WS_URL/ws?token={access_token}", on_message=on_message)
ws.run_forever()

import (
    "encoding/json"
    "fmt"
    "log"
    "sync"
    "time"

    "github.com/gorilla/websocket"
)

conn, _, err := websocket.DefaultDialer.Dial("$WS_URL/ws?token="+accessToken, nil)
if err != nil {
    log.Fatal("dial:", err)
}
defer conn.Close()

var writeMu sync.Mutex // one writer at a time
send := func(message interface{}) {
    writeMu.Lock()
    defer writeMu.Unlock()
    conn.WriteJSON(message)
}
go func() { // keeps the connection open
    for range time.Tick(15 * time.Second) {
        writeMu.Lock()
        conn.WriteMessage(websocket.TextMessage, []byte("ping"))
        writeMu.Unlock()
    }
}()

ready := false
for {
    _, data, err := conn.ReadMessage()
    if err != nil {
        break
    }
    if string(data) == "pong" {
        continue
    }
    var msg struct {
        Type    string          `json:"type"`
        Error   string          `json:"error"`
        Payload json.RawMessage `json:"payload"`
    }
    if json.Unmarshal(data, &msg) != nil {
        continue
    }
    switch msg.Type {
    case "connected":
        send(map[string]interface{}{
            "type":    "joinRoom",
            "payload": map[string]interface{}{"room": "ABC123", "presenterName": "Show control", "api": true},
        })
    case "clicksEnabled":
        if string(msg.Payload) == "true" && !ready {
            ready = true
            send(map[string]interface{}{
                "type":    "webAction",
                "payload": map[string]interface{}{"action": "next", "id": "a1"},
            })
            // Also: {"action": "goto", "slide": 5}, {"action": "blackout", "on": true}, ...
        }
    case "webActionResult", "slide", "error":
        fmt.Printf("%s %s %s\n", msg.Type, msg.Error, msg.Payload)
    }
}

use WebSocket\Client;
use WebSocket\TimeoutException;

// A 15 second read timeout doubles as the keepalive timer.
$client = new Client("$WS_URL/ws?token={$accessToken}", ['timeout' => 15]);

$ready = false;
while (true) {
    try {
        $message = $client->receive();
    } catch (TimeoutException $e) {
        $client->text('ping'); // keeps the connection open
        continue;
    }
    if ($message === null) break; // closed
    if ($message === 'pong') continue;
    $msg = json_decode($message, true);
    if ($msg['type'] === 'connected') {
        $client->text(json_encode([
            'type' => 'joinRoom',
            'payload' => ['room' => 'ABC123', 'presenterName' => 'Show control', 'api' => true]
        ]));
    } elseif ($msg['type'] === 'clicksEnabled' && $msg['payload'] === true && !$ready) {
        $ready = true;
        $client->text(json_encode([
            'type' => 'webAction',
            'payload' => ['action' => 'next', 'id' => 'a1']
        ]));
        // Also: ['action' => 'goto', 'slide' => 5], ['action' => 'blackout', 'on' => true], ...
    } elseif (in_array($msg['type'], ['webActionResult', 'slide', 'error'], true)) {
        echo json_encode($msg), PHP_EOL;
    }
}

use futures_util::{SinkExt, StreamExt};
use serde_json::{json, Value};
use tokio_tungstenite::{connect_async, tungstenite::Message};

let url = format!("$WS_URL/ws?token={}", access_token);
let (ws_stream, _) = connect_async(&url).await?;
let (mut write, mut read) = ws_stream.split();

let every = std::time::Duration::from_secs(15);
let mut keepalive = tokio::time::interval_at(tokio::time::Instant::now() + every, every);
let mut ready = false;
loop {
    tokio::select! {
        _ = keepalive.tick() => write.send(Message::Text("ping".into())).await?, // keeps the connection open
        frame = read.next() => {
            let Some(frame) = frame else { break };
            let Message::Text(text) = frame? else { continue };
            if text.as_str() == "pong" { continue }
            let msg: Value = serde_json::from_str(&text)?;
            match msg["type"].as_str() {
                Some("connected") => {
                    let join = json!({"type": "joinRoom", "payload": {"room": "ABC123", "presenterName": "Show control", "api": true}});
                    write.send(Message::Text(join.to_string().into())).await?;
                }
                Some("clicksEnabled") if msg["payload"] == true && !ready => {
                    ready = true;
                    let next = json!({"type": "webAction", "payload": {"action": "next", "id": "a1"}});
                    write.send(Message::Text(next.to_string().into())).await?;
                    // Also: {"action": "goto", "slide": 5}, {"action": "blackout", "on": true}, ...
                }
                Some("webActionResult") | Some("slide") | Some("error") => println!("{}", msg),
                _ => {}
            }
        }
    }
}

# Join as an API client, then send a message. Replies print as they arrive.
( sleep 2
  echo '{"type":"joinRoom","payload":{"room":"ABC123","presenterName":"Show control","api":true}}'
  sleep 3
  echo '{"type":"messageToHosts","payload":{"text":"Two minutes to the break","id":"m1"}}'
  sleep 30 ) | websocat "$WS_URL/ws?token=YOUR_SESSION_TOKEN"

// After joining (see Slide Navigation): send a message, print the replies.
send({ type: 'messageToHosts', payload: { text: 'Two minutes to the break', id: 'm1' } })

ws.addEventListener('message', (event) => {
  if (event.data === 'pong') return
  const msg = JSON.parse(event.data)
  if (msg.type === 'messageToHostsResult') console.log(`Delivered to ${msg.payload.hosts} host(s)`)
  if (msg.type === 'messageFromHost') console.log(`${msg.payload.fromPresenterName}: ${msg.payload.originalPayload.text}`)
})

# After joining (see Slide Navigation): send a message.
send(ws, {"type": "messageToHosts", "payload": {"text": "Two minutes to the break", "id": "m1"}})

# In on_message, print the replies:
#     elif msg["type"] == "messageFromHost":
#         print(f"{msg['payload']['fromPresenterName']}: {msg['payload']['originalPayload']['text']}")

// After joining (see Slide Navigation): send a message.
send(map[string]interface{}{
    "type":    "messageToHosts",
    "payload": map[string]interface{}{"text": "Two minutes to the break", "id": "m1"},
})

// In the read loop, print the replies:
//     case "messageFromHost":
//         fmt.Printf("%s\n", msg.Payload)

// After joining (see Slide Navigation): send a message.
$client->text(json_encode([
    'type' => 'messageToHosts',
    'payload' => ['text' => 'Two minutes to the break', 'id' => 'm1']
]));

// In the read loop, print the replies:
//     } elseif ($msg['type'] === 'messageFromHost') {
//         echo $msg['payload']['originalPayload']['text'], PHP_EOL;

// After joining (see Slide Navigation): send a message.
let message = json!({"type": "messageToHosts", "payload": {"text": "Two minutes to the break", "id": "m1"}});
write.send(Message::Text(message.to_string().into())).await?;

// In the read loop, print the replies:
//     Some("messageFromHost") => println!("{}", msg["payload"]["originalPayload"]["text"]),