├── .gitignore
├── .styleci.yml
├── src
    ├── Builders
    │   ├── BuilderInterface.php
    │   ├── TokenOptionsBuilder.php
    │   ├── SubscriberBuilder.php
    │   ├── PublisherBuilder.php
    │   ├── ConnectionBuilder.php
    │   ├── SignalPropertiesBuilder.php
    │   ├── PublishStreamBuilder.php
    │   ├── SessionPropertiesBuilder.php
    │   ├── RecordingPropertiesBuilder.php
    │   └── RecordingBuilder.php
    ├── Enums
    │   ├── MediaMode.php
    │   ├── OpenViduRole.php
    │   ├── OutputMode.php
    │   ├── RecordingMode.php
    │   ├── Uri.php
    │   ├── RecordingLayout.php
    │   └── RecordingStatus.php
    ├── StreamInterface.php
    ├── Exceptions
    │   ├── OpenViduException.php
    │   ├── OpenViduRecordingStatusException.php
    │   ├── OpenViduStreamCantCloseException.php
    │   ├── OpenViduRecordingNotFoundException.php
    │   ├── OpenViduSessionCantCloseException.php
    │   ├── OpenViduSessionCantCreateException.php
    │   ├── OpenViduSessionCantRecordingException.php
    │   ├── OpenViduStreamTypeInvalidException.php
    │   ├── OpenViduSessionNotFoundException.php
    │   ├── OpenViduInvalidArgumentException.php
    │   ├── OpenViduConnectionNotFoundException.php
    │   ├── OpenViduProblemWithBodyParameterException.php
    │   ├── OpenViduSessionHasNotConnectedParticipantsException.php
    │   ├── OpenViduServerRecordingIsDisabledException.php
    │   ├── OpenViduRecordingResolutionException.php
    │   └── OpenViduTokenCantCreateException.php
    ├── Events
    │   ├── SessionCreated.php
    │   ├── FilterEventDispatched.php
    │   ├── SessionDestroyed.php
    │   ├── ParticipantJoined.php
    │   ├── ParticipantLeft.php
    │   ├── WebRTCConnectionCreated.php
    │   ├── WebRTCConnectionDestroyed.php
    │   └── RecordingStatusChanged.php
    ├── Http
    │   ├── Requests
    │   │   ├── WebhookEventRequest.php
    │   │   ├── SignalRequest.php
    │   │   ├── StartRecordingRequest.php
    │   │   ├── PublishStreamRequest.php
    │   │   └── GenerateTokenRequest.php
    │   ├── routes.php
    │   └── Controllers
    │   │   └── OpenViduController.php
    ├── Facades
    │   └── OpenVidu.php
    ├── TokenOptions.php
    ├── Dispatchers
    │   └── WebhookEventDispatcher.php
    ├── SignalProperties.php
    ├── Providers
    │   └── OpenViduServiceProvider.php
    ├── KurentoOptions.php
    ├── IPCameraOptions.php
    ├── Subscriber.php
    ├── SessionProperties.php
    ├── Recording.php
    ├── RecordingProperties.php
    ├── Publisher.php
    ├── Connection.php
    ├── Cache
    │   └── SessionStore.php
    ├── OpenVidu.php
    └── Session.php
├── database
    └── migrations
    │   └── 2019_12_01_000001_create_openvidu_cache_table.php
├── LICENSE.md
└── composer.json


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | vendor


--------------------------------------------------------------------------------
/.styleci.yml:
--------------------------------------------------------------------------------
1 | preset: laravel


--------------------------------------------------------------------------------
/src/Builders/BuilderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | /**
 6 |  * @method static void build()
 7 |  */
 8 | interface BuilderInterface
 9 | {
10 | 
11 | }


--------------------------------------------------------------------------------
/src/Enums/MediaMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | 
 6 | /**
 7 |  * Class MediaMode
 8 |  * @package SquareetLabs\LaravelOpenVidu\Enums
 9 |  */
