Laravel Breeze Event Broadcasting

January 27, 2025 · AI Conversations

User

larave breeze blade broadcast event

Assistant

To broadcast an event in a Laravel Breeze application, you can integrate Laravel's **event broadcasting** system. Here’s a step-by-step guide on broadcasting and handling events in Laravel Breeze with Blade views:

—

### **1. Set Up Event Broadcasting**
#### **Install and Configure Pusher or Laravel Websockets**
1. **Install Pusher**:

composer require pusher/pusher-php-server

2. **Configure `.env`**:
Add your Pusher credentials:

BROADCAST_DRIVER=pusher

   PUSHER_APP_ID=your-app-id
   PUSHER_APP_KEY=your-app-key
   PUSHER_APP_SECRET=your-app-secret
   PUSHER_HOST=127.0.0.1  # For Laravel Websockets, otherwise leave blank
   PUSHER_PORT=6001       # For Laravel Websockets, adjust if needed
   PUSHER_SCHEME=http
   PUSHER_APP_CLUSTER=mt1 # Use your Pusher cluster

3. **Install Laravel Echo** for real-time frontend updates:

yarn add laravel-echo pusher-js

—

### **2. Create an Event**
Generate a new event:

php artisan make:event MessageSent

Edit the event class in `app/Events/MessageSent.php` to include necessary data:

namespace AppEvents;

use IlluminateBroadcastingChannel;
use IlluminateBroadcastingInteractsWithSockets;
use IlluminateBroadcastingPresenceChannel;
use IlluminateBroadcastingPrivateChannel;
use IlluminateContractsBroadcastingShouldBroadcast;
use IlluminateQueueSerializesModels;

class MessageSent implements ShouldBroadcast
{
    use InteractsWithSockets, SerializesModels;

    public $message;

    public function __construct($message)
    {
        $this->message = $message;
    }

    public function broadcastOn()
    {
        return new Channel('messages'); // or PrivateChannel if using private channels
    }
}

—

### **3. Set Up a Broadcast Listener in the Frontend**
1. **Install Echo in your frontend (using Breeze)**:
Update your `resources/js/app.js`:

import Echo from 'laravel-echo';
   import Pusher from 'pusher-js';

   window.Pusher = Pusher;

   window.Echo = new Echo({
       broadcaster: 'pusher',
       key: import.meta.env.VITE_PUSHER_APP_KEY,
       cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
       wsHost: import.meta.env.VITE_PUSHER_HOST || window.location.hostname,
       wsPort: import.meta.env.VITE_PUSHER_PORT || 6001,
       forceTLS: import.meta.env.VITE_PUSHER_SCHEME === 'https',
       disableStats: true,
   });

2. **Listen to the Event**:
Add a listener in your JavaScript:

Echo.channel('messages')
       .listen('MessageSent', (event) => {
           console.log('New message received:', event.message);
       });

—

### **4. Trigger the Event**
In your controller, broadcast the event:

use AppEventsMessageSent;

public function sendMessage(Request $request)
{
    $message = $request->input('message');

    broadcast(new MessageSent($message))->toOthers();

    return response()->json(['status' => 'Message broadcasted!']);
}

—

### **5. Update Blade View**
Add a form in a Blade view (`resources/views/chat.blade.php`) to send messages:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Broadcast Example</title>
    @vite('resources/js/app.js') <!-- Include your JS -->
</head>
<body>
    <div id="messages"></div>
    <form id="messageForm">
        <input type="text" id="message" placeholder="Type your message" />
        <button type="submit">Send</button>
    </form>

    <script>
        const form = document.getElementById('messageForm');
        const messagesDiv = document.getElementById('messages');

        form.addEventListener('submit', async (e) => {
            e.preventDefault();
            const message = document.getElementById('message').value;

            // Send the message to the server
            await fetch('/send-message', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]').getAttribute('content'),
                },
                body: JSON.stringify({ message }),
            });

            document.getElementById('message').value = '';
        });

        // Listen for new messages
        Echo.channel('messages').listen('MessageSent', (event) => {
            const newMessage = document.createElement('div');
            newMessage.textContent = event.message;
            messagesDiv.appendChild(newMessage);
        });
    </script>
