Events

use PhpOpcua\Client\ClientBuilder;
use Psr\EventDispatcher\EventDispatcherInterface;

$client = ClientBuilder::create()
    ->setEventDispatcher($yourDispatcher)
    ->connect('opc.tcp://localhost:4840');

// Get the current dispatcher (on the builder before connecting)
$builder = ClientBuilder::create();
$dispatcher = $builder->getEventDispatcher();

$builder = ClientBuilder::create();
$builder->setEventDispatcher(app(EventDispatcherInterface::class));
$client = $builder->connect('opc.tcp://localhost:4840');

$this->app->afterResolving(ClientBuilder::class, function (ClientBuilder $builder) {
    $builder->setEventDispatcher($this->app->make(EventDispatcherInterface::class));
});

// EventServiceProvider
protected $listen = [
    \PhpOpcua\Client\Event\DataChangeReceived::class => [
        \App\Listeners\HandleOpcUaDataChange::class,
    ],
    \PhpOpcua\Client\Event\AlarmActivated::class => [
        \App\Listeners\HandleOpcUaAlarm::class,
    ],
];

class DataChangeListener
{
    public function __invoke(DataChangeReceived $event): void
    {
        DB::table('opcua_values')->insert([
            'subscription_id' => $event->subscriptionId,
            'client_handle' => $event->clientHandle,
            'value' => $event->dataValue->getValue(),
            'status_code' => $event->dataValue->statusCode,
            'source_timestamp' => $event->dataValue->sourceTimestamp,
            'recorded_at' => now(),
        ]);
    }
}

class AlarmAlertListener
{
    public function __invoke(AlarmActivated $event): void
    {
        Notification::route('slack', config('opcua.slack_webhook'))
            ->notify(new AlarmNotification(
                source: $event->sourceName,
                severity: $event->severity,
                message: $event->message,
            ));
    }
}

class ConnectionHealthListener
{
    public function handleConnected(ClientConnected $event): void
    {
        Cache::put("opcua:{$event->endpointUrl}:status", 'connected');
        Metrics::gauge('opcua.connections.active', 1);
    }

    public function handleFailed(ConnectionFailed $event): void
    {
        Cache::put("opcua:{$event->endpointUrl}:status", 'failed');
        Log::error('OPC UA connection failed', [
            'endpoint' => $event->endpointUrl,
            'error' => $event->exception->getMessage(),
        ]);
    }

    public function handleRetry(RetryAttempt $event): void
    {
        Metrics::increment('opcua.retries', tags: [
            'attempt' => $event->attempt,
        ]);
    }
}

class SubscriptionTracker
{
    public function handleCreated(SubscriptionCreated $event): void
    {
        Redis::hSet('opcua:subscriptions', $event->subscriptionId, json_encode([
            'interval' => $event->revisedPublishingInterval,
            'created_at' => now()->toIso8601String(),
        ]));
    }

    public function handleDeleted(SubscriptionDeleted $event): void
    {
        Redis::hDel('opcua:subscriptions', $event->subscriptionId);
    }
}

$result = $client->createEventMonitoredItem(
    $sub->subscriptionId,
    $alarmNodeId,
    [
        'EventId', 'EventType', 'SourceName', 'Time', 'Message', 'Severity',
        'ActiveState',      // enables AlarmActivated / AlarmDeactivated
        'AckedState',       // enables AlarmAcknowledged
        'ConfirmedState',   // enables AlarmConfirmed
    ],
);