10 | class MediaMode
11 | {
12 |     /**
13 |      * <i>(not available yet)</i> The session will attempt to transmit streams
14 |      * directly between clients
15 |      */
16 |     public const RELAYED = 'RELAYED';
17 | 
18 |     /**
19 |      * The session will transmit streams using LaravelOpenVidu Media Node
20 |      */
21 |     public const ROUTED = 'ROUTED';
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Builders/TokenOptionsBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | 
 6 | use SquareetLabs\LaravelOpenVidu\TokenOptions;
 7 | 
 8 | /**
 9 |  * Class TokenOptionsBuilder
10 |  * @package SquareetLabs\LaravelOpenVidu\Builders
11 |  */
12 | class TokenOptionsBuilder implements BuilderInterface
13 | {
14 |     /**
15 |      * @param  mixed  $tokenOptions
16 |      * @return TokenOptions|null
17 |      */
18 |     public static function build(array $tokenOptions)
19 |     {
20 |         return new TokenOptions($tokenOptions['role'], $tokenOptions['data']);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/StreamInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu;
 4 | 
 5 | 
 6 | /**
 7 |  * Interface StreamInterface
 8 |  * @package SquareetLabs\LaravelOpenVidu
 9 |  */
10 | interface StreamInterface
11 | {
12 |     /** @return  string */
13 |     public function getRtspUri();
14 | 
15 |     /** @return  string */
16 |     public function getType();
17 | 
18 |     /** @return  bool */
19 |     public function getAdaptativeBitrate();
20 | 
21 |     /** @return  bool */
22 |     public function getOnlyPlayWithSubscribers();
23 | 
24 |     /** @return  string */
25 |     public function getData();
26 | }


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Exception;
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * Class OpenViduException
11 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
12 |  */
13 | class OpenViduException extends Exception
14 | {
15 |     public function __construct($message = "", $code = 500, Throwable $previous = null)
16 |     {
17 |         parent::__construct($message, $code, $previous);
18 |     }
19 | 
20 |     public function __toString()
21 |     {
22 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Builders/SubscriberBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Subscriber;
 6 | 
 7 | /**
 8 |  * Class SubscriberBuilder
 9 |  * @package SquareetLabs\LaravelOpenVidu\Builders
10 |  */
11 | class SubscriberBuilder implements BuilderInterface
12 | {
13 |     /**
14 |      * @param  array  $properties
15 |      * @return Subscriber
16 |      */
17 |     public static function build(array $properties)
18 |     {
19 |         return new Subscriber($properties['streamId'],
20 |             $properties['publisherStreamId'],
21 |             $properties['createdAt']);
22 |     }
23 | }


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduRecordingStatusException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduRecordingNotFoundException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduRecordingStatusException extends OpenViduException
13 | {
14 |     public function __construct($message = "", Throwable $previous = null)
15 |     {
16 |         parent::__construct($message, 406, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduStreamCantCloseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduStreamCantCloseException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduStreamCantCloseException extends OpenViduException
13 | {
14 |     public function __construct($message = "", Throwable $previous = null)
15 |     {
16 |         parent::__construct($message, 405, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduRecordingNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduRecordingNotFoundException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduRecordingNotFoundException extends OpenViduException
13 | {
14 |     public function __construct($message = "", Throwable $previous = null)
15 |     {
16 |         parent::__construct($message, 404, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduSessionCantCloseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionCantCloseException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduSessionCantCloseException extends OpenViduException
13 | {
14 |     public function __construct($message = "", Throwable $previous = null)
15 |     {
16 |         parent::__construct($message, 409, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduSessionCantCreateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionCantCreateException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduSessionCantCreateException extends OpenViduException
13 | {
14 |     public function __construct($message = "", Throwable $previous = null)
15 |     {
16 |         parent::__construct($message, 409, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduSessionCantRecordingException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionCantRecordingException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduSessionCantRecordingException extends OpenViduException
13 | {
14 |     public function __construct($message = "", Throwable $previous = null)
15 |     {
16 |         parent::__construct($message, 409, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduStreamTypeInvalidException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduStreamTypeInvalidException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduStreamTypeInvalidException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('The stream type is not valid', 409, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduSessionNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionCantCloseException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduSessionNotFoundException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('No session exists for the passed sessionId', 404, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduInvalidArgumentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Exception;
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * Class OpenViduInvalidArgumentException
11 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
12 |  */
13 | class OpenViduInvalidArgumentException extends Exception
14 | {
15 |     public function __construct($message = "", $code = 422, Throwable $previous = null)
16 |     {
17 |         parent::__construct($message, $code, $previous);
18 |     }
19 | 
20 |     public function __toString()
21 |     {
22 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduConnectionNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduConnectionNotFoundException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduConnectionNotFoundException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('No connection exists for the passed sessionId', 404, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduProblemWithBodyParameterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduProblemWithBodyParameterException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduProblemWithBodyParameterException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('There is a problem with some body parameter', 400, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduSessionHasNotConnectedParticipantsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionHasNotConnectedParticipantsException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduSessionHasNotConnectedParticipantsException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('The session has no connected participants', 406, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduServerRecordingIsDisabledException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionCantRecordingException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduServerRecordingIsDisabledException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('OpenVidu Server recording module is disabled (openvidu.recording property set to false)', 409, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Enums/OpenViduRole.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | /**
 6 |  * Class OpenViduRole
 7 |  * @package SquareetLabs\LaravelOpenVidu\Enums
 8 |  */
 9 | class OpenViduRole
10 | {
11 |     /**
12 |      * SUBSCRIBER permissions + can publish their own Streams (call Session.publish())
13 |      */
14 |     public const SUBSCRIBER = 'SUBSCRIBER';
15 | 
16 |     /**
17 |      * Can subscribe to published Streams of other users
18 |      */
19 |     public const PUBLISHER = 'PUBLISHER';
20 | 
21 |     /**
22 |      * SUBSCRIBER + PUBLISHER permissions + can force the unpublishing or disconnection over a third-party Stream or Connection (call Session.forceUnpublish() and Session.forceDisconnect())
23 |      */
24 |     public const MODERATOR = 'MODERATOR';
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduRecordingResolutionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduRecordingResolutionException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduRecordingResolutionException extends OpenViduException
13 | {
14 |     public function __construct(Throwable $previous = null)
15 |     {
16 |         parent::__construct('"Resolution" parameter exceeds acceptable values (for both width and height, min 100px and max 1999px) or trying to start a recording with both "hasAudio" and "hasVideo" to false', 422, $previous);
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/database/migrations/2019_12_01_000001_create_openvidu_cache_table.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateOpenviduCacheTable extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('openvidu_cache', function (Blueprint $table) {
17 |             $table->string('key')->unique();
18 |             $table->text('value');
19 |             $table->integer('expiration');
20 |         });
21 |     }
22 | 
23 |     /**
24 |      * Reverse the migrations.
25 |      *
26 |      * @return void
27 |      */
28 |     public function down()
29 |     {
30 |         Schema::dropIfExists('openvidu_cache');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Enums/OutputMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | /**
 6 |  * Class OutputMode
 7 |  * @package SquareetLabs\LaravelOpenVidu\Enums
 8 |  */
 9 | class OutputMode
10 | {
11 |     /**
12 |      * Record all streams in a grid layout in a single archive
13 |      */
14 |     public const COMPOSED = 'COMPOSED';
15 | 
16 |     /**
17 |      * Record each stream individually
18 |      */
19 |     public const INDIVIDUAL = 'INDIVIDUAL';
20 | 
21 | 
22 |     /**
23 |      * There is an extra recording output mode which is a variation of Composed recording.
24 |      * The resulting recorded file will be exactly the same, but in this case the lifespan
25 |      * of the recording module will be attached to the lifecycle of the session, not to the
26 |      * lifecycle of the recording.
27 |      */
28 |     public const COMPOSED_QUICK_START = 'COMPOSED_QUICK_START';
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Enums/RecordingMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\SessionProperties;
 6 | 
 7 | /**
 8 |  * Class RecordingMode
 9 |  * @package SquareetLabs\LaravelOpenVidu\Enums
10 |  * {@see SessionProperties::$recordingMode}
11 |  */
12 | class RecordingMode
13 | {
14 |     /**
15 |      * The session is recorded automatically as soon as the first client publishes a stream to the session.
16 |      * It is automatically stopped after last user leaves the session (or until you call {@see OpenVidu::stopRecording}.
17 |      */
18 |     public const ALWAYS = 'ALWAYS';
19 | 
20 |     /**
21 |      * The session is not recorded automatically. To record the session, you must call  {@see OpenVidu::startRecording} method.
22 |      * To stop the recording, you must call  {@see OpenVidu::stopRecording}.
23 |      */
24 |     public const MANUAL = 'MANUAL';
25 | 
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Builders/PublisherBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Publisher;
 6 | 
 7 | /**
 8 |  * Class PublisherBuilder
 9 |  * @package SquareetLabs\LaravelOpenVidu\Builders
10 |  */
11 | class PublisherBuilder implements BuilderInterface
12 | {
13 |     /**
14 |      * @param  array  $properties
15 |      * @return Publisher
16 |      */
17 |     public static function build(array $properties)
18 |     {
19 |         return new Publisher($properties['streamId'],
20 |             $properties['createdAt'],
21 |             $properties['mediaOptions']['hasAudio'],
22 |             $properties['mediaOptions']['hasVideo'],
23 |             $properties['mediaOptions']['audioActive'],
24 |             $properties['mediaOptions']['videoActive'],
25 |             $properties['mediaOptions']['frameRate'],
26 |             $properties['mediaOptions']['typeOfVideo'],
27 |             $properties['mediaOptions']['videoDimensions']
28 |         );
29 |     }
30 | }


--------------------------------------------------------------------------------
/src/Events/SessionCreated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Events;
 4 | 
 5 | 
 6 | /**
 7 |  * Class SessionCreated
 8 |  * @package SquareetLabs\LaravelOpenVidu\Events
 9 |  */
10 | class SessionCreated
11 | {
12 |     /**
13 |      * @var string $sessionId
14 |      * Session for which the event was triggered
15 |      * A string with the session unique identifier
16 |      */
17 |     public $sessionId;
18 |     /**
19 |      * @var int $timestamp
20 |      * Time when the event was triggered
21 |      * UTC milliseconds
22 |      */
23 |     public $timestamp;
24 |     /**
25 |      * @var string $event
26 |      * Openvidu server webhook event
27 |      */
28 |     public $event;
29 | 
30 |     /**
31 |      * Create a new SessionCreated event instance.
32 |      * @param  array  $data
33 |      */
34 |     public function __construct(array $data)
35 |     {
36 |         $this->sessionId = $data['sessionId'];
37 |         $this->timestamp = $data['timestamp'];
38 |         $this->event = $data['event'];
39 |     }
40 | }


--------------------------------------------------------------------------------
/src/Builders/ConnectionBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Connection;
 6 | 
 7 | /**
 8 |  * Class ConnectionBuilder
 9 |  * @package SquareetLabs\LaravelOpenVidu\Builders
10 |  */
11 | class ConnectionBuilder implements BuilderInterface
12 | {
13 |     /**
14 |      * @param  array  $properties
15 |      * @param  array|null  $publishers
16 |      * @param  array|null  $subscribers
17 |      * @return Connection
18 |      */
19 |     public static function build(array $properties, ?array $publishers = [], ?array $subscribers = [])
20 |     {
21 |         return new Connection($properties['connectionId'],
22 |             $properties['createdAt'],
23 |             $properties['role'],
24 |             $properties['token'],
25 |             $properties['location'],
26 |             $properties['platform'],
27 |             $properties['serverData'],
28 |             $properties['clientData'],
29 |             $publishers,
30 |             $subscribers
31 |         );
32 |     }
33 | }


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright (c) 2019 SquareetLabs S.L. <labs@squareet.com> - https://www.squareet.com
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/src/Exceptions/OpenViduTokenCantCreateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Exceptions;
 4 | 
 5 | 
 6 | use Throwable;
 7 | 
 8 | /**
 9 |  * Class OpenViduSessionCantCreateException
10 |  * @package SquareetLabs\LaravelOpenVidu\Exceptions
11 |  */
12 | class OpenViduTokenCantCreateException extends OpenViduException
13 | {
14 |     /**
15 |      * OpenViduTokenCantCreateException constructor.
16 |      * The 424 (Failed Dependency) status code means that the method could not be performed on the resource because the requested action depended on another action and that action failed.
17 |      * In this case, in obtaining the session.
18 |      * https://tools.ietf.org/html/rfc4918#section-11.4
19 |      * @param  string  $message
20 |      * @param  Throwable|null  $previous
21 |      *
22 |      */
23 |     public function __construct($message = "", Throwable $previous = null)
24 |     {
25 |         parent::__construct($message, 424, $previous);
26 |     }
27 | 
28 |     public function __toString()
29 |     {
30 |         return __CLASS__.":[{$this->code}]:{$this->message}\n";
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Builders/SignalPropertiesBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduInvalidArgumentException;
 6 | use SquareetLabs\LaravelOpenVidu\SignalProperties;
 7 | 
 8 | /**
 9 |  * Class SignalPropertiesBuilder
10 |  * @package SquareetLabs\LaravelOpenVidu\Builders
11 |  */
12 | class SignalPropertiesBuilder implements BuilderInterface
13 | {
14 |     /**
15 |      * @param  array  $properties
16 |      * @return SignalProperties|null
17 |      */
18 |     public static function build(array $properties)
19 |     {
20 |         if (array_key_exists('session', $properties)) {
21 |             return new SignalProperties(
22 |                 $properties['session'],
23 |                 array_key_exists('data', $properties) ? $properties['data'] : null,
24 |                 array_key_exists('type', $properties) ? $properties['type'] : null,
25 |                 array_key_exists('to', $properties) ? $properties['to'] : null
26 |             );
27 |         }
28 |         throw new OpenViduInvalidArgumentException('SignalPropertiesBuilder::build spects an array with session key');
29 |     }
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Enums/Uri.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | /**
 6 |  * Class Uri
 7 |  * @package SquareetLabs\LaravelOpenVidu\Enums
 8 |  */
 9 | class Uri
10 | {
11 |     /**
12 |      *  https://openvidu.io/docs/reference-docs/REST-API/#get-apirecordings
13 |      */
14 |     public const RECORDINGS_URI = 'api/recordings';
15 |     /**
16 |      * https://openvidu.io/docs/reference-docs/REST-API/#post-apirecordingsstart
17 |      */
18 |     public const RECORDINGS_START = 'api/recordings/start';
19 |     /**
20 |      * https://openvidu.io/docs/reference-docs/REST-API/#post-apirecordingsstopltrecording_idgt
21 |      */
22 |     public const RECORDINGS_STOP = 'api/recordings/stop';
23 |     /**
24 |      * https://openvidu.io/docs/reference-docs/REST-API/#post-apisessions
25 |      */
26 |     public const SESSION_URI = 'api/sessions';
27 |     /**
28 |      * https://openvidu.io/docs/reference-docs/REST-API/#post-apitokens
29 |      */
30 |     public const TOKEN_URI = 'api/tokens';
31 | 
32 |     /**
33 |      * https://docs.openvidu.io/en/2.12.0/reference-docs/REST-API/#post-apisignal
34 |      */
35 |     public const SIGNAL_URI = 'api/signal';
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Builders/PublishStreamBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduStreamTypeInvalidException;
 6 | use SquareetLabs\LaravelOpenVidu\IPCameraOptions;
 7 | use SquareetLabs\LaravelOpenVidu\StreamInterface;
 8 | 
 9 | /**
10 |  * Class PublishStreamBuilder
11 |  * @package SquareetLabs\LaravelOpenVidu\Builders
12 |  */
13 | class PublishStreamBuilder implements BuilderInterface
14 | {
15 |     /**
16 |      * @param  array  $properties
17 |      * @return StreamInterface
18 |      * @throws OpenViduStreamTypeInvalidException
19 |      */
20 |     public static function build(array $properties)
21 |     {
22 |         switch ($properties['type']) {
23 |             case 'IPCAM':
24 |                 return new IPCameraOptions($properties['rtspUri'],
25 |                     $properties['type'],
26 |                     $properties['adaptativeBitrate'],
27 |                     $properties['onlyPlayWithSubscribers'],
28 |                     $properties['data']
29 |                 );
30 |             default:
31 |                 throw new OpenViduStreamTypeInvalidException();
32 |         }
33 |     }
34 | }


--------------------------------------------------------------------------------
/src/Http/Requests/WebhookEventRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | /**
 8 |  * Class WebhookEventRequest
 9 |  * @package SquareetLabs\LaravelOpenVidu\Http\Requests
10 |  */
11 | class WebhookEventRequest extends /** @scrutinizer ignore-call */
12 |     FormRequest
13 | {
14 | 
15 | 
16 |     /**
17 |      * Determine if the user is authorized to make this request.
18 |      *
19 |      * @return bool
20 |      */
21 |     public function authorize()
22 |     {
23 |         return true;
24 |     }
25 | 
26 |     /**
27 |      * Get the validation rules that apply to the request.
28 |      *
29 |      * @return array
30 |      */
31 |     public function rules()
32 |     {
33 |         return [
34 |             'event' => 'string|required'
35 |         ];
36 |     }
37 | 
38 |     /**
39 |      * Get the error messages for the defined validation rules.
40 |      *
41 |      * @return array
42 |      */
43 |     public function messages()
44 |     {
45 |         return [
46 |             'event.required' => /** @scrutinizer ignore-call */ __('validation.webhook_event.required'),
47 |         ];
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Enums/RecordingLayout.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\SessionProperties;
 6 | 
 7 | /**
 8 |  * Class RecordingLayout
 9 |  * @package SquareetLabs\LaravelOpenVidu\Enums
10 |  * {@see SessionProperties::$defaultRecordingLayout} and {@see RecordingProperties::$recordingLayout}
11 |  */
12 | class RecordingLayout
13 | {
14 |     /**
15 |      * All the videos are evenly distributed, taking up as much space as possible
16 |      */
17 |     public const BEST_FIT = 'BEST_FIT';
18 | 
19 |     /**
20 |      * Use your own custom recording layout.
21 |      * See Custom recording layouts to learn more
22 |      * https://openvidu.io/docs/advanced-features/recording#custom-recording-layouts
23 |      */
24 |     public const CUSTOM = 'CUSTOM';
25 | 
26 |     /**
27 |      * _(not available yet)_
28 |      */
29 |     public const PICTURE_IN_PICTURE = 'PICTURE_IN_PICTURE';
30 | 
31 |     /**
32 |      * _(not available yet)_
33 |      */
34 |     public const VERTICAL_PRESENTATION = 'VERTICAL_PRESENTATION';
35 | 
36 |     /**
37 |      * _(not available yet)_
38 |      */
39 |     public const HORIZONTAL_PRESENTATION = 'HORIZONTAL_PRESENTATION';
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Enums/RecordingStatus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Enums;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Recording;
 6 | 
 7 | /**
 8 |  * Class RecordingStatus
 9 |  * @package SquareetLabs\LaravelOpenVidu\Enums
10 |  * {@see Recording::$status}
11 |  */
12 | class RecordingStatus
13 | {
14 |     /**
15 |      * The recording is starting (cannot be stopped). Some recording may not go
16 |      * through this status and directly reach "started" status
17 |      */
18 |     public const STARTING = 'starting';
19 | 
20 |     /**
21 |      * The recording has started and is going on
22 |      */
23 |     public const STARTED = 'STARTED';
24 | 
25 |     /**
26 |      * The recording has stopped and is being processed. At some point it will reach
27 |      * "ready" status
28 |      */
29 |     public const STOPPED = 'stopped';
30 | 
31 |     /**
32 |      * The recording has finished OK and is available for download through OpenVidu
33 |      * Server recordings endpoint:
34 |      * https://YOUR_OPENVIDUSERVER_IP/recordings/{RECORDING_ID}/{RECORDING_NAME}.{EXTENSION}
35 |      */
36 |     public const READY = 'ready';
37 | 
38 |     /**
39 |      * The recording has failed. This status may be reached from "starting",
40 |      * "started" and "stopped" status
41 |      */
42 |     public const FAILED = 'failed';
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Facades/OpenVidu.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Facades;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | use SquareetLabs\LaravelOpenVidu\Recording;
 7 | use SquareetLabs\LaravelOpenVidu\RecordingProperties;
 8 | use SquareetLabs\LaravelOpenVidu\Session;
 9 | use SquareetLabs\LaravelOpenVidu\SessionProperties;
10 | use SquareetLabs\LaravelOpenVidu\SignalProperties;
11 | 
12 | /**
13 |  * Class LaravelOpenVidu
14 |  * @package SquareetLabs\LaravelOpenVidu\Facades
15 |  * @method static Session createSession(?SessionProperties $properties = null)
16 |  * @method static Session getSession(string $sessionId)
17 |  * @method static bool existsSession(string $sessionId)
18 |  * @method static bool deleteRecording(string $recordingId)
19 |  * @method static array getActiveSessions()
20 |  * @method static string getRecording(string $recordingId)
21 |  * @method static array getRecordings()
22 |  * @method static Recording startRecording(?RecordingProperties $properties = null)
23 |  * @method static Recording stopRecording(string $recordingId)
24 |  * @method static bool sendSignal(?SignalProperties $properties = null)
25 |  * @method static setClient(GuzzleHttp\Client $client)
26 |  */
27 | class OpenVidu extends Facade
28 | {
29 |     protected static function getFacadeAccessor()
30 |     {
31 |         return 'openVidu';
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Http/Requests/SignalRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | /**
 8 |  * Class SignalRequest
 9 |  * @package SquareetLabs\LaravelOpenVidu\Http\Requests
10 |  */
11 | class SignalRequest extends /** @scrutinizer ignore-call */
12 |     FormRequest
13 | {
14 |     /**
15 |      * Determine if the user is authorized to make this request.
16 |      *
17 |      * @return bool
18 |      */
19 |     public function authorize()
20 |     {
21 |         return true;
22 |     }
23 | 
24 |     /**
25 |      * Get the validation rules that apply to the request.
26 |      *
27 |      * @return array
28 |      */
29 |     public function rules()
30 |     {
31 |         return [
32 | 
33 |             'session' => 'string|required',
34 |             'to' => 'array',
35 |             'to.*' => 'string|distinct',
36 |             'type' => 'string',
37 |             'data' => 'string',
38 |         ];
39 |     }
40 | 
41 |     /**
42 |      * Get the error messages for the defined validation rules.
43 |      *
44 |      * @return array
45 |      */
46 |     public function messages()
47 |     {
48 |         return [
49 |             'session.required' => /** @scrutinizer ignore-call */ __('validation.signal.session_required'),
50 |             'to.array' => /** @scrutinizer ignore-call */ __('validation.signal.to_array')
51 |         ];
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Events/FilterEventDispatched.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Events;
 4 | 
 5 | 
 6 | /**
 7 |  * Class FilterEventDispatched
 8 |  * @package SquareetLabs\LaravelOpenVidu\Events
 9 |  */
10 | class FilterEventDispatched
11 | {
12 |     /**
13 |      * @var string $sessionId
14 |      * Session for which the event was triggered
15 |      * A string with the session unique identifier
16 |      */
17 |     public $sessionId;
18 |     /**
19 |      * @var int $timestamp
20 |      * Time when the event was triggered
21 |      * UTC milliseconds
22 |      */
23 |     public $timestamp;
24 | 
25 |     /**
26 |      * @var string $participantId
27 |      * Identifier of the participant
28 |      * A string with the participant unique identifier
29 |      */
30 |     public $participantId;
31 | 
32 |     /**
33 |      * @var string $streamId
34 |      * Identifier of the stream for which the filter is applied
35 |      * A string with the stream unique identifier
36 |      */
37 |     public $streamId;
38 | 
39 |     /**
40 |      * @var string $event
41 |      * Openvidu server webhook event
42 |      */
43 |     public $event;
44 | 
45 |     /**
46 |      * Create a new SessionCreated event instance.
47 |      * @param  array  $data
48 |      */
49 |     public function __construct(array $data)
50 |     {
51 |         $this->sessionId = $data['sessionId'];
52 |         $this->timestamp = $data['timestamp'];
53 |         $this->event = $data['event'];
54 |     }
55 | }


--------------------------------------------------------------------------------
/src/Builders/SessionPropertiesBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Enums\MediaMode;
 6 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
 7 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
 8 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingMode;
 9 | use SquareetLabs\LaravelOpenVidu\SessionProperties;
10 | 
11 | /**
12 |  * Class SessionPropertiesBuilder
13 |  * @package SquareetLabs\LaravelOpenVidu\Builders
14 |  */
15 | class SessionPropertiesBuilder implements BuilderInterface
16 | {
17 |     /**
18 |      * @param  array  $properties
19 |      * @return SessionProperties|null
20 |      */
21 |     public static function build(array $properties)
22 |     {
23 |         return new SessionProperties(
24 |             array_key_exists('mediaMode', $properties) ? $properties['mediaMode'] : MediaMode::ROUTED,
25 |             array_key_exists('recordingMode', $properties) ? $properties['recordingMode'] : RecordingMode::MANUAL,
26 |             array_key_exists('defaultOutputMode', $properties) ? $properties['defaultOutputMode'] : OutputMode::COMPOSED,
27 |             array_key_exists('defaultRecordingLayout', $properties) ? $properties['defaultRecordingLayout'] : RecordingLayout::BEST_FIT,
28 |             array_key_exists('customSessionId', $properties) ? $properties['customSessionId'] : null,
29 |             array_key_exists('defaultCustomLayout', $properties) ? $properties['defaultCustomLayout'] : null
30 |         );
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Http/Requests/StartRecordingRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | /**
 8 |  * Class StartRecordingRequest
 9 |  * @package SquareetLabs\LaravelOpenVidu\Http\Requests
10 |  */
11 | class StartRecordingRequest extends /** @scrutinizer ignore-call */
12 |     FormRequest
13 | {
14 | 
15 | 
16 |     /**
17 |      * Determine if the user is authorized to make this request.
18 |      *
19 |      * @return bool
20 |      */
21 |     public function authorize()
22 |     {
23 |         return true;
24 |     }
25 | 
26 |     /**
27 |      * Get the validation rules that apply to the request.
28 |      *
29 |      * @return array
30 |      */
31 |     public function rules()
32 |     {
33 |         return [
34 |             'hasAudio' => 'boolean',
35 |             'hasVideo' => 'boolean',
36 |             'name' => 'string',
37 |             'outputMode' => 'string',
38 |             'recordingLayout' => 'string',
39 |             'customLayout' => 'string',
40 |             'resolution' => 'string'
41 |         ];
42 |     }
43 | 
44 |     /**
45 |      * Get the error messages for the defined validation rules.
46 |      *
47 |      * @return array
48 |      */
49 |     public function messages()
50 |     {
51 |         return [
52 |             'hasAudio.boolean' => /** @scrutinizer ignore-call */ __('validation.recording.hasAudio_boolean'),
53 |             'hasVideo.boolean' => /** @scrutinizer ignore-call */ __('validation.recording.hasVideo_boolean'),
54 |         ];
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Http/Requests/PublishStreamRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | /**
 8 |  * Class PublishStreamRequest
 9 |  * @package SquareetLabs\LaravelOpenVidu\Http\Requests
10 |  */
11 | class PublishStreamRequest extends /** @scrutinizer ignore-call */
12 |     FormRequest
13 | {
14 | 
15 | 
16 |     /**
17 |      * Determine if the user is authorized to make this request.
18 |      *
19 |      * @return bool
20 |      */
21 |     public function authorize()
22 |     {
23 |         return true;
24 |     }
25 | 
26 |     /**
27 |      * Get the validation rules that apply to the request.
28 |      *
29 |      * @return array
30 |      */
31 |     public function rules()
32 |     {
33 |         return [
34 |             'rtspUri' => 'string|required',
35 |             'type' => 'string',
36 |             'adaptativeBitrate' => 'boolean',
37 |             'onlyPlayWithSubscribers' => 'boolean',
38 |             'data' => 'string'
39 |         ];
40 |     }
41 | 
42 |     /**
43 |      * Get the error messages for the defined validation rules.
44 |      *
45 |      * @return array
46 |      */
47 |     public function messages()
48 |     {
49 |         return [
50 |             'rtspUri.required' => /** @scrutinizer ignore-call */ __('validation.publish.rtspUri_required'),
51 |             'adaptativeBitrate.boolean' => /** @scrutinizer ignore-call */ __('validation.publish.adaptativeBitrate_boolean'),
52 |             'onlyPlayWithSubscribers.boolean' => /** @scrutinizer ignore-call */ __('validation.publish.onlyPlayWithSubscribers_boolean'),
53 |         ];
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Events/SessionDestroyed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Events;
 4 | 
 5 | 
 6 | /**
 7 |  * Class SessionDestroyed
 8 |  * @package SquareetLabs\LaravelOpenVidu\Events
 9 |  */
10 | class SessionDestroyed
11 | {
12 |     /**
13 |      * @var string $sessionId
14 |      * Session for which the event was triggered
15 |      * A string with the session unique identifier
16 |      */
17 |     public $sessionId;
18 | 
19 |     /**
20 |      * @var int $timestamp
21 |      * Time when the event was triggered
22 |      * UTC milliseconds
23 |      */
24 |     public $timestamp;
25 | 
26 | 
27 |     /**
28 |      * @var int $startTime
29 |      * Time when the session started
30 |      * UTC milliseconds
31 |      */
32 |     public $startTime;
33 | 
34 |     /**
35 |      * @var int $duration
36 |      * Total duration of the session
37 |      * Seconds
38 |      */
39 |     public $duration;
40 | 
41 |     /**
42 |      * @var string $reason
43 |      * Why the session was destroyed
44 |      * ["lastParticipantLeft","sessionClosedByServer","openviduServerStopped"]
45 |      */
46 |     public $reason;
47 | 
48 |     /**
49 |      * @var string $event
50 |      * Openvidu server webhook event
51 |      */
52 |     public $event;
53 | 
54 |     /**
55 |      * Create a new SessionCreated event instance.
56 |      * @param  array  $data
57 |      */
58 |     public function __construct(array $data)
59 |     {
60 |         $this->sessionId = $data['sessionId'];
61 |         $this->timestamp = $data['timestamp'];
62 |         $this->startTime = $data['startTime'];
63 |         $this->duration = $data['duration'];
64 |         $this->reason = $data['reason'];
65 |         $this->event = $data['event'];
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/Builders/RecordingPropertiesBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Enums\MediaMode;
 6 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
 7 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
 8 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduInvalidArgumentException;
 9 | use SquareetLabs\LaravelOpenVidu\RecordingProperties;
10 | 
11 | /**
12 |  * Class RecordingPropertiesBuilder
13 |  * @package SquareetLabs\LaravelOpenVidu\Builders
14 |  */
15 | class RecordingPropertiesBuilder implements BuilderInterface
16 | {
17 |     /**
18 |      * @param  array  $properties
19 |      * @return RecordingProperties|null
20 |      * @throws OpenViduInvalidArgumentException
21 |      */
22 |     public static function build(array $properties)
23 |     {
24 |         if (array_key_exists('session', $properties)) {
25 |             return new RecordingProperties(
26 |                 $properties['session'],
27 |                 array_key_exists('name', $properties) ? $properties['name'] : '',
28 |                 array_key_exists('outputMode', $properties) ? $properties['outputMode'] : OutputMode::COMPOSED,
29 |                 array_key_exists('recordingLayout', $properties) ? $properties['recordingLayout'] : RecordingLayout::BEST_FIT,
30 |                 array_key_exists('resolution', $properties) ? $properties['resolution'] : null,
31 |                 array_key_exists('hasAudio', $properties) ? $properties['hasAudio'] : true,
32 |                 array_key_exists('hasVideo', $properties) ? $properties['hasVideo'] : true,
33 |                 array_key_exists('customLayout', $properties) ? $properties['customLayout'] : MediaMode::ROUTED
34 |             );
35 |         }
36 |         throw new OpenViduInvalidArgumentException('RecordingPropertiesBuilder::build spects an array with session key');
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Http/routes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Support\Facades\Route;
 4 | 
 5 | Route::post('/token', 'OpenViduController@token')->name('openvidu.token');
 6 | Route::get('/sessions', 'OpenViduController@sessions')->name('openvidu.sessions');
 7 | Route::get('/sessions/{sessionId}', 'OpenViduController@session')->name('openvidu.sessions.session');
 8 | Route::get('/sessions/{sessionId}/fetch', 'OpenViduController@fetch')->name('openvidu.sessions.session.fetch');
 9 | Route::get('/sessions/{sessionId}/isBeingRecording', 'OpenViduController@isBeingRecording')->name('openvidu.sessions.session.isBeingRecording');
10 | Route::get('/sessions/{sessionId}/connections', 'OpenViduController@connections')->name('openvidu.sessions.session.connections');
11 | Route::post('/sessions/{sessionId}/publish', 'OpenViduController@publish')->name('openvidu.sessions.session.publish');
12 | Route::delete('/sessions/{sessionId}/forceUnpublish/{streamId}', 'OpenViduController@forceUnpublish')->name('openvidu.sessions.session.forceUnpublish');
13 | Route::delete('/sessions/{sessionId}/forceDisconnect/{connectionId}', 'OpenViduController@forceDisconnect')->name('openvidu.sessions.session.forceDisconnect');
14 | Route::patch('/sessions/{sessionId}/close', 'OpenViduController@close')->name('openvidu.sessions.session.close');
15 | 
16 | Route::post('/recordings/start', 'OpenViduController@startRecording')->name('openvidu.recordings.start');
17 | Route::post('/recordings/{recordingId}/stop', 'OpenViduController@stopRecording')->name('openvidu.recordings.recording.stop');
18 | Route::get('/recordings/{recordingId}', 'OpenViduController@recording')->name('openvidu.recordings.recording');
19 | Route::delete('/recordings/{recordingId}', 'OpenViduController@deleteRecording')->name('openvidu.recordings.recording.delete');
20 | 
21 | Route::post('/sendSignal', 'OpenViduController@sendSignal')->name('openvidu.sendsignal');
22 | 
23 | Route::post('/webhook', 'OpenViduController@webhook')->name('openvidu.webhook');


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "squareetlabs/laravel-openvidu",
 3 |   "description": "Laravel client for controlling your videocalls from your Openvidu server.",
 4 |   "keywords": [
 5 |     "openvidu",
 6 |     "laravel-openvidu",
 7 |     "videoconference",
 8 |     "video-conferencing",
 9 |     "kurento",
10 |     "room",
11 |     "chat",
12 |     "webrtc"
13 |   ],
14 |   "homepage": "https://github.com/squareetlabs/laravel-openvidu",
15 |   "license": "MIT",
16 |   "authors": [
17 |     {
18 |       "name": "Jacobo Cantorna Cigarrán",
19 |       "email": "jacobo@squareet.com",
20 |       "homepage": "https://www.squareet.com",
21 |       "role": "Developer"
22 |     },
23 |     {
24 |       "name": "Alberto Rial Barreiro",
25 |       "email": "alberto@squareet.com",
26 |       "homepage": "https://www.squareet.com",
27 |       "role": "Developer"
28 |     }
29 |   ],
30 |   "require": {
31 |     "php": ">=7.2.5",
32 |     "ext-json": "*",
33 |     "guzzlehttp/guzzle": "^v6.0|~v7.0",
34 |     "illuminate/cache": "^v6.0|^v7.0|^v8.0",
35 |     "illuminate/config": "^v6.0|^v7.0|^v8.0",
36 |     "illuminate/database": "^v6.20.26|^v7.30.6|^v8.0",
37 |     "illuminate/events": "^v6.0|^v7.0|^v8.0",
38 |     "illuminate/http": "^v6.0|^v7.0|^v8.0",
39 |     "illuminate/routing": "^v6.0|^v7.0|^v8.0",
40 |     "illuminate/support": "^v6.0|^v7.0|^v8.0",
41 |     "illuminate/translation": "^v6.0|^v7.0|^v8.0",
42 |     "illuminate/validation": "^v6.0|^v7.0|^v8.0"
43 |   },
44 |   "require-dev": {
45 |     "squizlabs/php_codesniffer": "3.5.8"
46 |   },
47 |   "autoload": {
48 |     "psr-4": {
49 |       "SquareetLabs\\LaravelOpenVidu\\": "src"
50 |     }
51 |   },
52 |   "extra": {
53 |     "laravel": {
54 |       "providers": [
55 |         "SquareetLabs\\LaravelOpenVidu\\Providers\\OpenViduServiceProvider"
56 |       ],
57 |       "aliases": {
58 |         "OpenVidu": "SquareetLabs\\LaravelOpenVidu\\Facades\\OpenVidu"
59 |       }
60 |     }
61 |   },
62 |   "config": {
63 |     "sort-packages": true
64 |   }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Events/ParticipantJoined.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Events;
 4 | 
 5 | 
 6 | /**
 7 |  * Class ParticipantJoined
 8 |  * @package SquareetLabs\LaravelOpenVidu\Events
 9 |  */
10 | class ParticipantJoined
11 | {
12 |     /**
13 |      * @var string $sessionId
14 |      * Session for which the event was triggered
15 |      * A string with the session unique identifier
16 |      */
17 |     public $sessionId;
18 | 
19 |     /**
20 |      * @var int $timestamp
21 |      * Time when the event was triggered
22 |      * UTC milliseconds
23 |      */
24 |     public $timestamp;
25 | 
26 |     /**
27 |      * @var string $participantId
28 |      * Identifier of the participant
29 |      * A string with the participant unique identifier
30 |      */
31 |     public $participantId;
32 | 
33 |     /**
34 |      * @var string $platform
35 |      * Complete description of the platform used by the participant to connect to the session
36 |      * A string with the platform description
37 |      */
38 |     public $platform;
39 | 
40 |     /**
41 |      * @var string $clientData
42 |      * Additional data added client side while connecting to Session
43 |      */
44 |     public $clientData;
45 | 
46 |     /**
47 |      * @var string $serverData
48 |      * Additional data added server side while generating Token
49 |      */
50 |     public $serverData;
51 | 
52 |     /**
53 |      * @var string $event
54 |      * Openvidu server webhook event
55 |      */
56 |     public $event;
57 | 
58 |     /**
59 |      * Create a new SessionCreated event instance.
60 |      * @param  array  $data
61 |      */
62 |     public function __construct(array $data)
63 |     {
64 |         $this->sessionId = $data['sessionId'];
65 |         $this->timestamp = $data['timestamp'];
66 |         $this->participantId = $data['participantId'];
67 |         $this->platform = $data['platform'];
68 |         $this->clientData = $data['clientData'] ?? "";
69 |         $this->serverData = $data['serverData'] ?? "";
70 |         $this->event = $data['event'];
71 |     }
72 | }
73 | 
74 | 


--------------------------------------------------------------------------------
/src/TokenOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu;
 4 | 
 5 | use JsonSerializable;
 6 | 
 7 | /**
 8 |  * Class TokenOptions
 9 |  * @package SquareetLabs\LaravelOpenVidu
10 |  */
11 | class TokenOptions implements JsonSerializable
12 | {
13 |     /** @var  string */
14 |     private $data;
15 |     /** @var  string */
16 |     private $role;
17 |     /** @var  KurentoOptions */
18 |     private $kurentoOptions;
19 | 
20 | 
21 |     /**
22 |      * TokenOptions constructor.
23 |      * @param  string  $role
24 |      * @param  string|null  $data
25 |      * @param  KurentoOptions|null  $kurentoOptions
26 |      */
27 |     public function __construct(string $role, ?string $data = null, ?KurentoOptions $kurentoOptions = null)
28 |     {
29 |         $this->role = $role;
30 |         $this->data = $data;
31 |         $this->kurentoOptions = $kurentoOptions;
32 |     }
33 | 
34 |     /**
35 |      * Convert the model instance to JSON.
36 |      *
37 |      * @param  int  $options
38 |      * @return string
39 |      *
40 |      */
41 |     public function toJson($options = 0): string
42 |     {
43 |         return json_encode($this->jsonSerialize(), $options);
44 |     }
45 | 
46 |     /**
47 |      * Specify data which should be serialized to JSON
48 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
49 |      * @return mixed data which can be serialized by <b>json_encode</b>,
50 |      * which is a value of any type other than a resource.
51 |      * @since 5.4.0
52 |      */
53 |     public function jsonSerialize()
54 |     {
55 |         return $this->toArray();
56 |     }
57 | 
58 |     /**
59 |      * Convert the model instance to an array.
60 |      *
61 |      * @return array
62 |      */
63 |     public function toArray(): array
64 |     {
65 |         $array = ['role' => $this->role, 'data' => $this->data];
66 |         foreach ($array as $key => $value) {
67 |             if (is_null($value) || $value == '') {
68 |                 unset($array[$key]);
69 |             }
70 |         }
71 |         return $array;
72 |     }
73 | 
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Dispatchers/WebhookEventDispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Dispatchers;
 4 | 
 5 | use Illuminate\Support\Facades\Event;
 6 | use SquareetLabs\LaravelOpenVidu\Events\FilterEventDispatched;
 7 | use SquareetLabs\LaravelOpenVidu\Events\ParticipantJoined;
 8 | use SquareetLabs\LaravelOpenVidu\Events\ParticipantLeft;
 9 | use SquareetLabs\LaravelOpenVidu\Events\RecordingStatusChanged;
10 | use SquareetLabs\LaravelOpenVidu\Events\SessionCreated;
11 | use SquareetLabs\LaravelOpenVidu\Events\SessionDestroyed;
12 | use SquareetLabs\LaravelOpenVidu\Events\WebRTCConnectionCreated;
13 | use SquareetLabs\LaravelOpenVidu\Events\WebRTCConnectionDestroyed;
14 | 
15 | /**
16 |  * Class WebhookEventFactory
17 |  * @package SquareetLabs\LaravelOpenVidu\Factories
18 |  */
19 | class WebhookEventDispatcher
20 | {
21 |     public static function dispatch(array $webhookEvent)
22 |     {
23 |         switch ($webhookEvent['event']) {
24 |             case 'sessionCreated':
25 |                 Event::dispatch(new SessionCreated($webhookEvent));
26 |                 break;
27 |             case 'sessionDestroyed':
28 |                 Event::dispatch(new SessionDestroyed($webhookEvent));
29 |                 break;
30 |             case 'participantJoined':
31 |                 Event::dispatch(new ParticipantJoined($webhookEvent));
32 |                 break;
33 |             case 'participantLeft':
34 |                 Event::dispatch(new ParticipantLeft($webhookEvent));
35 |                 break;
36 |             case 'webrtcConnectionCreated':
37 |                 Event::dispatch(new WebRTCConnectionCreated($webhookEvent));
38 |                 break;
39 |             case 'webrtcConnectionDestroyed':
40 |                 Event::dispatch(new WebRTCConnectionDestroyed($webhookEvent));
41 |                 break;
42 |             case 'recordingStatusChanged':
43 |                 Event::dispatch(new RecordingStatusChanged($webhookEvent));
44 |                 break;
45 |             case 'filterEventDispatched':
46 |                 Event::dispatch(new FilterEventDispatched($webhookEvent));
47 |                 break;
48 |         }
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/Builders/RecordingBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Builders;
 4 | 
 5 | use SquareetLabs\LaravelOpenVidu\Enums\MediaMode;
 6 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
 7 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
 8 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduInvalidArgumentException;
 9 | use SquareetLabs\LaravelOpenVidu\Recording;
10 | use SquareetLabs\LaravelOpenVidu\RecordingProperties;
11 | 
12 | /**
13 |  * Class RecordingBuilder
14 |  * @package SquareetLabs\LaravelOpenVidu\Builders
15 |  */
16 | class RecordingBuilder implements BuilderInterface
17 | {
18 |     /**
19 |      * @param  array  $properties
20 |      * @return Recording|null
21 |      * @throws OpenViduInvalidArgumentException
22 |      */
23 |     public static function build(array $properties)
24 |     {
25 |         if (array_key_exists('sessionId', $properties)) {
26 |             return new Recording(
27 |                 $properties['id'],
28 |                 $properties['sessionId'],
29 |                 $properties['createdAt'],
30 |                 $properties['size'],
31 |                 $properties['duration'],
32 |                 $properties['url'],
33 |                 new RecordingProperties(
34 |                     $properties['sessionId'],
35 |                     array_key_exists('name', $properties) ? $properties['name'] : RecordingLayout::BEST_FIT,
36 |                     array_key_exists('outputMode', $properties) ? $properties['outputMode'] : OutputMode::COMPOSED,
37 |                     array_key_exists('recordingLayout', $properties) ? $properties['recordingLayout'] : RecordingLayout::BEST_FIT,
38 |                     array_key_exists('resolution', $properties) ? $properties['resolution'] : null,
39 |                     array_key_exists('hasAudio', $properties) ? $properties['hasAudio'] : true,
40 |                     array_key_exists('hasVideo', $properties) ? $properties['hasVideo'] : true,
41 |                     array_key_exists('customLayout', $properties) ? $properties['customLayout'] : MediaMode::ROUTED
42 | 
43 |                 ));
44 |         }
45 |         throw new OpenViduInvalidArgumentException('RecordingBuilder::build spects an array with sessionId key.');
46 | 
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/SignalProperties.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu;
 4 | 
 5 | use JsonSerializable;
 6 | 
 7 | /**
 8 |  * Class SignalProperties
 9 |  * @package SquareetLabs\LaravelOpenVidu
10 |  */
11 | class SignalProperties implements JsonSerializable
12 | {
13 |     /** @var  string */
14 |     private $session;
15 |     /** @var  array */
16 |     private $to;
17 |     /** @var  string */
18 |     private $type;
19 |     /** @var  string */
20 |     private $data;
21 | 
22 |     /**
23 |      * SignalProperties constructor.
24 |      * @param  string  $session
25 |      * @param  string|null  $data
26 |      * @param  string|null  $type
27 |      * @param  array|null  $to
28 |      */
29 |     public function __construct(string $session, ?string $data = null, ?string $type = null, ?array $to = null)
30 |     {
31 |         $this->session = $session;
32 |         $this->data = $data;
33 |         $this->type = $type;
34 |         $this->to = $to;
35 |     }
36 | 
37 |     /**
38 |      * Session name of the recording
39 |      *
40 |      * @return string
41 |      */
42 |     public function session()
43 |     {
44 |         return $this->session;
45 |     }
46 | 
47 |     /**
48 |      * Convert the model instance to JSON.
49 |      *
50 |      * @param  int  $options
51 |      * @return string
52 |      *
53 |      */
54 |     public function toJson($options = 0): string
55 |     {
56 |         return json_encode($this->jsonSerialize(), $options);
57 |     }
58 | 
59 |     /**
60 |      * Specify data which should be serialized to JSON
61 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
62 |      * @return mixed data which can be serialized by <b>json_encode</b>,
63 |      * which is a value of any type other than a resource.
64 |      * @since 5.4.0
65 |      */
66 |     public function jsonSerialize()
67 |     {
68 |         return $this->toArray();
69 |     }
70 | 
71 |     /**
72 |      * Convert the model instance to an array.
73 |      *
74 |      * @return array
75 |      */
76 |     public function toArray(): array
77 |     {
78 |         $array = [
79 |             'session' => $this->session,
80 |             'data' => $this->data,
81 |             'type' => $this->type,
82 |             'to' => $this->to
83 |         ];
84 |         foreach ($array as $key => $value) {
85 |             if (is_null($value) || $value == '') {
86 |                 unset($array[$key]);
87 |             }
88 |         }
89 |         return $array;
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/Providers/OpenViduServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Providers;
 4 | 
 5 | use Illuminate\Support\Facades\Cache;
 6 | use Illuminate\Support\Facades\DB;
 7 | use Illuminate\Support\Facades\Route;
 8 | use Illuminate\Support\ServiceProvider;
 9 | use SquareetLabs\LaravelOpenVidu\Cache\SessionStore;
10 | use SquareetLabs\LaravelOpenVidu\OpenVidu;
11 | 
12 | /**
13 |  * Class OpenViduServiceProvider
14 |  * @package SquareetLabs\LaravelOpenVidu\Providers
15 |  */
16 | class OpenViduServiceProvider extends ServiceProvider
17 | {
18 |     /**
19 |      * Register.
20 |      */
21 |     public function register()
22 |     {
23 |         $this->app->singleton(OpenVidu::class, function () {
24 |             return new OpenVidu(/** @scrutinizer ignore-call */ config('services.openvidu'));
25 |         });
26 | 
27 |         $this->app->alias(OpenVidu::class, 'openVidu');
28 |         //Default parameter added true due to the compatibility
29 |         if (config('services.openvidu.use_routes', true)) {
30 |             $this->registerRoutes();
31 |         }
32 |     }
33 | 
34 |     /**
35 |      * Register the package routes.
36 |      *
37 |      * @return void
38 |      */
39 |     private function registerRoutes()
40 |     {
41 |         Route::group($this->routeConfiguration(), function () {
42 |             $this->loadRoutesFrom(__DIR__.'/../Http/routes.php');
43 |         });
44 |     }
45 | 
46 |     /**
47 |      * Get the SmsUp route group configuration array.
48 |      *
49 |      * @return array
50 |      */
51 |     private function routeConfiguration()
52 |     {
53 |         return [
54 |             'domain' => null,
55 |             'namespace' => 'SquareetLabs\LaravelOpenVidu\Http\Controllers',
56 |             'prefix' => 'openvidu'
57 |         ];
58 |     }
59 | 
60 |     /**
61 |      * Bootstrap the application services.
62 |      *
63 |      * @return void
64 |      */
65 |     public function boot()
66 |     {
67 |         if ($this->app->runningInConsole()) {
68 |             $this->loadMigrationsFrom(__DIR__.'/../../database/migrations');
69 | 
70 |             $this->publishes([
71 |                 __DIR__.'/../../database/migrations' => /** @scrutinizer ignore-call */ database_path('migrations'),
72 |             ], 'openvidu-migrations');
73 | 
74 |         }
75 |         Cache::extend('openvidu', function () {
76 |             return Cache::repository(new SessionStore(DB::connection(), /** @scrutinizer ignore-call */ config('cache.stores.openvidu.table')));
77 |         });
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Events/ParticipantLeft.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Events;
 4 | 
 5 | 
 6 | /**
 7 |  * Class ParticipantLeft
 8 |  * @package SquareetLabs\LaravelOpenVidu\Events
 9 |  */
10 | class ParticipantLeft
11 | {
12 |     /**
13 |      * @var string $sessionId
14 |      * Session for which the event was triggered
15 |      * A string with the session unique identifier
16 |      */
17 |     public $sessionId;
18 | 
19 |     /**
20 |      * @var int $timestamp
21 |      * Time when the event was triggered
22 |      * UTC milliseconds
23 |      */
24 |     public $timestamp;
25 | 
26 |     /**
27 |      * @var string $participantId
28 |      * Identifier of the participant
29 |      * A string with the participant unique identifier
30 |      */
31 |     public $participantId;
32 | 
33 |     /**
34 |      * @var string $platform
35 |      * Complete description of the platform used by the participant to connect to the session
36 |      * A string with the platform description
37 |      */
38 |     public $platform;
39 | 
40 |     /**
41 |      * @var string $clientData
42 |      * Additional data added client side while connecting to Session
43 |      */
44 |     public $clientData;
45 | 
46 |     /**
47 |      * @var string $serverData
48 |      * Additional data added server side while generating Token
49 |      */
50 |     public $serverData;
51 | 
52 |     /**
53 |      * @var int $startTime
54 |      * Time when the participant joined the session
55 |      * UTC milliseconds
56 |      */
57 |     public $startTime;
58 | 
59 |     /**
60 |      * @var int $duration
61 |      * Total duration of the participant's connection to the session
62 |      * Seconds
63 |      */
64 |     public $duration;
65 | 
66 |     /**
67 |      * @var string $reason
68 |      * How the participant left the session
69 |      * ["disconnect","forceDisconnectByUser","forceDisconnectByServer","sessionClosedByServer","networkDisconnect","openviduServerStopped"]
70 |      */
71 |     public $reason;
72 | 
73 |     /**
74 |      * @var string $event
75 |      * Openvidu server webhook event
76 |      */
77 |     public $event;
78 | 
79 |     /**
80 |      * Create a new SessionCreated event instance.
81 |      * @param  array  $data
82 |      */
83 |     public function __construct(array $data)
84 |     {
85 |         $this->sessionId = $data['sessionId'];
86 |         $this->timestamp = $data['timestamp'];
87 |         $this->participantId = $data['participantId'];
88 |         $this->platform = $data['platform'];
89 |         $this->clientData = $data['clientData'] ?? "";
90 |         $this->serverData = $data['serverData'] ?? "";
91 |         $this->startTime = $data['startTime'];
92 |         $this->duration = $data['duration'];
93 |         $this->reason = $data['reason'];
94 |         $this->event = $data['event'];
95 |     }
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/src/Http/Requests/GenerateTokenRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | use Illuminate\Validation\Rule;
 7 | use SquareetLabs\LaravelOpenVidu\Enums\MediaMode;
 8 | use SquareetLabs\LaravelOpenVidu\Enums\OpenViduRole;
 9 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
10 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
11 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingMode;
12 | 
13 | /**
14 |  * Class GenerateTokenRequest
15 |  * @package SquareetLabs\LaravelOpenVidu\Http\Requests
16 |  */
17 | class GenerateTokenRequest extends /** @scrutinizer ignore-call */
18 |     FormRequest
19 | {
20 | 
21 | 
22 |     /**
23 |      * Determine if the user is authorized to make this request.
24 |      *
25 |      * @return bool
26 |      */
27 |     public function authorize()
28 |     {
29 |         return true;
30 |     }
31 | 
32 |     /**
33 |      * Get the validation rules that apply to the request.
34 |      *
35 |      * @return array
36 |      */
37 |     public function rules()
38 |     {
39 |         return [
40 |             'session.mediaMode' => ['string', Rule::in([MediaMode::ROUTED, MediaMode::RELAYED])],
41 |             'session.recordingMode' => ['string', Rule::in([RecordingMode::MANUAL, RecordingMode::ALWAYS])],
42 |             'session.defaultOutputMode' => ['string', Rule::in([OutputMode::COMPOSED, OutputMode::COMPOSED_QUICK_START, OutputMode::INDIVIDUAL])],
43 |             'session.defaultRecordingLayout' => ['string', Rule::in([RecordingLayout::CUSTOM, RecordingLayout::BEST_FIT])],
44 |             'session.defaultCustomLayout' => 'string',
45 |             'session.customSessionId' => 'string',
46 |             'tokenOptions.data' => 'nullable|string',
47 |             'tokenOptions.role' => ['string', Rule::in([OpenViduRole::MODERATOR, OpenViduRole::PUBLISHER, OpenViduRole::SUBSCRIBER])],
48 |         ];
49 |     }
50 | 
51 |     /**
52 |      * Get the error messages for the defined validation rules.
53 |      *
54 |      * @return array
55 |      */
56 |     public function messages()
57 |     {
58 |         return [
59 |             'session.mediaMode.in' => /** @scrutinizer ignore-call */ __('validation.session.mediaMode_in'),
60 |             'session.recordingMode.in' => /** @scrutinizer ignore-call */ __('validation.session.recordingMode_in'),
61 |             'session.defaultOutputMode.in' => /** @scrutinizer ignore-call */ __('validation.session.defaultOutputMode_in'),
62 |             'session.defaultRecordingLayout.in' => /** @scrutinizer ignore-call */ __('validation.session.defaultRecordingLayout_in'),
63 |             'session.defaultCustomLayout.in' => /** @scrutinizer ignore-call */ __('validation.session.defaultCustomLayout_in'),
64 |             'tokenOptions.role.in' => /** @scrutinizer ignore-call */ __('validation.session.defaultCustomLayout_in'),
65 |         ];
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/KurentoOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SquareetLabs\LaravelOpenVidu;
 4 | 
 5 | use JsonSerializable;
 6 | 
 7 | /**
 8 |  * Class KurentoOptions
 9 |  * @package SquareetLabs\LaravelOpenVidu
10 |  */
11 | class KurentoOptions implements JsonSerializable
12 | {
13 |     /** @var  int */
14 |     private $videoMaxRecvBandwidth;
15 |     /** @var  int */
16 |     private $videoMinRecvBandwidth;
17 |     /** @var  int */
18 |     private $videoMaxSendBandwidth;
19 |     /** @var  int */
20 |     private $videoMinSendBandwidth;
21 |     /** @var  array */
22 |     private $allowedFilters = [];
23 | 
24 |     /**
25 |      * KurentoOptions constructor.
26 |      * @param  int|null  $videoMaxRecvBandwidth
27 |      * @param  int|null  $videoMinRecvBandwidth
28 |      * @param  int|null  $videoMaxSendBandwidth
29 |      * @param  int|null  $videoMinSendBandwidth
30 |      * @param  array|null  $allowedFilters
31 |      */
32 |     public function __construct(?int $videoMaxRecvBandwidth = null, ?int $videoMinRecvBandwidth = null, ?int $videoMaxSendBandwidth = null, ?int $videoMinSendBandwidth = null, ?array $allowedFilters = null)
33 |     {
34 |         $this->videoMaxRecvBandwidth = $videoMaxRecvBandwidth;
35 |         $this->videoMinRecvBandwidth = $videoMinRecvBandwidth;
36 |         $this->videoMaxSendBandwidth = $videoMaxSendBandwidth;
37 |         $this->videoMinSendBandwidth = $videoMinSendBandwidth;
38 |         $this->allowedFilters = $allowedFilters;
39 |     }
40 | 
41 |     /**
42 |      * Convert the model instance to JSON.
43 |      *
44 |      * @param  int  $options
45 |      * @return string
46 |      *
47 |      */
48 |     public function toJson($options = 0): string
49 |     {
50 |         return json_encode($this->jsonSerialize(), $options);
51 |     }
52 | 
53 |     /**
54 |      * Specify data which should be serialized to JSON
55 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
56 |      * @return mixed data which can be serialized by <b>json_encode</b>,
57 |      * which is a value of any type other than a resource.
58 |      * @since 5.4.0
59 |      */
60 |     public function jsonSerialize()
61 |     {
62 |         return $this->toArray();
63 |     }
64 | 
65 |     /**
66 |      * Convert the model instance to an array.
67 |      *
68 |      * @return array
69 |      */
70 |     public function toArray(): array
71 |     {
72 |         $array = ['videoMaxRecvBandwidth' => $this->videoMaxRecvBandwidth, 'videoMinRecvBandwidth' => $this->videoMinRecvBandwidth, 'videoMaxSendBandwidth' => $this->videoMaxSendBandwidth, 'videoMinSendBandwidth' => $this->videoMinSendBandwidth];
73 |         foreach ($this->allowedFilters as $allowed_filter) {
74 |             $array['allowedFilters'][] = $allowed_filter;
75 |         }
76 |         foreach ($array as $key => $value) {
77 |             if (is_null($value) || $value == '') {
78 |                 unset($array[$key]);
79 |             }
80 |         }
81 |         return $array;
82 |     }
83 | 
84 | }
85 | 


--------------------------------------------------------------------------------
/src/IPCameraOptions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use JsonSerializable;
  6 | 
  7 | /**
  8 |  * Class IPCameraOptions
  9 |  * @package SquareetLabs\LaravelOpenVidu
 10 |  */
 11 | class IPCameraOptions implements JsonSerializable, StreamInterface
 12 | {
 13 |     /** @var  string */
 14 |     private $rtspUri;
 15 |     /** @var  string */
 16 |     private $type;
 17 |     /** @var  bool */
 18 |     private $adaptativeBitrate;
 19 |     /** @var  bool */
 20 |     private $onlyPlayWithSubscribers;
 21 |     /** @var  string */
 22 |     private $data;
 23 | 
 24 |     /**
 25 |      * IPCameraOptions constructor.
 26 |      * @param  string  $rtspUri
 27 |      * @param  string|null  $type
 28 |      * @param  bool|null  $adaptativeBitrate
 29 |      * @param  bool|null  $onlyPlayWithSubscribers
 30 |      * @param  string|null  $data
 31 |      */
 32 |     public function __construct(string $rtspUri, ?string $type = null, ?bool $adaptativeBitrate = true, ?bool $onlyPlayWithSubscribers = true, ?string $data = null)
 33 |     {
 34 |         $this->rtspUri = $rtspUri;
 35 |         $this->type = $type;
 36 |         $this->adaptativeBitrate = $adaptativeBitrate;
 37 |         $this->onlyPlayWithSubscribers = $onlyPlayWithSubscribers;
 38 |         $this->data = $data;
 39 |     }
 40 | 
 41 |     /**
 42 |      * Convert the model instance to JSON.
 43 |      *
 44 |      * @param  int  $options
 45 |      * @return string
 46 |      *
 47 |      */
 48 |     public function toJson($options = 0): string
 49 |     {
 50 |         return json_encode($this->jsonSerialize(), $options);
 51 |     }
 52 | 
 53 |     /**
 54 |      * Specify data which should be serialized to JSON
 55 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
 56 |      * @return mixed data which can be serialized by <b>json_encode</b>,
 57 |      * which is a value of any type other than a resource.
 58 |      * @since 5.4.0
 59 |      */
 60 |     public function jsonSerialize()
 61 |     {
 62 |         return $this->toArray();
 63 |     }
 64 | 
 65 |     /**
 66 |      * Convert the model instance to an array.
 67 |      *
 68 |      * @return array
 69 |      */
 70 |     public function toArray(): array
 71 |     {
 72 |         $array = ['rtspUri' => $this->rtspUri, 'type' => $this->type, 'adaptativeBitrate' => $this->adaptativeBitrate, 'onlyPlayWithSubscribers' => $this->onlyPlayWithSubscribers, 'data' => $this->data];
 73 |         foreach ($array as $key => $value) {
 74 |             if (is_null($value) || $value == '') {
 75 |                 unset($array[$key]);
 76 |             }
 77 |         }
 78 |         return $array;
 79 |     }
 80 | 
 81 |     /** @return  string */
 82 |     public function getRtspUri()
 83 |     {
 84 |         return $this->rtspUri;
 85 |     }
 86 | 
 87 |     /** @return  string */
 88 |     public function getType()
 89 |     {
 90 |         return $this->type;
 91 |     }
 92 | 
 93 |     /** @return  bool */
 94 |     public function getAdaptativeBitrate()
 95 |     {
 96 |         return $this->adaptativeBitrate;
 97 |     }
 98 | 
 99 |     /** @return  bool */
100 |     public function getOnlyPlayWithSubscribers()
101 |     {
102 |         return $this->onlyPlayWithSubscribers;
103 |     }
104 | 
105 |     /** @return  string */
106 |     public function getData()
107 |     {
108 |         return $this->data;
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/src/Events/WebRTCConnectionCreated.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu\Events;
  4 | 
  5 | 
  6 | /**
  7 |  * Class WebRTCConnectionCreated
  8 |  * @package SquareetLabs\LaravelOpenVidu\Events
  9 |  */
 10 | class WebRTCConnectionCreated
 11 | {
 12 |     /**
 13 |      * @var string $sessionId
 14 |      * Session for which the event was triggered
 15 |      * A string with the session unique identifier
 16 |      */
 17 |     public $sessionId;
 18 | 
 19 |     /**
 20 |      * @var int $timestamp
 21 |      * Time when the event was triggered
 22 |      * UTC milliseconds
 23 |      */
 24 |     public $timestamp;
 25 | 
 26 |     /**
 27 |      * @var string $participantId
 28 |      * Identifier of the participant
 29 |      * A string with the participant unique identifier
 30 |      */
 31 |     public $participantId;
 32 | 
 33 |     /**
 34 |      * @var string $connection
 35 |      * Whether the media connection is an inbound connection (the participant is receiving media from OpenVidu) or an outbound connection (the participant is sending media to OpenVidu)
 36 |      * ["INBOUND","OUTBOUND"]
 37 |      */
 38 |     public $connection;
 39 | 
 40 | 
 41 |     /**
 42 |      * @var string $receivingFrom
 43 |      * If connection is "INBOUND", the participant from whom the media stream is being received
 44 |      * A string with the participant (sender) unique identifier
 45 |      */
 46 |     public $receivingFrom;
 47 | 
 48 |     /**
 49 |      * @var bool $audioEnabled
 50 |      * Whether the media connection has negotiated audio or not
 51 |      * [true,false]
 52 |      */
 53 |     public $audioEnabled;
 54 | 
 55 |     /**
 56 |      * @var bool $videoEnabled
 57 |      * Whether the media connection has negotiated video or not
 58 |      * [true,false]
 59 |      */
 60 |     public $videoEnabled;
 61 | 
 62 |     /**
 63 |      * @var string $videoSource
 64 |      * If videoEnabled is true, the type of video that is being transmitted
 65 |      * ["CAMERA","SCREEN"]
 66 |      */
 67 |     public $videoSource;
 68 | 
 69 |     /**
 70 |      * @var int $videoFramerate
 71 |      * If videoEnabled is true, the framerate of the transmitted video
 72 |      * Number of fps
 73 |      */
 74 |     public $videoFramerate;
 75 | 
 76 |     /**
 77 |      * @var int $videoDimensions
 78 |      * If videoEnabled is true, the dimensions transmitted video
 79 |      * String with the dimensions (e.g. "1920x1080")
 80 |      */
 81 |     public $videoDimensions;
 82 | 
 83 |     /**
 84 |      * @var string $event
 85 |      * Openvidu server webhook event
 86 |      */
 87 |     public $event;
 88 | 
 89 | 
 90 |     /**
 91 |      * Create a new SessionCreated event instance.
 92 |      * @param  array  $data
 93 |      */
 94 |     public function __construct(array $data)
 95 |     {
 96 |         $this->sessionId = $data['sessionId'];
 97 |         $this->timestamp = $data['timestamp'];
 98 |         $this->participantId = $data['participantId'];
 99 |         if (array_key_exists('receivingFrom', $data)) {
100 |             $this->receivingFrom = $data['receivingFrom'];
101 |         }
102 |         $this->audioEnabled = $data['audioEnabled'];
103 |         $this->videoEnabled = $data['videoEnabled'];
104 |         if (array_key_exists('videoSource', $data)) {
105 |             $this->videoSource = $data['videoSource'];
106 |             $this->videoFramerate = $data['videoFramerate'];
107 |             $this->videoDimensions = $data['videoDimensions'];
108 |         }
109 |         $this->event = $data['event'];
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/Subscriber.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use JsonSerializable;
  6 | 
  7 | /**
  8 |  * Class Subscriber
  9 |  * @package SquareetLabs\LaravelOpenVidu
 10 |  * This is a backend representation of a published media stream (see [OpenVidu Browser Stream class](/api/openvidu-browser/classes/stream.html)
 11 |  * {@see Connection::getPublishers()}
 12 |  */
 13 | class Subscriber implements JsonSerializable
 14 | {
 15 | 
 16 |     /** @var  string
 17 |      * Unique identifier of the Stream {@link https://api/openvidu-browser/classes/stream.html} associated to this Subscriber.
 18 |      */
 19 |     private $streamId;
 20 | 
 21 |     /** @var  string
 22 |      * Unique identifier of the Stream {@link https://api/openvidu-browser/classes/stream.html} associated to the Publisher.
 23 |      * Each Publisher is paired with only one Stream, so you can identify each Publisher by its
 24 |      * Stream.streamId {@link https://api/openvidu-browser/classes/stream.html#streamid}
 25 |      */
 26 |     private $publisherStreamId;
 27 | 
 28 |     /** @var int
 29 |      * Timestamp when this connection was established, in UTC milliseconds (ms since Jan 1, 1970, 00:00:00 UTC)
 30 |      */
 31 |     private $createdAt;
 32 | 
 33 |     /**
 34 |      * Publisher constructor.
 35 |      * @param  string  $streamId
 36 |      * @param  string  $publisherStreamId
 37 |      * @param  int  $createdAt
 38 |      */
 39 |     public function __construct(string $streamId, string $publisherStreamId, int $createdAt)
 40 |     {
 41 |         $this->streamId = $streamId;
 42 |         $this->publisherStreamId = $publisherStreamId;
 43 |         $this->createdAt = $createdAt;
 44 |     }
 45 | 
 46 |     public function __toString(): string
 47 |     {
 48 |         return $this->getStreamId();
 49 |     }
 50 | 
 51 |     /**
 52 |      * @return string
 53 |      */
 54 |     public function getStreamId(): string
 55 |     {
 56 |         return $this->streamId;
 57 |     }
 58 | 
 59 |     /**
 60 |      * @return string
 61 |      */
 62 |     public function getPublisherStreamId(): string
 63 |     {
 64 |         return $this->publisherStreamId;
 65 |     }
 66 | 
 67 | 
 68 |     /**
 69 |      * Convert the model instance to JSON.
 70 |      *
 71 |      * @param  int  $options
 72 |      * @return string
 73 |      *
 74 |      */
 75 |     public function toJson($options = 0): string
 76 |     {
 77 |         return json_encode($this->jsonSerialize(), $options);
 78 |     }
 79 | 
 80 |     /**
 81 |      * Specify data which should be serialized to JSON
 82 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
 83 |      * @return mixed data which can be serialized by <b>json_encode</b>,
 84 |      * which is a value of any type other than a resource.
 85 |      * @since 5.4.0
 86 |      */
 87 |     public function jsonSerialize()
 88 |     {
 89 |         return $this->toArray();
 90 |     }
 91 | 
 92 |     /**
 93 |      * Convert the model instance to an array.
 94 |      *
 95 |      * @return array
 96 |      */
 97 |     public function toArray(): array
 98 |     {
 99 |         $array = [
100 |             'streamId' => $this->streamId,
101 |             'publisherStreamId' => $this->publisherStreamId,
102 |             'createdAt' => $this->createdAt
103 |         ];
104 |         foreach ($array as $key => $value) {
105 |             if (is_null($value) || $value == '') {
106 |                 unset($array[$key]);
107 |             }
108 |         }
109 |         return $array;
110 |     }
111 | 
112 |     /**
113 |      * @param  Publisher  $other
114 |      * @return bool
115 |      */
116 |     public function equalTo(Publisher $other): bool
117 |     {
118 |         return (
119 |             $this->streamId === $other->getStreamId() &&
120 |             $this->createdAt === $other->getCreatedAt() &&
121 |             $this->publisherStreamId === $other->publisherStreamId()
122 |         );
123 |     }
124 | 
125 |     /**
126 |      * @return int
127 |      */
128 |     public function getCreatedAt(): int
129 |     {
130 |         return $this->createdAt;
131 |     }
132 | }
133 | 


--------------------------------------------------------------------------------
/src/Events/WebRTCConnectionDestroyed.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu\Events;
  4 | 
  5 | 
  6 | /**
  7 |  * Class WebRTCConnectionCreated
  8 |  * @package SquareetLabs\LaravelOpenVidu\Events
  9 |  */
 10 | class WebRTCConnectionDestroyed
 11 | {
 12 | 
 13 |     /**
 14 |      * @var string $sessionId
 15 |      * Session for which the event was triggered
 16 |      * A string with the session unique identifier
 17 |      */
 18 |     public $sessionId;
 19 | 
 20 |     /**
 21 |      * @var int $timestamp
 22 |      * Time when the event was triggered
 23 |      * UTC milliseconds
 24 |      */
 25 |     public $timestamp;
 26 | 
 27 |     /**
 28 |      * @var string $participantId
 29 |      * Identifier of the participant
 30 |      * A string with the participant unique identifier
 31 |      */
 32 |     public $participantId;
 33 | 
 34 |     /**
 35 |      * @var int $startTime
 36 |      * Time when the media connection was established
 37 |      * UTC milliseconds
 38 |      */
 39 |     public $startTime;
 40 | 
 41 |     /**
 42 |      * @var int $duration
 43 |      * Total duration of the media connection
 44 |      * Seconds
 45 |      */
 46 |     public $duration;
 47 | 
 48 |     /**
 49 |      * @var string $connection
 50 |      * Whether the media connection is an inbound connection (the participant is receiving media from OpenVidu) or an outbound connection (the participant is sending media to OpenVidu)
 51 |      * ["INBOUND","OUTBOUND"]
 52 |      */
 53 |     public $connection;
 54 | 
 55 |     /**
 56 |      * @var string $receivingFrom
 57 |      * If connection is "INBOUND", the participant from whom the media stream is being received
 58 |      * A string with the participant (sender) unique identifier
 59 |      */
 60 |     public $receivingFrom;
 61 | 
 62 |     /**
 63 |      * @var bool $audioEnabled
 64 |      * Whether the media connection has negotiated audio or not
 65 |      * [true,false]
 66 |      */
 67 |     public $audioEnabled;
 68 | 
 69 |     /**
 70 |      * @var bool $videoEnabled
 71 |      * Whether the media connection has negotiated video or not
 72 |      * [true,false]
 73 |      */
 74 |     public $videoEnabled;
 75 | 
 76 |     /**
 77 |      * @var string $videoSource
 78 |      * If videoEnabled is true, the type of video that is being transmitted
 79 |      * ["CAMERA","SCREEN"]
 80 |      */
 81 |     public $videoSource;
 82 | 
 83 |     /**
 84 |      * @var int $videoFramerate
 85 |      * If videoEnabled is true, the framerate of the transmitted video
 86 |      * Number of fps
 87 |      */
 88 |     public $videoFramerate;
 89 | 
 90 |     /**
 91 |      * @var int $videoDimensions
 92 |      * If videoEnabled is true, the dimensions transmitted video
 93 |      * String with the dimensions (e.g. "1920x1080")
 94 |      */
 95 |     public $videoDimensions;
 96 | 
 97 |     /**
 98 |      * @var  string $reason
 99 |      * How the WebRTC connection was destroyed
100 |      *["unsubscribe","unpublish","disconnect","forceUnpublishByUser","forceUnpublishByServer","forceDisconnectByUser","forceDisconnectByServer","sessionClosedByServer","networkDisconnect","openviduServerStopped","mediaServerDisconnect"]
101 |      */
102 |     public $reason;
103 | 
104 |     /**
105 |      * @var string $event
106 |      * Openvidu server webhook event
107 |      */
108 |     public $event;
109 | 
110 | 
111 |     /**
112 |      * Create a new SessionCreated event instance.
113 |      * @param  array  $data
114 |      */
115 |     public function __construct(array $data)
116 |     {
117 |         $this->sessionId = $data['sessionId'];
118 |         $this->timestamp = $data['timestamp'];
119 |         $this->participantId = $data['participantId'];
120 |         if (array_key_exists('receivingFrom', $data)) {
121 |             $this->receivingFrom = $data['receivingFrom'];
122 |         }
123 |         $this->audioEnabled = $data['audioEnabled'];
124 |         $this->videoEnabled = $data['videoEnabled'];
125 |         if (array_key_exists('videoSource', $data)) {
126 |             $this->videoSource = $data['videoSource'];
127 |             $this->videoFramerate = $data['videoFramerate'];
128 |             $this->videoDimensions = $data['videoDimensions'];
129 |         }
130 |         $this->startTime = $data['startTime'];
131 |         $this->duration = $data['duration'];
132 |         $this->reason = $data['reason'];
133 |         $this->event = $data['event'];
134 |     }
135 | }


--------------------------------------------------------------------------------
/src/Events/RecordingStatusChanged.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu\Events;
  4 | 
  5 | 
  6 | /**
  7 |  * Class RecordingStatusChanged
  8 |  * @package SquareetLabs\LaravelOpenVidu\Events
  9 |  */
 10 | class RecordingStatusChanged
 11 | {
 12 |     /**
 13 |      * @var string $sessionId
 14 |      * Session for which the event was triggered
 15 |      * A string with the session unique identifier
 16 |      */
 17 |     public $sessionId;
 18 | 
 19 |     /**
 20 |      * @var int $timestamp
 21 |      * Time when the event was triggered
 22 |      * UTC milliseconds
 23 |      */
 24 |     public $timestamp;
 25 | 
 26 | 
 27 |     /**
 28 |      * @var string $participantId
 29 |      * Identifier of the participant
 30 |      * A string with the participant unique identifier
 31 |      */
 32 |     public $participantId;
 33 | 
 34 |     /**
 35 |      * @var int $startTime
 36 |      * Time when the recording started
 37 |      * UTC milliseconds
 38 |      */
 39 |     public $startTime;
 40 | 
 41 |     /**
 42 |      * @var string $id
 43 |      * Unique identifier of the recording
 44 |      * A string with the recording unique identifier
 45 |      */
 46 |     public $id;
 47 | 
 48 |     /**
 49 |      * @var string $name
 50 |      * Name given to the recording file
 51 |      * A string with the recording name
 52 |      */
 53 |     public $name;
 54 | 
 55 | 
 56 |     /**
 57 |      * @var string $outputMode
 58 |      * Output mode of the recording (COMPOSED or INDIVIDUAL)
 59 |      * A string with the recording output mode
 60 |      */
 61 |     public $outputMode;
 62 | 
 63 | 
 64 |     /**
 65 |      * @var bool $hasAudio
 66 |      * Wheter the recording file has audio or not
 67 |      *    [true,false]
 68 |      */
 69 |     public $hasAudio;
 70 | 
 71 |     /**
 72 |      * @var bool $hasVideo
 73 |      * Wheter the recording file has video or not
 74 |      *    [true,false]
 75 |      */
 76 |     public $hasVideo;
 77 | 
 78 |     /**
 79 |      * @var string $recordingLayout
 80 |      * The type of layout used in the recording. Only defined if outputMode is COMPOSED and hasVideo is true
 81 |      *  A RecordingLayout value (BEST_FIT, PICTURE_IN_PICTURE, CUSTOM ...)
 82 |      */
 83 |     public $recordingLayout;
 84 | 
 85 |     /**
 86 |      * @var string $resolution
 87 |      * Resolution of the recorded file. Only defined if outputMode is COMPOSED and hasVideo is true
 88 |      * A string with the width and height of the video file in pixels. e.g. "1280x720"
 89 |      */
 90 |     public $resolution;
 91 | 
 92 |     /**
 93 |      * @var int $size
 94 |      * The size of the video file. 0 until status is stopped
 95 |      * Bytes
 96 |      */
 97 |     public $size;
 98 | 
 99 |     /**
100 |      * @var int $duration
101 |      * Duration of the video file. 0 until status is stopped
102 |      * Seconds
103 |      */
104 |     public $duration;
105 | 
106 |     /**
107 |      * @var string $status
108 |      * Status of the recording
109 |      * ["started","stopped","ready","failed"]
110 |      */
111 |     public $status;
112 | 
113 |     /**
114 |      * @var string $reason
115 |      * Why the recording stopped. Only defined when status is stopped or ready
116 |      * ["recordingStoppedByServer","lastParticipantLeft","sessionClosedByServer","automaticStop","openviduServerStopped","mediaServerDisconnect"]
117 |      */
118 |     public $reason;
119 | 
120 |     /**
121 |      * @var string $event
122 |      * Openvidu server webhook event
123 |      */
124 |     public $event;
125 | 
126 |     /**
127 |      * Create a new SessionCreated event instance.
128 |      * @param  array  $data
129 |      */
130 |     public function __construct(array $data)
131 |     {
132 |         $this->sessionId = $data['sessionId'];
133 |         $this->timestamp = $data['timestamp'];
134 |         if (array_key_exists('participantId', $data)) {
135 |             $this->participantId = $data['participantId'];
136 |         }
137 |         $this->startTime = $data['startTime'];
138 |         $this->id = $data['id'];
139 |         $this->name = $data['name'];
140 |         $this->outputMode = $data['outputMode'];
141 |         $this->hasAudio = $data['hasAudio'];
142 |         $this->hasVideo = $data['hasVideo'];
143 |         $this->recordingLayout = $data['recordingLayout'];
144 |         $this->resolution = $data['resolution'];
145 |         $this->status = $data['status'];
146 |         if (array_key_exists('reason', $data)) {
147 |             $this->size = $data['size'];
148 |             $this->duration = $data['duration'];
149 |             $this->reason = $data['reason'];
150 |         }
151 |         $this->event = $data['event'];
152 |     }
153 | }


--------------------------------------------------------------------------------
/src/SessionProperties.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use InvalidArgumentException;
  6 | use JsonSerializable;
  7 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
  8 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
  9 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingMode;
 10 | 
 11 | /**
 12 |  * Class SessionProperties
 13 |  * @package SquareetLabs\LaravelOpenVidu
 14 |  */
 15 | class SessionProperties implements JsonSerializable
 16 | {
 17 |     /** @var  string */
 18 |     private $mediaMode;
 19 | 
 20 |     /** @var  string
 21 |      * {@see RecordingMode}
 22 |      */
 23 |     private $recordingMode;
 24 |     /** @var  string
 25 |      * {@see OutputMode}
 26 |      */
 27 |     private $defaultOutputMode;
 28 |     /** @var  string
 29 |      * {@see RecordingLayout}
 30 |      */
 31 |     private $defaultRecordingLayout;
 32 | 
 33 |     /** @var  string */
 34 |     private $defaultCustomLayout;
 35 | 
 36 |     /** @var  string */
 37 |     private $customSessionId;
 38 | 
 39 | 
 40 |     /**
 41 |      * SessionProperties constructor.
 42 |      * @param  string  $mediaMode
 43 |      * @param  string  $recordingMode
 44 |      * @param  string  $defaultOutputMode
 45 |      * @param  string|null  $defaultRecordingLayout
 46 |      * @param  string|null  $customSessionId
 47 |      * @param  string|null  $defaultCustomLayout
 48 |      */
 49 |     public function __construct(string $mediaMode, string $recordingMode, string $defaultOutputMode, ?string $defaultRecordingLayout, ?string $customSessionId = null, ?string $defaultCustomLayout = null)
 50 |     {
 51 |         if ($defaultRecordingLayout == RecordingLayout::CUSTOM && empty($defaultCustomLayout)) {
 52 |             throw new InvalidArgumentException("If you pass the value \"CUSTOM\" for the parameter \"$defaultRecordingLayout\" you must indicate a value for the parameter \"$defaultCustomLayout\".");
 53 |         }
 54 |         $this->mediaMode = $mediaMode;
 55 |         $this->recordingMode = $recordingMode;
 56 |         $this->defaultOutputMode = $defaultOutputMode;
 57 |         $this->defaultRecordingLayout = $defaultRecordingLayout;
 58 |         $this->defaultCustomLayout = $defaultCustomLayout;
 59 |         $this->customSessionId = $customSessionId;
 60 |     }
 61 | 
 62 |     /**
 63 |      * @return string
 64 |      */
 65 |     public function getCustomSessionId(): ?string
 66 |     {
 67 |         return $this->customSessionId;
 68 |     }
 69 | 
 70 |     /**
 71 |      * @return string
 72 |      */
 73 |     public function getMediaMode(): string
 74 |     {
 75 |         return $this->mediaMode;
 76 |     }
 77 | 
 78 |     /**
 79 |      * @return string
 80 |      */
 81 |     public function getRecordingMode(): string
 82 |     {
 83 |         return $this->recordingMode;
 84 |     }
 85 | 
 86 |     /**
 87 |      * @return string
 88 |      */
 89 |     public function getDefaultOutputMode(): string
 90 |     {
 91 |         return $this->defaultOutputMode;
 92 |     }
 93 | 
 94 |     /**
 95 |      * @return string
 96 |      */
 97 |     public function getDefaultRecordingLayout(): ?string
 98 |     {
 99 |         return $this->defaultRecordingLayout;
100 |     }
101 | 
102 |     /**
103 |      * @return string
104 |      */
105 |     public function getDefaultCustomLayout(): ?string
106 |     {
107 |         return $this->defaultCustomLayout;
108 |     }
109 | 
110 |     /**
111 |      * Convert the model instance to JSON.
112 |      *
113 |      * @param  int  $options
114 |      * @return string
115 |      *
116 |      */
117 |     public function toJson($options = 0): string
118 |     {
119 |         $json = json_encode($this->jsonSerialize(), $options);
120 |         return $json;
121 |     }
122 | 
123 |     /**
124 |      * Specify data which should be serialized to JSON
125 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
126 |      * @return mixed data which can be serialized by <b>json_encode</b>,
127 |      * which is a value of any type other than a resource.
128 |      * @since 5.4.0
129 |      */
130 |     public function jsonSerialize()
131 |     {
132 |         return $this->toArray();
133 |     }
134 | 
135 |     /**
136 |      * Convert the model instance to an array.
137 |      *
138 |      * @return array
139 |      */
140 |     public function toArray(): array
141 |     {
142 |         $array = [
143 |             'mediaMode' => $this->mediaMode,
144 |             'recordingMode' => $this->recordingMode,
145 |             'defaultOutputMode' => $this->defaultOutputMode,
146 |             'defaultRecordingLayout' => $this->defaultRecordingLayout,
147 |             'defaultCustomLayout' => $this->defaultCustomLayout,
148 |             'customSessionId' => $this->customSessionId
149 |         ];
150 |         foreach ($array as $key => $value) {
151 |             if (is_null($value) || $value == '') {
152 |                 unset($array[$key]);
153 |             }
154 |         }
155 |         return $array;
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/src/Recording.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use JsonSerializable;
  6 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
  7 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
  8 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingStatus;
  9 | 
 10 | /**
 11 |  * Class Recording
 12 |  * @package SquareetLabs\LaravelOpenVidu
 13 |  */
 14 | class Recording implements JsonSerializable
 15 | {
 16 | 
 17 |     /** @var  string */
 18 |     private $id;
 19 | 
 20 |     /** @var  string */
 21 |     private $sessionId;
 22 | 
 23 |     /** @var int */
 24 |     private $createdAt;
 25 | 
 26 |     /** @var int */
 27 |     private $size = 0;
 28 | 
 29 |     /** @var float */
 30 |     private $duration;
 31 | 
 32 |     /** @var string */
 33 |     private $url;
 34 | 
 35 |     /** @var RecordingStatus */
 36 |     private $status;
 37 | 
 38 | 
 39 |     /** @var RecordingProperties */
 40 |     private $recordingProperties;
 41 | 
 42 |     /**
 43 |      * Session constructor.
 44 |      * @param  string  $id
 45 |      * @param  string  $sessionId
 46 |      * @param  int  $createdAt
 47 |      * @param  int  $size
 48 |      * @param  float|null  $duration
 49 |      * @param  string|null  $url
 50 |      * @param  RecordingProperties|null  $recordingProperties
 51 |      */
 52 |     public function __construct(string $id, string $sessionId, int $createdAt, int $size, ?float $duration, ?string $url, ?RecordingProperties $recordingProperties = null)
 53 |     {
 54 |         $this->id = $id;
 55 |         $this->sessionId = $sessionId;
 56 |         $this->createdAt = $createdAt;
 57 |         $this->size = $size;
 58 |         $this->duration = $duration;
 59 |         $this->url = $url;
 60 |         $this->recordingProperties = $recordingProperties ? $recordingProperties : $this->getDefaultRecordingProperties();
 61 | 
 62 |     }
 63 | 
 64 |     /**
 65 |      * @return RecordingProperties
 66 |      */
 67 |     private function getDefaultRecordingProperties(): RecordingProperties
 68 |     {
 69 |         return new RecordingProperties($this->sessionId, $this->sessionId, OutputMode::COMPOSED, RecordingLayout::BEST_FIT);
 70 |     }
 71 | 
 72 |     /**
 73 |      * Session associated to the recording
 74 |      * @return string
 75 |      */
 76 |     public function getSessionId(): string
 77 |     {
 78 |         return $this->sessionId;
 79 |     }
 80 | 
 81 |     /**
 82 |      * Time when the recording started in UTC milliseconds
 83 |      * @return int
 84 |      */
 85 |     public function getCreatedAt(): int
 86 |     {
 87 |         return $this->createdAt;
 88 |     }
 89 | 
 90 |     /**
 91 |      * Size of the recording in bytes (0 until the recording is stopped)
 92 |      * @return int
 93 |      */
 94 |     public function getSize(): int
 95 |     {
 96 |         return $this->size;
 97 |     }
 98 | 
 99 |     /**
100 |      * Duration of the recording in seconds (0 until the recording is stopped)
101 |      * @return float
102 |      */
103 |     public function getDuration(): float
104 |     {
105 |         return $this->duration;
106 |     }
107 | 
108 |     /**
109 |      * URL of the recording. You can access the file from there. It is
110 |      * <code>null</code> until recording reaches "ready" or "failed" status. If
111 |      * <a href="https://openvidu.io/docs/reference-docs/openvidu-server-params/"
112 |      * target="_blank">OpenVidu Server configuration</a> property
113 |      * <code>openvidu.recording.public-access</code> is false, this path will be
114 |      * secured with OpenVidu credentials
115 |      */
116 |     public function getUrl(): string
117 |     {
118 |         return $this->url;
119 |     }
120 | 
121 |     /**
122 |      * Status of the recording
123 |      * @return RecordingStatus
124 |      */
125 |     public function getStatus()
126 |     {
127 |         return $this->status;
128 |     }
129 | 
130 | 
131 |     /**
132 |      * Technical properties of the recorded file
133 |      * @return RecordingProperties
134 |      */
135 |     public function getRecordingProperties(): RecordingProperties
136 |     {
137 |         return $this->recordingProperties;
138 |     }
139 | 
140 |     /**
141 |      * @return string
142 |      */
143 |     public function __toString(): string
144 |     {
145 |         return $this->getId();
146 |     }
147 | 
148 |     /**
149 |      * Recording unique identifier
150 |      * @return string
151 |      */
152 |     public function getId(): string
153 |     {
154 |         return $this->id;
155 |     }
156 | 
157 |     /**
158 |      * Convert the model instance to JSON.
159 |      *
160 |      * @param  int  $options
161 |      * @return string
162 |      *
163 |      */
164 |     public function toJson($options = 0): string
165 |     {
166 |         $json = json_encode($this->jsonSerialize(), $options);
167 |         return $json;
168 |     }
169 | 
170 |     /**
171 |      * Specify data which should be serialized to JSON
172 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
173 |      * @return mixed data which can be serialized by <b>json_encode</b>,
174 |      * which is a value of any type other than a resource.
175 |      * @since 5.4.0
176 |      */
177 |     public function jsonSerialize()
178 |     {
179 |         return $this->toArray();
180 |     }
181 | 
182 |     /**
183 |      * Convert the model instance to an array.
184 |      *
185 |      * @return array
186 |      */
187 |     public function toArray(): array
188 |     {
189 |         $array = ['id' => $this->id, 'sessionId' => $this->sessionId, 'size' => $this->size, 'status' => $this->status, 'duration' => $this->duration, 'resolution' => $this->getResolution(), 'hasAudio' => $this->hasAudio(), 'hasVideo' => $this->hasVideo(), 'url' => $this->url, 'createdAt' => $this->createdAt];
190 |         foreach ($array as $key => $value) {
191 |             if (is_null($value) || $value == '') {
192 |                 unset($array[$key]);
193 |             }
194 |         }
195 |         return $array;
196 |     }
197 | 
198 |     /**
199 |      * Resolution of the video file. Only defined if OutputMode of the Recording is
200 |      * set to {@see OutputMode::COMPOSED}
201 |      */
202 |     public function getResolution(): string
203 |     {
204 |         return $this->recordingProperties->resolution();
205 |     }
206 | 
207 |     /**
208 |      * <code>true</code> if the recording has an audio track, <code>false</code>
209 |      * otherwise (currently fixed to true)
210 |      */
211 |     public function hasAudio(): bool
212 |     {
213 |         return $this->recordingProperties->hasAudio();
214 |     }
215 | 
216 |     /**
217 |      * <code>true</code> if the recording has a video track, <code>false</code>
218 |      * otherwise (currently fixed to true)
219 |      */
220 |     public function hasVideo(): bool
221 |     {
222 |         return $this->recordingProperties->hasVideo();
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------
/src/RecordingProperties.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use JsonSerializable;
  6 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
  7 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
  8 | 
  9 | /**
 10 |  * Class RecordingProperties
 11 |  * @package SquareetLabs\LaravelOpenVidu
 12 |  */
 13 | class RecordingProperties implements JsonSerializable
 14 | {
 15 |     /** @var  string */
 16 |     private $session;
 17 |     /** @var  string */
 18 |     private $customLayout;
 19 |     /** @var  bool */
 20 |     private $hasAudio;
 21 |     /** @var  bool */
 22 |     private $hasVideo;
 23 |     /** @var  string */
 24 |     private $name;
 25 |     /** @var  string */
 26 |     private $outputMode;
 27 |     /** @var  string */
 28 |     private $recordingLayout;
 29 |     /** @var  string */
 30 |     private $resolution;
 31 | 
 32 |     /**
 33 |      * RecordingProperties constructor.
 34 |      * @param  string  $session
 35 |      * @param  string  $name
 36 |      * @param  string  $outputMode
 37 |      * @param  string  $recordingLayout
 38 |      * @param  string|null  $resolution
 39 |      * @param  bool  $hasAudio
 40 |      * @param  bool  $hasVideo
 41 |      * @param  string|null  $customLayout
 42 |      */
 43 |     public function __construct(string $session, string $name, string $outputMode, string $recordingLayout, ?string $resolution = null, ?bool $hasAudio = true, ?bool $hasVideo = true, ?string $customLayout = null)
 44 |     {
 45 |         $this->session = $session;
 46 |         $this->hasAudio = $hasAudio;
 47 |         $this->hasVideo = $hasVideo;
 48 |         $this->name = $name;
 49 |         $this->outputMode = $outputMode;
 50 |         if ($this->outputMode === OutputMode::COMPOSED && $this->hasVideo) {
 51 |             $this->resolution = $resolution ? $resolution : '1920x1080';
 52 |             $this->recordingLayout = $recordingLayout ? $recordingLayout : RecordingLayout::BEST_FIT;
 53 | 
 54 |             if ($this->recordingLayout === RecordingLayout::CUSTOM) {
 55 |                 $this->customLayout = $customLayout;
 56 |             }
 57 |         }
 58 |     }
 59 | 
 60 |     /**
 61 |      * Session name of the recording
 62 |      *
 63 |      * @return string
 64 |      */
 65 |     public function session()
 66 |     {
 67 |         return $this->session;
 68 |     }
 69 | 
 70 |     /**
 71 |      * Defines the name you want to give to the video file. You can access this same
 72 |      * value in your clients on recording events (<code>recordingStarted</code>,
 73 |      * <code>recordingStopped</code>)
 74 |      *
 75 |      * @return string
 76 |      */
 77 |     public function name()
 78 |     {
 79 |         return $this->name;
 80 |     }
 81 | 
 82 |     /**
 83 |      * Defines the mode of recording: {@see OutputMode::COMPOSED} or {@see OutputMode::COMPOSED_QUICK_START} for a
 84 |      * single archive in a grid layout or {@@see OutputMode::INDIVIDUAL}
 85 |      * for one archive for each stream.<br>
 86 |      * <br>
 87 |      *
 88 |      * Default to {@see OutputMode::COMPOSED}
 89 |      *
 90 |      * @return OutputMode|string
 91 |      */
 92 |     public function outputMode()
 93 |     {
 94 |         return $this->outputMode;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Defines the layout to be used in the recording.<br>
 99 |      * Will only have effect if has been cealled with value {@see OutputMode::COMPOSED} or {@see OutputMode::COMPOSED_QUICK_START}.<br>
100 |      * <br>
101 |      *
102 |      * Default to {@see RecordingLayout#BEST_FIT}
103 |      *
104 |      * @return RecordingLayout|string
105 |      */
106 |     public function recordingLayout()
107 |     {
108 |         return $this->recordingLayout;
109 |     }
110 | 
111 |     /**
112 |      * If {@see RecordingProperties::$recordingLayout} is
113 |      * set to {@see RecordingLayout::CUSTOM}, this property
114 |      * defines the relative path to the specific custom layout you want to use.<br>
115 |      * See <a href="https://openvidu.io/docs/advanced-features/recording#custom-recording-layouts" target="_blank">Custom recording layouts</a> to learn more
116 |      *
117 |      * @return string|null
118 |      */
119 |     public function customLayout()
120 |     {
121 |         return $this->customLayout;
122 |     }
123 | 
124 |     /**
125 |      * Defines the resolution of the recorded video.<br>
126 |      * Will only have effect if has been called with value
127 |      * {@see  outputMode::COMPOSED}.
128 |      * {@see  OutputMode::COMPOSED_QUICK_START}
129 |      * {@see  OutputMode::INDIVIDUAL}
130 |      * <br>
131 |      *
132 |      * Default to "1920x1080"
133 |      * @return string
134 |      */
135 |     public function resolution(): string
136 |     {
137 |         return $this->resolution;
138 |     }
139 | 
140 |     /**
141 |      * Defines whether to record audio or not. Cannot be set to false at the same
142 |      * time as {@see hasVideo()}.<br>
143 |      * <br>
144 |      *
145 |      * Default to true
146 |      *
147 |      * @return bool
148 |      */
149 |     public function hasAudio()
150 |     {
151 |         return $this->hasAudio;
152 |     }
153 | 
154 |     /**
155 |      * Defines whether to record video or not. Cannot be set to false at the same
156 |      * time as {@see hasAudio()}.<br>
157 |      * <br>
158 |      *
159 |      * Default to true
160 |      *
161 |      * @return bool
162 |      */
163 |     public function hasVideo()
164 |     {
165 |         return $this->hasVideo;
166 |     }
167 | 
168 |     /**
169 |      * Convert the model instance to JSON.
170 |      *
171 |      * @param  int  $options
172 |      * @return string
173 |      *
174 |      */
175 |     public function toJson($options = 0): string
176 |     {
177 |         return json_encode($this->jsonSerialize(), $options);
178 |     }
179 | 
180 |     /**
181 |      * Specify data which should be serialized to JSON
182 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
183 |      * @return mixed data which can be serialized by <b>json_encode</b>,
184 |      * which is a value of any type other than a resource.
185 |      * @since 5.4.0
186 |      */
187 |     public function jsonSerialize()
188 |     {
189 |         return $this->toArray();
190 |     }
191 | 
192 |     /**
193 |      * Convert the model instance to an array.
194 |      *
195 |      * @return array
196 |      */
197 |     public function toArray(): array
198 |     {
199 |         $array = [
200 |             'session' => $this->session,
201 |             'hasAudio' => $this->hasAudio,
202 |             'hasVideo' => $this->hasVideo,
203 |             'name' => $this->name,
204 |             'outputMode' => $this->outputMode,
205 |             'recordingLayout' => $this->recordingLayout,
206 |             'resolution' => $this->resolution,
207 |             'customLayout' => $this->customLayout
208 |         ];
209 |         foreach ($array as $key => $value) {
210 |             if (is_null($value) || $value == '') {
211 |                 unset($array[$key]);
212 |             }
213 |         }
214 |         return $array;
215 |     }
216 | }
217 | 


--------------------------------------------------------------------------------
/src/Publisher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use JsonSerializable;
  6 | 
  7 | /**
  8 |  * Class Publisher
  9 |  * @package SquareetLabs\LaravelOpenVidu
 10 |  * This is a backend representation of a published media stream (see [OpenVidu Browser Stream class](/api/openvidu-browser/classes/stream.html)
 11 |  * {@see Connection::getPublishers()}
 12 |  */
 13 | class Publisher implements JsonSerializable
 14 | {
 15 | 
 16 |     /** @var  string
 17 |      * Unique identifier of the Stream {@link https://api/openvidu-browser/classes/stream.html} associated to this Publisher.
 18 |      * Each Publisher is paired with only one Stream, so you can identify each Publisher by its
 19 |      * Stream.streamId {@link https://api/openvidu-browser/classes/stream.html#streamid}
 20 |      */
 21 |     private $streamId;
 22 | 
 23 |     /** @var int
 24 |      * Timestamp when this connection was established, in UTC milliseconds (ms since Jan 1, 1970, 00:00:00 UTC)
 25 |      */
 26 |     private $createdAt;
 27 | 
 28 | 
 29 |     /** @var bool
 30 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html} object in OpenVidu Browser library to find out more
 31 |      */
 32 |     private $hasAudio;
 33 | 
 34 | 
 35 |     /** @var  bool
 36 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html}object in OpenVidu Browser library to find out more
 37 |      */
 38 |     private $hasVideo;
 39 | 
 40 | 
 41 |     /** @var  bool
 42 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html} object in OpenVidu Browser library to find out more
 43 |      */
 44 |     private $audioActive;
 45 | 
 46 | 
 47 |     /** @var  bool
 48 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html} object in OpenVidu Browser library to find out more
 49 |      */
 50 |     private $videoActive;
 51 | 
 52 | 
 53 |     /**
 54 |      * @var int
 55 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html} object in OpenVidu Browser library to find out more
 56 |      */
 57 |     private $frameRate;
 58 | 
 59 | 
 60 |     /**
 61 |      * @var string
 62 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html} object in OpenVidu Browser library to find out more
 63 |      */
 64 |     private $typeOfVideo;
 65 | 
 66 | 
 67 |     /**
 68 |      * var string
 69 |      * See properties of Stream {@link https://api/openvidu-browser/classes/stream.html} object in OpenVidu Browser library to find out more
 70 |      */
 71 |     private $videoDimensions;
 72 | 
 73 | 
 74 |     /**
 75 |      * Publisher constructor.
 76 |      * @param  string  $streamId
 77 |      * @param  int  $createdAt
 78 |      * @param  bool  $hasAudio
 79 |      * @param  bool  $hasVideo
 80 |      * @param  bool  $audioActive
 81 |      * @param  bool  $videoActive
 82 |      * @param  int  $frameRate
 83 |      * @param  string  $typeOfVideo
 84 |      * @param  string  $videoDimensions
 85 |      */
 86 |     public function __construct(string $streamId, int $createdAt, bool $hasAudio, bool $hasVideo, bool $audioActive, bool $videoActive, int $frameRate, string $typeOfVideo, string $videoDimensions)
 87 |     {
 88 |         $this->streamId = $streamId;
 89 |         $this->createdAt = $createdAt;
 90 |         $this->hasAudio = $hasAudio;
 91 |         $this->hasVideo = $hasVideo;
 92 |         $this->audioActive = $audioActive;
 93 |         $this->videoActive = $videoActive;
 94 |         $this->frameRate = $frameRate;
 95 |         $this->typeOfVideo = $typeOfVideo;
 96 |         $this->videoDimensions = $videoDimensions;
 97 | 
 98 |     }
 99 | 
100 |     public function __toString(): string
101 |     {
102 |         return $this->getStreamId();
103 |     }
104 | 
105 |     /**
106 |      * @return string
107 |      */
108 |     public function getStreamId(): string
109 |     {
110 |         return $this->streamId;
111 |     }
112 | 
113 |     /**
114 |      * Convert the model instance to JSON.
115 |      *
116 |      * @param  int  $options
117 |      * @return string
118 |      *
119 |      */
120 |     public function toJson($options = 0): string
121 |     {
122 |         return json_encode($this->jsonSerialize(), $options);
123 |     }
124 | 
125 |     /**
126 |      * Specify data which should be serialized to JSON
127 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
128 |      * @return mixed data which can be serialized by <b>json_encode</b>,
129 |      * which is a value of any type other than a resource.
130 |      * @since 5.4.0
131 |      */
132 |     public function jsonSerialize()
133 |     {
134 |         return $this->toArray();
135 |     }
136 | 
137 |     /**
138 |      * Convert the model instance to an array.
139 |      *
140 |      * @return array
141 |      */
142 |     public function toArray(): array
143 |     {
144 |         $array = [
145 |             'streamId' => $this->streamId,
146 |             'createdAt' => $this->createdAt,
147 |             'hasAudio' => $this->hasAudio,
148 |             'hasVideo' => $this->hasVideo,
149 |             'audioActive' => $this->audioActive,
150 |             'videoActive' => $this->videoActive,
151 |             'frameRate' => $this->frameRate,
152 |             'typeOfVideo' => $this->typeOfVideo,
153 |             'videoDimensions' => $this->videoDimensions
154 |         ];
155 |         foreach ($array as $key => $value) {
156 |             if (is_null($value) || $value == '') {
157 |                 unset($array[$key]);
158 |             }
159 |         }
160 |         return $array;
161 |     }
162 | 
163 |     /**
164 |      * @param  Publisher  $other
165 |      * @return bool
166 |      */
167 |     public function equalTo(Publisher $other): bool
168 |     {
169 |         return (
170 |             $this->streamId === $other->getStreamId() &&
171 |             $this->createdAt === $other->getCreatedAt() &&
172 |             $this->hasAudio === $other->hasAudio() &&
173 |             $this->hasVideo === $other->hasVideo() &&
174 |             $this->audioActive === $other->isAudioActive() &&
175 |             $this->videoActive === $other->isVideoActive() &&
176 |             $this->frameRate === $other->getFrameRate() &&
177 |             $this->typeOfVideo === $other->getTypeOfVideo() &&
178 |             $this->videoDimensions === $other->getVideoDimensions()
179 |         );
180 |     }
181 | 
182 |     /**
183 |      * @return int
184 |      */
185 |     public function getCreatedAt(): int
186 |     {
187 |         return $this->createdAt;
188 |     }
189 | 
190 |     /**
191 |      * @return bool
192 |      */
193 |     public function hasAudio(): bool
194 |     {
195 |         return $this->hasAudio;
196 |     }
197 | 
198 |     /**
199 |      * @return bool
200 |      */
201 |     public function hasVideo(): bool
202 |     {
203 |         return $this->hasVideo;
204 |     }
205 | 
206 |     /**
207 |      * @return bool
208 |      */
209 |     public function isAudioActive(): bool
210 |     {
211 |         return $this->audioActive;
212 |     }
213 | 
214 |     /**
215 |      * @return bool
216 |      */
217 |     public function isVideoActive(): bool
218 |     {
219 |         return $this->videoActive;
220 |     }
221 | 
222 |     /**
223 |      * @return int
224 |      */
225 |     public function getFrameRate(): int
226 |     {
227 |         return $this->frameRate;
228 |     }
229 | 
230 |     /**
231 |      * @return string
232 |      */
233 |     public function getTypeOfVideo(): string
234 |     {
235 |         return $this->typeOfVideo;
236 |     }
237 | 
238 |     /**
239 |      * @return string
240 |      */
241 |     public function getVideoDimensions(): string
242 |     {
243 |         return $this->videoDimensions;
244 |     }
245 | }
246 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/OpenViduController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu\Http\Controllers;
  4 | 
  5 | use Illuminate\Routing\Controller;
  6 | use Illuminate\Support\Facades\Response;
  7 | use SquareetLabs\LaravelOpenVidu\Builders\PublishStreamBuilder;
  8 | use SquareetLabs\LaravelOpenVidu\Builders\RecordingPropertiesBuilder;
  9 | use SquareetLabs\LaravelOpenVidu\Builders\SessionPropertiesBuilder;
 10 | use SquareetLabs\LaravelOpenVidu\Builders\SignalPropertiesBuilder;
 11 | use SquareetLabs\LaravelOpenVidu\Builders\TokenOptionsBuilder;
 12 | use SquareetLabs\LaravelOpenVidu\Dispatchers\WebhookEventDispatcher;
 13 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduConnectionNotFoundException;
 14 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduException;
 15 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduInvalidArgumentException;
 16 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduSessionNotFoundException;
 17 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduStreamTypeInvalidException;
 18 | use SquareetLabs\LaravelOpenVidu\Facades\OpenVidu;
 19 | use SquareetLabs\LaravelOpenVidu\Http\Requests\GenerateTokenRequest;
 20 | use SquareetLabs\LaravelOpenVidu\Http\Requests\PublishStreamRequest;
 21 | use SquareetLabs\LaravelOpenVidu\Http\Requests\SignalRequest;
 22 | use SquareetLabs\LaravelOpenVidu\Http\Requests\StartRecordingRequest;
 23 | use SquareetLabs\LaravelOpenVidu\Http\Requests\WebhookEventRequest;
 24 | 
 25 | /**
 26 |  * Class SmsUpReportController
 27 |  * @package SquareetLabs\LaravelOpenVidu\Http\Controllers
 28 |  */
 29 | class OpenViduController extends Controller
 30 | {
 31 |     /**
 32 |      * @param  GenerateTokenRequest  $request
 33 |      * @return string
 34 |      * @throws OpenViduException
 35 |      */
 36 |     public function token(GenerateTokenRequest $request)
 37 |     {
 38 |         $session = OpenVidu::createSession(SessionPropertiesBuilder::build($request->get('session')));
 39 |         $token = $session->generateToken(TokenOptionsBuilder::build($request->get('tokenOptions')));
 40 |         return Response::json(['token' => $token], 200);
 41 |     }
 42 | 
 43 |     /**
 44 |      * @param  string  $sessionId
 45 |      * @return string
 46 |      */
 47 |     public function session(string $sessionId)
 48 |     {
 49 |         $session = OpenVidu::getSession($sessionId);
 50 |         return Response::json(['session' => $session], 200);
 51 |     }
 52 | 
 53 |     /**
 54 |      * @return string
 55 |      */
 56 |     public function sessions()
 57 |     {
 58 |         $sessions = OpenVidu::getActiveSessions();
 59 |         return Response::json(['sessions' => $sessions], 200);
 60 |     }
 61 | 
 62 |     /**
 63 |      * @param  string  $sessionId
 64 |      * @return string
 65 |      */
 66 |     public function connections(string $sessionId)
 67 |     {
 68 |         $session = OpenVidu::getSession($sessionId);
 69 |         $connections = $session->getActiveConnections();
 70 |         return Response::json(['connections' => $connections], 200);
 71 |     }
 72 | 
 73 |     /**
 74 |      * @param  string  $sessionId
 75 |      * @return string
 76 |      * @throws OpenViduException
 77 |      */
 78 |     public function close(string $sessionId)
 79 |     {
 80 |         $session = OpenVidu::getSession($sessionId);
 81 |         $closed = $session->close();
 82 |         return Response::json(['closed' => $closed], 200);
 83 |     }
 84 | 
 85 | 
 86 |     /**
 87 |      * @param  string  $sessionId
 88 |      * @return string
 89 |      */
 90 |     public function fetch(string $sessionId)
 91 |     {
 92 |         $session = OpenVidu::getSession($sessionId);
 93 |         $hasChanges = $session->fetch();
 94 |         return Response::json(['session' => $session, 'hasChanges' => $hasChanges], 200);
 95 |     }
 96 | 
 97 | 
 98 |     /**
 99 |      * @param  string  $sessionId
100 |      * @return string
101 |      */
102 |     public function isBeingRecording(string $sessionId)
103 |     {
104 |         $session = OpenVidu::getSession($sessionId);
105 |         $isBeingRecording = $session->isBeingRecorded();
106 |         return Response::json(['isBeingRecording' => $isBeingRecording], 200);
107 |     }
108 | 
109 | 
110 |     /**
111 |      * @param  string  $sessionId
112 |      * @param  PublishStreamRequest  $request
113 |      * @return string
114 |      * @throws OpenViduException
115 |      * @throws OpenViduSessionNotFoundException
116 |      * @throws OpenViduStreamTypeInvalidException
117 |      */
118 |     public function publish(string $sessionId, PublishStreamRequest $request)
119 |     {
120 |         $session = OpenVidu::getSession($sessionId);
121 |         $connection = $session->publish(PublishStreamBuilder::build($request->all()));
122 |         return Response::json(['connection' => $connection], 200);
123 |     }
124 | 
125 | 
126 |     /**
127 |      * @param  string  $sessionId
128 |      * @param  string  $streamId
129 |      * @return string
130 |      * @throws OpenViduConnectionNotFoundException
131 |      * @throws OpenViduException
132 |      * @throws OpenViduSessionNotFoundException
133 |      */
134 |     public function forceUnpublish(string $sessionId, string $streamId)
135 |     {
136 |         $session = OpenVidu::getSession($sessionId);
137 |         $session->forceUnpublish($streamId);
138 |         return Response::json(['unpublished' => true], 200);
139 |     }
140 | 
141 |     /**
142 |      * @param  string  $sessionId
143 |      * @param  string  $connectionId
144 |      * @return string
145 |      * @throws OpenViduException
146 |      */
147 |     public function forceDisconnect(string $sessionId, string $connectionId)
148 |     {
149 |         $session = OpenVidu::getSession($sessionId);
150 |         $session->forceDisconnect($connectionId);
151 |         return Response::json(['disconnected' => true], 200);
152 |     }
153 | 
154 | 
155 |     /**
156 |      * @param  StartRecordingRequest  $request
157 |      * @return string
158 |      * @throws OpenViduInvalidArgumentException
159 |      */
160 |     public function startRecording(StartRecordingRequest $request)
161 |     {
162 |         $recording = OpenVidu::startRecording(RecordingPropertiesBuilder::build($request->all()));
163 |         return Response::json(['recording' => $recording], 200);
164 |     }
165 | 
166 | 
167 |     /**
168 |      * @param  string  $recordingId
169 |      * @return string
170 |      */
171 |     public function stopRecording(string $recordingId)
172 |     {
173 |         $recording = OpenVidu::stopRecording($recordingId);
174 |         return Response::json(['recording' => $recording], 200);
175 |     }
176 | 
177 |     /**
178 |      * @param  string  $recordingId
179 |      * @return string
180 |      */
181 |     public function recording(string $recordingId)
182 |     {
183 |         $recording = OpenVidu::getRecording($recordingId);
184 |         return Response::json(['recording' => $recording], 200);
185 |     }
186 | 
187 | 
188 |     /**
189 |      * @param  string  $recordingId
190 |      * @return string
191 |      */
192 |     public function deleteRecording(string $recordingId)
193 |     {
194 |         $recording = OpenVidu::deleteRecording($recordingId);
195 |         return Response::json(['recording' => $recording], 200);
196 |     }
197 | 
198 |     /**
199 |      * @param  SignalRequest  $request
200 |      * @return string
201 |      * @throws OpenViduInvalidArgumentException
202 |      */
203 |     public function signal(SignalRequest $request)
204 |     {
205 |         $sent = OpenVidu::sendSignal(SignalPropertiesBuilder::build($request->all()));
206 |         return Response::json(['sent' => $sent], 200);
207 |     }
208 | 
209 |     /**
210 |      * @param  WebhookEventRequest  $request
211 |      * @return string
212 |      */
213 |     public function webhook(WebhookEventRequest $request)
214 |     {
215 |         WebhookEventDispatcher::dispatch($request->all());
216 |         return Response::json(['success' => true], 200);
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------
/src/Connection.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use JsonSerializable;
  6 | use SquareetLabs\LaravelOpenVidu\Enums\OpenViduRole;
  7 | 
  8 | /**
  9 |  * Class Connection
 10 |  * @package SquareetLabs\LaravelOpenVidu
 11 |  */
 12 | class Connection implements JsonSerializable
 13 | {
 14 | 
 15 |     /** @var  string
 16 |      * Identifier of the connection. You can call [[Session.forceDisconnect]] passing this property as parameter
 17 |      */
 18 |     private $connectionId;
 19 | 
 20 |     /** @var int
 21 |      * Timestamp when this connection was established, in UTC milliseconds (ms since Jan 1, 1970, 00:00:00 UTC)
 22 |      */
 23 |     private $createdAt;
 24 | 
 25 | 
 26 |     /** @var  string
 27 |      * Role of the connection {@see OpenViduRole}
 28 |      */
 29 |     private $role;
 30 | 
 31 | 
 32 |     /** @var string
 33 |      * Token associated to the connection
 34 |      */
 35 |     private $token;
 36 | 
 37 |     /** @var string
 38 |      * <a href="/docs/openvidu-pro/" target="_blank" style="display: inline-block; background-color: rgb(0, 136, 170); color: white; font-weight: bold; padding: 0px 5px; margin-right: 5px; border-radius: 3px; font-size: 13px; line-height:21px; font-family: Montserrat, sans-serif">PRO</a>
 39 |      * Geo location of the connection, with the following format: `"CITY, COUNTRY"` (`"unknown"` if it wasn't possible to locate it)
 40 |      */
 41 |     private $location;
 42 | 
 43 |     /** @var string
 44 |      * A complete description of the platform used by the participant to connect to the session
 45 |      */
 46 |     private $platform;
 47 | 
 48 |     /** @var string
 49 |      * Data associated to the connection on the server-side. This value is set with {@uses TokenOptions::$data} when calling {@see Session::generateToken()}
 50 |      */
 51 |     private $serverData;
 52 | 
 53 |     /** @var string
 54 |      * Data associated to the connection on the client-side. This value is set with second parameter of method
 55 |      * {@method Session.connect}(/api/openvidu-browser/classes/session.html#connect) in OpenVidu Browser
 56 |      */
 57 |     private $clientData;
 58 | 
 59 |     /** @var array
 60 |      * Array of Publisher objects this particular Connection is publishing to the Session (each Publisher object has one Stream, uniquely
 61 |      * identified by its `streamId`). You can call {@uses Session::forceUnpublish} passing any of this values as parameter
 62 |      */
 63 |     private $publishers = [];
 64 | 
 65 |     /** @var array
 66 |      *  Array of streams (their `streamId` properties) this particular Connection is subscribed to. Each one always corresponds to one
 67 |      * Publisher of some other Connection: each string of this array must be equal to one [[Publisher.streamId]] of other Connection
 68 |      */
 69 |     private $subscribers = [];
 70 | 
 71 |     /**
 72 |      * Connection constructor.
 73 |      * @param  string  $connectionId
 74 |      * @param  int  $createdAt
 75 |      * @param  string  $role
 76 |      * @param  string  $token
 77 |      * @param  string  $location
 78 |      * @param  string  $platform
 79 |      * @param  string  $serverData
 80 |      * @param  string  $clientData
 81 |      * @param  array  $publishers
 82 |      * @param  array  $subscribers
 83 |      */
 84 |     public function __construct(string $connectionId, int $createdAt, string $role, string $token, string $location, string $platform, string $serverData, string $clientData, array $publishers, array $subscribers)
 85 |     {
 86 |         $this->connectionId = $connectionId;
 87 |         $this->createdAt = $createdAt;
 88 |         $this->role = $role;
 89 |         $this->token = $token;
 90 |         $this->location = $location;
 91 |         $this->platform = $platform;
 92 |         $this->serverData = $serverData;
 93 |         $this->clientData = $clientData;
 94 |         $this->publishers = $publishers;
 95 |         $this->subscribers = $subscribers;
 96 | 
 97 |     }
 98 | 
 99 |     /**
100 |      * @return string
101 |      */
102 |     public function getClientData(): string
103 |     {
104 |         return $this->clientData;
105 |     }
106 | 
107 |     public function __toString(): string
108 |     {
109 |         return $this->getConnectionId();
110 |     }
111 | 
112 |     /**
113 |      * @return string
114 |      */
115 |     public function getConnectionId(): string
116 |     {
117 |         return $this->connectionId;
118 |     }
119 | 
120 |     /**
121 |      * Remove publishers based on streamId
122 |      * @param  string  $streamId
123 |      */
124 |     public function unpublish(string $streamId)
125 |     {
126 |         $this->publishers = array_filter($this->publishers, function (Publisher $publisher) use ($streamId) {
127 |             return $streamId !== $publisher->getStreamId();
128 |         });
129 |     }
130 | 
131 |     /**
132 |      * Remove subscribers  based on publisher streamId
133 |      * @param  string  $streamId
134 |      */
135 |     public function unsubscribe(string $streamId)
136 |     {
137 |         if (!empty($this->subscribers)) {
138 |             $this->subscribers = array_filter($this->subscribers, function (Subscriber $subscriber) use ($streamId) {
139 |                 return $subscriber->getPublisherStreamId() !== $streamId;
140 |             });
141 |         }
142 |     }
143 | 
144 |     /**
145 |      * Convert the model instance to JSON.
146 |      *
147 |      * @param  int  $options
148 |      * @return string
149 |      *
150 |      */
151 |     public function toJson($options = 0): string
152 |     {
153 |         $json = json_encode($this->jsonSerialize(), $options);
154 |         return $json;
155 |     }
156 | 
157 |     /**
158 |      * Specify data which should be serialized to JSON
159 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
160 |      * @return mixed data which can be serialized by <b>json_encode</b>,
161 |      * which is a value of any type other than a resource.
162 |      * @since 5.4.0
163 |      */
164 |     public function jsonSerialize()
165 |     {
166 |         return $this->toArray();
167 |     }
168 | 
169 |     /**
170 |      * Convert the model instance to an array.
171 |      *
172 |      * @return array
173 |      */
174 |     public function toArray(): array
175 |     {
176 |         $array = [
177 |             'connectionId' => $this->connectionId,
178 |             'createdAt' => $this->createdAt,
179 |             'role' => $this->role,
180 |             'token' => $this->token,
181 |             'location' => $this->location,
182 |             'platform' => $this->platform,
183 |             'serverData' => $this->serverData,
184 |             'clientData' => $this->clientData,
185 |             'subscribers' => $this->subscribers
186 |         ];
187 |         foreach ($this->publishers as $publisher) {
188 |             $array['publishers'][] = $publisher->toArray();
189 |         }
190 | 
191 | 
192 |         foreach ($array as $key => $value) {
193 |             if (is_null($value) || $value == '') {
194 |                 unset($array[$key]);
195 |             }
196 |         }
197 |         return $array;
198 |     }
199 | 
200 |     /**
201 |      * @param  string  $json
202 |      * @return Connection
203 |      */
204 |     public function fromJson(string $json): Connection
205 |     {
206 |         return $this->fromArray(json_decode($json, true));
207 |     }
208 | 
209 |     /**
210 |      * @param  array  $connectionArray
211 |      * @return Connection
212 |      */
213 |     public function fromArray(array $connectionArray): Connection
214 |     {
215 |         $this->connectionId = $connectionArray['connectionId'];
216 |         $this->createdAt = $connectionArray['createdAt'] ?? null;
217 |         $this->role = $connectionArray['role'] ?? null;
218 |         $this->token = $connectionArray['token'] ?? null;
219 |         $this->location = $connectionArray['location'] ?? null;
220 |         $this->platform = $connectionArray['platform'] ?? null;
221 |         $this->serverData = $connectionArray['serverData'] ?? null;
222 |         $this->clientData = $connectionArray['clientData'] ?? null;
223 | 
224 | 
225 |         if (array_key_exists('subscribers', $connectionArray)) {
226 |             $this->subscribers = $connectionArray['subscribers'];
227 |         }
228 |         return $this;
229 |     }
230 | 
231 |     /**
232 |      * @return int
233 |      */
234 |     public function getCreatedAt(): int
235 |     {
236 |         return $this->createdAt;
237 |     }
238 | 
239 |     /**
240 |      * @return string
241 |      */
242 |     public function getRole(): string
243 |     {
244 |         return $this->role;
245 |     }
246 | 
247 |     /**
248 |      * @return string
249 |      */
250 |     public function getToken(): string
251 |     {
252 |         return $this->token;
253 |     }
254 | 
255 |     /**
256 |      * @return string
257 |      */
258 |     public function getLocation(): string
259 |     {
260 |         return $this->location;
261 |     }
262 | 
263 |     /**
264 |      * @return string
265 |      */
266 |     public function getPlatform(): string
267 |     {
268 |         return $this->platform;
269 |     }
270 | 
271 |     /**
272 |      * @return string
273 |      */
274 |     public function getServerData(): string
275 |     {
276 |         return $this->serverData;
277 |     }
278 | 
279 |     /**
280 |      * @return array
281 |      */
282 |     public function getSubscribers(): array
283 |     {
284 |         return $this->subscribers;
285 |     }
286 | 
287 |     /**
288 |      * @return array
289 |      */
290 |     public function getPublishers(): array
291 |     {
292 |         return $this->publishers;
293 |     }
294 | }
295 | 


--------------------------------------------------------------------------------
/src/Cache/SessionStore.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu\Cache;
  4 | 
  5 | use Closure;
  6 | use Exception;
  7 | use Illuminate\Cache\RetrievesMultipleKeys;
  8 | use Illuminate\Contracts\Cache\Store;
  9 | use Illuminate\Database\ConnectionInterface;
 10 | use Illuminate\Database\PostgresConnection;
 11 | use Illuminate\Database\Query\Builder;
 12 | use Illuminate\Support\InteractsWithTime;
 13 | use Illuminate\Support\Str;
 14 | use Throwable;
 15 | 
 16 | class SessionStore implements Store
 17 | {
 18 |     use InteractsWithTime, RetrievesMultipleKeys;
 19 | 
 20 |     /**
 21 |      * The database connection instance.
 22 |      *
 23 |      * @var ConnectionInterface
 24 |      */
 25 |     protected $connection;
 26 | 
 27 |     /**
 28 |      * The name of the cache table.
 29 |      *
 30 |      * @var string
 31 |      */
 32 |     protected $table;
 33 | 
 34 |     /**
 35 |      * Create a new database store.
 36 |      *
 37 |      * @param  ConnectionInterface  $connection
 38 |      * @param  string  $table
 39 |      */
 40 |     public function __construct(ConnectionInterface $connection, $table)
 41 |     {
 42 |         $this->table = $table;
 43 |         $this->connection = $connection;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Update an item from the cache by key.
 48 |      *
 49 |      * @param  string  $key
 50 |      * @param $value
 51 |      * @return mixed
 52 |      */
 53 |     public function update($key, $value)
 54 |     {
 55 |         if ($this->table()->where('key', '=', $key)->exists()) {
 56 |             $value = $this->serialize($value);
 57 |             $this->table()->where('key', $key)->update(compact('value'));
 58 |             return $this->get($key);
 59 |         }
 60 |         return;
 61 |     }
 62 | 
 63 |     /**
 64 |      * Get a query builder for the cache table.
 65 |      *
 66 |      * @return Builder
 67 |      */
 68 |     protected function table()
 69 |     {
 70 |         return $this->connection->table($this->table);
 71 |     }
 72 | 
 73 |     /**
 74 |      * Serialize the given value.
 75 |      *
 76 |      * @param  mixed  $value
 77 |      * @return string
 78 |      */
 79 |     protected function serialize($value)
 80 |     {
 81 |         $result = serialize($value);
 82 | 
 83 |         if ($this->connection instanceof PostgresConnection && Str::contains($result, "\0")) {
 84 |             $result = base64_encode($result);
 85 |         }
 86 | 
 87 |         return $result;
 88 |     }
 89 | 
 90 |     /**
 91 |      * Retrieve an item from the cache by key.
 92 |      *
 93 |      * @param  string  $key
 94 |      * @return mixed
 95 |      */
 96 |     public function get($key)
 97 |     {
 98 |         $cache = $this->table()->where('key', '=', $key)->first();
 99 |         // If we have a cache record we will check the expiration time against current
100 |         // time on the system and see if the record has expired. If it has, we will
101 |         // remove the records from the database table so it isn't returned again.
102 |         if (is_null($cache)) {
103 |             return;
104 |         }
105 | 
106 |         $cache = is_array($cache) ? (object) $cache : $cache;
107 | 
108 |         // If this cache expiration date is past the current time, we will remove this
109 |         // item from the cache. Then we will return a null value since the cache is
110 |         // expired. We will use "Carbon" to make this comparison with the column.
111 |         if ($this->currentTime() >= $cache->expiration) {
112 |             $this->forget($key);
113 | 
114 |             return;
115 |         }
116 | 
117 |         return $this->unserialize($cache->value);
118 |     }
119 | 
120 |     /**
121 |      * Remove an item from the cache.
122 |      *
123 |      * @param  string  $key
124 |      * @return bool
125 |      */
126 |     public function forget($key)
127 |     {
128 |         $this->table()->where('key', '=', $key)->delete();
129 | 
130 |         return true;
131 |     }
132 | 
133 |     /**
134 |      * Unserialize the given value.
135 |      *
136 |      * @param  string  $value
137 |      * @return mixed
138 |      */
139 |     protected function unserialize($value)
140 |     {
141 |         if ($this->connection instanceof PostgresConnection && !Str::contains($value, [':', ';'])) {
142 |             $value = base64_decode($value);
143 |         }
144 | 
145 |         return unserialize($value);
146 |     }
147 | 
148 |     /**
149 |      * Retrieve all items from the cache.
150 |      *
151 |      * @return mixed
152 |      */
153 |     public function getAll()
154 |     {
155 | 
156 |         $cache = $this->table()->get();
157 | 
158 |         // If we have a cache record we will check the expiration time against current
159 |         // time on the system and see if the record has expired. If it has, we will
160 |         // remove the records from the database table so it isn't returned again.
161 |         if (is_null($cache)) {
162 |             return;
163 |         }
164 | 
165 |         $cache = is_array($cache) ? (object) $cache : $cache;
166 |         // If this cache expiration date is past the current time, we will remove this
167 |         // item from the cache. Then we will return a null value since the cache is
168 |         // expired. We will use "Carbon" to make this comparison with the column.
169 |         $entries = [];
170 |         foreach ($cache as $entry) {
171 |             if ($this->currentTime() >= $entry->expiration) {
172 |                 $this->forget($entry->key);
173 |             } else {
174 |                 $entries[] = $this->unserialize($entry->value);
175 |             }
176 | 
177 | 
178 |         }
179 |         return $entries;
180 |     }
181 | 
182 |     /**
183 |      * Increment the value of an item in the cache.
184 |      *
185 |      * @param  string  $key
186 |      * @param  mixed  $value
187 |      * @return int|bool
188 |      * @throws Throwable
189 |      */
190 |     public function increment($key, $value = 1)
191 |     {
192 |         return $this->incrementOrDecrement($key, $value, function ($current, $value) {
193 |             return $current + $value;
194 |         });
195 |     }
196 | 
197 |     /**
198 |      * Increment or decrement an item in the cache.
199 |      *
200 |      * @param  string  $key
201 |      * @param  mixed  $value
202 |      * @param  Closure  $callback
203 |      * @return int|bool
204 |      * @throws Throwable
205 |      */
206 |     protected function incrementOrDecrement($key, $value, Closure $callback)
207 |     {
208 |         return $this->connection->transaction(function () use ($key, $value, $callback) {
209 | 
210 | 
211 |             $cache = $this->table()->where('key', $key)
212 |                 ->lockForUpdate()->first();
213 | 
214 |             // If there is no value in the cache, we will return false here. Otherwise the
215 |             // value will be decrypted and we will proceed with this function to either
216 |             // increment or decrement this value based on the given action callbacks.
217 |             if (is_null($cache)) {
218 |                 return false;
219 |             }
220 | 
221 |             $cache = is_array($cache) ? (object) $cache : $cache;
222 | 
223 |             $current = $this->unserialize($cache->value);
224 | 
225 |             // Here we'll call this callback function that was given to the function which
226 |             // is used to either increment or decrement the function. We use a callback
227 |             // so we do not have to recreate all this logic in each of the functions.
228 |             $new = $callback((int) $current, $value);
229 | 
230 |             if (!is_numeric($current)) {
231 |                 return false;
232 |             }
233 | 
234 |             // Here we will update the values in the table. We will also encrypt the value
235 |             // since database cache values are encrypted by default with secure storage
236 |             // that can't be easily read. We will return the new value after storing.
237 |             $this->table()->where('key', $key)->update([
238 |                 'value' => $this->serialize($new),
239 |             ]);
240 | 
241 |             return $new;
242 |         });
243 |     }
244 | 
245 |     /**
246 |      * Decrement the value of an item in the cache.
247 |      *
248 |      * @param  string  $key
249 |      * @param  mixed  $value
250 |      * @return int|bool
251 |      * @throws Throwable
252 |      */
253 |     public function decrement($key, $value = 1)
254 |     {
255 |         return $this->incrementOrDecrement($key, $value, function ($current, $value) {
256 |             return $current - $value;
257 |         });
258 |     }
259 | 
260 |     /**
261 |      * Store an item in the cache indefinitely.
262 |      *
263 |      * @param  string  $key
264 |      * @param  mixed  $value
265 |      * @return bool
266 |      */
267 |     public function forever($key, $value)
268 |     {
269 |         return $this->put($key, $value, 315360000);
270 |     }
271 | 
272 |     /**
273 |      * Store an item in the cache for a given number of seconds.
274 |      *
275 |      * @param  string  $key
276 |      * @param  mixed  $value
277 |      * @param  int  $seconds
278 |      * @return bool
279 |      */
280 |     public function put($key, $value, $seconds)
281 |     {
282 | 
283 |         $value = $this->serialize($value);
284 | 
285 |         $expiration = $this->getTime() + $seconds;
286 | 
287 |         try {
288 |             return $this->table()->insert(compact('key', 'value', 'expiration'));
289 |         } catch (Exception $e) {
290 |             $result = $this->table()->where('key', $key)->update(compact('value', 'expiration'));
291 | 
292 |             return $result > 0;
293 |         }
294 |     }
295 | 
296 |     /**
297 |      * Get the current system time.
298 |      *
299 |      * @return int
300 |      */
301 |     protected function getTime()
302 |     {
303 |         return $this->currentTime();
304 |     }
305 | 
306 |     /**
307 |      * Remove all items from the cache.
308 |      *
309 |      * @return bool
310 |      */
311 |     public function flush()
312 |     {
313 |         $this->table()->delete();
314 | 
315 |         return true;
316 |     }
317 | 
318 |     /**
319 |      * Get the underlying database connection.
320 |      *
321 |      * @return ConnectionInterface
322 |      */
323 |     public function getConnection()
324 |     {
325 |         return $this->connection;
326 |     }
327 | 
328 |     /**
329 |      * Get the cache key prefix.
330 |      *
331 |      * @return string
332 |      */
333 |     public function getPrefix()
334 |     {
335 |         return '';
336 |     }
337 | 
338 |     /**
339 |      * Retrieve multiple items from the cache by key.
340 |      *
341 |      * Items not found in the cache will have a null value.
342 |      *
343 |      * @param  array  $keys
344 |      * @return void
345 |      */
346 |     public function many(array $keys)
347 |     {
348 |         // TODO: Implement many() method.
349 |     }
350 | 
351 |     /**
352 |      * Store multiple items in the cache for a given number of seconds.
353 |      *
354 |      * @param  array  $values
355 |      * @param  int  $seconds
356 |      * @return void
357 |      */
358 |     public function putMany(array $values, $seconds)
359 |     {
360 |         // TODO: Implement putMany() method.
361 |     }
362 | }
363 | 


--------------------------------------------------------------------------------
/src/OpenVidu.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use Exception;
  6 | use GuzzleHttp\Client;
  7 | use GuzzleHttp\RequestOptions;
  8 | use Illuminate\Support\Facades\Cache;
  9 | use Psr\SimpleCache\InvalidArgumentException;
 10 | use SquareetLabs\LaravelOpenVidu\Builders\RecordingBuilder;
 11 | use SquareetLabs\LaravelOpenVidu\Enums\Uri;
 12 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduException;
 13 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduProblemWithBodyParameterException;
 14 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduRecordingNotFoundException;
 15 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduRecordingResolutionException;
 16 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduRecordingStatusException;
 17 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduServerRecordingIsDisabledException;
 18 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduSessionCantRecordingException;
 19 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduSessionHasNotConnectedParticipantsException;
 20 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduSessionNotFoundException;
 21 | 
 22 | /**
 23 |  * Class OpenVidu
 24 |  * @package App\SquareetLabs\LaravelOpenVidu
 25 |  */
 26 | class OpenVidu
 27 | {
 28 |     /**
 29 |      * @var Client
 30 |      */
 31 |     private $client;
 32 | 
 33 |     /**
 34 |      * @var
 35 |      */
 36 |     private $config;
 37 | 
 38 | 
 39 |     /**
 40 |      * SmsUp constructor.
 41 |      * @param  array  $config
 42 |      */
 43 |     public function __construct(array $config)
 44 |     {
 45 |         $this->config = $config;
 46 |     }
 47 | 
 48 |     /**
 49 |      * @param  SessionProperties|null  $properties
 50 |      * @return Session
 51 |      * @throws Exceptions\OpenViduException
 52 |      */
 53 |     public function createSession(?SessionProperties $properties = null): Session
 54 |     {
 55 |         $session = new Session($this->client(), null, $properties);
 56 |         Cache::store('openvidu')->forever($session->getSessionId(), $session->toJson());
 57 |         return $session;
 58 |     }
 59 | 
 60 |     /**
 61 |      * @return Client
 62 |      */
 63 |     private function client(): Client
 64 |     {
 65 |         if ($this->client) {
 66 |             return $this->client;
 67 |         }
 68 | 
 69 |         $client = new Client([
 70 |             'headers' => [
 71 |                 'Content-Type' => 'application/json',
 72 |                 'Accept' => 'application/json',
 73 |             ],
 74 |             'auth' => [
 75 |                 $this->config['app'], $this->config['secret']
 76 |             ],
 77 |             'base_uri' => $this->config['domain'] . ':' . $this->config['port'],
 78 |             'debug' => $this->config['debug'],
 79 |             'http_errors' => false,
 80 |             'verify' => false
 81 |         ]);
 82 |         return $client;
 83 |     }
 84 | 
 85 |     /**
 86 |      * @param  Client  $client
 87 |      */
 88 |     public function setClient(Client $client)
 89 |     {
 90 |         $this->client = $client;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Starts the recording of a {@see Session}
 95 |      * @param  RecordingProperties  $properties
 96 |      * @return Recording
 97 |      * @throws OpenViduException
 98 |      * @throws OpenViduRecordingResolutionException
 99 |      * @throws OpenViduServerRecordingIsDisabledException
100 |      * @throws OpenViduSessionCantRecordingException
101 |      * @throws OpenViduSessionHasNotConnectedParticipantsException
102 |      * @throws OpenViduSessionNotFoundException
103 |      * @throws InvalidArgumentException
104 |      * @throws Exceptions\OpenViduInvalidArgumentException
105 |      */
106 |     public function startRecording(RecordingProperties $properties): Recording
107 |     {
108 |         $activeSession = $this->getSession($properties->session());
109 |         if ($activeSession->isBeingRecorded()) {
110 |             $lastRecordingId = $activeSession->getLastRecordingId();
111 |             if (!$lastRecordingId) {
112 |                 throw new OpenViduSessionCantRecordingException("The session is not configured for using media routed or has recording problems");
113 |             }
114 |             return $this->getRecording($lastRecordingId);
115 |         }
116 |         $response = $this->client()->post(Uri::RECORDINGS_START, [
117 |             RequestOptions::JSON => $properties->toArray() ?? null
118 |         ]);
119 |         switch ($response->getStatusCode()) {
120 |             case 200:
121 |                 $recording = RecordingBuilder::build(json_decode($response->getBody()->getContents(), true));
122 | 
123 |                 if ($activeSession != null) {
124 |                     $activeSession->setIsBeingRecorded(true);
125 |                     $activeSession->setLastRecordingId($recording->getId());
126 |                 }
127 |                 return $recording;
128 |             case 404:
129 |                 throw new OpenViduSessionNotFoundException();
130 |             case 406:
131 |                 throw new OpenViduSessionHasNotConnectedParticipantsException();
132 |             case 409:
133 |                 throw new OpenViduSessionCantRecordingException("The session is not configured for using media routed or it is already being recorded");
134 |             case 422:
135 |                 throw new OpenViduRecordingResolutionException();
136 |             case 501:
137 |                 throw new OpenViduServerRecordingIsDisabledException();
138 |             default:
139 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
140 |         }
141 |     }
142 | 
143 |     /**
144 |      * Gets an existing {@see Session}
145 |      * @param  string  $sessionId
146 |      * @return Session
147 |      * @throws OpenViduException
148 |      * @throws OpenViduSessionNotFoundException
149 |      * @throws InvalidArgumentException
150 |      */
151 |     public function getSession(string $sessionId): Session
152 |     {
153 |         if (Cache::store('openvidu')->has($sessionId)) {
154 |             return (new Session($this->client(), $sessionId))->fromJson(Cache::store('openvidu')->get($sessionId));
155 |         }
156 |         throw new OpenViduSessionNotFoundException();
157 |     }
158 | 
159 |     /**
160 |      * Gets an existing {@see Recording}
161 |      * @param  string  $recordingId  The `id` property of the {@see Recording} you want to retrieve
162 |      * @return Recording
163 |      * @throws Exceptions\OpenViduInvalidArgumentException
164 |      * @throws OpenViduException
165 |      * @throws OpenViduRecordingNotFoundException
166 |      */
167 |     public function getRecording(string $recordingId): Recording
168 |     {
169 |         $response = $this->client()->get(Uri::RECORDINGS_URI . '/' . $recordingId);
170 |         switch ($response->getStatusCode()) {
171 |             case 200:
172 |                 return RecordingBuilder::build(json_decode($response->getBody()->getContents(), true));
173 |             case 404:
174 |                 throw new OpenViduRecordingNotFoundException();
175 |             default:
176 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
177 |         }
178 |     }
179 | 
180 |     /**
181 |      * Check if exists {@see Session}
182 |      * @param  string  $sessionId
183 |      * @return bool
184 |      * @throws InvalidArgumentException
185 |      */
186 |     public function existsSession(string $sessionId): bool
187 |     {
188 |         return Cache::store('openvidu')->has($sessionId);
189 |     }
190 | 
191 |     /**
192 |      * Stops the recording of a {@see Session}
193 |      * @param  string  $recordingId  The `id` property of the {@see Recording} you want to stop
194 |      * @return Recording
195 |      * @throws OpenViduException
196 |      * @throws OpenViduRecordingNotFoundException
197 |      * @throws OpenViduRecordingStatusException
198 |      * @throws OpenViduSessionNotFoundException
199 |      * @throws InvalidArgumentException
200 |      * @throws Exceptions\OpenViduInvalidArgumentException
201 |      */
202 |     public function stopRecording(string $recordingId): Recording
203 |     {
204 |         $response = $this->client()->post(Uri::RECORDINGS_STOP . '/' . $recordingId);
205 |         switch ($response->getStatusCode()) {
206 |             case 200:
207 |                 $recording = RecordingBuilder::build(json_decode($response->getBody()->getContents(), true));
208 |                 $activeSession = $this->getSession($recording->getSessionId());
209 |                 if ($activeSession != null) {
210 |                     $activeSession->setIsBeingRecorded(false);
211 |                     $activeSession->setLastRecordingId($recordingId);
212 |                 }
213 |                 return $recording;
214 |             case 404:
215 |                 throw new OpenViduRecordingNotFoundException();
216 |             case 406:
217 |                 throw new OpenViduRecordingStatusException("The recording has `starting` status. Wait until `started` status before stopping the recording.");
218 |             default:
219 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
220 |         }
221 |     }
222 | 
223 |     /**
224 |      * Gets an array with all existing recordings
225 |      * @return array
226 |      * @throws OpenViduException
227 |      * @throws Exceptions\OpenViduInvalidArgumentException
228 |      */
229 |     public function getRecordings(): array
230 |     {
231 |         $recordings = [];
232 |         $response = $this->client()->get(Uri::RECORDINGS_URI);
233 |         switch ($response->getStatusCode()) {
234 |             case 200:
235 |                 $items = json_decode($response->getBody()->getContents(), true);
236 |                 foreach ($items as $item) {
237 |                     $recordings[] = RecordingBuilder::build($item);
238 |                 }
239 |                 return $recordings;
240 |             default:
241 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
242 |         }
243 |     }
244 | 
245 | 
246 |     /**
247 |      * Deletes a {@see Recording}. The recording must have status `stopped`, `ready` or `failed`
248 |      * @param  string  $recordingId  The `id` property of the {@see Recording} you want to delete
249 |      * @return bool
250 |      * @throws OpenViduException
251 |      * @throws OpenViduRecordingNotFoundException
252 |      * @throws OpenViduRecordingStatusException
253 |      */
254 |     public function deleteRecording(string $recordingId): bool
255 |     {
256 |         $response = $this->client()->delete(Uri::RECORDINGS_URI . '/' . $recordingId);
257 | 
258 |         switch ($response->getStatusCode()) {
259 |             case 200:
260 |                 return true;
261 |             case 404:
262 |                 throw new OpenViduRecordingNotFoundException();
263 |                 break;
264 |             case 409:
265 |                 throw new OpenViduRecordingStatusException("The recording has `started` status. Stop it before deletion.");
266 |                 break;
267 |             default:
268 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
269 |         }
270 |     }
271 | 
272 |     /**
273 |      * Returns the list of active sessions. <strong>This value will remain unchanged
274 |      * since the last time method {@link SquareetLabs\LaravelOpenVidu#fetch()}
275 |      * was called</strong>. Exceptions to this rule are:
276 |      * <ul>
277 |      * <li>Calling {@see Session::fetch} updates that
278 |      * specific Session status</li>
279 |      * <li>Calling {@see Session::close()} automatically
280 |      * removes the Session from the list of active Sessions</li>
281 |      * <li>Calling
282 |      * {@see Session::forceDisconnect(string)}
283 |      * automatically updates the inner affected connections for that specific
284 |      * Session</li>
285 |      * <li>Calling {@see Session::forceUnpublish(string)}
286 |      * also automatically updates the inner affected connections for that specific
287 |      * Session</li>
288 |      * <li>Calling {@see OpenVidu::startRecording(string)}
289 |      * and {@see LaravelOpenVidu::stopRecording(string)}
290 |      * automatically updates the recording status of the Session
291 |      * </ul>
292 |      * <br>
293 |      * To get the list of active sessions with their current actual value, you must
294 |      * call first {@see OpenVidu::fetch()} and then
295 |      * {@see OpenVidu::getActiveSessions()}
296 |      * @throws OpenViduException
297 |      */
298 |     public function getActiveSessions(): array
299 |     {
300 |         try {
301 |             return Cache::store('openvidu')->getAll();
302 |         } catch (Exception $e) {
303 |             throw new OpenViduException("Make sure you have correctly configured the openvidu cache driver.", 500);
304 |         }
305 |     }
306 | 
307 |     /**
308 |      * Sends signal to session with given SignalProperties
309 |      * @param  SignalProperties  $properties
310 |      * @return bool
311 |      * @throws OpenViduException
312 |      * @throws OpenViduProblemWithBodyParameterException
313 |      * @throws OpenViduSessionHasNotConnectedParticipantsException
314 |      * @throws OpenViduSessionNotFoundException
315 |      */
316 |     public function sendSignal(SignalProperties $properties): bool
317 |     {
318 |         $response = $this->client()->post(Uri::SIGNAL_URI, [
319 |             RequestOptions::JSON => $properties->toArray() ?? null
320 |         ]);
321 |         switch ($response->getStatusCode()) {
322 |             case 200:
323 |                 return true;
324 |             case 400:
325 |                 throw new OpenViduProblemWithBodyParameterException();
326 |             case 404:
327 |                 throw new OpenViduSessionNotFoundException();
328 |             case 406:
329 |                 throw new OpenViduSessionHasNotConnectedParticipantsException();
330 |             default:
331 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
332 |         }
333 |     }
334 | }
335 | 
336 | 


--------------------------------------------------------------------------------
/src/Session.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace SquareetLabs\LaravelOpenVidu;
  4 | 
  5 | use Exception;
  6 | use GuzzleHttp\Client;
  7 | use GuzzleHttp\RequestOptions;
  8 | use Illuminate\Support\Facades\Cache;
  9 | use JsonSerializable;
 10 | use SquareetLabs\LaravelOpenVidu\Builders\ConnectionBuilder;
 11 | use SquareetLabs\LaravelOpenVidu\Builders\PublisherBuilder;
 12 | use SquareetLabs\LaravelOpenVidu\Builders\SessionPropertiesBuilder;
 13 | use SquareetLabs\LaravelOpenVidu\Builders\SubscriberBuilder;
 14 | use SquareetLabs\LaravelOpenVidu\Enums\MediaMode;
 15 | use SquareetLabs\LaravelOpenVidu\Enums\OpenViduRole;
 16 | use SquareetLabs\LaravelOpenVidu\Enums\OutputMode;
 17 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingLayout;
 18 | use SquareetLabs\LaravelOpenVidu\Enums\RecordingMode;
 19 | use SquareetLabs\LaravelOpenVidu\Enums\Uri;
 20 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduConnectionNotFoundException;
 21 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduException;
 22 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduProblemWithBodyParameterException;
 23 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduSessionNotFoundException;
 24 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduStreamCantCloseException;
 25 | use SquareetLabs\LaravelOpenVidu\Exceptions\OpenViduTokenCantCreateException;
 26 | 
 27 | /**
 28 |  * Class Session
 29 |  * @package SquareetLabs\LaravelOpenVidu
 30 |  */
 31 | class Session implements JsonSerializable
 32 | {
 33 |     /** @var  Client */
 34 |     private $client;
 35 | 
 36 |     /** @var  string */
 37 |     private $sessionId;
 38 | 
 39 |     /** @var SessionProperties */
 40 |     private $properties;
 41 | 
 42 |     /** @var bool */
 43 |     private $recording;
 44 | 
 45 |     /** @var string */
 46 |     private $lastRecordingId;
 47 | 
 48 |     /** @var array */
 49 |     private $activeConnections = [];
 50 | 
 51 |     /** @var int */
 52 |     private $createdAt;
 53 | 
 54 |     /**
 55 |      * Session constructor.
 56 |      * @param  Client  $client
 57 |      * @param  string|null  $sessionId
 58 |      * @param  SessionProperties|null  $properties
 59 |      * @throws OpenViduException
 60 |      */
 61 |     public function __construct(Client $client, ?string $sessionId = null, ?SessionProperties $properties = null)
 62 |     {
 63 |         $this->client = $client;
 64 |         if (!$sessionId) {
 65 |             $this->properties = $properties ? $properties : new SessionProperties(MediaMode::ROUTED, RecordingMode::MANUAL, OutputMode::COMPOSED, RecordingLayout::BEST_FIT);
 66 |             $this->sessionId = $this->getSessionId();
 67 |         }
 68 |     }
 69 | 
 70 |     /**
 71 |      * @return string
 72 |      * @throws OpenViduException
 73 |      */
 74 |     public function getSessionId()
 75 |     {
 76 |         if (empty($this->sessionId)) {
 77 |             $response = $this->client->post(Uri::SESSION_URI, [
 78 |                 RequestOptions::JSON => $this->properties->toArray()
 79 |             ]);
 80 |             switch ($response->getStatusCode()) {
 81 |                 case 200:
 82 |                     return json_decode($response->getBody()->getContents())->id;
 83 |                 case 400:
 84 |                     throw  new OpenViduProblemWithBodyParameterException();
 85 |                 case 409:
 86 |                     return $this->properties->getCustomSessionId();
 87 |                 default:
 88 |                     throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
 89 |             }
 90 |         } else {
 91 |             return $this->sessionId;
 92 |         }
 93 |     }
 94 | 
 95 |     /**
 96 |      ** Gets a new token associated to Session object with default values for
 97 |      * {@see TokenOptions}. This always translates into a
 98 |      * new request to OpenVidu Server
 99 |      *
100 |      * @param  TokenOptions|null  $tokenOptions
101 |      * @return string The generated token
102 |      * @throws OpenViduException
103 |      */
104 |     public function generateToken(?TokenOptions $tokenOptions = null)
105 |     {
106 |         $this->getSessionId();
107 |         try {
108 |             if (!$tokenOptions) {
109 |                 $tokenOptions = new TokenOptions(OpenViduRole::PUBLISHER);
110 |             }
111 |             $response = $this->client->post(Uri::TOKEN_URI, [
112 |                 RequestOptions::JSON => array_merge($tokenOptions->toArray(), ['session' => $this->sessionId])
113 |             ]);
114 |             switch ($response->getStatusCode()) {
115 |                 case 200:
116 |                     return json_decode($response->getBody()->getContents());
117 |                 case 400:
118 |                     throw new OpenViduProblemWithBodyParameterException();
119 |                 case 404:
120 |                     throw new OpenViduSessionNotFoundException();
121 |                 default:
122 |                     throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
123 |             }
124 |         } catch (Exception $e) {
125 |             throw new OpenViduTokenCantCreateException($e->getMessage(), $e);
126 |         }
127 |     }
128 | 
129 |     /**
130 |      * Gracefully closes the Session: unpublishes all streams and evicts every
131 |      * participant
132 |      * @throws OpenViduException
133 |      */
134 |     public function close()
135 |     {
136 |         $response = $this->client->delete(Uri::SESSION_URI . '/' . $this->sessionId);
137 |         switch ($response->getStatusCode()) {
138 |             case 204:
139 |                 Cache::store('openvidu')->forget($this->sessionId);
140 |                 return true;
141 |             case 404:
142 |                 throw new OpenViduSessionNotFoundException();
143 |             default:
144 |                 throw new OpenViduException("Invalid response status code ".$response->getStatusCode(), $response->getStatusCode());
145 |         }
146 |     }
147 | 
148 |     /**
149 |      * Updates every property of the Session with the current status it has in
150 |      * OpenVidu Server. This is especially useful for getting the list of active
151 |      * connections to the Session
152 |      * ({@see getActiveConnections()}) and use
153 |      * those values to call
154 |      * {@see forceDisconnect(Connection)} or
155 |      * {@link forceUnpublish(Publisher)}. <br>
156 |      *
157 |      * To update every Session object owned by OpenVidu object, call
158 |      * {@see fetch()}
159 |      *
160 |      * @return bool true if the Session status has changed with respect to the server,
161 |      * false if not. This applies to any property or sub-property of the object
162 |      */
163 | 
164 |     public function fetch()
165 |     {
166 |         $response = $this->client->get(Uri::SESSION_URI . '/' . $this->sessionId, [
167 |             'headers' => [
168 |                 'Content-Type' => 'application/x-www-form-urlencoded',
169 |                 'Accept' => 'application/json',
170 |             ]
171 |         ]);
172 |         if ($response->getStatusCode() === 200) {
173 |             $beforeJSON = $this->toJson();
174 |             $this->fromJson($response->getBody()->getContents());
175 |             $afterJSON = $this->toJson();
176 |             if ($beforeJSON !== $afterJSON) {
177 |                 Cache::store('openvidu')->update($this->sessionId, $this->toJson());
178 |                 return true;
179 |             }
180 |         }
181 |         return false;
182 |     }
183 | 
184 |     /**
185 |      * Convert the model instance to JSON.
186 |      *
187 |      * @param  int  $options
188 |      * @return string
189 |      *
190 |      */
191 |     public function toJson($options = 0): string
192 |     {
193 |         $json = json_encode($this->jsonSerialize(), $options);
194 |         return $json;
195 |     }
196 | 
197 |     /**
198 |      * Specify data which should be serialized to JSON
199 |      * @link https://php.net/manual/en/jsonserializable.jsonserialize.php
200 |      * @return mixed data which can be serialized by <b>json_encode</b>,
201 |      * which is a value of any type other than a resource.
202 |      * @since 5.4.0
203 |      */
204 |     public function jsonSerialize()
205 |     {
206 |         return $this->toArray();
207 |     }
208 | 
209 |     /**
210 |      * Convert the model instance to an array.
211 |      *
212 |      * @return array
213 |      */
214 |     public function toArray(): array
215 |     {
216 |         $array = ['sessionId' => $this->sessionId, 'properties' => $this->properties->toArray(), 'recording' => $this->recording, 'createdAt' => $this->createdAt];
217 |         foreach ($this->activeConnections as $connection) {
218 |             $array['activeConnections'][] = $connection->toArray();
219 |         }
220 | 
221 |         foreach ($array as $key => $value) {
222 |             if (is_null($value) || $value == '') {
223 |                 unset($array[$key]);
224 |             }
225 |         }
226 |         return $array;
227 |     }
228 | 
229 |     /**
230 |      * @param  string  $json
231 |      * @return Session
232 |      */
233 |     public function fromJson(string $json): Session
234 |     {
235 |         return $this->fromArray(json_decode($json, true));
236 |     }
237 | 
238 |     /**
239 |      * @param  array  $sessionArray
240 |      * @return Session
241 |      */
242 |     public function fromArray(array $sessionArray): Session
243 |     {
244 |         $this->sessionId = $sessionArray['sessionId'];
245 |         $this->createdAt = $sessionArray['createdAt'] ?? null;
246 |         $this->recording = $sessionArray['recording'] ?? null;
247 | 
248 |         if (array_key_exists('properties', $sessionArray)) {
249 |             $this->properties = SessionPropertiesBuilder::build($sessionArray['properties']);
250 |         }
251 | 
252 |         $this->activeConnections = [];
253 |         if (array_key_exists('connections', $sessionArray)) {
254 |             foreach ($sessionArray['connections']['content'] as $connection) {
255 |                 $publishers = [];
256 |                 $ensure = $connection['content'] ?? $connection;
257 |                 foreach ($ensure['publishers'] as $publisher) {
258 |                     $publishers[] = PublisherBuilder::build($publisher);
259 |                 }
260 |                 $subscribers = [];
261 | 
262 |                 foreach ($ensure['subscribers'] as $subscriber) {
263 |                     $subscribers[] = SubscriberBuilder::build($subscriber);
264 |                 }
265 |                 $this->activeConnections[] = ConnectionBuilder::build($ensure, $publishers, $subscribers);
266 |             }
267 |         }
268 |         return $this;
269 |     }
270 | 
271 |     /**
272 |      * Forces the user with Connection `connectionId` to leave the session. OpenVidu Browser will trigger the proper events on the client-side
273 |      * (`streamDestroyed`, `connectionDestroyed`, `sessionDisconnected`) with reason set to `"forceDisconnectByServer"`
274 |      *
275 |      *
276 |      * @param  string  $connectionId
277 |      * @throws OpenViduException
278 |      */
279 |     public function forceDisconnect(string $connectionId)
280 |     {
281 |         $response = $this->client->delete(Uri::SESSION_URI . '/' . $this->sessionId . '/connection/' . $connectionId, [
282 |             'headers' => [
283 |                 'Content-Type' => 'application/x-www-form-urlencoded',
284 |                 'Accept' => 'application/json',
285 |             ]
286 |         ]);
287 |         switch ($response->getStatusCode()) {
288 |             case 204:
289 |                 $this->leaveSession($connectionId);
290 |                 Cache::store('openvidu')->update($this->sessionId, $this->toJson());
291 |                 break;
292 |             case 400:
293 |                 throw new OpenViduSessionNotFoundException();
294 |             case 404:
295 |                 throw new OpenViduConnectionNotFoundException();
296 |             default:
297 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
298 |         }
299 |     }
300 | 
301 |     /**
302 |      * Get `connection` parameter from activeConnections array {@see Connection::getConnectionId()} for getting each `connectionId` property).
303 |      * Remember to call {@see fetch()} before to fetch the current actual properties of the Session from OpenVidu Server
304 |      * @param  string  $connectionId
305 |      */
306 | 
307 |     private function leaveSession(string $connectionId)
308 |     {
309 |         $connectionClosed = null;
310 |         $this->activeConnections = array_filter($this->activeConnections, function (Connection $connection) use (&$connectionClosed, $connectionId) {
311 |             if ($connection->getConnectionId() !== $connectionId) {
312 |                 return true;
313 |             }
314 |             $connectionClosed = $connection;
315 |             return false;
316 |         });
317 |         if ($connectionClosed != null) {
318 |             foreach ($connectionClosed->getPublishers() as $publisher) {
319 |                 foreach ($this->activeConnections as $con) {
320 |                     $con->unsubscribe($publisher->getStreamId());
321 |                 }
322 |             }
323 |         }
324 |     }
325 | 
326 | 
327 |     /**
328 |      * Allows publish a Stream (For now can only be IPCAM).
329 |      * Remember to call
330 |      * {@see fetch()} before to fetch the current
331 |      * actual properties of the Session from OpenVidu Server
332 |      *
333 |      * @param  IPCameraOptions  $IPCameraOptions
334 |      * @return Connection
335 |      * @throws OpenViduException
336 |      * @throws OpenViduSessionNotFoundException
337 |      */
338 |     public function publish(IPCameraOptions $IPCameraOptions)
339 |     {
340 |         $response = $this->client->post(Uri::SESSION_URI . '/' . $this->sessionId . '/connection', [
341 |             RequestOptions::JSON => array_merge($IPCameraOptions->toArray())
342 |         ]);
343 |         switch ($response->getStatusCode()) {
344 |             case 200:
345 |                 return json_decode($response->getBody()->getContents());
346 |             case 400:
347 |                 throw new OpenViduProblemWithBodyParameterException();
348 |             case 404:
349 |                 throw new OpenViduSessionNotFoundException();
350 |             default:
351 |                 throw new OpenViduException("Unexpected error when publishing the IP camera stream into the session.");
352 |         }
353 |     }
354 | 
355 |     /**
356 |      * Forces some user to unpublish a Stream. OpenVidu Browser will trigger the
357 |      * proper events on the client-side (<code>streamDestroyed</code>) with reason
358 |      * set to "forceUnpublishByServer". <br>
359 |      *
360 |      * You can get <code>streamId</code> parameter with
361 |      * {@see Session::getActiveConnections()} and then for
362 |      * each Connection you can call
363 |      * {@see  Connection::getPublishers()}. Finally
364 |      * {@see Publisher::getStreamId()}) will give you the
365 |      * <code>streamId</code>. Remember to call
366 |      * {@see fetch()} before to fetch the current
367 |      * actual properties of the Session from OpenVidu Server
368 |      *
369 |      * @param  string  $streamId
370 |      * @return void
371 |      * @throws OpenViduConnectionNotFoundException
372 |      * @throws OpenViduException
373 |      * @throws OpenViduSessionNotFoundException
374 |      */
375 |     public function forceUnpublish(string $streamId)
376 |     {
377 |         $response = $this->client->delete(Uri::SESSION_URI . '/' . $this->sessionId . '/stream/' . $streamId, [
378 |             'headers' => [
379 |                 'Content-Type' => 'application/x-www-form-urlencoded',
380 |                 'Accept' => 'application/json',
381 |             ]
382 |         ]);
383 |         switch ($response->getStatusCode()) {
384 |             case 204:
385 |                 foreach ($this->activeConnections as $connection) {
386 |                     $connection->unpublish($streamId);
387 |                     $connection->unsubscribe($streamId);
388 |                 }
389 |                 Cache::store('openvidu')->update($this->sessionId, $this->toJson());
390 |                 break;
391 |             case 400:
392 |                 throw new OpenViduSessionNotFoundException();
393 |             case 404:
394 |                 throw new OpenViduConnectionNotFoundException();
395 |             case 405:
396 |                 throw new OpenViduStreamCantCloseException("You cannot directly delete the stream of an IPCAM participant");
397 |             default:
398 |                 throw new OpenViduException("Invalid response status code " . $response->getStatusCode(), $response->getStatusCode());
399 |         }
400 |     }
401 | 
402 |     /**
403 |      * Returns the list of active connections to the session. <strong>This value
404 |      * will remain unchanged since the last time method
405 |      * {@see fetch()} was called</strong>.
406 |      * Exceptions to this rule are:
407 |      * <ul>
408 |      * <li>Calling {@see Session::forceUnpublish(string)}
409 |      * updates each affected Connection status</li>
410 |      * <li>Calling {@see Session::forceDisconnect(string)}
411 |      * updates each affected Connection status</li>
412 |      * </ul>
413 |      * <br>
414 |      * To get the list of active connections with their current actual value, you
415 |      * must call first {@see Session::fetch()} and then
416 |      * {@see Session::getActiveConnections()}
417 |      */
418 |     public function getActiveConnections(): array
419 |     {
420 |         return $this->activeConnections;
421 |     }
422 | 
423 |     /**
424 |      * Returns whether the session is being recorded or not
425 |      */
426 |     public function isBeingRecorded(): bool
427 |     {
428 |         return !!$this->recording;
429 |     }
430 | 
431 |     /**
432 |      * Set value
433 |      * @param  bool  $recording
434 |      */
435 |     public function setIsBeingRecorded(bool $recording)
436 |     {
437 |         $this->recording = $recording;
438 |         Cache::store('openvidu')->update($this->sessionId, $this->toJson());
439 |     }
440 | 
441 |     public function getLastRecordingId()
442 |     {
443 |         return $this->lastRecordingId;
444 |     }
445 | 
446 |     public function setLastRecordingId(string $lastRecordingId)
447 |     {
448 |         $this->lastRecordingId = $lastRecordingId;
449 |         Cache::store('openvidu')->update($this->sessionId, $this->toJson());
450 |     }
451 | 
452 |     /**
453 |      * @return string
454 |      * @throws OpenViduException
455 |      */
456 |     public function __toString(): string
457 |     {
458 |         return $this->getSessionId();
459 |     }
460 | }
461 | 


--------------------------------------------------------------------------------