</body>
</html>

—

### **6. Configure Broadcasting in Laravel**
Run the following commands to set up:

php artisan queue:work   # For handling broadcasts
php artisan serve        # Start the Laravel server

Ensure your `BROADCAST_DRIVER` is set to `pusher` in `.env`.

—

Now, when you submit the form, it will broadcast the `MessageSent` event in real time, and listeners will see the message without refreshing the page! Let me know if you need help debugging or customizing this setup.

User

Uncaught TypeError: Cannot read properties of undefined (reading 'private')

Assistant

The error `Uncaught TypeError: Cannot read properties of undefined (reading 'private')` occurs because the `Echo` instance is not properly configured, or there’s an issue with how you are calling `Echo.private()`. Let’s troubleshoot and resolve it step by step:

—

### **1. Verify Echo Configuration**
Ensure `Echo` is correctly configured in `resources/js/app.js`. The issue often arises due to missing or incorrect configuration for the broadcaster.

Here’s a working example for Laravel and Pusher:

#### **Basic Echo Setup (app.js):**

import Echo from 'laravel-echo';
import Pusher from 'pusher-js';

window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_PUSHER_APP_KEY,
    cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
    wsHost: import.meta.env.VITE_PUSHER_HOST || window.location.hostname,
    wsPort: import.meta.env.VITE_PUSHER_PORT || 6001,
    wssPort: import.meta.env.VITE_PUSHER_PORT || 6001,
    forceTLS: import.meta.env.VITE_PUSHER_SCHEME === 'https',
    enabledTransports: ['ws', 'wss'], // Only allow WebSocket connections
    disableStats: true,
});

#### **Check `.env` Variables:**
Make sure the required `.env` variables are properly set:

BROADCAST_DRIVER=pusher

PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret
PUSHER_APP_CLUSTER=mt1
PUSHER_HOST=127.0.0.1  # Only needed for Laravel Websockets
PUSHER_PORT=6001       # Ensure it matches your WebSocket server port
PUSHER_SCHEME=http     # Set to https if using TLS

—

### **2. Debug the `Echo` Instance**
Add debugging to ensure `Echo` is properly initialized. Open your browser console and type:

console.log(window.Echo);

If the result is `undefined` or incorrect, your `Echo` setup is likely not being loaded correctly.

—

### **3. Use the Correct Channel Type**
Ensure you're using the correct method for the channel type:

#### **For Public Channels:**

Echo.channel('public-channel')
    .listen('EventName', (event) => {
        console.log(event);
    });

#### **For Private Channels:**

Echo.private('private-channel-name')
    .listen('EventName', (event) => {
        console.log(event);
    });

#### **For Presence Channels:**

Echo.join('presence-channel-name')
    .listen('EventName', (event) => {
        console.log(event);
    });

—

### **4. Check Server-Side Configuration**
Ensure your event is set to broadcast on the appropriate channel. For example:

namespace AppEvents;

use IlluminateBroadcastingChannel;
use IlluminateBroadcastingPrivateChannel; // Use PrivateChannel for private broadcasts
use IlluminateContractsBroadcastingShouldBroadcast;
use IlluminateQueueSerializesModels;

class MessageSent implements ShouldBroadcast
{
    use SerializesModels;

    public $message;

    public function __construct($message)
    {
        $this->message = $message;
    }

    public function broadcastOn()
    {
        return new PrivateChannel('private-channel-name');
    }
}

—

### **5. Check Authentication for Private Channels**
Private channels require user authentication. Ensure your Laravel application has the necessary configurations:

1. **BroadcastServiceProvider**:
Check `app/Providers/BroadcastServiceProvider.php`:

public function boot()
   {
       Broadcast::routes();

       // Add custom authorization if required
       require base_path('routes/channels.php');
   }

