feat(behavior): Add key toggle

app/CMakeLists.txt

@@ -43,6 +43,7 @@ target_sources_ifdef(CONFIG_ZMK_BLE app PRIVATE src/events/battery_state_changed
 target_sources_ifdef(CONFIG_USB app PRIVATE src/events/usb_conn_state_changed.c)
 if ((NOT CONFIG_ZMK_SPLIT) OR CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
   target_sources(app PRIVATE src/behaviors/behavior_key_press.c)
+  target_sources(app PRIVATE src/behaviors/behavior_key_toggle.c)
   target_sources(app PRIVATE src/behaviors/behavior_reset.c)
   target_sources(app PRIVATE src/behaviors/behavior_hold_tap.c)
   target_sources(app PRIVATE src/behaviors/behavior_sticky_key.c)

app/dts/behaviors.dtsi

@@ -1,4 +1,5 @@
 #include <behaviors/key_press.dtsi>
+#include <behaviors/key_toggle.dtsi>
 #include <behaviors/transparent.dtsi>
 #include <behaviors/none.dtsi>
 #include <behaviors/mod_tap.dtsi>

app/dts/behaviors/key_toggle.dtsi

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+/ {
+	behaviors {
+		/omit-if-no-ref/ kt: behavior_key_toggle {
+			compatible = "zmk,behavior-key-toggle";
+			label = "KEY_TOGGLE";
+			#binding-cells = <1>;
+		};
+	};
+};

app/dts/bindings/behaviors/zmk,behavior-key-toggle.yaml

@@ -0,0 +1,8 @@
+# Copyright (c) 2020 The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+description: Key toggle behavior
+
+compatible: "zmk,behavior-key-toggle"
+
+include: one_param.yaml

app/include/zmk/hid.h

@@ -169,6 +169,8 @@ struct zmk_hid_consumer_report {
 zmk_mod_flags_t zmk_hid_get_explicit_mods();
 int zmk_hid_register_mod(zmk_mod_t modifier);
 int zmk_hid_unregister_mod(zmk_mod_t modifier);
+bool zmk_hid_mod_is_pressed(zmk_mod_t modifier);
+
 int zmk_hid_register_mods(zmk_mod_flags_t explicit_modifiers);
 int zmk_hid_unregister_mods(zmk_mod_flags_t explicit_modifiers);
 int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t implicit_modifiers);
@@ -177,13 +179,16 @@ int zmk_hid_implicit_modifiers_release();
 int zmk_hid_keyboard_press(zmk_key_t key);
 int zmk_hid_keyboard_release(zmk_key_t key);
 void zmk_hid_keyboard_clear();
+bool zmk_hid_keyboard_is_pressed();
 
 int zmk_hid_consumer_press(zmk_key_t key);
 int zmk_hid_consumer_release(zmk_key_t key);
 void zmk_hid_consumer_clear();
+bool zmk_hid_consumer_is_pressed(zmk_key_t key);
 
 int zmk_hid_press(uint8_t usage_page, zmk_key_t code);
 int zmk_hid_release(uint8_t usage_page, zmk_key_t code);
+bool zmk_hid_is_pressed(uint8_t usage_page, zmk_key_t code);
 
 struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report();
 struct zmk_hid_consumer_report *zmk_hid_get_consumer_report();

app/src/behaviors/behavior_key_toggle.c

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_behavior_key_toggle
+
+#include <device.h>
+#include <drivers/behavior.h>
+#include <logging/log.h>
+
+#include <zmk/hid.h>
+#include <zmk/event_manager.h>
+#include <zmk/events/keycode_state_changed.h>
+#include <zmk/behavior.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
+
+static int behavior_key_toggle_init(const struct device *dev) { return 0; };
+
+static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
+                                     struct zmk_behavior_binding_event event) {
+    LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1);
+    bool pressed =
+        zmk_hid_is_pressed(HID_USAGE_PAGE(binding->param1), HID_USAGE_ID(binding->param1));
+    return ZMK_EVENT_RAISE(
+        zmk_keycode_state_changed_from_encoded(binding->param1, !pressed, event.timestamp));
+}
+
+static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
+                                      struct zmk_behavior_binding_event event) {
+    return 0;
+}
+
+static const struct behavior_driver_api behavior_key_toggle_driver_api = {
+    .binding_pressed = on_keymap_binding_pressed,
+    .binding_released = on_keymap_binding_released,
+};
+
+#define KP_INST(n)                                                                                 \
+    DEVICE_AND_API_INIT(behavior_key_toggle_##n, DT_INST_LABEL(n), behavior_key_toggle_init, NULL, \
+                        NULL, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,                    \
+                        &behavior_key_toggle_driver_api);
+
+DT_INST_FOREACH_STATUS_OKAY(KP_INST)
+
+#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */

