event.h

#pragma once
#include "device.h"
#include "keycode.h"
#include <picofuse/hw/usb.h>
#include <picofuse/hw/wifi.h>
#include <picofuse/pix/types.h>
#include <picofuse/sys/date.h>
#include <picofuse/sys/io.h>
#include <stdbool.h>

#ifndef HID_EVENT_CAPACITY
#define HID_EVENT_CAPACITY 16u
#endif

typedef enum {
  hid_event_type_none = 0,
  hid_event_type_keycode = 1,
  hid_event_type_touch = 2,
  hid_event_type_metric = 3,
  hid_event_type_timer = 4,
  hid_event_type_signal = 5,
  hid_event_type_wifi = 6,
  hid_event_type_iostream = 7,
  hid_event_type_time = 8,
  hid_event_type_usb = 9,
} hid_event_type_t;

typedef struct {
  hid_state_t state; 
  uint16_t keycode;  
} hid_keycode_t;

typedef struct {
  hid_state_t state; 
  pix_point_t point; 
  uint8_t slot;      
} hid_touch_t;

typedef struct {
  const char *name; 
  const char *unit; 
  float value;      
} hid_metric_t;

typedef struct {
  void *userdata; 
} hid_timer_t;

typedef struct {
  sys_env_signal_t signal; 
} hid_signal_t;

typedef struct {
  hw_wifi_event_t event;     
  hw_wifi_network_t network; 
  bool has_network;          
} hid_wifi_t;

typedef struct {
  hw_usb_event_t event;   
  hw_usb_device_t device; 
  bool has_device;        
} hid_usb_t;

typedef struct {
  sys_iostream_event_t events; 
} hid_iostream_t;

typedef struct {
  sys_date_t date; 
} hid_time_t;

typedef struct {
  hid_device_t *device;  
  hid_event_type_t type; 
  union {
    hid_keycode_t keycode;
    hid_touch_t touch;
    hid_metric_t metric;
    hid_timer_t timer;
    hid_signal_t signal;
    hid_wifi_t wifi;
    hid_iostream_t iostream;
    hid_time_t time;
    hid_usb_t usb;
  } data; 
} hid_event_t;

bool hid_event_queue_keycode(hid_device_t *device, hid_state_t state,
                             uint16_t keycode);

bool hid_event_queue_metric_float(hid_device_t *device, const char *name,
                                  const char *unit, float value);

bool hid_event_queue_touch(hid_device_t *device, hid_state_t state,
                           pix_point_t point, uint8_t slot);

bool hid_event_queue_signal(hid_device_t *device, sys_env_signal_t signal);

bool hid_event_queue_wifi(hid_device_t *device, hw_wifi_event_t event,
                          const hw_wifi_network_t *network);

bool hid_event_queue_usb(hid_device_t *device, hw_usb_event_t event,
                         const hw_usb_device_t *usb_device);

bool hid_event_queue_iostream(hid_device_t *device,
                              sys_iostream_event_t events);

bool hid_event_queue_time(hid_device_t *device, const sys_date_t *date);

void hid_event_free(hid_event_t *event);