2. **Define Authorization Logic**:
In `routes/channels.php`:

use IlluminateSupportFacadesBroadcast;

   Broadcast::channel('private-channel-name', function ($user) {
       return $user !== null; // Adjust logic as needed
   });

3. **Ensure Authenticated User**:
Private channels require an authenticated user. Verify that your frontend properly authenticates the user by checking:

console.log(window.Laravel.user); // Should return the logged-in user

If `window.Laravel.user` is `undefined`, ensure you pass the user to your Blade templates:

<script>
       window.Laravel = {!! json_encode(['user' => Auth::user()]) !!};
   </script>

—

### **6. Run Required Services**
Ensure the following services are running:

1. **Queue Worker**:
Laravel broadcasting uses queued jobs by default. Start the queue worker:

php artisan queue:work

2. **WebSocket Server (for Laravel Websockets)**:
If using Laravel Websockets, ensure the WebSocket server is running:

php artisan websockets:serve

—

### **7. Verify Pusher Debugging**
If you’re using Pusher, enable debugging in the console to check for connection issues:

Pusher.logToConsole = true;

—

### **8. Reinstall Dependencies (if necessary)**
Sometimes, dependencies may not be properly installed or configured. Try reinstalling them:

yarn install
composer install

—

### **Checklist**
– Ensure `.env` variables are properly configured for broadcasting.
– Verify `Echo` initialization in the browser console.
– Use the correct channel type (`channel`, `private`, `presence`).
– Confirm queue worker and WebSocket server are running.
– Check user authentication and authorization for private channels.

Let me know if the issue persists or if you need help debugging further!

User

<script>
Echo.private(`admin-notifications`).listen('AdminNotification', (event) => {
                console.log('Post Approved:', event.message);
                alert(event.message);
                // Handle post approval (e.g., update the UI)
            }
            );
</script>

in blade it gives error posts/?user_id=1:17 Uncaught ReferenceError: Echo is not defined

Assistant

The error `Uncaught ReferenceError: Echo is not defined` means that the `Echo` instance is either not properly initialized or not available in your Blade file. Let’s fix this step by step:

—

### **1. Ensure Echo is Imported in `resources/js/app.js`**
Check your `resources/js/app.js` file and confirm that `Echo` is initialized properly.

#### **Sample Configuration for Laravel Echo with Pusher:**

import Echo from 'laravel-echo';
import Pusher from 'pusher-js';

window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_PUSHER_APP_KEY,
    cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
    wsHost: import.meta.env.VITE_PUSHER_HOST || window.location.hostname,
    wsPort: import.meta.env.VITE_PUSHER_PORT || 6001,
    wssPort: import.meta.env.VITE_PUSHER_PORT || 6001,
    forceTLS: import.meta.env.VITE_PUSHER_SCHEME === 'https',
    enabledTransports: ['ws', 'wss'], // Only allow WebSocket connections
});

—

### **2. Include `app.js` in Your Blade File**
Ensure you’re including your compiled JavaScript file (`app.js`) in your Blade template. Usually, this is done by adding the `@vite` directive in the “ section:

#### **Example Blade File:**

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Admin Notifications</title>
    @vite('resources/js/app.js') <!-- Ensure your JS file is loaded -->
</head>
<body>
    <script>
        Echo.private(`admin-notifications`).listen('AdminNotification', (event) => {
            console.log('Post Approved:', event.message);
            alert(event.message);
        });
    </script>
</body>
</html>

—

### **3. Verify Your JavaScript is Compiled**
After making changes, ensure your JavaScript is compiled and available. Run the following command:

yarn dev

If you’re using production mode, use:

yarn build

—

### **4. Debug Echo in the Browser**
After loading your page, open the browser’s developer console and type:

console.log(window.Echo);

If `window.Echo` is `undefined`, check the following:
1. **Is `app.js` properly included in your Blade file?**
2. **Is `Echo` properly initialized in `resources/js/app.js`?**
3. **Are your `.env` variables for broadcasting correct?**