app/src/hid.c

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 
+#include "zmk/keys.h"
 #include <logging/log.h>
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
@@ -51,6 +52,11 @@ int zmk_hid_unregister_mod(zmk_mod_t modifier) {
     return 0;
 }
 
+bool zmk_hid_mod_is_pressed(zmk_mod_t modifier) {
+    zmk_mod_flags_t mod_flag = 1 << modifier;
+    return (zmk_hid_get_explicit_mods() & mod_flag) == mod_flag;
+}
+
 int zmk_hid_register_mods(zmk_mod_flags_t modifiers) {
     for (zmk_mod_t i = 0; i < 8; i++) {
         if (modifiers & (1 << i)) {
@@ -117,6 +123,18 @@ int zmk_hid_keyboard_release(zmk_key_t code) {
     return 0;
 };
 
+bool zmk_hid_keyboard_is_pressed(zmk_key_t code) {
+    if (code >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL && code <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI) {
+        return zmk_hid_mod_is_pressed(code - HID_USAGE_KEY_KEYBOARD_LEFTCONTROL);
+    }
+    for (int idx = 0; idx < ZMK_HID_KEYBOARD_NKRO_SIZE; idx++) {
+        if (keyboard_report.body.keys[idx] == code) {
+            return true;
+        }
+    }
+    return false;
+}
+
 void zmk_hid_keyboard_clear() { memset(&keyboard_report.body, 0, sizeof(keyboard_report.body)); }
 
 int zmk_hid_consumer_press(zmk_key_t code) {
@@ -129,6 +147,17 @@ int zmk_hid_consumer_release(zmk_key_t code) {
     return 0;
 };
 
+void zmk_hid_consumer_clear() { memset(&consumer_report.body, 0, sizeof(consumer_report.body)); }
+
+bool zmk_hid_consumer_is_pressed(zmk_key_t key) {
+    for (int idx = 0; idx < ZMK_HID_CONSUMER_NKRO_SIZE; idx++) {
+        if (consumer_report.body.keys[idx] == key) {
+            return true;
+        }
+    }
+    return false;
+}
+
 int zmk_hid_press(uint8_t usage_page, zmk_key_t code) {
     switch (usage_page) {
     case HID_USAGE_KEY:
@@ -149,7 +178,15 @@ int zmk_hid_release(uint8_t usage_page, zmk_key_t code) {
     return -EINVAL;
 }
 
-void zmk_hid_consumer_clear() { memset(&consumer_report.body, 0, sizeof(consumer_report.body)); }
+bool zmk_hid_is_pressed(uint8_t usage_page, zmk_key_t code) {
+    switch (usage_page) {
+    case HID_USAGE_KEY:
+        return zmk_hid_keyboard_is_pressed(code);
+    case HID_USAGE_CONSUMER:
+        return zmk_hid_consumer_is_pressed(code);
+    }
+    return false;
+}
 
 struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report() {
     return &keyboard_report;

app/tests/keytoggle/behavior_keymap.dtsi

@@ -0,0 +1,17 @@
+#include <dt-bindings/zmk/keys.h>
+#include <behaviors.dtsi>
+#include <dt-bindings/zmk/kscan_mock.h>
+
+/ {
+	keymap {
+		compatible = "zmk,keymap";
+		label ="Default keymap";
+
+		default_layer {
+			bindings = <
+				&kt B &none
+				&none &none
+			>;
+		};
+	};
+};

app/tests/keytoggle/kt-press-release/events.patterns

@@ -0,0 +1 @@
+s/.*hid_listener_keycode_//p

app/tests/keytoggle/kt-press-release/keycode_events.snapshot

@@ -0,0 +1,2 @@
+pressed: usage_page 0x07 keycode 0x05 implicit_mods 0x00 explicit_mods 0x00
+released: usage_page 0x07 keycode 0x05 implicit_mods 0x00 explicit_mods 0x00

app/tests/keytoggle/kt-press-release/native_posix.keymap

@@ -0,0 +1,10 @@
+#include "../behavior_keymap.dtsi"
+
+&kscan {
+	events = <
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+	>;
+};