PHPackages                             cydrickn/socketio - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [HTTP & Networking](/categories/http)
4. /
5. cydrickn/socketio

ActiveLibrary[HTTP & Networking](/categories/http)

cydrickn/socketio
=================

PHP Websocket Server that is compatible with socket.io

v1.6.8(2y ago)282.3k↓79.8%6[1 issues](https://github.com/cydrickn/SocketIO/issues)MITPHPPHP >=8.1

Since Sep 9Pushed 2y ago1 watchersCompare

[ Source](https://github.com/cydrickn/SocketIO)[ Packagist](https://packagist.org/packages/cydrickn/socketio)[ RSS](/packages/cydrickn-socketio/feed)WikiDiscussions main Synced 2d ago

READMEChangelog (10)Dependencies (1)Versions (29)Used By (0)

PHP SocketIO Server
===================

[](#php-socketio-server)

PHP Websocket Server that is compatible with [socket.io](https://socket.io/)

So far the function use in this package is almost same with the naming in socket.io

Installation
------------

[](#installation)

```
composer require cydrickn/socketio
```

Then in your main php code add

```
require __DIR__ . '/../vendor/autoload.php';
```

Usage
-----

[](#usage)

### Initializing your server

[](#initializing-your-server)

To initialize

```
$server = new \Cydrickn\SocketIO\Server([
    'host' => '0.0.0.0',
    'port' => 8000,
    'mode' => SWOOLE_PROCESS,
    'settings' => [
        \Swoole\Constant::OPTION_WORKER_NUM => swoole_cpu_num() * 2,
        \Swoole\Constant::OPTION_ENABLE_STATIC_HANDLER => true,
    ]
]);

$server->on('Started', function (\Cydrickn\SocketIO\Server $server) {
    echo 'Websocket is now listening in ' . $server->getHost() . ':' . $server->getPort() . PHP_EOL;
});

$server->on('connection', function (\Cydrickn\SocketIO\Socket $socket) {
    // ...
});

$server->start();
```

### Server Options

[](#server-options)

KeyDetailsDefaulthostThe host of the server127.0.0.1portThe port of the server8000modeThe mode for server2 / SWOOLE\_PROCESSsock\_typeThe socket type for server1 / SWOOLE\_SOCK\_TCPsettingsThe setting is base on [swoole configuration ](https://openswoole.com/docs/modules/swoole-server/configuration)\[\] / Empty ArrayServer Instance
---------------

[](#server-instance)

This is the server [\\Cydrickn\\SocketIO\\Server](src/Server.php), it also inherited all methods of [\\Cydrickn\\SocketIO\\Socket](src/Socket.php)

Events
------

[](#events)

### Basic Emit

[](#basic-emit)

To emit, just need to call the `\Cydrickn\SocketIO\Socket::emit`

```
$server->on('connection', function (\Cydrickn\SocketIO\Socket $socket) {
    $socket->emit('hello', 'world');
});
```

You can also pass as many as you want for the parameters

```
$socket->emit('hello', 'world', 1, 2, 3, 'more');
```

There is no need to run json\_encode on objects/arrays as it will be done for you.

```
// BAD
$socket->emit('hi', json_encode(['name' => 'Juan']));

// GOOD
$socket->emit('hi', ['name' => 'Juan']);
```

### Broadcasting

[](#broadcasting)

Broadcast is like just the simple emit, but it will send to all connected client except the current client

```
$socket->broadcast()->emit('hi', ['name' => 'Juan']);
```

### Sending to all clients

[](#sending-to-all-clients)

The toAll will emit a message to all connected clients including the current client

```
$socket->toAll()->emit('hi', ['name' => 'Juan']);
```

### Acknowledgements

[](#acknowledgements)

Same with the socket io for nodejs, you just need to add a callable as the last argument in the emit

Server

```
$socket->emit('hi', function () {
    //...
});
```

Client

```
socket.on('hi', (callback) => {
    callback('hello');
});
```

#### With Timeout

[](#with-timeout)

Assign a timeout to each emit:

```
// timeout for 5 seconds
$socket->timeout(5000)->emit('hi', function (bool $err) {
    if ($err) {
        // the other side did not acknowledge the event in the given delay
    }
});
```

Add callback default arguments value for timeout

```
// timeout for 5 seconds
$socket->timeout(5000, 'Juan')->emit('hi', function (bool $err, string $name) {
    var_dump($name); // if the other side did not acknowledge the event the $name will be 'Juan'
    if ($err) {
        // the other side did not acknowledge the event in the given delay
    }
});
```

### Listening

[](#listening)

To listen to any event

```
$server->on('hello', function (\Cydrickn\SocketIO\Socket $socket, string $world) {
    // ...
});

$server->on('hi', function (\Cydrickn\SocketIO\Socket $socket, array $name) {
    // ...
});
```

Server Event
------------

[](#server-event)

This event can't be use for the route Since this event are Swoole Websocket Event All Event with \* should not be used

- Request - When you use it for http
- \*WorkerStart - You must not replace this event since this is the worker start logic for this package
- \*Start - You must not replace this event since this is the start logic for this package
- \*Open - You must not replace this event since this is the connection logic for this package
- \*Message - You must not replace this event since this is the message logic for this package
- \*Close - You must not replace this event since this is the message logic for this package

Rooms
-----

[](#rooms)

In this package it was already included the rooms

To join to group just call the function `join`

```
$socket->join('room1');
```

To emit a message

```
$socket->to('room1')->emit('hi', ['name' => 'Juan']);
```

Emit to multiple room

```
$socket->to('room1')->to('room2')->emit('hi', ['name' => 'Juan']);
```

Leaving the room

```
$socket->leave('room1');
```

Sending to specific user

In socket.io javascript, the user was automatically created a new room for each client sid.

But currently in this package it will not create a new room for each client.

In this package you just need to specify if its a room or a sid

```
use Cydrickn\SocketIO\Message\Response;

$socket->on('private message', (\Cydrickn\SocketIO\Socket $socket, $anotherSocketId, $msg) => {
    $socket->($anotherSocketId, Response::TO_TYPE_SID).emit('private message', $socket->sid, $msg);
});
```

Middleware
----------

[](#middleware)

You can add an middleware for the server

```
$server->use(function (\Cydrickn\SocketIO\Socket $socket, callable $next) {
    // ...
    $next();
});
```

To not continue the connection you just pass \\Error in the $next

```
$server->use(function (\Cydrickn\SocketIO\Socket $socket, callable $next) {
    // ...
    $next(new \Error('Something went wrong'));
});
```

You can also add middleware for handshake event of Swoole Server. Just passed true to the second argument.

Also in callback it will pass the response for you to modify if you need it

```
$server->use(function (\Cydrickn\SocketIO\Socket $socket, \Swoole\Http\Response $response, callable $next) {
    // ...
}, true);
```

If you want to create a middleware as a class we recommend to implement the `Cydrickn\SocketIO\Middleware\MiddlewareInterface`and if for handshake use `Cydrickn\SocketIO\Middleware\HandshakeMiddlewareInterface`

Example of middleware that use in handshake is the [Cydrickn\\SocketIO\\Middleware\\CookieSessionMiddleware](/src/Middleware/CookieSessionMiddleware.php). This middleware will create a session that uses the cookie and if the client did not send the session cookie then it will create a cookie and response it from the handshake.

Session
-------

[](#session)

In this package the there is already session storage that you can use,

- **SessionsTable** - Uses the Swoole\\Table as the storage
- **SessionsNative** - Uses the file storage

Using Swoole, session\_start, $\_SESSION should not be use since this function are global it stores the data in the process itself.

The session that provided here does not use this predefined session extensions. Currently, the session is define per connection so you can take the session via.

```
$socket->getSession();
```

This getSession can return null if you don't have any middleware that creating the session.

To set a session

```
$session = $server->getSessionStorage()->get('123456'); // This will automatically created once it does not exists
$socket->setSession($session);
```

You can also customize your session storage, just implement the [Cydrickn\\SocketIO\\Session\\SessionStorageInterface](src/Session/SessionStorageInterface.php)

```