—

### **5. Add Fallback for Undefined Echo**
Sometimes, your script might run before `Echo` is initialized. To avoid this, wrap your `Echo` logic in a `DOMContentLoaded` or `window.onload` event:

#### **Update Script in Blade:**

<script>
    document.addEventListener('DOMContentLoaded', function () {
        if (typeof Echo !== 'undefined') {
            Echo.private(`admin-notifications`).listen('AdminNotification', (event) => {
                console.log('Post Approved:', event.message);
                alert(event.message);
            });
        } else {
            console.error('Echo is not defined. Check your JavaScript setup.');
        }
    });
</script>

—

### **6. Test with Laravel Websockets or Pusher**
Make sure your backend broadcasting setup is working. For example:

#### **Broadcast Event Example:**

namespace AppEvents;

use IlluminateBroadcastingChannel;
use IlluminateBroadcastingPrivateChannel;
use IlluminateContractsBroadcastingShouldBroadcast;
use IlluminateQueueSerializesModels;

class AdminNotification implements ShouldBroadcast
{
    use SerializesModels;

    public $message;

    public function __construct($message)
    {
        $this->message = $message;
    }

    public function broadcastOn()
    {
        return new PrivateChannel('admin-notifications');
    }
}

#### **Fire the Event:**

use AppEventsAdminNotification;

event(new AdminNotification('Your post has been approved!'));

—

### **7. Additional Debugging**
– Ensure your WebSocket server (e.g., Laravel Websockets) is running:

php artisan websockets:serve

– Check the browser’s network tab to see if the WebSocket connection is established.
– Ensure the Laravel queue worker is running for broadcasting:

php artisan queue:work

Let me know if this resolves the issue!

User

we have app.js
import Alpine from 'alpinejs';

window.Alpine = Alpine;

Alpine.start();

Assistant

If your `app.js` only imports and initializes Alpine.js, you need to integrate Laravel Echo separately for broadcasting events. Here's how you can add Laravel Echo alongside Alpine.js in your `app.js`:

—

### **Update Your `app.js` to Include Laravel Echo**
Add the following code to your `app.js` to set up Laravel Echo with your broadcasting driver (e.g., Pusher or Laravel WebSockets):

#### **Complete Updated `app.js`**

import Alpine from 'alpinejs';

window.Alpine = Alpine;

Alpine.start();

// Import Echo and Pusher
import Echo from 'laravel-echo';
import Pusher from 'pusher-js';

// Initialize Laravel Echo
window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_PUSHER_APP_KEY,
    cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
    wsHost: import.meta.env.VITE_PUSHER_HOST || window.location.hostname,
    wsPort: import.meta.env.VITE_PUSHER_PORT || 6001,
    wssPort: import.meta.env.VITE_PUSHER_PORT || 6001,
    forceTLS: import.meta.env.VITE_PUSHER_SCHEME === 'https',
    enabledTransports: ['ws', 'wss'], // Only allow WebSocket connections
});

—

### **Update Your Blade Template**
Now that `Echo` is properly initialized in `app.js`, include the `@vite` directive in your Blade file to load the compiled JavaScript.

#### Example Blade Template:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Admin Notifications</title>
    @vite('resources/js/app.js') <!-- Include the compiled JavaScript -->
</head>
<body>
    <h1>Notifications</h1>

    <script>
        document.addEventListener('DOMContentLoaded', function () {
            if (typeof Echo !== 'undefined') {
                Echo.private('admin-notifications').listen('AdminNotification', (event) => {
                    console.log('Post Approved:', event.message);
                    alert(event.message);
                });
            } else {
                console.error('Echo is not defined. Check your JavaScript setup.');
            }
        });
    </script>
</body>
</html>

—

### **Broadcasting Backend Configuration**
#### **Broadcast Event:**
Here’s an example event to broadcast:

namespace AppEvents;

