01_Event-Driven Programming

Event-driven programming is a programming paradigm where the program reacts to events, such as user actions, sensor inputs, or system-generated signals. Instead of following a strict sequence of commands, the program listens for events and responds when they occur.

Core Concepts of Event-Driven Programming

1. Events

Actions or occurrences that the program can respond to.
Examples: Button clicks, keyboard input, mouse movement.

2. Event Handlers

Functions or methods that execute in response to events.

3. Event Loop

A continuous loop that listens for events and triggers their respective handlers when events occur.

Key Components and Simple Python Examples

1. Basic Event-Driven Program

This example demonstrates a simple event-driven system with custom events and handlers.

# Simple Event-Driven Example
class Event:
    def __init__(self, name):
        self.name = name

# Event handlers
def handle_event_1(event):
    print(f"Handling event: {event.name}")

def handle_event_2(event):
    print(f"Handling another event: {event.name}")

# Main event loop
def event_loop(events):
    for event in events:
        if event.name == "event_1":
            handle_event_1(event)
        elif event.name == "event_2":
            handle_event_2(event)

# Example usage
events = [Event("event_1"), Event("event_2"), Event("event_1")]
event_loop(events)

Output:

Handling event: event_1
Handling another event: event_2
Handling event: event_1

2. Keyboard Input Event Handling

Using Python's built-in keyboard library to respond to keypresses.

import keyboard  # Install with: pip install keyboard

def on_key_event(event):
    print(f"Key {event.name} pressed!")

# Attach the event handler
keyboard.on_press(on_key_event)

# Keep the program running to listen for events
print("Press any key (Ctrl+C to exit)")
keyboard.wait()  # Blocks and listens for events

What Happens:

Whenever a key is pressed, the on_key_event function is executed.

3. Timer-Based Event Handling

This example uses the threading library to trigger events based on a timer.

import threading

# Event handler
def on_timer_event():
    print("Timer event triggered!")

# Set up a repeating timer
def start_timer():
    threading.Timer(2.0, start_timer).start()  # Triggers every 2 seconds
    on_timer_event()

start_timer()

What Happens:

The program triggers on_timer_event every 2 seconds.

4. Event Handling with PyQt

PyQt is another popular library for GUI development. It relies on signals and slots for event handling.

from PyQt5.QtWidgets import QApplication, QPushButton, QLabel, QVBoxLayout, QWidget

def on_button_click():
    label.setText("Button clicked!")

app = QApplication([])
window = QWidget()
layout = QVBoxLayout()

label = QLabel("Click the button!")
button = QPushButton("Click Me")
button.clicked.connect(on_button_click)  # Connect signal to handler

layout.addWidget(label)
layout.addWidget(button)
window.setLayout(layout)
window.show()
app.exec_()

What Happens:

Clicking the button emits a signal, triggering the on_button_click handler to update the label.

5. AR Foundation Plane Detection Event

For AR Foundation, use ARPlaneManager to detect planes in an AR session.

using UnityEngine;
using UnityEngine.XR.ARFoundation;

public class ARPlaneDetection : MonoBehaviour
{
    [SerializeField] private ARPlaneManager planeManager;

    void OnEnable()
    {
        planeManager.planesChanged += OnPlanesChanged;
    }

    void OnDisable()
    {
        planeManager.planesChanged -= OnPlanesChanged;
    }

    private void OnPlanesChanged(ARPlanesChangedEventArgs args)
    {
        foreach (var plane in args.added)
        {
            Debug.Log($"Plane added: {plane.trackableId}");
        }
    }
}

Explanation:

Event: Plane detection event in AR Foundation.
Handler: OnPlanesChanged is executed whenever a plane is added, updated, or removed.

Best Practices for Event-Driven Programming in Unity

Use Built-in Events Where Possible:
- Leverage Unity's UnityEvent, UI events, and physics events instead of reinventing the wheel.
Avoid Overusing Global Events:
- Delegate-based or static events are powerful but can lead to tight coupling and difficulty debugging.
Unsubscribe When Done:
- Always unsubscribe from events to avoid memory leaks or unintended behavior.
csharp

void OnDisable() { myButton.onClick.RemoveListener(OnButtonClick); }
Debugging:
- Use logs or breakpoints to verify that your events are being triggered and handled correctly.
Combine with Coroutines:
- For delayed or time-based responses to events, pair event handlers with Unity's coroutines.

Building a Simple Event Framework

Here’s how you can build a small event-driven framework in Python:

class EventManager:
    def __init__(self):
        self.listeners = {}

    def subscribe(self, event_name, handler):
        if event_name not in self.listeners:
            self.listeners[event_name] = []
        self.listeners[event_name].append(handler)

    def emit(self, event_name, *args, **kwargs):
        if event_name in self.listeners:
            for handler in self.listeners[event_name]:
                handler(*args, **kwargs)

# Example usage
def on_custom_event(data):
    print(f"Custom event received with data: {data}")

event_manager = EventManager()
event_manager.subscribe("custom_event", on_custom_event)
event_manager.emit("custom_event", data="Hello, World!")

Output:

Custom event received with data: Hello, World!

Advantages of Event-Driven Programming

Modularity:
- Event handlers can be written as independent, reusable functions or modules.
Responsiveness:
- Ideal for interactive applications where user input or external events dictate program behavior.
Scalability:
- Can easily add more event types or handlers without major changes to the main program.

Challenges in Event-Driven Programming

Debugging:
- The flow of execution is non-linear, making it harder to trace bugs.
Performance:
- Poorly designed event handlers or excessive events can degrade performance.
State Management:
- Ensuring consistency across multiple event handlers requires careful planning.

Would you like more advanced examples or help applying event-driven programming in a specific context, like AR, gaming, or data pipelines? 🚀