Broadcasting

Learn how to broadcast messages to multiple clients using Sockeon's broadcasting system.

Types of Broadcasting

Global Broadcasting

Send messages to all connected clients:

class GlobalBroadcastController extends SocketController
{
    #[SocketOn('server.announcement')]
    public function serverAnnouncement(string $clientId, array $data): void
    {
        $message = $data['message'] ?? '';
        
        // Broadcast to all connected clients
        $this->broadcast('server.announcement', [
            'message' => $message,
            'from' => 'server',
            'timestamp' => time()
        ]);
        
        // Confirm to sender
        $this->emit($clientId, 'announcement.sent', [
            'message' => 'Announcement sent to all clients'
        ]);
    }
}

Namespace Broadcasting

Send messages to all clients in a specific namespace:

class NamespaceBroadcastController extends SocketController
{
    #[SocketOn('namespace.broadcast')]
    public function namespaceBroadcast(string $clientId, array $data): void
    {
        $namespace = $data['namespace'] ?? '/';
        $message = $data['message'] ?? '';
        
        // Broadcast to specific namespace
        $this->broadcastToNamespaceClients('namespace.message', [
            'message' => $message,
            'from_client' => $clientId,
            'namespace' => $namespace,
            'timestamp' => time()
        ], $namespace);
        
        $this->emit($clientId, 'broadcast.sent', [
            'namespace' => $namespace
        ]);
    }
}

Room Broadcasting

Send messages to all clients in a specific room:

class RoomBroadcastController extends SocketController
{
    #[SocketOn('room.message')]
    public function roomMessage(string $clientId, array $data): void
    {
        $room = $data['room'] ?? '';
        $message = $data['message'] ?? '';
        
        if (empty($room)) {
            $this->emit($clientId, 'error', ['message' => 'Room is required']);
            return;
        }
        
        // Broadcast to specific room
        $this->broadcastToRoomClients('room.message', [
            'message' => $message,
            'from_client' => $clientId,
            'room' => $room,
            'timestamp' => time()
        ], $room);
        
        $this->emit($clientId, 'message.sent', [
            'room' => $room
        ]);
    }
}

Broadcasting Patterns

Chat Application

class ChatController extends SocketController
{
    #[SocketOn('chat.message')]
    public function handleMessage(string $clientId, array $data): void
    {
        $message = $data['message'] ?? '';
        $room = $data['room'] ?? 'general';
        
        if (empty($message)) {
            $this->emit($clientId, 'error', ['message' => 'Message cannot be empty']);
            return;
        }
        
        // Broadcast to room
        $this->broadcastToRoomClients('chat.message', [
            'from' => $clientId,
            'message' => $message,
            'room' => $room,
            'timestamp' => time()
        ], $room);
    }

    #[SocketOn('chat.typing')]
    public function handleTyping(string $clientId, array $data): void
    {
        $isTyping = $data['typing'] ?? false;
        $room = $data['room'] ?? 'general';
        
        // Broadcast typing status to room
        $this->broadcastToRoomClients('chat.typing', [
            'clientId' => $clientId,
            'typing' => $isTyping,
            'room' => $room
        ], $room);
    }
}

Game Broadcasting

class GameController extends SocketController
{
    #[SocketOn('game.move')]
    public function handleMove(string $clientId, array $data): void
    {
        $gameId = $data['gameId'] ?? '';
        $move = $data['move'] ?? '';
        
        if (empty($gameId)) {
            $this->emit($clientId, 'error', ['message' => 'Game ID is required']);
            return;
        }
        
        // Broadcast move to game room
        $this->broadcastToRoomClients('game.move', [
            'player' => $clientId,
            'move' => $move,
            'gameId' => $gameId,
            'timestamp' => time()
        ], $gameId);
    }

    #[SocketOn('game.chat')]
    public function handleGameChat(string $clientId, array $data): void
    {
        $gameId = $data['gameId'] ?? '';
        $message = $data['message'] ?? '';
        
        // Broadcast chat to game room
        $this->broadcastToRoomClients('game.chat', [
            'player' => $clientId,
            'message' => $message,
            'gameId' => $gameId,
            'timestamp' => time()
        ], $gameId);
    }
}

Broadcasting Methods

Available Methods

class BroadcastingExamples extends SocketController
{
    #[SocketOn('example.broadcast')]
    public function exampleBroadcast(string $clientId, array $data): void
    {
        // Broadcast to all clients
        $this->broadcast('event.name', ['data' => 'value']);
        
        // Broadcast to specific namespace
        $this->broadcastToNamespaceClients('event.name', ['data' => 'value'], '/namespace');
        
        // Broadcast to specific room
        $this->broadcastToRoomClients('event.name', ['data' => 'value'], 'room_name');
        
        // Send to specific client
        $this->emit($clientId, 'event.name', ['data' => 'value']);
    }
}

Broadcasting With Custom Event Classes

Use this pattern when you need broadcasting outside controller methods (jobs, CLI commands, services).

<?php

use Sockeon\Sockeon\Contracts\WebSocket\EventableContract;
use Sockeon\Sockeon\Core\Event;

final class DeploymentFinished implements EventableContract
{
    public function __construct(
        private readonly string $version,
        private readonly bool $success,
    ) {
    }

    public function broadcastAs(): string
    {
        return 'deployment.finished';
    }

    public function broadcastWith(): array
    {
        return [
            'version' => $this->version,
            'success' => $this->success,
            'time' => time(),
        ];
    }

    public function broadcastOn(): ?array
    {
        return ['ops-room'];
    }

    public function broadcastNamespace(): ?string
    {
        return '/admin';
    }
}

Event::broadcast(new DeploymentFinished('v2.1.0', true));

Controller vs Custom Event Broadcasting

• Use controller methods (broadcast, broadcastToRoomClients, broadcastToNamespaceClients) for request/event lifecycle broadcasting.
• Use Event::broadcast() + EventableContract for decoupled broadcasting from non-controller code.