use IlluminateBroadcastingChannel;
use IlluminateBroadcastingPrivateChannel;
use IlluminateContractsBroadcastingShouldBroadcast;
use IlluminateQueueSerializesModels;

class AdminNotification implements ShouldBroadcast
{
    use SerializesModels;

    public $message;

    public function __construct($message)
    {
        $this->message = $message;
    }

    public function broadcastOn()
    {
        return new PrivateChannel('admin-notifications');
    }
}

#### **Fire the Event:**
You can fire this event from a controller or anywhere in your application:

use AppEventsAdminNotification;

event(new AdminNotification('Your post has been approved!'));

—

### **Ensure `.env` is Configured**
Make sure your `.env` file is properly configured for broadcasting:

BROADCAST_DRIVER=pusher
PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret
PUSHER_APP_CLUSTER=your-app-cluster
PUSHER_HOST=your-host
PUSHER_PORT=6001
PUSHER_SCHEME=https

—

### **Recompile Your Assets**
After modifying `app.js`, recompile your assets using:

yarn dev

Or for production:

yarn build

—

### **Test Your Setup**
– Open your browser's console and type `window.Echo`. Ensure it is not `undefined`.
– Broadcast an event and confirm it is logged in the console or an alert is displayed.

If you encounter any issues, let me know!

User

now get pusher-Bu7g8Mo_.js:7

POST https://syt.ddev.site/broadcasting/auth 500 (Internal Server Error)

Assistant

The `500 Internal Server Error` when making a POST request to the `/broadcasting/auth` endpoint typically indicates an issue with the Laravel backend when attempting to authenticate the broadcast channel. Here are the steps to troubleshoot and resolve this issue:

### **1. Check Laravel Logs**
First, check the Laravel logs for any specific error messages that can give you more insight into what went wrong. You can find the logs in the `storage/logs/laravel.log` file. Look for the most recent entries related to broadcasting or authentication.

### **2. Verify Authentication Middleware**
Ensure that your broadcast routes are protected by the correct authentication middleware. By default, Laravel uses the `auth` middleware for private channels. You may need to define the `broadcast` route in your `routes/channels.php` file.

#### **Example `routes/channels.php`**

use IlluminateSupportFacadesBroadcast;

Broadcast::channel('admin-notifications', function ($user) {
    // Allow access if the user is an admin or has appropriate permission
    return $user->isAdmin(); // Adjust this according to your logic
});

### **3. Confirm User is Authenticated**
Make sure the user is properly authenticated before attempting to access the private channel. You can do this by checking if the user is logged in. If you're using Laravel Breeze, ensure that the authentication setup is correctly implemented.

### **4. Check Broadcasting Configuration**
Verify that your broadcasting configuration in `config/broadcasting.php` is correct for the driver you're using (e.g., Pusher). Ensure that your credentials are properly set.

#### **Example Pusher Configuration in `config/broadcasting.php`**

'pusher' => [
    'driver' => 'pusher',
    'key' => env('PUSHER_APP_KEY'),
    'secret' => env('PUSHER_APP_SECRET'),
    'app_id' => env('PUSHER_APP_ID'),
    'options' => [
        'cluster' => env('PUSHER_APP_CLUSTER'),
        'useTLS' => true,
    ],
],

### **5. Check Environment Variables**
Ensure that your `.env` file contains the correct values for Pusher and broadcasting. The key names must match what you have in your broadcasting configuration.

### **6. Set Up CORS (If Applicable)**
If your frontend is on a different domain or subdomain, ensure that your CORS (Cross-Origin Resource Sharing) settings allow requests from your frontend. You can configure CORS in the `config/cors.php` file.

### **7. Debugging the Auth Route**
You can create a temporary route to check if the `/broadcasting/auth` endpoint is working as expected:

#### **Temporary Route in `routes/web.php`**

Route::get('/test-broadcast-auth', function () {
    return response()->json(['message' => 'Broadcast Auth is working.']);
});

Access this route and see if it returns the expected message. If it doesn't, there may be issues with the authentication setup or middleware.

