pwarren/zmk_mf68
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

refactor(core): Extra event payloads to own types, refactor API.

Browse source 
* Make it easier to use *just* event payloads by defining the data,
  and then having event manager macros generate "wrapper structs"
* Improve is_*/cast_* APIs to hide details of full event struct.
* Create `zmk_event_t` typedef to pass to event handlers.
* Bring event names inline w/ consistent `zmk_` prefix.
This commit is contained in:
Pete Johanson 2021-01-18 00:35:56 -05:00
parent 003db892ad
commit 3fe2acc2d1
40 changed files with 190 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

49
app/include/zmk/event_manager.h
View file

@ -14,16 +14,16 @@ struct zmk_event_type {
const char *name; const char *name;
}; };
struct zmk_event_header { typedef struct {
const struct zmk_event_type *event; const struct zmk_event_type *event;
uint8_t last_listener_index; uint8_t last_listener_index;
}; } zmk_event_t;
#define ZMK_EV_EVENT_BUBBLE 0 #define ZMK_EV_EVENT_BUBBLE 0
#define ZMK_EV_EVENT_HANDLED 1 #define ZMK_EV_EVENT_HANDLED 1
#define ZMK_EV_EVENT_CAPTURED 2 #define ZMK_EV_EVENT_CAPTURED 2
typedef int (*zmk_listener_callback_t)(const struct zmk_event_header *eh); typedef int (*zmk_listener_callback_t)(const zmk_event_t *eh);
struct zmk_listener { struct zmk_listener {
zmk_listener_callback_t callback; zmk_listener_callback_t callback;
}; };
@ -34,25 +34,29 @@ struct zmk_event_subscription {
}; };
#define ZMK_EVENT_DECLARE(event_type) \ #define ZMK_EVENT_DECLARE(event_type) \
struct event_type *new_##event_type(); \ struct event_type##_event { \
bool is_##event_type(const struct zmk_event_header *eh); \ zmk_event_t header; \
struct event_type *cast_##event_type(const struct zmk_event_header *eh); \ struct event_type data; \
}; \
struct event_type##_event *new_##event_type(struct event_type); \
bool is_##event_type(const zmk_event_t *eh); \
struct event_type *cast_##event_type(const zmk_event_t *eh); \
extern const struct zmk_event_type zmk_event_##event_type; extern const struct zmk_event_type zmk_event_##event_type;
#define ZMK_EVENT_IMPL(event_type) \ #define ZMK_EVENT_IMPL(event_type) \
const struct zmk_event_type zmk_event_##event_type = {.name = STRINGIFY(event_type)}; \ const struct zmk_event_type zmk_event_##event_type = {.name = STRINGIFY(event_type)}; \
const struct zmk_event_type *zmk_event_ref_##event_type __used \ const struct zmk_event_type *zmk_event_ref_##event_type __used \
__attribute__((__section__(".event_type"))) = &zmk_event_##event_type; \ __attribute__((__section__(".event_type"))) = &zmk_event_##event_type; \
struct event_type *new_##event_type() { \ struct event_type##_event *new_##event_type(struct event_type data) { \
struct event_type *ev = (struct event_type *)k_malloc(sizeof(struct event_type)); \ struct event_type##_event *ev = \
(struct event_type##_event *)k_malloc(sizeof(struct event_type##_event)); \
ev->header.event = &zmk_event_##event_type; \ ev->header.event = &zmk_event_##event_type; \
ev->data = data; \
return ev; \ return ev; \
}; \ }; \
bool is_##event_type(const struct zmk_event_header *eh) { \ bool is_##event_type(const zmk_event_t *eh) { return eh->event == &zmk_event_##event_type; }; \
return eh->event == &zmk_event_##event_type; \ struct event_type *cast_##event_type(const zmk_event_t *eh) { \
}; \ return &((struct event_type##_event *)eh)->data; \
struct event_type *cast_##event_type(const struct zmk_event_header *eh) { \
return (struct event_type *)eh; \
}; };
#define ZMK_LISTENER(mod, cb) const struct zmk_listener zmk_listener_##mod = {.callback = cb}; #define ZMK_LISTENER(mod, cb) const struct zmk_listener zmk_listener_##mod = {.callback = cb};
@ -65,18 +69,19 @@ struct zmk_event_subscription {
.listener = &zmk_listener_##mod, \ .listener = &zmk_listener_##mod, \
}; };
#define ZMK_EVENT_RAISE(ev) zmk_event_manager_raise((struct zmk_event_header *)ev); #define ZMK_EVENT_RAISE(ev) zmk_event_manager_raise((zmk_event_t *)ev);
#define ZMK_EVENT_RAISE_AFTER(ev, mod) \ #define ZMK_EVENT_RAISE_AFTER(ev, mod) \
zmk_event_manager_raise_after((struct zmk_event_header *)ev, &zmk_listener_##mod); zmk_event_manager_raise_after((zmk_event_t *)ev, &zmk_listener_##mod);
#define ZMK_EVENT_RAISE_AT(ev, mod) \ #define ZMK_EVENT_RAISE_AT(ev, mod) \
zmk_event_manager_raise_at((struct zmk_event_header *)ev, &zmk_listener_##mod); zmk_event_manager_raise_at((zmk_event_t *)ev, &zmk_listener_##mod);
#define ZMK_EVENT_RELEASE(ev) zmk_event_manager_release((struct zmk_event_header *)ev); #define ZMK_EVENT_RELEASE(ev) zmk_event_manager_release((zmk_event_t *)ev);
int zmk_event_manager_raise(struct zmk_event_header *event); #define ZMK_EVENT_FREE(ev) k_free((void *)ev);
int zmk_event_manager_raise_after(struct zmk_event_header *event,
const struct zmk_listener *listener); int zmk_event_manager_raise(zmk_event_t *event);
int zmk_event_manager_raise_at(struct zmk_event_header *event, const struct zmk_listener *listener); int zmk_event_manager_raise_after(zmk_event_t *event, const struct zmk_listener *listener);
int zmk_event_manager_release(struct zmk_event_header *event); int zmk_event_manager_raise_at(zmk_event_t *event, const struct zmk_listener *listener);
int zmk_event_manager_release(zmk_event_t *event);

13
app/include/zmk/events/activity_state_changed.h
View file

@ -10,17 +10,8 @@
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
#include <zmk/activity.h> #include <zmk/activity.h>
struct activity_state_changed { struct zmk_activity_state_changed {
struct zmk_event_header header;
enum zmk_activity_state state; enum zmk_activity_state state;
}; };
ZMK_EVENT_DECLARE(activity_state_changed); ZMK_EVENT_DECLARE(zmk_activity_state_changed);
static inline struct activity_state_changed *
create_activity_state_changed(enum zmk_activity_state state) {
struct activity_state_changed *ev = new_activity_state_changed();
ev->state = state;
return ev;
}

5
app/include/zmk/events/battery_state_changed.h
View file

@ -9,10 +9,9 @@
#include <zephyr.h> #include <zephyr.h>
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
struct battery_state_changed { struct zmk_battery_state_changed {
struct zmk_event_header header;
// TODO: Other battery channels // TODO: Other battery channels
uint8_t state_of_charge; uint8_t state_of_charge;
}; };
ZMK_EVENT_DECLARE(battery_state_changed); ZMK_EVENT_DECLARE(zmk_battery_state_changed);

5
app/include/zmk/events/ble_active_profile_changed.h
View file

@ -12,10 +12,9 @@
#include <zmk/ble/profile.h> #include <zmk/ble/profile.h>
struct ble_active_profile_changed { struct zmk_ble_active_profile_changed {
struct zmk_event_header header;
uint8_t index; uint8_t index;
struct zmk_ble_profile *profile; struct zmk_ble_profile *profile;
}; };
ZMK_EVENT_DECLARE(ble_active_profile_changed); ZMK_EVENT_DECLARE(zmk_ble_active_profile_changed);

22
app/include/zmk/events/keycode_state_changed.h
View file

@ -12,8 +12,7 @@
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
#include <zmk/keys.h> #include <zmk/keys.h>
struct keycode_state_changed { struct zmk_keycode_state_changed {
struct zmk_event_header header;
uint16_t usage_page; uint16_t usage_page;
uint32_t keycode; uint32_t keycode;
uint8_t implicit_modifiers; uint8_t implicit_modifiers;
@ -21,10 +20,10 @@ struct keycode_state_changed {
int64_t timestamp; int64_t timestamp;
}; };
ZMK_EVENT_DECLARE(keycode_state_changed); ZMK_EVENT_DECLARE(zmk_keycode_state_changed);
static inline struct keycode_state_changed * static inline struct zmk_keycode_state_changed_event *
keycode_state_changed_from_encoded(uint32_t encoded, bool pressed, int64_t timestamp) { zmk_keycode_state_changed_from_encoded(uint32_t encoded, bool pressed, int64_t timestamp) {
uint16_t page = HID_USAGE_PAGE(encoded) & 0xFF; uint16_t page = HID_USAGE_PAGE(encoded) & 0xFF;
uint16_t id = HID_USAGE_ID(encoded); uint16_t id = HID_USAGE_ID(encoded);
zmk_mod_flags_t implicit_mods = SELECT_MODS(encoded); zmk_mod_flags_t implicit_mods = SELECT_MODS(encoded);
@ -33,11 +32,10 @@ keycode_state_changed_from_encoded(uint32_t encoded, bool pressed, int64_t times
page = HID_USAGE_KEY; page = HID_USAGE_KEY;
} }
struct keycode_state_changed *ev = new_keycode_state_changed(); return new_zmk_keycode_state_changed(
ev->usage_page = page; (struct zmk_keycode_state_changed){.usage_page = page,
ev->keycode = id; .keycode = id,
ev->implicit_modifiers = implicit_mods; .implicit_modifiers = implicit_mods,
ev->state = pressed; .state = pressed,
ev->timestamp = timestamp; .timestamp = timestamp});
return ev;
} }

16
app/include/zmk/events/layer_state_changed.h
View file

@ -9,20 +9,16 @@
#include <zephyr.h> #include <zephyr.h>
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
struct layer_state_changed { struct zmk_layer_state_changed {
struct zmk_event_header header;
uint8_t layer; uint8_t layer;
bool state; bool state;
int64_t timestamp; int64_t timestamp;
}; };
ZMK_EVENT_DECLARE(layer_state_changed); ZMK_EVENT_DECLARE(zmk_layer_state_changed);
static inline struct layer_state_changed *create_layer_state_changed(uint8_t layer, bool state) { static inline struct zmk_layer_state_changed_event *create_layer_state_changed(uint8_t layer,
struct layer_state_changed *ev = new_layer_state_changed(); bool state) {
ev->layer = layer; return new_zmk_layer_state_changed((struct zmk_layer_state_changed){
ev->state = state; .layer = layer, .state = state, .timestamp = k_uptime_get()});
ev->timestamp = k_uptime_get();
return ev;
} }

14
app/include/zmk/events/modifiers_state_changed.h
View file

@ -10,19 +10,9 @@
#include <zmk/keys.h> #include <zmk/keys.h>
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
struct modifiers_state_changed { struct zmk_modifiers_state_changed {
struct zmk_event_header header;
zmk_mod_flags_t modifiers; zmk_mod_flags_t modifiers;
bool state; bool state;
}; };
ZMK_EVENT_DECLARE(modifiers_state_changed); ZMK_EVENT_DECLARE(zmk_modifiers_state_changed);
inline struct modifiers_state_changed *create_modifiers_state_changed(zmk_mod_flags_t modifiers,
bool state) {
struct modifiers_state_changed *ev = new_modifiers_state_changed();
ev->modifiers = modifiers;
ev->state = state;
return ev;
}

10
app/include/zmk/events/position_state_changed.h
View file

@ -8,16 +8,10 @@
#include <zephyr.h> #include <zephyr.h>
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
struct zmk_position_state_changed {
struct zmk_position_state_changed_data {
uint32_t position; uint32_t position;
bool state; bool state;
int64_t timestamp; int64_t timestamp;
}; };
struct position_state_changed { ZMK_EVENT_DECLARE(zmk_position_state_changed);
struct zmk_event_header header;
struct zmk_position_state_changed_data data;
};
ZMK_EVENT_DECLARE(position_state_changed);

6
app/include/zmk/events/sensor_event.h
View file

@ -9,12 +9,10 @@
#include <zephyr.h> #include <zephyr.h>
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
#include <device.h> #include <device.h>
struct zmk_sensor_event {
struct sensor_event {
struct zmk_event_header header;
uint8_t sensor_number; uint8_t sensor_number;
const struct device *sensor; const struct device *sensor;
int64_t timestamp; int64_t timestamp;
}; };
ZMK_EVENT_DECLARE(sensor_event); ZMK_EVENT_DECLARE(zmk_sensor_event);

5
app/include/zmk/events/usb_conn_state_changed.h
View file

@ -12,9 +12,8 @@
#include <zmk/event_manager.h> #include <zmk/event_manager.h>
#include <zmk/usb.h> #include <zmk/usb.h>
struct usb_conn_state_changed { struct zmk_usb_conn_state_changed {
struct zmk_event_header header;
enum zmk_usb_conn_state conn_state; enum zmk_usb_conn_state conn_state;
}; };
ZMK_EVENT_DECLARE(usb_conn_state_changed); ZMK_EVENT_DECLARE(zmk_usb_conn_state_changed);

11
app/src/activity.c
View file

@ -29,7 +29,10 @@ static uint32_t activity_last_uptime;
#define MAX_SLEEP_MS CONFIG_ZMK_IDLE_SLEEP_TIMEOUT #define MAX_SLEEP_MS CONFIG_ZMK_IDLE_SLEEP_TIMEOUT
#endif #endif
int raise_event() { return ZMK_EVENT_RAISE(create_activity_state_changed(activity_state)); } int raise_event() {
return ZMK_EVENT_RAISE(new_zmk_activity_state_changed(
(struct zmk_activity_state_changed){.state = activity_state}));
}
int set_state(enum zmk_activity_state state) { int set_state(enum zmk_activity_state state) {
if (activity_state == state) if (activity_state == state)
@ -41,7 +44,7 @@ int set_state(enum zmk_activity_state state) {
enum zmk_activity_state zmk_activity_get_state() { return activity_state; } enum zmk_activity_state zmk_activity_get_state() { return activity_state; }
int activity_event_listener(const struct zmk_event_header *eh) { int activity_event_listener(const zmk_event_t *eh) {
activity_last_uptime = k_uptime_get(); activity_last_uptime = k_uptime_get();
return set_state(ZMK_ACTIVITY_ACTIVE); return set_state(ZMK_ACTIVITY_ACTIVE);
@ -74,7 +77,7 @@ int activity_init() {
} }
ZMK_LISTENER(activity, activity_event_listener); ZMK_LISTENER(activity, activity_event_listener);
ZMK_SUBSCRIPTION(activity, position_state_changed); ZMK_SUBSCRIPTION(activity, zmk_position_state_changed);
ZMK_SUBSCRIPTION(activity, sensor_event); ZMK_SUBSCRIPTION(activity, zmk_sensor_event);
SYS_INIT(activity_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY); SYS_INIT(activity_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

5
app/src/battery.c
View file

@ -45,9 +45,8 @@ static int zmk_battery_update(const struct device *battery) {
return rc; return rc;
} }
struct battery_state_changed *ev = new_battery_state_changed(); return ZMK_EVENT_RAISE(new_zmk_battery_state_changed(
ev->state_of_charge = state_of_charge.val1; (struct zmk_battery_state_changed){.state_of_charge = state_of_charge.val1}));
return ZMK_EVENT_RAISE(ev);
} }
static void zmk_battery_work(struct k_work *work) { static void zmk_battery_work(struct k_work *work) {

73
app/src/behaviors/behavior_hold_tap.c
View file

@ -69,9 +69,9 @@ struct active_hold_tap {
struct active_hold_tap *undecided_hold_tap = NULL; struct active_hold_tap *undecided_hold_tap = NULL;
struct active_hold_tap active_hold_taps[ZMK_BHV_HOLD_TAP_MAX_HELD] = {}; struct active_hold_tap active_hold_taps[ZMK_BHV_HOLD_TAP_MAX_HELD] = {};
// We capture most position_state_changed events and some modifiers_state_changed events. // We capture most position_state_changed events and some modifiers_state_changed events.
const struct zmk_event_header *captured_events[ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS] = {}; const zmk_event_t *captured_events[ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS] = {};
static int capture_event(const struct zmk_event_header *event) { static int capture_event(const zmk_event_t *event) {
for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) { for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
if (captured_events[i] == NULL) { if (captured_events[i] == NULL) {
captured_events[i] = event; captured_events[i] = event;
@ -81,18 +81,18 @@ static int capture_event(const struct zmk_event_header *event) {
return -ENOMEM; return -ENOMEM;
} }
static struct position_state_changed *find_captured_keydown_event(uint32_t position) { static struct zmk_position_state_changed *find_captured_keydown_event(uint32_t position) {
struct position_state_changed *last_match = NULL; struct zmk_position_state_changed *last_match = NULL;
for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) { for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
const struct zmk_event_header *eh = captured_events[i]; const zmk_event_t *eh = captured_events[i];
if (eh == NULL) { if (eh == NULL) {
return last_match; return last_match;
} }
if (!is_position_state_changed(eh)) { if (!is_zmk_position_state_changed(eh)) {
continue; continue;
} }
struct position_state_changed *position_event = cast_position_state_changed(eh); struct zmk_position_state_changed *position_event = cast_zmk_position_state_changed(eh);
if (position_event->data.position == position && position_event->data.state) { if (position_event->position == position && position_event->state) {
last_match = position_event; last_match = position_event;
} }
} }
@ -132,7 +132,7 @@ static void release_captured_events() {
// [k1_down, k1_up, null, null, null, ...] // [k1_down, k1_up, null, null, null, ...]
// now mt2 will start releasing it's own captured positions. // now mt2 will start releasing it's own captured positions.
for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) { for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
const struct zmk_event_header *captured_event = captured_events[i]; const zmk_event_t *captured_event = captured_events[i];
if (captured_event == NULL) { if (captured_event == NULL) {
return; return;
} }
@ -140,15 +140,14 @@ static void release_captured_events() {
if (undecided_hold_tap != NULL) { if (undecided_hold_tap != NULL) {
k_msleep(10); k_msleep(10);
} }
if (is_position_state_changed(captured_event)) { if (is_zmk_position_state_changed(captured_event)) {
struct position_state_changed *position_event = struct zmk_position_state_changed *position_event =
cast_position_state_changed(captured_event); cast_zmk_position_state_changed(captured_event);
LOG_DBG("Releasing key position event for position %d %s", LOG_DBG("Releasing key position event for position %d %s", position_event->position,
position_event->data.position, (position_event->state ? "pressed" : "released"));
(position_event->data.state ? "pressed" : "released"));
} else { } else {
struct keycode_state_changed *modifier_event = struct zmk_keycode_state_changed *modifier_event =
cast_keycode_state_changed(captured_event); cast_zmk_keycode_state_changed(captured_event);
LOG_DBG("Releasing mods changed event 0x%02X %s", modifier_event->keycode, LOG_DBG("Releasing mods changed event 0x%02X %s", modifier_event->keycode,
(modifier_event->state ? "pressed" : "released")); (modifier_event->state ? "pressed" : "released"));
} }
@ -388,16 +387,16 @@ static const struct behavior_driver_api behavior_hold_tap_driver_api = {
.binding_released = on_hold_tap_binding_released, .binding_released = on_hold_tap_binding_released,
}; };
static int position_state_changed_listener(const struct zmk_event_header *eh) { static int position_state_changed_listener(const zmk_event_t *eh) {
struct position_state_changed *ev = cast_position_state_changed(eh); struct zmk_position_state_changed *ev = cast_zmk_position_state_changed(eh);
if (undecided_hold_tap == NULL) { if (undecided_hold_tap == NULL) {
LOG_DBG("%d bubble (no undecided hold_tap active)", ev->data.position); LOG_DBG("%d bubble (no undecided hold_tap active)", ev->position);
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
if (undecided_hold_tap->position == ev->data.position) { if (undecided_hold_tap->position == ev->position) {
if (ev->data.state) { // keydown if (ev->state) { // keydown
LOG_ERR("hold-tap listener should be called before before most other listeners!"); LOG_ERR("hold-tap listener should be called before before most other listeners!");
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} else { // keyup } else { // keyup
@ -409,34 +408,34 @@ static int position_state_changed_listener(const struct zmk_event_header *eh) {
// If these events were queued, the timer event may be queued too late or not at all. // If these events were queued, the timer event may be queued too late or not at all.
// We make a timer decision before the other key events are handled if the timer would // We make a timer decision before the other key events are handled if the timer would
// have run out. // have run out.
if (ev->data.timestamp > if (ev->timestamp >
(undecided_hold_tap->timestamp + undecided_hold_tap->config->tapping_term_ms)) { (undecided_hold_tap->timestamp + undecided_hold_tap->config->tapping_term_ms)) {
decide_hold_tap(undecided_hold_tap, HT_TIMER_EVENT); decide_hold_tap(undecided_hold_tap, HT_TIMER_EVENT);
} }
if (!ev->data.state && find_captured_keydown_event(ev->data.position) == NULL) { if (!ev->state && find_captured_keydown_event(ev->position) == NULL) {
// no keydown event has been captured, let it bubble. // no keydown event has been captured, let it bubble.
// we'll catch modifiers later in modifier_state_changed_listener // we'll catch modifiers later in modifier_state_changed_listener
LOG_DBG("%d bubbling %d %s event", undecided_hold_tap->position, ev->data.position, LOG_DBG("%d bubbling %d %s event", undecided_hold_tap->position, ev->position,
ev->data.state ? "down" : "up"); ev->state ? "down" : "up");
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
LOG_DBG("%d capturing %d %s event", undecided_hold_tap->position, ev->data.position, LOG_DBG("%d capturing %d %s event", undecided_hold_tap->position, ev->position,
ev->data.state ? "down" : "up"); ev->state ? "down" : "up");
capture_event(eh); capture_event(eh);
decide_hold_tap(undecided_hold_tap, ev->data.state ? HT_OTHER_KEY_DOWN : HT_OTHER_KEY_UP); decide_hold_tap(undecided_hold_tap, ev->state ? HT_OTHER_KEY_DOWN : HT_OTHER_KEY_UP);
return ZMK_EV_EVENT_CAPTURED; return ZMK_EV_EVENT_CAPTURED;
} }
static inline bool only_mods(struct keycode_state_changed *ev) { static inline bool only_mods(struct zmk_keycode_state_changed *ev) {
return ev->usage_page == HID_USAGE_KEY && ev->keycode >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL && return ev->usage_page == HID_USAGE_KEY && ev->keycode >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL &&
ev->keycode <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI; ev->keycode <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI;
} }
static int keycode_state_changed_listener(const struct zmk_event_header *eh) { static int keycode_state_changed_listener(const zmk_event_t *eh) {
// we want to catch layer-up events too... how? // we want to catch layer-up events too... how?
struct keycode_state_changed *ev = cast_keycode_state_changed(eh); struct zmk_keycode_state_changed *ev = cast_zmk_keycode_state_changed(eh);
if (undecided_hold_tap == NULL) { if (undecided_hold_tap == NULL) {
// LOG_DBG("0x%02X bubble (no undecided hold_tap active)", ev->keycode); // LOG_DBG("0x%02X bubble (no undecided hold_tap active)", ev->keycode);
@ -456,19 +455,19 @@ static int keycode_state_changed_listener(const struct zmk_event_header *eh) {
return ZMK_EV_EVENT_CAPTURED; return ZMK_EV_EVENT_CAPTURED;
} }
int behavior_hold_tap_listener(const struct zmk_event_header *eh) { int behavior_hold_tap_listener(const zmk_event_t *eh) {
if (is_position_state_changed(eh)) { if (is_zmk_position_state_changed(eh)) {
return position_state_changed_listener(eh); return position_state_changed_listener(eh);
} else if (is_keycode_state_changed(eh)) { } else if (is_zmk_keycode_state_changed(eh)) {
return keycode_state_changed_listener(eh); return keycode_state_changed_listener(eh);
} }
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
ZMK_LISTENER(behavior_hold_tap, behavior_hold_tap_listener); ZMK_LISTENER(behavior_hold_tap, behavior_hold_tap_listener);
ZMK_SUBSCRIPTION(behavior_hold_tap, position_state_changed); ZMK_SUBSCRIPTION(behavior_hold_tap, zmk_position_state_changed);
// this should be modifiers_state_changed, but unfrotunately that's not implemented yet. // this should be modifiers_state_changed, but unfrotunately that's not implemented yet.
ZMK_SUBSCRIPTION(behavior_hold_tap, keycode_state_changed); ZMK_SUBSCRIPTION(behavior_hold_tap, zmk_keycode_state_changed);
void behavior_hold_tap_timer_work_handler(struct k_work *item) { void behavior_hold_tap_timer_work_handler(struct k_work *item) {
struct active_hold_tap *hold_tap = CONTAINER_OF(item, struct active_hold_tap, work); struct active_hold_tap *hold_tap = CONTAINER_OF(item, struct active_hold_tap, work);

4
app/src/behaviors/behavior_key_press.c
View file

@ -22,14 +22,14 @@ static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1); LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1);
return ZMK_EVENT_RAISE( return ZMK_EVENT_RAISE(
keycode_state_changed_from_encoded(binding->param1, true, event.timestamp)); zmk_keycode_state_changed_from_encoded(binding->param1, true, event.timestamp));
} }
static int on_keymap_binding_released(struct zmk_behavior_binding *binding, static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event) { struct zmk_behavior_binding_event event) {
LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1); LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1);
return ZMK_EVENT_RAISE( return ZMK_EVENT_RAISE(
keycode_state_changed_from_encoded(binding->param1, false, event.timestamp)); zmk_keycode_state_changed_from_encoded(binding->param1, false, event.timestamp));
} }
static const struct behavior_driver_api behavior_key_press_driver_api = { static const struct behavior_driver_api behavior_key_press_driver_api = {

4
app/src/behaviors/behavior_sensor_rotate_key_press.c
View file

@ -45,12 +45,12 @@ static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding,
LOG_DBG("SEND %d", keycode); LOG_DBG("SEND %d", keycode);
ZMK_EVENT_RAISE(keycode_state_changed_from_encoded(keycode, true, timestamp)); ZMK_EVENT_RAISE(zmk_keycode_state_changed_from_encoded(keycode, true, timestamp));
// TODO: Better way to do this? // TODO: Better way to do this?
k_msleep(5); k_msleep(5);
return ZMK_EVENT_RAISE(keycode_state_changed_from_encoded(keycode, false, timestamp)); return ZMK_EVENT_RAISE(zmk_keycode_state_changed_from_encoded(keycode, false, timestamp));
} }
static const struct behavior_driver_api behavior_sensor_rotate_key_press_driver_api = { static const struct behavior_driver_api behavior_sensor_rotate_key_press_driver_api = {

8
app/src/behaviors/behavior_sticky_key.c
View file

@ -175,11 +175,11 @@ static const struct behavior_driver_api behavior_sticky_key_driver_api = {
.binding_released = on_sticky_key_binding_released, .binding_released = on_sticky_key_binding_released,
}; };
static int sticky_key_keycode_state_changed_listener(const struct zmk_event_header *eh) { static int sticky_key_keycode_state_changed_listener(const zmk_event_t *eh) {
if (!is_keycode_state_changed(eh)) { if (!is_zmk_keycode_state_changed(eh)) {
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
struct keycode_state_changed *ev = cast_keycode_state_changed(eh); struct zmk_keycode_state_changed *ev = cast_zmk_keycode_state_changed(eh);
for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) { for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {
struct active_sticky_key *sticky_key = &active_sticky_keys[i]; struct active_sticky_key *sticky_key = &active_sticky_keys[i];
if (sticky_key->position == ZMK_BHV_STICKY_KEY_POSITION_FREE) { if (sticky_key->position == ZMK_BHV_STICKY_KEY_POSITION_FREE) {
@ -226,7 +226,7 @@ static int sticky_key_keycode_state_changed_listener(const struct zmk_event_head
} }
ZMK_LISTENER(behavior_sticky_key, sticky_key_keycode_state_changed_listener); ZMK_LISTENER(behavior_sticky_key, sticky_key_keycode_state_changed_listener);
ZMK_SUBSCRIPTION(behavior_sticky_key, keycode_state_changed); ZMK_SUBSCRIPTION(behavior_sticky_key, zmk_keycode_state_changed);
void behavior_sticky_key_timer_handler(struct k_work *item) { void behavior_sticky_key_timer_handler(struct k_work *item) {
struct active_sticky_key *sticky_key = struct active_sticky_key *sticky_key =

7
app/src/ble.c
View file

@ -92,11 +92,8 @@ static bt_addr_le_t peripheral_addr;
#endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL) */ #endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL) */
static void raise_profile_changed_event() { static void raise_profile_changed_event() {
struct ble_active_profile_changed *ev = new_ble_active_profile_changed(); ZMK_EVENT_RAISE(new_zmk_ble_active_profile_changed((struct zmk_ble_active_profile_changed){
ev->index = active_profile; .index = active_profile, .profile = &profiles[active_profile]}));
ev->profile = &profiles[active_profile];
ZMK_EVENT_RAISE(ev);
} }
static void raise_profile_changed_event_callback(struct k_work *work) { static void raise_profile_changed_event_callback(struct k_work *work) {

40
app/src/combo.c
View file

@ -40,7 +40,7 @@ struct active_combo {
// key_positions_pressed is filled with key_positions when the combo is pressed. // key_positions_pressed is filled with key_positions when the combo is pressed.
// The keys are removed from this array when they are released. // The keys are removed from this array when they are released.
// Once this array is empty, the behavior is released. // Once this array is empty, the behavior is released.
struct position_state_changed *key_positions_pressed[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO]; const zmk_event_t *key_positions_pressed[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO];
}; };
struct combo_candidate { struct combo_candidate {
@ -52,7 +52,7 @@ struct combo_candidate {
}; };
// set of keys pressed // set of keys pressed
struct position_state_changed *pressed_keys[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO] = {NULL}; const zmk_event_t *pressed_keys[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO] = {NULL};
// the set of candidate combos based on the currently pressed_keys // the set of candidate combos based on the currently pressed_keys
struct combo_candidate candidates[CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY]; struct combo_candidate candidates[CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY];
// the last candidate that was completely pressed // the last candidate that was completely pressed
@ -202,7 +202,7 @@ static int clear_candidates() {
return CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; return CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY;
} }
static int capture_pressed_key(struct position_state_changed *ev) { static int capture_pressed_key(const zmk_event_t *ev) {
for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) { for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) {
if (pressed_keys[i] != NULL) { if (pressed_keys[i] != NULL) {
continue; continue;
@ -228,7 +228,7 @@ static void release_pressed_keys() {
if (pressed_keys[i] == NULL) { if (pressed_keys[i] == NULL) {
return; return;
} }
struct position_state_changed *captured_event = pressed_keys[i]; const zmk_event_t *captured_event = pressed_keys[i];
pressed_keys[i] = NULL; pressed_keys[i] = NULL;
ZMK_EVENT_RAISE(captured_event); ZMK_EVENT_RAISE(captured_event);
} }
@ -290,7 +290,8 @@ static void activate_combo(struct combo_cfg *combo) {
return; return;
} }
move_pressed_keys_to_active_combo(active_combo); move_pressed_keys_to_active_combo(active_combo);
press_combo_behavior(combo, active_combo->key_positions_pressed[0]->timestamp); press_combo_behavior(
combo, cast_zmk_position_state_changed(active_combo->key_positions_pressed[0])->timestamp);
} }
static void deactivate_combo(int active_combo_index) { static void deactivate_combo(int active_combo_index) {
@ -314,10 +315,11 @@ static bool release_combo_key(int32_t position, int64_t timestamp) {
for (int i = 0; i < active_combo->combo->key_position_len; i++) { for (int i = 0; i < active_combo->combo->key_position_len; i++) {
if (active_combo->key_positions_pressed[i] == NULL) { if (active_combo->key_positions_pressed[i] == NULL) {
all_keys_pressed = false; all_keys_pressed = false;
} else if (active_combo->key_positions_pressed[i]->position != position) { } else if (cast_zmk_position_state_changed(active_combo->key_positions_pressed[i])
->position != position) {
all_keys_released = false; all_keys_released = false;
} else { // not null and position matches } else { // not null and position matches
k_free(active_combo->key_positions_pressed[i]); ZMK_EVENT_FREE(active_combo->key_positions_pressed[i]);
active_combo->key_positions_pressed[i] = NULL; active_combo->key_positions_pressed[i] = NULL;
key_released = true; key_released = true;
} }
@ -362,16 +364,16 @@ static void update_timeout_task() {
} }
} }
static int position_state_down(struct position_state_changed *ev) { static int position_state_down(const zmk_event_t *ev, struct zmk_position_state_changed *data) {
int num_candidates; int num_candidates;
if (candidates[0].combo == NULL) { if (candidates[0].combo == NULL) {
num_candidates = setup_candidates_for_first_keypress(ev->position, ev->timestamp); num_candidates = setup_candidates_for_first_keypress(data->position, data->timestamp);
if (num_candidates == 0) { if (num_candidates == 0) {
return 0; return 0;
} }
} else { } else {
filter_timed_out_candidates(ev->timestamp); filter_timed_out_candidates(data->timestamp);
num_candidates = filter_candidates(ev->position); num_candidates = filter_candidates(data->position);
} }
update_timeout_task(); update_timeout_task();
@ -395,7 +397,7 @@ static int position_state_down(struct position_state_changed *ev) {
} }
} }
static int position_state_up(struct position_state_changed *ev) { static int position_state_up(struct zmk_position_state_changed *ev) {
cleanup(); cleanup();
if (release_combo_key(ev->position, ev->timestamp)) { if (release_combo_key(ev->position, ev->timestamp)) {
return ZMK_EV_EVENT_HANDLED; return ZMK_EV_EVENT_HANDLED;
@ -415,21 +417,21 @@ static void combo_timeout_handler(struct k_work *item) {
update_timeout_task(); update_timeout_task();
} }
static int position_state_changed_listener(const struct zmk_event_header *eh) { static int position_state_changed_listener(const zmk_event_t *ev) {
if (!is_position_state_changed(eh)) { if (!is_zmk_position_state_changed(ev)) {
return 0; return 0;
} }
struct position_state_changed *ev = cast_position_state_changed(eh); struct zmk_position_state_changed *data = cast_zmk_position_state_changed(ev);
if (ev->state) { // keydown if (data->state) { // keydown
return position_state_down(ev); return position_state_down(ev, data);
} else { // keyup } else { // keyup
return position_state_up(ev); return position_state_up(data);
} }
} }
ZMK_LISTENER(combo, position_state_changed_listener); ZMK_LISTENER(combo, position_state_changed_listener);
ZMK_SUBSCRIPTION(combo, position_state_changed); ZMK_SUBSCRIPTION(combo, zmk_position_state_changed);
// todo: remove this once #506 is merged and #include <zmk/keymap.h> // todo: remove this once #506 is merged and #include <zmk/keymap.h>
#define KEY_BINDING_TO_STRUCT(idx, drv_inst) \ #define KEY_BINDING_TO_STRUCT(idx, drv_inst) \

6
app/src/display/main.c
View file

@ -75,8 +75,8 @@ int zmk_display_init() {
return 0; return 0;
} }
int display_event_handler(const struct zmk_event_header *eh) { int display_event_handler(const zmk_event_t *eh) {
struct activity_state_changed *ev = cast_activity_state_changed(eh); struct zmk_activity_state_changed *ev = cast_zmk_activity_state_changed(eh);
switch (ev->state) { switch (ev->state) {
case ZMK_ACTIVITY_ACTIVE: case ZMK_ACTIVITY_ACTIVE:
start_display_updates(); start_display_updates();
@ -93,4 +93,4 @@ int display_event_handler(const struct zmk_event_header *eh) {
} }
ZMK_LISTENER(display, display_event_handler); ZMK_LISTENER(display, display_event_handler);
ZMK_SUBSCRIPTION(display, activity_state_changed); ZMK_SUBSCRIPTION(display, zmk_activity_state_changed);

6
app/src/display/widgets/battery_status.c
View file

@ -75,14 +75,14 @@ lv_obj_t *zmk_widget_battery_status_obj(struct zmk_widget_battery_status *widget
return widget->obj; return widget->obj;
} }
int battery_status_listener(const struct zmk_event_header *eh) { int battery_status_listener(const zmk_event_t *eh) {
struct zmk_widget_battery_status *widget; struct zmk_widget_battery_status *widget;
SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_battery_symbol(widget->obj); } SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_battery_symbol(widget->obj); }
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
ZMK_LISTENER(widget_battery_status, battery_status_listener) ZMK_LISTENER(widget_battery_status, battery_status_listener)
ZMK_SUBSCRIPTION(widget_battery_status, battery_state_changed); ZMK_SUBSCRIPTION(widget_battery_status, zmk_battery_state_changed);
#if IS_ENABLED(CONFIG_USB) #if IS_ENABLED(CONFIG_USB)
ZMK_SUBSCRIPTION(widget_battery_status, usb_conn_state_changed); ZMK_SUBSCRIPTION(widget_battery_status, zmk_usb_conn_state_changed);
#endif /* IS_ENABLED(CONFIG_USB) */ #endif /* IS_ENABLED(CONFIG_USB) */

4
app/src/display/widgets/layer_status.c
View file

@ -69,11 +69,11 @@ lv_obj_t *zmk_widget_layer_status_obj(struct zmk_widget_layer_status *widget) {
return widget->obj; return widget->obj;
} }
int layer_status_listener(const struct zmk_event_header *eh) { int layer_status_listener(const zmk_event_t *eh) {
struct zmk_widget_layer_status *widget; struct zmk_widget_layer_status *widget;
SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_layer_symbol(widget->obj); } SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_layer_symbol(widget->obj); }
return 0; return 0;
} }
ZMK_LISTENER(widget_layer_status, layer_status_listener) ZMK_LISTENER(widget_layer_status, layer_status_listener)
ZMK_SUBSCRIPTION(widget_layer_status, layer_state_changed); ZMK_SUBSCRIPTION(widget_layer_status, zmk_layer_state_changed);

6
app/src/display/widgets/output_status.c
View file

@ -79,7 +79,7 @@ lv_obj_t *zmk_widget_output_status_obj(struct zmk_widget_output_status *widget)
return widget->obj; return widget->obj;
} }
int output_status_listener(const struct zmk_event_header *eh) { int output_status_listener(const zmk_event_t *eh) {
struct zmk_widget_output_status *widget; struct zmk_widget_output_status *widget;
SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_status_symbol(widget->obj); } SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_status_symbol(widget->obj); }
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
@ -87,8 +87,8 @@ int output_status_listener(const struct zmk_event_header *eh) {
ZMK_LISTENER(widget_output_status, output_status_listener) ZMK_LISTENER(widget_output_status, output_status_listener)
#if defined(CONFIG_USB) #if defined(CONFIG_USB)
ZMK_SUBSCRIPTION(widget_output_status, usb_conn_state_changed); ZMK_SUBSCRIPTION(widget_output_status, zmk_usb_conn_state_changed);
#endif #endif
#if defined(CONFIG_ZMK_BLE) #if defined(CONFIG_ZMK_BLE)
ZMK_SUBSCRIPTION(widget_output_status, ble_active_profile_changed); ZMK_SUBSCRIPTION(widget_output_status, zmk_ble_active_profile_changed);
#endif #endif

6
app/src/endpoints.c
View file

@ -245,17 +245,17 @@ static void update_current_endpoint() {
} }
} }
static int endpoint_listener(const struct zmk_event_header *eh) { static int endpoint_listener(const zmk_event_t *eh) {
update_current_endpoint(); update_current_endpoint();
return 0; return 0;
} }
ZMK_LISTENER(endpoint_listener, endpoint_listener); ZMK_LISTENER(endpoint_listener, endpoint_listener);
#if IS_ENABLED(CONFIG_ZMK_USB) #if IS_ENABLED(CONFIG_ZMK_USB)
ZMK_SUBSCRIPTION(endpoint_listener, usb_conn_state_changed); ZMK_SUBSCRIPTION(endpoint_listener, zmk_usb_conn_state_changed);
#endif #endif
#if IS_ENABLED(CONFIG_ZMK_BLE) #if IS_ENABLED(CONFIG_ZMK_BLE)
ZMK_SUBSCRIPTION(endpoint_listener, ble_active_profile_changed); ZMK_SUBSCRIPTION(endpoint_listener, zmk_ble_active_profile_changed);
#endif #endif
SYS_INIT(zmk_endpoints_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY); SYS_INIT(zmk_endpoints_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

14
app/src/event_manager.c
View file

@ -17,7 +17,7 @@ extern struct zmk_event_type *__event_type_end[];
extern struct zmk_event_subscription __event_subscriptions_start[]; extern struct zmk_event_subscription __event_subscriptions_start[];
extern struct zmk_event_subscription __event_subscriptions_end[]; extern struct zmk_event_subscription __event_subscriptions_end[];
int zmk_event_manager_handle_from(struct zmk_event_header *event, uint8_t start_index) { int zmk_event_manager_handle_from(zmk_event_t *event, uint8_t start_index) {
int ret = 0; int ret = 0;
uint8_t len = __event_subscriptions_end - __event_subscriptions_start; uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
for (int i = start_index; i < len; i++) { for (int i = start_index; i < len; i++) {
@ -48,12 +48,9 @@ release:
return ret; return ret;
} }
int zmk_event_manager_raise(struct zmk_event_header *event) { int zmk_event_manager_raise(zmk_event_t *event) { return zmk_event_manager_handle_from(event, 0); }
return zmk_event_manager_handle_from(event, 0);
}
int zmk_event_manager_raise_after(struct zmk_event_header *event, int zmk_event_manager_raise_after(zmk_event_t *event, const struct zmk_listener *listener) {
const struct zmk_listener *listener) {
uint8_t len = __event_subscriptions_end - __event_subscriptions_start; uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
for (int i = 0; i < len; i++) { for (int i = 0; i < len; i++) {
struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i; struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
@ -68,8 +65,7 @@ int zmk_event_manager_raise_after(struct zmk_event_header *event,
return -EINVAL; return -EINVAL;
} }
int zmk_event_manager_raise_at(struct zmk_event_header *event, int zmk_event_manager_raise_at(zmk_event_t *event, const struct zmk_listener *listener) {
const struct zmk_listener *listener) {
uint8_t len = __event_subscriptions_end - __event_subscriptions_start; uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
for (int i = 0; i < len; i++) { for (int i = 0; i < len; i++) {
struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i; struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
@ -84,6 +80,6 @@ int zmk_event_manager_raise_at(struct zmk_event_header *event,
return -EINVAL; return -EINVAL;
} }
int zmk_event_manager_release(struct zmk_event_header *event) { int zmk_event_manager_release(zmk_event_t *event) {
return zmk_event_manager_handle_from(event, event->last_listener_index + 1); return zmk_event_manager_handle_from(event, event->last_listener_index + 1);
} }

2
app/src/events/activity_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/activity_state_changed.h> #include <zmk/events/activity_state_changed.h>
ZMK_EVENT_IMPL(activity_state_changed); ZMK_EVENT_IMPL(zmk_activity_state_changed);

2
app/src/events/battery_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/battery_state_changed.h> #include <zmk/events/battery_state_changed.h>
ZMK_EVENT_IMPL(battery_state_changed); ZMK_EVENT_IMPL(zmk_battery_state_changed);

2
app/src/events/ble_active_profile_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/ble_active_profile_changed.h> #include <zmk/events/ble_active_profile_changed.h>
ZMK_EVENT_IMPL(ble_active_profile_changed); ZMK_EVENT_IMPL(zmk_ble_active_profile_changed);

2
app/src/events/keycode_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/keycode_state_changed.h> #include <zmk/events/keycode_state_changed.h>
ZMK_EVENT_IMPL(keycode_state_changed); ZMK_EVENT_IMPL(zmk_keycode_state_changed);

2
app/src/events/layer_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/layer_state_changed.h> #include <zmk/events/layer_state_changed.h>
ZMK_EVENT_IMPL(layer_state_changed); ZMK_EVENT_IMPL(zmk_layer_state_changed);

2
app/src/events/modifiers_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/modifiers_state_changed.h> #include <zmk/events/modifiers_state_changed.h>
ZMK_EVENT_IMPL(modifiers_state_changed); ZMK_EVENT_IMPL(zmk_modifiers_state_changed);

2
app/src/events/position_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/position_state_changed.h> #include <zmk/events/position_state_changed.h>
ZMK_EVENT_IMPL(position_state_changed); ZMK_EVENT_IMPL(zmk_position_state_changed);

2
app/src/events/sensor_event.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/sensor_event.h> #include <zmk/events/sensor_event.h>
ZMK_EVENT_IMPL(sensor_event); ZMK_EVENT_IMPL(zmk_sensor_event);

2
app/src/events/usb_conn_state_changed.c
View file

@ -7,4 +7,4 @@
#include <kernel.h> #include <kernel.h>
#include <zmk/events/usb_conn_state_changed.h> #include <zmk/events/usb_conn_state_changed.h>
ZMK_EVENT_IMPL(usb_conn_state_changed); ZMK_EVENT_IMPL(zmk_usb_conn_state_changed);

8
app/src/hid_listener.c
View file

@ -70,9 +70,9 @@ static int hid_listener_keycode_released(uint16_t usage_page, uint32_t keycode,
return zmk_endpoints_send_report(usage_page); return zmk_endpoints_send_report(usage_page);
} }
int hid_listener(const struct zmk_event_header *eh) { int hid_listener(const zmk_event_t *eh) {
if (is_keycode_state_changed(eh)) { if (is_zmk_keycode_state_changed(eh)) {
const struct keycode_state_changed *ev = cast_keycode_state_changed(eh); const struct zmk_keycode_state_changed *ev = cast_zmk_keycode_state_changed(eh);
if (ev->state) { if (ev->state) {
hid_listener_keycode_pressed(ev->usage_page, ev->keycode, ev->implicit_modifiers); hid_listener_keycode_pressed(ev->usage_page, ev->keycode, ev->implicit_modifiers);
} else { } else {
@ -83,4 +83,4 @@ int hid_listener(const struct zmk_event_header *eh) {
} }
ZMK_LISTENER(hid_listener, hid_listener); ZMK_LISTENER(hid_listener, hid_listener);
ZMK_SUBSCRIPTION(hid_listener, keycode_state_changed); ZMK_SUBSCRIPTION(hid_listener, zmk_keycode_state_changed);

17
app/src/keymap.c
View file

@ -246,14 +246,13 @@ int zmk_keymap_sensor_triggered(uint8_t sensor_number, const struct device *sens
#endif /* ZMK_KEYMAP_HAS_SENSORS */ #endif /* ZMK_KEYMAP_HAS_SENSORS */
int keymap_listener(const struct zmk_event_header *eh) { int keymap_listener(const zmk_event_t *eh) {
if (is_position_state_changed(eh)) { if (is_zmk_position_state_changed(eh)) {
const struct position_state_changed *ev = cast_position_state_changed(eh); const struct zmk_position_state_changed *ev = cast_zmk_position_state_changed(eh);
return zmk_keymap_position_state_changed(ev->data.position, ev->data.state, return zmk_keymap_position_state_changed(ev->position, ev->state, ev->timestamp);
ev->data.timestamp);
#if ZMK_KEYMAP_HAS_SENSORS #if ZMK_KEYMAP_HAS_SENSORS
} else if (is_sensor_event(eh)) { } else if (is_zmk_sensor_event(eh)) {
const struct sensor_event *ev = cast_sensor_event(eh); const struct zmk_sensor_event *ev = cast_zmk_sensor_event(eh);
return zmk_keymap_sensor_triggered(ev->sensor_number, ev->sensor, ev->timestamp); return zmk_keymap_sensor_triggered(ev->sensor_number, ev->sensor, ev->timestamp);
#endif /* ZMK_KEYMAP_HAS_SENSORS */ #endif /* ZMK_KEYMAP_HAS_SENSORS */
} }
@ -262,8 +261,8 @@ int keymap_listener(const struct zmk_event_header *eh) {
} }
ZMK_LISTENER(keymap, keymap_listener); ZMK_LISTENER(keymap, keymap_listener);
ZMK_SUBSCRIPTION(keymap, position_state_changed); ZMK_SUBSCRIPTION(keymap, zmk_position_state_changed);
#if ZMK_KEYMAP_HAS_SENSORS #if ZMK_KEYMAP_HAS_SENSORS
ZMK_SUBSCRIPTION(keymap, sensor_event); ZMK_SUBSCRIPTION(keymap, zmk_sensor_event);
#endif /* ZMK_KEYMAP_HAS_SENSORS */ #endif /* ZMK_KEYMAP_HAS_SENSORS */

7
app/src/kscan.c
View file

@ -47,13 +47,10 @@ void zmk_kscan_process_msgq(struct k_work *item) {
while (k_msgq_get(&zmk_kscan_msgq, &ev, K_NO_WAIT) == 0) { while (k_msgq_get(&zmk_kscan_msgq, &ev, K_NO_WAIT) == 0) {
bool pressed = (ev.state == ZMK_KSCAN_EVENT_STATE_PRESSED); bool pressed = (ev.state == ZMK_KSCAN_EVENT_STATE_PRESSED);
uint32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column); uint32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column);
struct position_state_changed *pos_ev;
LOG_DBG("Row: %d, col: %d, position: %d, pressed: %s\n", ev.row, ev.column, position, LOG_DBG("Row: %d, col: %d, position: %d, pressed: %s\n", ev.row, ev.column, position,
(pressed ? "true" : "false")); (pressed ? "true" : "false"));
pos_ev = new_position_state_changed(); ZMK_EVENT_RAISE(new_zmk_position_state_changed((struct zmk_position_state_changed){
pos_ev->data = (struct zmk_position_state_changed_data){ .state = pressed, .position = position, .timestamp = k_uptime_get()}));
.state = pressed, .position = position, .timestamp = k_uptime_get()};
ZMK_EVENT_RAISE(pos_ev);
} }
} }

9
app/src/sensors.c
View file

@ -35,7 +35,6 @@ static struct sensors_data_item sensors[] = {UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN
static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_trigger *trigger) { static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_trigger *trigger) {
int err; int err;
struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger); struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger);
struct sensor_event *event;
LOG_DBG("sensor %d", item->sensor_number); LOG_DBG("sensor %d", item->sensor_number);
@ -45,12 +44,8 @@ static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_
return; return;
} }
event = new_sensor_event(); ZMK_EVENT_RAISE(new_zmk_sensor_event((struct zmk_sensor_event){
event->sensor_number = item->sensor_number; .sensor_number = item->sensor_number, .sensor = dev, .timestamp = k_uptime_get()}));
event->sensor = dev;
event->timestamp = k_uptime_get();
ZMK_EVENT_RAISE(event);
} }
static void zmk_sensors_init_item(const char *node, uint8_t i, uint8_t abs_i) { static void zmk_sensors_init_item(const char *node, uint8_t i, uint8_t abs_i) {

11
app/src/split/bluetooth/central.c
View file

@ -33,17 +33,14 @@ static struct bt_uuid_128 uuid = BT_UUID_INIT_128(ZMK_SPLIT_BT_SERVICE_UUID);
static struct bt_gatt_discover_params discover_params; static struct bt_gatt_discover_params discover_params;
static struct bt_gatt_subscribe_params subscribe_params; static struct bt_gatt_subscribe_params subscribe_params;
K_MSGQ_DEFINE(peripheral_event_msgq, sizeof(struct zmk_position_state_changed_data), K_MSGQ_DEFINE(peripheral_event_msgq, sizeof(struct zmk_position_state_changed),
CONFIG_ZMK_SPLIT_BLE_CENTRAL_POSITION_QUEUE_SIZE, 4); CONFIG_ZMK_SPLIT_BLE_CENTRAL_POSITION_QUEUE_SIZE, 4);
void peripheral_event_work_callback(struct k_work *work) { void peripheral_event_work_callback(struct k_work *work) {
struct zmk_position_state_changed_data ev; struct zmk_position_state_changed ev;
while (k_msgq_get(&peripheral_event_msgq, &ev, K_NO_WAIT) == 0) { while (k_msgq_get(&peripheral_event_msgq, &ev, K_NO_WAIT) == 0) {
struct position_state_changed *pos_ev = new_position_state_changed();
pos_ev->data = ev;
LOG_DBG("Trigger key position state change for %d", ev.position); LOG_DBG("Trigger key position state change for %d", ev.position);
ZMK_EVENT_RAISE(pos_ev); ZMK_EVENT_RAISE(new_zmk_position_state_changed(ev));
} }
} }
@ -74,7 +71,7 @@ static uint8_t split_central_notify_func(struct bt_conn *conn,
if (changed_positions[i] & BIT(j)) { if (changed_positions[i] & BIT(j)) {
uint32_t position = (i * 8) + j; uint32_t position = (i * 8) + j;
bool pressed = position_state[i] & BIT(j); bool pressed = position_state[i] & BIT(j);
struct zmk_position_state_changed_data ev = { struct zmk_position_state_changed ev = {
.position = position, .state = pressed, .timestamp = k_uptime_get()}; .position = position, .state = pressed, .timestamp = k_uptime_get()};
k_msgq_put(&peripheral_event_msgq, &ev, K_NO_WAIT); k_msgq_put(&peripheral_event_msgq, &ev, K_NO_WAIT);

14
app/src/split_listener.c
View file

@ -19,18 +19,18 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/hid.h> #include <zmk/hid.h>
#include <zmk/endpoints.h> #include <zmk/endpoints.h>
int split_listener(const struct zmk_event_header *eh) { int split_listener(const zmk_event_t *eh) {
LOG_DBG(""); LOG_DBG("");
if (is_position_state_changed(eh)) { if (is_zmk_position_state_changed(eh)) {
const struct position_state_changed *ev = cast_position_state_changed(eh); const struct zmk_position_state_changed *ev = cast_zmk_position_state_changed(eh);
if (ev->data.state) { if (ev->state) {
return zmk_split_bt_position_pressed(ev->data.position); return zmk_split_bt_position_pressed(ev->position);
} else { } else {
return zmk_split_bt_position_released(ev->data.position); return zmk_split_bt_position_released(ev->position);
} }
} }
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
ZMK_LISTENER(split_listener, split_listener); ZMK_LISTENER(split_listener, split_listener);
ZMK_SUBSCRIPTION(split_listener, position_state_changed); ZMK_SUBSCRIPTION(split_listener, zmk_position_state_changed);

6
app/src/usb.c
View file

@ -55,10 +55,8 @@ int zmk_usb_hid_send_report(const uint8_t *report, size_t len) {
#endif /* CONFIG_ZMK_USB */ #endif /* CONFIG_ZMK_USB */
static void raise_usb_status_changed_event() { static void raise_usb_status_changed_event() {
struct usb_conn_state_changed *ev = new_usb_conn_state_changed(); ZMK_EVENT_RAISE(new_zmk_usb_conn_state_changed(
ev->conn_state = zmk_usb_get_conn_state(); (struct zmk_usb_conn_state_changed){.conn_state = zmk_usb_get_conn_state()}));
ZMK_EVENT_RAISE(ev);
} }
enum usb_dc_status_code zmk_usb_get_status() { return usb_status; } enum usb_dc_status_code zmk_usb_get_status() { return usb_status; }