Attempt to properly pass through sources

app/include/zmk/behavior.h

@@ -26,6 +26,7 @@ struct zmk_behavior_binding_event {
     int layer;
     uint32_t position;
     int64_t timestamp;
+    uint8_t source;
 };
 
 /**

app/include/zmk/behavior_queue.h

@@ -10,5 +10,5 @@
 #include <stdint.h>
 #include <zmk/behavior.h>
 
-int zmk_behavior_queue_add(uint32_t position, const struct zmk_behavior_binding behavior,
+int zmk_behavior_queue_add(uint32_t position, uint8_t source,
-                           bool press, uint32_t wait);
+                           const struct zmk_behavior_binding behavior, bool press, uint32_t wait);

app/include/zmk/keymap.h

@@ -29,8 +29,7 @@ int zmk_keymap_position_state_changed(uint8_t source, uint32_t position, bool pr
                                       int64_t timestamp);
 
 int zmk_trigger_behavior_callbacks(struct zmk_behavior_binding *binding,
-                                   struct zmk_behavior_binding_event event, uint8_t source,
+                                   struct zmk_behavior_binding_event event, bool pressed);
-                                   bool pressed);
 
 #define ZMK_KEYMAP_EXTRACT_BINDING(idx, drv_inst)                                                  \
     {                                                                                              \

app/include/zmk/split/bluetooth/service.h

@@ -20,6 +20,7 @@ struct sensor_event {
 
 struct zmk_split_run_behavior_data {
     uint8_t position;
+    uint8_t source;
     uint8_t state;
     uint32_t param1;
     uint32_t param2;

app/src/behavior_queue.c

@@ -15,6 +15,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct q_item {
     uint32_t position;
+    uint8_t source;
     struct zmk_behavior_binding binding;
     bool press : 1;
     uint32_t wait : 31;
@@ -32,13 +33,13 @@ static void behavior_queue_process_next(struct k_work *work) {
         LOG_DBG("Invoking %s: 0x%02x 0x%02x", item.binding.behavior_dev, item.binding.param1,
                 item.binding.param2);
 
-        struct zmk_behavior_binding_event event = {.position = item.position,
+        struct zmk_behavior_binding_event event = {
-                                                   .timestamp = k_uptime_get()};
+            .position = item.position, .timestamp = k_uptime_get(), .source = item.source};
 
         if (item.press) {
-            zmk_trigger_behavior_callbacks(&item.binding, event, 0, true);
+            zmk_trigger_behavior_callbacks(&item.binding, event, true);
         } else {
-            zmk_trigger_behavior_callbacks(&item.binding, event, 0, false);
+            zmk_trigger_behavior_callbacks(&item.binding, event, false);
         }
 
         LOG_DBG("Processing next queued behavior in %dms", item.wait);
@@ -50,9 +51,10 @@ static void behavior_queue_process_next(struct k_work *work) {
     }
 }
 
-int zmk_behavior_queue_add(uint32_t position, const struct zmk_behavior_binding binding, bool press,
+int zmk_behavior_queue_add(uint32_t position, uint8_t source,
-                           uint32_t wait) {
+                           const struct zmk_behavior_binding binding, bool press, uint32_t wait) {
-    struct q_item item = {.press = press, .binding = binding, .wait = wait};
+    struct q_item item = {
+        .press = press, .binding = binding, .wait = wait, .position = position, .source = source};
 
     const int ret = k_msgq_put(&zmk_behavior_queue_msgq, &item, K_NO_WAIT);
     if (ret < 0) {

app/src/behaviors/behavior_hold_tap.c

@@ -77,6 +77,7 @@ struct behavior_hold_tap_data {
 // this data is specific for each hold-tap
 struct active_hold_tap {
     int32_t position;
+    uint8_t source;
     uint32_t param_hold;
     uint32_t param_tap;
     int64_t timestamp;
@@ -250,14 +251,16 @@ static struct active_hold_tap *find_hold_tap(uint32_t position) {
     return NULL;
 }
 
-static struct active_hold_tap *store_hold_tap(uint32_t position, uint32_t param_hold,
+static struct active_hold_tap *store_hold_tap(uint32_t position, uint8_t source,
-                                              uint32_t param_tap, int64_t timestamp,
+                                              uint32_t param_hold, uint32_t param_tap,
+                                              int64_t timestamp,
                                               const struct behavior_hold_tap_config *config) {
     for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_HELD; i++) {
         if (active_hold_taps[i].position != ZMK_BHV_HOLD_TAP_POSITION_NOT_USED) {
             continue;
         }
         active_hold_taps[i].position = position;
+        active_hold_taps[i].source = source;
         active_hold_taps[i].status = STATUS_UNDECIDED;
         active_hold_taps[i].config = config;
         active_hold_taps[i].param_hold = param_hold;
@@ -400,45 +403,49 @@ static int press_hold_binding(struct active_hold_tap *hold_tap) {
     struct zmk_behavior_binding_event event = {
         .position = hold_tap->position,
         .timestamp = hold_tap->timestamp,
+        .source = hold_tap->source,
     };
 
     struct zmk_behavior_binding binding = {.behavior_dev = hold_tap->config->hold_behavior_dev,
                                            .param1 = hold_tap->param_hold};
-    return behavior_keymap_binding_pressed(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, true);
 }
 
 static int press_tap_binding(struct active_hold_tap *hold_tap) {
     struct zmk_behavior_binding_event event = {
         .position = hold_tap->position,
         .timestamp = hold_tap->timestamp,
+        .source = hold_tap->source,
     };
 
     struct zmk_behavior_binding binding = {.behavior_dev = hold_tap->config->tap_behavior_dev,
                                            .param1 = hold_tap->param_tap};
     store_last_hold_tapped(hold_tap);
-    return behavior_keymap_binding_pressed(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, true);
 }
 
 static int release_hold_binding(struct active_hold_tap *hold_tap) {
     struct zmk_behavior_binding_event event = {
         .position = hold_tap->position,
         .timestamp = hold_tap->timestamp,
+        .source = hold_tap->source,
     };
 
     struct zmk_behavior_binding binding = {.behavior_dev = hold_tap->config->hold_behavior_dev,
                                            .param1 = hold_tap->param_hold};
-    return behavior_keymap_binding_released(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, false);
 }
 
 static int release_tap_binding(struct active_hold_tap *hold_tap) {
     struct zmk_behavior_binding_event event = {
         .position = hold_tap->position,
         .timestamp = hold_tap->timestamp,
+        .source = hold_tap->source,
     };
 
     struct zmk_behavior_binding binding = {.behavior_dev = hold_tap->config->tap_behavior_dev,
                                            .param1 = hold_tap->param_tap};
-    return behavior_keymap_binding_released(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, false);
 }
 
 static int press_binding(struct active_hold_tap *hold_tap) {
@@ -597,8 +604,8 @@ static int on_hold_tap_binding_pressed(struct zmk_behavior_binding *binding,
         return ZMK_BEHAVIOR_OPAQUE;
     }
 
-    struct active_hold_tap *hold_tap =
+    struct active_hold_tap *hold_tap = store_hold_tap(event.position, event.source, binding->param1,
-        store_hold_tap(event.position, binding->param1, binding->param2, event.timestamp, cfg);
+                                                      binding->param2, event.timestamp, cfg);
     if (hold_tap == NULL) {
         LOG_ERR("unable to store hold-tap info, did you press more than %d hold-taps?",
                 ZMK_BHV_HOLD_TAP_MAX_HELD);

app/src/behaviors/behavior_macro.c

@@ -158,7 +158,8 @@ static void replace_params(struct behavior_macro_trigger_state *state,
     state->param2_source = PARAM_SOURCE_BINDING;
 }
 
-static void queue_macro(uint32_t position, const struct zmk_behavior_binding bindings[],
+static void queue_macro(uint32_t position, uint8_t source,
+                        const struct zmk_behavior_binding bindings[],
                         struct behavior_macro_trigger_state state,
                         const struct zmk_behavior_binding *macro_binding) {
     LOG_DBG("Iterating macro bindings - starting: %d, count: %d", state.start_index, state.count);
@@ -169,14 +170,14 @@ static void queue_macro(uint32_t position, const struct zmk_behavior_binding bin
 
             switch (state.mode) {
             case MACRO_MODE_TAP:
-                zmk_behavior_queue_add(position, binding, true, state.tap_ms);
+                zmk_behavior_queue_add(position, source, binding, true, state.tap_ms);
-                zmk_behavior_queue_add(position, binding, false, state.wait_ms);
+                zmk_behavior_queue_add(position, source, binding, false, state.wait_ms);
                 break;
             case MACRO_MODE_PRESS:
-                zmk_behavior_queue_add(position, binding, true, state.wait_ms);
+                zmk_behavior_queue_add(position, source, binding, true, state.wait_ms);
                 break;
             case MACRO_MODE_RELEASE:
-                zmk_behavior_queue_add(position, binding, false, state.wait_ms);
+                zmk_behavior_queue_add(position, source, binding, false, state.wait_ms);
                 break;
             default:
                 LOG_ERR("Unknown macro mode: %d", state.mode);
@@ -197,7 +198,7 @@ static int on_macro_binding_pressed(struct zmk_behavior_binding *binding,
                                                          .start_index = 0,
                                                          .count = state->press_bindings_count};
 
-    queue_macro(event.position, cfg->bindings, trigger_state, binding);
+    queue_macro(event.position, event.source, cfg->bindings, trigger_state, binding);
 
     return ZMK_BEHAVIOR_OPAQUE;
 }
@@ -208,7 +209,7 @@ static int on_macro_binding_released(struct zmk_behavior_binding *binding,
     const struct behavior_macro_config *cfg = dev->config;
     struct behavior_macro_state *state = dev->data;
 
-    queue_macro(event.position, cfg->bindings, state->release_state, binding);
+    queue_macro(event.position, event.source, cfg->bindings, state->release_state, binding);
 
     return ZMK_BEHAVIOR_OPAQUE;
 }

app/src/behaviors/behavior_mod_morph.c

@@ -10,6 +10,7 @@
 #include <drivers/behavior.h>
 #include <zephyr/logging/log.h>
 #include <zmk/behavior.h>
+#include <zmk/keymap.h>
 
 #include <zmk/matrix.h>
 #include <zmk/endpoints.h>
@@ -51,7 +52,7 @@ static int on_mod_morph_binding_pressed(struct zmk_behavior_binding *binding,
     } else {
         data->pressed_binding = (struct zmk_behavior_binding *)&cfg->normal_binding;
     }
-    return behavior_keymap_binding_pressed(data->pressed_binding, event);
+    return zmk_trigger_behavior_callbacks(data->pressed_binding, event, true);
 }
 
 static int on_mod_morph_binding_released(struct zmk_behavior_binding *binding,
@@ -67,7 +68,7 @@ static int on_mod_morph_binding_released(struct zmk_behavior_binding *binding,
     struct zmk_behavior_binding *pressed_binding = data->pressed_binding;
     data->pressed_binding = NULL;
     int err;
-    err = behavior_keymap_binding_released(pressed_binding, event);
+    err = zmk_trigger_behavior_callbacks(pressed_binding, event, false);
     zmk_hid_masked_modifiers_clear();
     return err;
 }

app/src/behaviors/behavior_sensor_rotate_common.c

@@ -90,8 +90,8 @@ int zmk_behavior_sensor_rotate_common_process(struct zmk_behavior_binding *bindi
     LOG_DBG("Sensor binding: %s", binding->behavior_dev);
 
     for (int i = 0; i < triggers; i++) {
-        zmk_behavior_queue_add(event.position, triggered_binding, true, cfg->tap_ms);
+        zmk_behavior_queue_add(event.position, event.source, triggered_binding, true, cfg->tap_ms);
-        zmk_behavior_queue_add(event.position, triggered_binding, false, 0);
+        zmk_behavior_queue_add(event.position, event.source, triggered_binding, false, 0);
     }
 
     return ZMK_BEHAVIOR_OPAQUE;

app/src/behaviors/behavior_sticky_key.c

@@ -40,6 +40,7 @@ struct behavior_sticky_key_config {
 
 struct active_sticky_key {
     uint32_t position;
+    uint8_t source;
     uint32_t param1;
     uint32_t param2;
     const struct behavior_sticky_key_config *config;
@@ -55,8 +56,8 @@ struct active_sticky_key {
 
 struct active_sticky_key active_sticky_keys[ZMK_BHV_STICKY_KEY_MAX_HELD] = {};
 
-static struct active_sticky_key *store_sticky_key(uint32_t position, uint32_t param1,
+static struct active_sticky_key *store_sticky_key(uint32_t position, uint8_t source,
-                                                  uint32_t param2,
+                                                  uint32_t param1, uint32_t param2,
                                                   const struct behavior_sticky_key_config *config) {
     for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {
         struct active_sticky_key *const sticky_key = &active_sticky_keys[i];
@@ -65,6 +66,7 @@ static struct active_sticky_key *store_sticky_key(uint32_t position, uint32_t pa
             continue;
         }
         sticky_key->position = position;
+        sticky_key->source = source;
         sticky_key->param1 = param1;
         sticky_key->param2 = param2;
         sticky_key->config = config;
@@ -101,8 +103,9 @@ static inline int press_sticky_key_behavior(struct active_sticky_key *sticky_key
     struct zmk_behavior_binding_event event = {
         .position = sticky_key->position,
         .timestamp = timestamp,
+        .source = sticky_key->source,
     };
-    return behavior_keymap_binding_pressed(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, true);
 }
 
 static inline int release_sticky_key_behavior(struct active_sticky_key *sticky_key,
@@ -115,10 +118,11 @@ static inline int release_sticky_key_behavior(struct active_sticky_key *sticky_k
     struct zmk_behavior_binding_event event = {
         .position = sticky_key->position,
         .timestamp = timestamp,
+        .source = sticky_key->source,
     };
 
     clear_sticky_key(sticky_key);
-    return behavior_keymap_binding_released(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, false);
 }
 
 static inline void on_sticky_key_timeout(struct active_sticky_key *sticky_key) {
@@ -149,7 +153,8 @@ static int on_sticky_key_binding_pressed(struct zmk_behavior_binding *binding,
         stop_timer(sticky_key);
         release_sticky_key_behavior(sticky_key, event.timestamp);
     }
-    sticky_key = store_sticky_key(event.position, binding->param1, binding->param2, cfg);
+    sticky_key =
+        store_sticky_key(event.position, event.source, binding->param1, binding->param2, cfg);
     if (sticky_key == NULL) {
         LOG_ERR("unable to store sticky key, did you press more than %d sticky_key?",
                 ZMK_BHV_STICKY_KEY_MAX_HELD);

app/src/behaviors/behavior_tap_dance.c

@@ -35,6 +35,7 @@ struct active_tap_dance {
     // Tap Dance Data
     int counter;
     uint32_t position;
+    uint8_t source;
     uint32_t param1;
     uint32_t param2;
     bool is_pressed;
@@ -59,13 +60,15 @@ static struct active_tap_dance *find_tap_dance(uint32_t position) {
     return NULL;
 }
 
-static int new_tap_dance(uint32_t position, const struct behavior_tap_dance_config *config,
+static int new_tap_dance(uint32_t position, uint8_t source,
+                         const struct behavior_tap_dance_config *config,
                          struct active_tap_dance **tap_dance) {
     for (int i = 0; i < ZMK_BHV_TAP_DANCE_MAX_HELD; i++) {
         struct active_tap_dance *const ref_dance = &active_tap_dances[i];
         if (ref_dance->position == ZMK_BHV_TAP_DANCE_POSITION_FREE) {
             ref_dance->counter = 0;
             ref_dance->position = position;
+            ref_dance->source = source;
             ref_dance->config = config;
             ref_dance->release_at = 0;
             ref_dance->is_pressed = true;
@@ -108,8 +111,9 @@ static inline int press_tap_dance_behavior(struct active_tap_dance *tap_dance, i
     struct zmk_behavior_binding_event event = {
         .position = tap_dance->position,
         .timestamp = timestamp,
+        .source = tap_dance->source,
     };
-    return behavior_keymap_binding_pressed(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, true);
 }
 
 static inline int release_tap_dance_behavior(struct active_tap_dance *tap_dance,
@@ -118,9 +122,10 @@ static inline int release_tap_dance_behavior(struct active_tap_dance *tap_dance,
     struct zmk_behavior_binding_event event = {
         .position = tap_dance->position,
         .timestamp = timestamp,
+        .source = tap_dance->source,
     };
     clear_tap_dance(tap_dance);
-    return behavior_keymap_binding_released(&binding, event);
+    return zmk_trigger_behavior_callbacks(&binding, event, false);
 }
 
 static int on_tap_dance_binding_pressed(struct zmk_behavior_binding *binding,
@@ -130,7 +135,7 @@ static int on_tap_dance_binding_pressed(struct zmk_behavior_binding *binding,
     struct active_tap_dance *tap_dance;
     tap_dance = find_tap_dance(event.position);
     if (tap_dance == NULL) {
-        if (new_tap_dance(event.position, cfg, &tap_dance) == -ENOMEM) {
+        if (new_tap_dance(event.position, event.source, cfg, &tap_dance) == -ENOMEM) {
             LOG_ERR("Unable to create new tap dance. Insufficient space in active_tap_dances[].");
             return ZMK_BEHAVIOR_OPAQUE;
         }

app/src/keymap.c

@@ -181,16 +181,16 @@ int zmk_keymap_apply_position_state(uint8_t source, int layer, uint32_t position
         .layer = layer,
         .position = position,
         .timestamp = timestamp,
+        .source = source,
     };
 
     LOG_DBG("layer: %d position: %d, binding name: %s", layer, position, binding.behavior_dev);
 
-    return zmk_trigger_behavior_callbacks(&binding, event, source, pressed);
+    return zmk_trigger_behavior_callbacks(&binding, event, pressed);
 }
 
 int zmk_trigger_behavior_callbacks(struct zmk_behavior_binding *binding,
-                                   struct zmk_behavior_binding_event event, uint8_t source,
+                                   struct zmk_behavior_binding_event event, bool pressed) {
-                                   bool pressed) {
     const struct device *behavior = zmk_behavior_get_binding(binding->behavior_dev);
 
     if (!behavior) {
@@ -216,10 +216,10 @@ int zmk_trigger_behavior_callbacks(struct zmk_behavior_binding *binding,
         return invoke_locally(binding, event, pressed);
     case BEHAVIOR_LOCALITY_EVENT_SOURCE:
 #if ZMK_BLE_IS_CENTRAL
-        if (source == ZMK_POSITION_STATE_CHANGE_SOURCE_LOCAL) {
+        if (event.source == ZMK_POSITION_STATE_CHANGE_SOURCE_LOCAL) {
             return invoke_locally(binding, event, pressed);
         } else {
-            return zmk_split_bt_invoke_behavior(source, binding, event, pressed);
+            return zmk_split_bt_invoke_behavior(event.source, binding, event, pressed);
         }
 #else
         return invoke_locally(binding, event, pressed);

app/src/split/bluetooth/central.c

@@ -816,6 +816,7 @@ int zmk_split_bt_invoke_behavior(uint8_t source, struct zmk_behavior_binding *bi
                                                          .param1 = binding->param1,
                                                          .param2 = binding->param2,
                                                          .position = event.position,
+                                                         .source = event.source,
                                                          .state = state ? 1 : 0,
                                                      }};
     const size_t payload_dev_size = sizeof(payload.behavior_dev);