### **8. Clear Cache**
After making changes to your configurations, clear your configuration and route cache:

php artisan config:cache
php artisan route:cache

### **9. Verify Laravel Websockets (If Used)**
If you're using Laravel Websockets, ensure that it is running properly:

php artisan websockets:serve

—

### **10. Test Again**
After making the necessary checks and updates, try broadcasting the event again and monitor the console for any error messages or logs.

If the issue persists, feel free to share any error messages from the Laravel logs for further assistance!

User

wenhave
Auth::guard('admin')
Broadcast::channel('admin-notifications', function ($user, $id) {
return auth('admin')->check();
});

Assistant

Given that you are using a custom guard for your admin users, let's ensure everything is correctly set up to authenticate the broadcasting channel for `admin-notifications`. Here’s a step-by-step guide to troubleshoot the `500 Internal Server Error` you encountered:

### **1. Update Your Channel Definition**
Make sure your channel definition in `routes/channels.php` properly checks the authentication using the `admin` guard. Your current setup looks good, but let's clarify it:

#### **Example `routes/channels.php`**

use IlluminateSupportFacadesBroadcast;
use IlluminateSupportFacadesAuth;

Broadcast::channel('admin-notifications', function ($user) {
    return Auth::guard('admin')->check(); // Use the 'admin' guard to check authentication
});

### **2. Check Your Authentication Logic**
Ensure that your admin users are being authenticated correctly. If you're using Laravel Breeze or any custom authentication, double-check that the admin guard is correctly set up in your `config/auth.php`:

#### **Example Configuration in `config/auth.php`**

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    'admin' => [
        'driver' => 'session', // or 'token' if you're using API tokens
        'provider' => 'admins', // Adjust this to match your provider
    ],
],

'providers' => [
    'admins' => [
        'driver' => 'eloquent',
        'model' => AppModelsAdmin::class, // Ensure this is correct
    ],
],

### **3. Check the Auth Middleware**
Make sure your application is correctly set up to use the `admin` guard for the admin routes. If your admin routes are protected by middleware, it should look something like this in your `routes/web.php`:

Route::middleware(['auth:admin'])->group(function () {
    // Your admin routes
});

### **4. Inspect Laravel Logs**
Since you are receiving a `500 Internal Server Error`, you should check the Laravel logs in `storage/logs/laravel.log` for any exceptions or error messages that can provide more details on what's going wrong during the authentication process.

### **5. Test the Channel Access**
To debug further, you can temporarily modify your channel definition to return more information for debugging:

#### **Example Temporary Debugging Code**

Broadcast::channel('admin-notifications', function ($user) {
    if (Auth::guard('admin')->check()) {
        return ['id' => $user->id]; // Return user ID for debugging
    }
    return false; // If not authenticated, return false
});

This will allow you to see if the channel can be accessed when you're logged in as an admin. You can check the console for any messages.

### **6. Clear Configuration Cache**
After making any changes, clear the configuration cache to ensure that Laravel is using the latest settings:

php artisan config:cache
php artisan route:cache

### **7. Check the Broadcasting Auth URL**
Ensure that your frontend is pointing to the correct `/broadcasting/auth` endpoint. In your JavaScript, when you set up Laravel Echo, it should be correctly configured to match your application URL:

#### **Example in `app.js`**

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_PUSHER_APP_KEY,
    cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
    forceTLS: true,
    encrypted: true,
    authEndpoint: '/broadcasting/auth', // Make sure this is correct
});

### **8. Verify Pusher Configuration**
Check that your Pusher configuration in the `.env` file matches the expected values:

BROADCAST_DRIVER=pusher
PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret
PUSHER_APP_CLUSTER=your-app-cluster

### **9. Test Again**
After making these changes and ensuring everything is configured correctly, try to trigger the broadcast event again.

If you still encounter the `500 Internal Server Error`, please share the specific error message from the Laravel logs so we can further diagnose the issue.

Laravel Breeze Event Broadcasting

Leave a Comment Cancel